Skip to content

Stack Deployments

zenml.stack_deployments

ZenML Stack Deployments.

Modules

aws_stack_deployment

Functionality to deploy a ZenML stack to AWS.

Classes
AWSZenMLCloudStackDeployment

Bases: ZenMLCloudStackDeployment

AWS ZenML Cloud Stack Deployment.

Functions
description() -> str classmethod

Return a description of the ZenML Cloud Stack Deployment.

This will be displayed when the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

A MarkDown description of the ZenML Cloud Stack Deployment.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    @classmethod
    def description(cls) -> str:
        """Return a description of the ZenML Cloud Stack Deployment.

        This will be displayed when the user is prompted to deploy
        the ZenML stack.

        Returns:
            A MarkDown description of the ZenML Cloud Stack Deployment.
        """
        return """
Provision and register a basic AWS ZenML stack authenticated and connected to
all the necessary cloud infrastructure resources required to run pipelines in
AWS.
"""
get_deployment_config() -> StackDeploymentConfig

Return the configuration to deploy the ZenML stack to the specified cloud provider.

The configuration should include:

  • a cloud provider console URL where the user will be redirected to deploy the ZenML stack. The URL should include as many pre-filled URL query parameters as possible.
  • a textual description of the URL
  • a Terraform script used to deploy the ZenML stack
  • some deployment providers may require additional configuration parameters or scripts to be passed to the cloud provider in addition to the deployment URL query parameters. Where that is the case, this method should also return a string that the user can copy and paste into the cloud provider console to deploy the ZenML stack (e.g. a set of environment variables, YAML configuration snippet, bash or Terraform script etc.).

Returns:

Type Description
StackDeploymentConfig

The configuration or script to deploy the ZenML stack to the
StackDeploymentConfig

specified cloud provider.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
    def get_deployment_config(
        self,
    ) -> StackDeploymentConfig:
        """Return the configuration to deploy the ZenML stack to the specified cloud provider.

        The configuration should include:

        * a cloud provider console URL where the user will be redirected to
        deploy the ZenML stack. The URL should include as many pre-filled
        URL query parameters as possible.
        * a textual description of the URL
        * a Terraform script used to deploy the ZenML stack
        * some deployment providers may require additional configuration
        parameters or scripts to be passed to the cloud provider in addition to
        the deployment URL query parameters. Where that is the case, this method
        should also return a string that the user can copy and paste into the
        cloud provider console to deploy the ZenML stack (e.g. a set of
        environment variables, YAML configuration snippet, bash or Terraform
        script etc.).

        Returns:
            The configuration or script to deploy the ZenML stack to the
            specified cloud provider.
        """
        params = dict(
            stackName=self.stack_name,
            templateURL="https://zenml-cf-templates.s3.eu-central-1.amazonaws.com/aws-ecr-s3-sagemaker.yaml",
            param_ResourceName=f"zenml-{random_str(6).lower()}",
            param_ZenMLServerURL=self.zenml_server_url,
            param_ZenMLServerAPIToken=self.zenml_server_api_token,
            param_CodeBuild="true",
        )
        # Encode the parameters as URL query parameters
        query_params = "&".join([f"{k}={v}" for k, v in params.items()])

        region = ""
        if self.location:
            region = f"region={self.location}"

        url = (
            f"https://console.aws.amazon.com/cloudformation/home?"
            f"{region}#/stacks/create/review?{query_params}"
        )

        config: Optional[str] = None
        if self.deployment_type == STACK_DEPLOYMENT_TERRAFORM:
            config = f"""terraform {{
    required_providers {{
        aws = {{
            source  = "hashicorp/aws"
        }}
        zenml = {{
            source = "zenml-io/zenml"
            version = "{TERRAFORM_PROVIDER_VERSION_SPEC}"
        }}
    }}
}}

provider "aws" {{
    region = "{self.location or "eu-central-1"}"
}}

provider "zenml" {{
    server_url = "{self.zenml_server_url}"
    api_token = "{self.zenml_server_api_token}"
}}

module "zenml_stack" {{
    source  = "zenml-io/zenml-stack/aws"
    version = "{TERRAFORM_AWS_MODULE_VERSION_SPEC}"
    zenml_stack_name = "{self.stack_name}"
    zenml_stack_deployment = "{self.deployment_type}"
}}
output "zenml_stack_id" {{
    value = module.zenml_stack.zenml_stack_id
}}
output "zenml_stack_name" {{
    value = module.zenml_stack.zenml_stack_name
}}"""

        return StackDeploymentConfig(
            deployment_url=url,
            deployment_url_text="AWS CloudFormation Console",
            configuration=config,
        )
instructions() -> str classmethod

Return instructions on how to deploy the ZenML stack to the specified cloud provider.

This will be displayed before the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

MarkDown instructions on how to deploy the ZenML stack to the
str

specified cloud provider.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
    @classmethod
    def instructions(cls) -> str:
        """Return instructions on how to deploy the ZenML stack to the specified cloud provider.

        This will be displayed before the user is prompted to deploy the ZenML
        stack.

        Returns:
            MarkDown instructions on how to deploy the ZenML stack to the
            specified cloud provider.
        """
        return """
You will be redirected to the AWS console in your browser where you'll be asked
to log into your AWS account and create a CloudFormation ZenML stack. The stack
parameters will be pre-filled with the necessary information to connect ZenML to
your AWS account, so you should only need to review and confirm the stack.

**NOTE**: The CloudFormation stack will create the following new resources in
your AWS account. Please ensure you have the necessary permissions and are aware
of any potential costs:

- An S3 bucket registered as a [ZenML artifact store](https://docs.zenml.io/stack-components/artifact-stores/s3).
- An ECR repository registered as a [ZenML container registry](https://docs.zenml.io/stack-components/container-registries/aws).
- Sagemaker registered as a [ZenML orchestrator](https://docs.zenml.io/stack-components/orchestrators/sagemaker)
as well as a [ZenML step operator](https://docs.zenml.io/stack-components/step-operators/sagemaker).
- A CodeBuild project registered as a [ZenML image builder](https://docs.zenml.io/stack-components/image-builder/aws).
- An IAM user and IAM role with the minimum necessary permissions to access the
above resources.
- An AWS access key used to give access to ZenML to connect to the above
resources through a [ZenML service connector](https://docs.zenml.io/how-to/auth-management/aws-service-connector).

The CloudFormation stack will automatically create an AWS secret key and
will share it with ZenML to give it permission to access the resources created
by the stack. You can revoke these permissions at any time by deleting the
CloudFormation stack.

**Estimated costs**

A small training job would cost around: $0.60

These are rough estimates and actual costs may vary based on your usage and specific AWS pricing. 
Some services may be eligible for the AWS Free Tier. Use [the AWS Pricing Calculator](https://calculator.aws)
for a detailed estimate based on your usage.

💡 **After the CloudFormation stack is deployed, you can return to the CLI to
view details about the associated ZenML stack automatically registered with
ZenML.**
"""
integrations() -> List[str] classmethod

Return the ZenML integrations required for the stack.

Returns:

Type Description
List[str]

The list of ZenML integrations that need to be installed for the
List[str]

stack to be usable.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
121
122
123
124
125
126
127
128
129
130
131
132
@classmethod
def integrations(cls) -> List[str]:
    """Return the ZenML integrations required for the stack.

    Returns:
        The list of ZenML integrations that need to be installed for the
        stack to be usable.
    """
    return [
        "aws",
        "s3",
    ]
locations() -> Dict[str, str] classmethod

Return the locations where the ZenML stack can be deployed.

Returns:

Type Description
Dict[str, str]

The regions where the ZenML stack can be deployed as a map of region
Dict[str, str]

names to region descriptions.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
@classmethod
def locations(cls) -> Dict[str, str]:
    """Return the locations where the ZenML stack can be deployed.

    Returns:
        The regions where the ZenML stack can be deployed as a map of region
        names to region descriptions.
    """
    # Return a list of all possible AWS regions

    # Based on the AWS regions listed at
    # https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html
    return {
        "Africa (Cape Town)": "af-south-1",
        "Asia Pacific (Hong Kong)": "ap-east-1",
        "Asia Pacific (Hyderabad)": "ap-south-2",
        "Asia Pacific (Jakarta)": "ap-southeast-3",
        "Asia Pacific (Melbourne)": "ap-southeast-4",
        "Asia Pacific (Mumbai)": "ap-south-1",
        "Asia Pacific (Osaka)": "ap-northeast-3",
        "Asia Pacific (Seoul)": "ap-northeast-2",
        "Asia Pacific (Singapore)": "ap-southeast-1",
        "Asia Pacific (Sydney)": "ap-southeast-2",
        "Asia Pacific (Tokyo)": "ap-northeast-1",
        "Canada (Central)": "ca-central-1",
        "Canada West (Calgary)": "ca-west-1",
        "Europe (Frankfurt)": "eu-central-1",
        "Europe (Ireland)": "eu-west-1",
        "Europe (London)": "eu-west-2",
        "Europe (Milan)": "eu-south-1",
        "Europe (Paris)": "eu-west-3",
        "Europe (Spain)": "eu-south-2",
        "Europe (Stockholm)": "eu-north-1",
        "Europe (Zurich)": "eu-central-2",
        "Israel (Tel Aviv)": "il-central-1",
        "Middle East (Bahrain)": "me-south-1",
        "Middle East (UAE)": "me-central-1",
        "South America (São Paulo)": "sa-east-1",
        "US East (Ohio)": "us-east-2",
        "US East (N. Virginia)": "us-east-1",
        "US West (N. California)": "us-west-1",
        "US West (Oregon)": "us-west-2",
    }
permissions() -> Dict[str, List[str]] classmethod

Return the permissions granted to ZenML to access the cloud resources.

Returns:

Type Description
Dict[str, List[str]]

The permissions granted to ZenML to access the cloud resources, as
Dict[str, List[str]]

a dictionary grouping permissions by resource.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
@classmethod
def permissions(cls) -> Dict[str, List[str]]:
    """Return the permissions granted to ZenML to access the cloud resources.

    Returns:
        The permissions granted to ZenML to access the cloud resources, as
        a dictionary grouping permissions by resource.
    """
    return {
        "S3 Bucket": [
            "s3:ListBucket",
            "s3:GetObject",
            "s3:PutObject",
            "s3:DeleteObject",
            "s3:GetBucketVersioning",
            "s3:ListBucketVersions",
            "s3:DeleteObjectVersion",
        ],
        "ECR Repository": [
            "ecr:DescribeRepositories",
            "ecr:ListRepositories",
            "ecr:DescribeRegistry",
            "ecr:BatchGetImage",
            "ecr:DescribeImages",
            "ecr:BatchCheckLayerAvailability",
            "ecr:GetDownloadUrlForLayer",
            "ecr:InitiateLayerUpload",
            "ecr:UploadLayerPart",
            "ecr:CompleteLayerUpload",
            "ecr:PutImage",
            "ecr:GetAuthorizationToken",
        ],
        "CloudBuild (Client)": [
            "codebuild:CreateProject",
            "codebuild:BatchGetBuilds",
        ],
        "CloudBuild (Service)": [
            "s3:GetObject",
            "s3:GetObjectVersion",
            "logs:CreateLogGroup",
            "logs:CreateLogStream",
            "logs:PutLogEvents",
            "ecr:BatchGetImage",
            "ecr:DescribeImages",
            "ecr:BatchCheckLayerAvailability",
            "ecr:GetDownloadUrlForLayer",
            "ecr:InitiateLayerUpload",
            "ecr:UploadLayerPart",
            "ecr:CompleteLayerUpload",
            "ecr:PutImage",
            "ecr:GetAuthorizationToken",
        ],
        "SageMaker (Client)": [
            "sagemaker:CreatePipeline",
            "sagemaker:StartPipelineExecution",
            "sagemaker:DescribePipeline",
            "sagemaker:DescribePipelineExecution",
        ],
        "SageMaker (Jobs)": [
            "AmazonSageMakerFullAccess",
        ],
    }
post_deploy_instructions() -> str classmethod

Return instructions on what to do after the deployment is complete.

This will be displayed after the deployment is complete.

Returns:

Type Description
str

MarkDown instructions on what to do after the deployment is
str

complete.
Source code in src/zenml/stack_deployments/aws_stack_deployment.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
    @classmethod
    def post_deploy_instructions(cls) -> str:
        """Return instructions on what to do after the deployment is complete.

        This will be displayed after the deployment is complete.

        Returns:
            MarkDown instructions on what to do after the deployment is
            complete.
        """
        return """
The ZenML stack has been successfully deployed and registered. You can delete
the CloudFormation at any time to revoke ZenML's access to your AWS account and
to clean up the resources created by the stack by using the AWS CloudFormation
console.
"""
Functions

azure_stack_deployment

Functionality to deploy a ZenML stack to Azure.

Classes
AZUREZenMLCloudStackDeployment

Bases: ZenMLCloudStackDeployment

Azure ZenML Cloud Stack Deployment.

Functions
description() -> str classmethod

Return a description of the ZenML Cloud Stack Deployment.

This will be displayed when the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

A MarkDown description of the ZenML Cloud Stack Deployment.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
    @classmethod
    def description(cls) -> str:
        """Return a description of the ZenML Cloud Stack Deployment.

        This will be displayed when the user is prompted to deploy
        the ZenML stack.

        Returns:
            A MarkDown description of the ZenML Cloud Stack Deployment.
        """
        return """
Provision and register a basic Azure ZenML stack authenticated and connected to
all the necessary cloud infrastructure resources required to run pipelines in
Azure.
"""
get_deployment_config() -> StackDeploymentConfig

Return the configuration to deploy the ZenML stack to the specified cloud provider.

The configuration should include:

  • a cloud provider console URL where the user will be redirected to deploy the ZenML stack. The URL should include as many pre-filled URL query parameters as possible.
  • a textual description of the URL
  • some deployment providers may require additional configuration parameters or scripts to be passed to the cloud provider in addition to the deployment URL query parameters. Where that is the case, this method should also return a string that the user can copy and paste into the cloud provider console to deploy the ZenML stack (e.g. a set of environment variables, YAML configuration snippet, bash or Terraform script etc.).

Returns:

Type Description
StackDeploymentConfig

The configuration or script to deploy the ZenML stack to the
StackDeploymentConfig

specified cloud provider.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
    def get_deployment_config(
        self,
    ) -> StackDeploymentConfig:
        """Return the configuration to deploy the ZenML stack to the specified cloud provider.

        The configuration should include:

        * a cloud provider console URL where the user will be redirected to
        deploy the ZenML stack. The URL should include as many pre-filled
        URL query parameters as possible.
        * a textual description of the URL
        * some deployment providers may require additional configuration
        parameters or scripts to be passed to the cloud provider in addition to
        the deployment URL query parameters. Where that is the case, this method
        should also return a string that the user can copy and paste into the
        cloud provider console to deploy the ZenML stack (e.g. a set of
        environment variables, YAML configuration snippet, bash or Terraform
        script etc.).

        Returns:
            The configuration or script to deploy the ZenML stack to the
            specified cloud provider.
        """
        config = f"""terraform {{
    required_providers {{
        azurerm = {{
            source  = "hashicorp/azurerm"
        }}
        azuread = {{
            source  = "hashicorp/azuread"
        }}
        zenml = {{
            source = "zenml-io/zenml"
            version = "{TERRAFORM_PROVIDER_VERSION_SPEC}"
        }}
    }}
}}

provider "azurerm" {{
    features {{
        resource_group {{
            prevent_deletion_if_contains_resources = false
        }}
    }}
}}

provider "zenml" {{
    server_url = "{self.zenml_server_url}"
    api_token = "{self.zenml_server_api_token}"
}}

module "zenml_stack" {{
    source  = "zenml-io/zenml-stack/azure"
    version = "{TERRAFORM_AZURE_MODULE_VERSION_SPEC}"

    location = "{self.location or "eastus"}"
    zenml_stack_name = "{self.stack_name}"
    zenml_stack_deployment = "{self.deployment_type}"
}}
output "zenml_stack_id" {{
    value = module.zenml_stack.zenml_stack_id
}}
output "zenml_stack_name" {{
    value = module.zenml_stack.zenml_stack_name
}}"""
        instructions = """
1. The Azure Cloud Shell console will open in your browser.
2. Create a file named `main.tf` in the Cloud Shell and copy and paste the
Terraform configuration below into it.
3. Run `terraform init --upgrade` to initialize the Terraform configuration.
4. Run `terraform apply` to deploy the ZenML stack to Azure.
"""

        return StackDeploymentConfig(
            deployment_url="https://shell.azure.com",
            deployment_url_text="Azure Cloud Shell Console",
            configuration=config,
            instructions=instructions,
        )
instructions() -> str classmethod

Return instructions on how to deploy the ZenML stack to the specified cloud provider.

This will be displayed before the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

MarkDown instructions on how to deploy the ZenML stack to the
str

specified cloud provider.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
    @classmethod
    def instructions(cls) -> str:
        """Return instructions on how to deploy the ZenML stack to the specified cloud provider.

        This will be displayed before the user is prompted to deploy the ZenML
        stack.

        Returns:
            MarkDown instructions on how to deploy the ZenML stack to the
            specified cloud provider.
        """
        return """
You will be redirected to an Azure Cloud Shell console in your browser where
you'll be asked to log into your Azure project and then use
[the Azure ZenML Stack Terraform module](https://registry.terraform.io/modules/zenml-io/zenml-stack/azure)
to provision the necessary cloud resources for ZenML.

**NOTE**: The Azure ZenML Stack Terraform module will create the following new
resources in your Azure subscription. Please ensure you have the necessary
permissions and are aware of any potential costs:

- An Azure Resource Group to contain all the resources required for the ZenML stack
- An Azure Storage Account and Blob Storage Container registered as a [ZenML artifact store](https://docs.zenml.io/stack-components/artifact-stores/azure).
- An Azure Container Registry registered as a [ZenML container registry](https://docs.zenml.io/stack-components/container-registries/azure).
- An AzureML Workspace registered as both a [ZenML orchestrator](https://docs.zenml.io/stack-components/orchestrators/azureml) and a
[ZenML step operator](https://docs.zenml.io/stack-components/step-operators/azureml) and used to run pipelines.
A Key Vault and Application Insights instance will also be created in the same Resource Group and used to construct the AzureML Workspace.
- An Azure Service Principal with the minimum necessary permissions to access
the above resources.
- An Azure Service Principal client secret used to give access to ZenML to
connect to the above resources through a [ZenML service connector](https://docs.zenml.io/how-to/auth-management/azure-service-connector).

The Azure ZenML Stack Terraform module will automatically create an Azure
Service Principal client secret and will share it with ZenML to give it
permission to access the resources created by the stack. You can revoke these
permissions at any time by deleting the Service Principal in your Azure
subscription.

**Estimated costs**

A small training job would cost around: $0.60

These are rough estimates and actual costs may vary based on your usage and specific Azure pricing. 
Some services may be eligible for the Azure Free Tier. Use [the Azure Pricing Calculator](https://azure.microsoft.com/en-us/pricing/calculator)
for a detailed estimate based on your usage.


💡 **After the Terraform deployment is complete, you can close the Cloud
Shell session and return to the CLI to view details about the associated ZenML
stack automatically registered with ZenML.**
"""
integrations() -> List[str] classmethod

Return the ZenML integrations required for the stack.

Returns:

Type Description
List[str]

The list of ZenML integrations that need to be installed for the
List[str]

stack to be usable.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
120
121
122
123
124
125
126
127
128
@classmethod
def integrations(cls) -> List[str]:
    """Return the ZenML integrations required for the stack.

    Returns:
        The list of ZenML integrations that need to be installed for the
        stack to be usable.
    """
    return ["azure"]
locations() -> Dict[str, str] classmethod

Return the locations where the ZenML stack can be deployed.

Returns:

Type Description
Dict[str, str]

The regions where the ZenML stack can be deployed as a map of region
Dict[str, str]

names to region descriptions.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
@classmethod
def locations(cls) -> Dict[str, str]:
    """Return the locations where the ZenML stack can be deployed.

    Returns:
        The regions where the ZenML stack can be deployed as a map of region
        names to region descriptions.
    """
    # Based on `az account list-locations -o table` on 16.07.2024
    return {
        "(Africa) South Africa North": "southafricanorth",
        "(Africa) South Africa West": "southafricawest",
        "(Asia Pacific) Australia Central": "australiacentral",
        "(Asia Pacific) Australia Central 2": "australiacentral2",
        "(Asia Pacific) Australia East": "australiaeast",
        "(Asia Pacific) Australia Southeast": "australiasoutheast",
        "(Asia Pacific) Central India": "centralindia",
        "(Asia Pacific) East Asia": "eastasia",
        "(Asia Pacific) East Asia (Stage)": "eastasiastage",
        "(Asia Pacific) Japan East": "japaneast",
        "(Asia Pacific) Japan West": "japanwest",
        "(Asia Pacific) Jio India Central": "jioindiacentral",
        "(Asia Pacific) Jio India West": "jioindiawest",
        "(Asia Pacific) Korea Central": "koreacentral",
        "(Asia Pacific) Korea South": "koreasouth",
        "(Asia Pacific) South India": "southindia",
        "(Asia Pacific) Southeast Asia": "southeastasia",
        "(Asia Pacific) Southeast Asia (Stage)": "southeastasiastage",
        "(Asia Pacific) West India": "westindia",
        "(Canada) Canada Central": "canadacentral",
        "(Canada) Canada East": "canadaeast",
        "(Europe) France Central": "francecentral",
        "(Europe) France South": "francesouth",
        "(Europe) Germany North": "germanynorth",
        "(Europe) Germany West Central": "germanywestcentral",
        "(Europe) Italy North": "italynorth",
        "(Europe) North Europe": "northeurope",
        "(Europe) Norway East": "norwayeast",
        "(Europe) Norway West": "norwaywest",
        "(Europe) Poland Central": "polandcentral",
        "(Europe) Spain Central": "spaincentral",
        "(Europe) Sweden Central": "swedencentral",
        "(Europe) Switzerland North": "switzerlandnorth",
        "(Europe) Switzerland West": "switzerlandwest",
        "(Europe) UK South": "uksouth",
        "(Europe) UK West": "ukwest",
        "(Europe) West Europe": "westeurope",
        "(Mexico) Mexico Central": "mexicocentral",
        "(Middle East) Israel Central": "israelcentral",
        "(Middle East) Qatar Central": "qatarcentral",
        "(Middle East) UAE Central": "uaecentral",
        "(Middle East) UAE North": "uaenorth",
        "(South America) Brazil South": "brazilsouth",
        "(South America) Brazil Southeast": "brazilsoutheast",
        "(South America) Brazil US": "brazilus",
        "(US) Central US": "centralus",
        "(US) Central US (Stage)": "centralusstage",
        "(US) Central US EUAP": "centraluseuap",
        "(US) East US": "eastus",
        "(US) East US (Stage)": "eastusstage",
        "(US) East US 2": "eastus2",
        "(US) East US 2 (Stage)": "eastus2stage",
        "(US) East US 2 EUAP": "eastus2euap",
        "(US) East US STG": "eastusstg",
        "(US) North Central US": "northcentralus",
        "(US) North Central US (Stage)": "northcentralusstage",
        "(US) South Central US": "southcentralus",
        "(US) South Central US (Stage)": "southcentralusstage",
        "(US) West Central US": "westcentralus",
        "(US) West US": "westus",
        "(US) West US (Stage)": "westusstage",
        "(US) West US 2": "westus2",
        "(US) West US 2 (Stage)": "westus2stage",
        "(US) West US 3": "westus3",
    }
permissions() -> Dict[str, List[str]] classmethod

Return the permissions granted to ZenML to access the cloud resources.

Returns:

Type Description
Dict[str, List[str]]

The permissions granted to ZenML to access the cloud resources, as
Dict[str, List[str]]

a dictionary grouping permissions by resource.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
@classmethod
def permissions(cls) -> Dict[str, List[str]]:
    """Return the permissions granted to ZenML to access the cloud resources.

    Returns:
        The permissions granted to ZenML to access the cloud resources, as
        a dictionary grouping permissions by resource.
    """
    return {
        "Storage Account": [
            "Storage Blob Data Contributor",
        ],
        "Container Registry": [
            "AcrPull",
            "AcrPush",
            "Contributor",
        ],
        "AzureML Workspace": [
            "AzureML Compute Operator",
            "AzureML Data Scientist",
        ],
    }
post_deploy_instructions() -> str classmethod

Return instructions on what to do after the deployment is complete.

This will be displayed after the deployment is complete.

Returns:

Type Description
str

MarkDown instructions on what to do after the deployment is
str

complete.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
    @classmethod
    def post_deploy_instructions(cls) -> str:
        """Return instructions on what to do after the deployment is complete.

        This will be displayed after the deployment is complete.

        Returns:
            MarkDown instructions on what to do after the deployment is
            complete.
        """
        return """
The ZenML stack has been successfully deployed and registered. You can delete
the provisioned Service Principal and Resource Group at any time to revoke
ZenML's access to your Azure subscription.
"""
skypilot_default_regions() -> Dict[str, str] classmethod

Returns the regions supported by default for the Skypilot.

Returns:

Type Description
Dict[str, str]

The regions supported by default for the Skypilot.
Source code in src/zenml/stack_deployments/azure_stack_deployment.py 
229
230
231
232
233
234
235
236
237
238
239
240
241
@classmethod
def skypilot_default_regions(cls) -> Dict[str, str]:
    """Returns the regions supported by default for the Skypilot.

    Returns:
        The regions supported by default for the Skypilot.
    """
    matcher = re.compile(r".*us\d*( |$)")
    return {
        k: v
        for k, v in cls.locations().items()
        if "(US)" in k and matcher.match(v)
    }

constants

Constants for the stack deployments.

gcp_stack_deployment

Functionality to deploy a ZenML stack to GCP.

Classes
GCPZenMLCloudStackDeployment

Bases: ZenMLCloudStackDeployment

GCP ZenML Cloud Stack Deployment.

Functions
description() -> str classmethod

Return a description of the ZenML Cloud Stack Deployment.

This will be displayed when the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

A MarkDown description of the ZenML Cloud Stack Deployment.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    @classmethod
    def description(cls) -> str:
        """Return a description of the ZenML Cloud Stack Deployment.

        This will be displayed when the user is prompted to deploy
        the ZenML stack.

        Returns:
            A MarkDown description of the ZenML Cloud Stack Deployment.
        """
        return """
Provision and register a basic GCP ZenML stack authenticated and connected to
all the necessary cloud infrastructure resources required to run pipelines in
GCP.
"""
get_deployment_config() -> StackDeploymentConfig

Return the configuration to deploy the ZenML stack to the specified cloud provider.

The configuration should include:

  • a cloud provider console URL where the user will be redirected to deploy the ZenML stack. The URL should include as many pre-filled URL query parameters as possible.
  • a textual description of the URL
  • some deployment providers may require additional configuration parameters or scripts to be passed to the cloud provider in addition to the deployment URL query parameters. Where that is the case, this method should also return a string that the user can copy and paste into the cloud provider console to deploy the ZenML stack (e.g. a set of environment variables, YAML configuration snippet, bash or Terraform script etc.).

Returns:

Type Description
StackDeploymentConfig

The configuration or script to deploy the ZenML stack to the
StackDeploymentConfig

specified cloud provider.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
    def get_deployment_config(
        self,
    ) -> StackDeploymentConfig:
        """Return the configuration to deploy the ZenML stack to the specified cloud provider.

        The configuration should include:

        * a cloud provider console URL where the user will be redirected to
        deploy the ZenML stack. The URL should include as many pre-filled
        URL query parameters as possible.
        * a textual description of the URL
        * some deployment providers may require additional configuration
        parameters or scripts to be passed to the cloud provider in addition to
        the deployment URL query parameters. Where that is the case, this method
        should also return a string that the user can copy and paste into the
        cloud provider console to deploy the ZenML stack (e.g. a set of
        environment variables, YAML configuration snippet, bash or Terraform
        script etc.).

        Returns:
            The configuration or script to deploy the ZenML stack to the
            specified cloud provider.
        """
        params = dict(
            cloudshell_git_repo="https://github.com/zenml-io/zenml",
            cloudshell_workspace="infra/gcp",
            cloudshell_open_in_editor="gcp-gar-gcs-vertex.jinja,gcp-gar-gcs-vertex-deploy.sh",
            cloudshell_tutorial="gcp-gar-gcs-vertex.md",
            ephemeral="true",
        )
        # Encode the parameters as URL query parameters
        query_params = "&".join([f"{k}={v}" for k, v in params.items()])
        url = (
            f"https://shell.cloud.google.com/cloudshell/editor?{query_params}"
        )

        if self.deployment_type == STACK_DEPLOYMENT_TERRAFORM:
            config = f"""terraform {{
    required_providers {{
        google = {{
            source  = "hashicorp/google"
        }}
        zenml = {{
            source = "zenml-io/zenml"
            version = "{TERRAFORM_PROVIDER_VERSION_SPEC}"
        }}
    }}
}}

provider "google" {{
    region  = "{self.location or "europe-west3"}"
    project = your GCP project name
}}

provider "zenml" {{
    server_url = "{self.zenml_server_url}"
    api_token = "{self.zenml_server_api_token}"
}}

module "zenml_stack" {{
    source  = "zenml-io/zenml-stack/gcp"
    version = "{TERRAFORM_GCP_MODULE_VERSION_SPEC}"

    zenml_stack_name = "{self.stack_name}"
    zenml_stack_deployment = "{self.deployment_type}"
}}
output "zenml_stack_id" {{
    value = module.zenml_stack.zenml_stack_id
}}
output "zenml_stack_name" {{
    value = module.zenml_stack.zenml_stack_name
}}"""
        else:
            config = f"""
### BEGIN CONFIGURATION ###
ZENML_STACK_NAME={self.stack_name}
ZENML_STACK_REGION={self.location or "europe-west3"}
ZENML_SERVER_URL={self.zenml_server_url}
ZENML_SERVER_API_TOKEN={self.zenml_server_api_token}
### END CONFIGURATION ###"""

        instructions = (
            "You will be asked to provide the following configuration values "
            "during the deployment process:"
        )

        return StackDeploymentConfig(
            deployment_url=url,
            deployment_url_text="GCP Cloud Shell Console",
            configuration=config,
            instructions=instructions,
        )
instructions() -> str classmethod

Return instructions on how to deploy the ZenML stack to the specified cloud provider.

This will be displayed before the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

MarkDown instructions on how to deploy the ZenML stack to the
str

specified cloud provider.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
    @classmethod
    def instructions(cls) -> str:
        """Return instructions on how to deploy the ZenML stack to the specified cloud provider.

        This will be displayed before the user is prompted to deploy the ZenML
        stack.

        Returns:
            MarkDown instructions on how to deploy the ZenML stack to the
            specified cloud provider.
        """
        return """
You will be redirected to a GCP Cloud Shell console in your browser where you'll
be asked to log into your GCP project and then create a Deployment Manager
deployment to provision the necessary cloud resources for ZenML.

**NOTE**: The Deployment Manager deployment will create the following new
resources in your GCP project. Please ensure you have the necessary permissions
and are aware of any potential costs:

- A GCS bucket registered as a [ZenML artifact store](https://docs.zenml.io/stack-components/artifact-stores/gcp).
- A Google Artifact Registry registered as a [ZenML container registry](https://docs.zenml.io/stack-components/container-registries/gcp).
- Vertex AI registered as a [ZenML orchestrator](https://docs.zenml.io/stack-components/orchestrators/vertex)
and as a [ZenML step operator](https://docs.zenml.io/stack-components/step-operators/vertex).
- GCP Cloud Build registered as a [ZenML image builder](https://docs.zenml.io/stack-components/image-builders/gcp).
- A GCP Service Account with the minimum necessary permissions to access the
above resources.
- A GCP Service Account access key used to give access to ZenML to connect to
the above resources through a [ZenML service connector](https://docs.zenml.io/how-to/auth-management/gcp-service-connector).

The Deployment Manager deployment will automatically create a GCP Service
Account secret key and will share it with ZenML to give it permission to access
the resources created by the stack. You can revoke these permissions at any time
by deleting the Deployment Manager deployment in the GCP Cloud Console.

**Estimated costs**

A small training job would cost around: $0.60

These are rough estimates and actual costs may vary based on your usage and specific GCP pricing. 
Some services may be eligible for the GCP Free Tier. Use [the GCP Pricing Calculator](https://cloud.google.com/products/calculator)
for a detailed estimate based on your usage.

⚠️  **The Cloud Shell session will warn you that the ZenML GitHub repository is
untrusted. We recommend that you review [the contents of the repository](https://github.com/zenml-io/zenml/tree/main/infra/gcp)
and then check the `Trust repo` checkbox to proceed with the deployment,
otherwise the Cloud Shell session will not be authenticated to access your
GCP projects. You will also get a chance to review the scripts that will be
executed in the Cloud Shell session before proceeding.**

💡 **After the Deployment Manager deployment is complete, you can close the Cloud
Shell session and return to the CLI to view details about the associated ZenML
stack automatically registered with ZenML.**
"""
integrations() -> List[str] classmethod

Return the ZenML integrations required for the stack.

Returns:

Type Description
List[str]

The list of ZenML integrations that need to be installed for the
List[str]

stack to be usable.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
127
128
129
130
131
132
133
134
135
136
137
@classmethod
def integrations(cls) -> List[str]:
    """Return the ZenML integrations required for the stack.

    Returns:
        The list of ZenML integrations that need to be installed for the
        stack to be usable.
    """
    return [
        "gcp",
    ]
locations() -> Dict[str, str] classmethod

Return the locations where the ZenML stack can be deployed.

Returns:

Type Description
Dict[str, str]

The regions where the ZenML stack can be deployed as a map of region
Dict[str, str]

names to region descriptions.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
@classmethod
def locations(cls) -> Dict[str, str]:
    """Return the locations where the ZenML stack can be deployed.

    Returns:
        The regions where the ZenML stack can be deployed as a map of region
        names to region descriptions.
    """
    # Return a list of all possible GCP regions

    # Based on the AWS regions listed at
    # https://cloud.google.com/about/locations
    return {
        "Africa (Johannesburg)": "africa-south1",
        "Asia Pacific (Taiwan)": "asia-east1",
        "Asia Pacific (Hong Kong)": "asia-east2",
        "Asia Pacific (Tokyo)": "asia-northeast1",
        "Asia Pacific (Osaka)": "asia-northeast2",
        "Asia Pacific (Seoul)": "asia-northeast3",
        "Asia Pacific (Mumbai)": "asia-south1",
        "Asia Pacific (Delhi)": "asia-south2",
        "Asia Pacific (Singapore)": "asia-southeast1",
        "Asia Pacific (Jakarta)": "asia-southeast2",
        "Australia (Sydney)": "australia-southeast1",
        "Australia (Melbourne)": "australia-southeast2",
        "Europe (Belgium)": "europe-west1",
        "Europe (London)": "europe-west2",
        "Europe (Frankfurt)": "europe-west3",
        "Europe (Netherlands)": "europe-west4",
        "Europe (Zurich)": "europe-west6",
        "Europe (Milan)": "europe-west8",
        "Europe (Paris)": "europe-west9",
        "Europe (Berlin)": "europe-west10",
        "Europe (Turin)": "europe-west12",
        "Europe (Warsaw)": "europe-central2",
        "Europe (Finland)": "europe-north1",
        "Europe (Madrid)": "europe-southwest1",
        "Middle East (Doha)": "me-central1",
        "Middle East (Dubai)": "me-central2",
        "Middle East (Tel Aviv)": "me-west1",
        "North America (Montreal)": "northamerica-northeast1",
        "North America (Toronto)": "northamerica-northeast2",
        "South America (Sao Paulo)": "southamerica-east1",
        "South America (Santiago)": "southamerica-west1",
        "US Central (Iowa)": "us-central1",
        "US East (South Carolina)": "us-east1",
        "US East (Northern Virginia)": "us-east4",
        "US East (Columbus)": "us-east5",
        "US South (Dallas)": "us-south1",
        "US West (Oregon)": "us-west1",
        "US West (Los Angeles)": "us-west2",
        "US West (Salt Lake City)": "us-west3",
        "US West (Las Vegas)": "us-west4",
    }
permissions() -> Dict[str, List[str]] classmethod

Return the permissions granted to ZenML to access the cloud resources.

Returns:

Type Description
Dict[str, List[str]]

The permissions granted to ZenML to access the cloud resources, as
Dict[str, List[str]]

a dictionary grouping permissions by resource.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
@classmethod
def permissions(cls) -> Dict[str, List[str]]:
    """Return the permissions granted to ZenML to access the cloud resources.

    Returns:
        The permissions granted to ZenML to access the cloud resources, as
        a dictionary grouping permissions by resource.
    """
    return {
        "GCS Bucket": [
            "roles/storage.objectUser",
        ],
        "GCP Artifact Registry": [
            "roles/artifactregistry.createOnPushWriter",
        ],
        "Vertex AI (Client)": [
            "roles/aiplatform.user",
        ],
        "Vertex AI (Jobs)": [
            "roles/aiplatform.serviceAgent",
        ],
        "Cloud Build (Client)": [
            "roles/cloudbuild.builds.editor",
        ],
    }
post_deploy_instructions() -> str classmethod

Return instructions on what to do after the deployment is complete.

This will be displayed after the deployment is complete.

Returns:

Type Description
str

MarkDown instructions on what to do after the deployment is
str

complete.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
    @classmethod
    def post_deploy_instructions(cls) -> str:
        """Return instructions on what to do after the deployment is complete.

        This will be displayed after the deployment is complete.

        Returns:
            MarkDown instructions on what to do after the deployment is
            complete.
        """
        return """
The ZenML stack has been successfully deployed and registered. You can delete
the Deployment Manager deployment at any time to revoke ZenML's access to your
GCP project and to clean up the resources created by the stack by using
[the GCP Cloud Console](https://console.cloud.google.com/dm/deployments).
"""
skypilot_default_regions() -> Dict[str, str] classmethod

Returns the regions supported by default for the Skypilot.

Returns:

Type Description
Dict[str, str]

The regions supported by default for the Skypilot.
Source code in src/zenml/stack_deployments/gcp_stack_deployment.py 
220
221
222
223
224
225
226
227
228
@classmethod
def skypilot_default_regions(cls) -> Dict[str, str]:
    """Returns the regions supported by default for the Skypilot.

    Returns:
        The regions supported by default for the Skypilot.
    """
    matcher = re.compile(r"us-.*")
    return {k: v for k, v in cls.locations().items() if matcher.match(v)}

stack_deployment

Functionality to deploy a ZenML stack to a cloud provider.

Classes
ZenMLCloudStackDeployment

Bases: BaseModel

ZenML Cloud Stack CLI Deployment base class.

Attributes
deployment_type: str property

Return the type of deployment.

Returns:

Type Description
str

The type of deployment.
Functions
description() -> str abstractmethod classmethod

Return a description of the ZenML Cloud Stack Deployment.

This will be displayed when the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

A MarkDown description of the ZenML Cloud Stack Deployment.
Source code in src/zenml/stack_deployments/stack_deployment.py 
45
46
47
48
49
50
51
52
53
54
55
@classmethod
@abstractmethod
def description(cls) -> str:
    """Return a description of the ZenML Cloud Stack Deployment.

    This will be displayed when the user is prompted to deploy
    the ZenML stack.

    Returns:
        A MarkDown description of the ZenML Cloud Stack Deployment.
    """
get_deployment_config() -> StackDeploymentConfig abstractmethod

Return the configuration to deploy the ZenML stack to the specified cloud provider.

The configuration should include:

  • a cloud provider console URL where the user will be redirected to deploy the ZenML stack. The URL should include as many pre-filled URL query parameters as possible.
  • a textual description of the URL
  • some deployment providers may require additional configuration parameters or scripts to be passed to the cloud provider in addition to the deployment URL query parameters. Where that is the case, this method should also return a string that the user can copy and paste into the cloud provider console to deploy the ZenML stack (e.g. a set of environment variables, YAML configuration snippet, bash or Terraform script etc.).

Returns:

Type Description
StackDeploymentConfig

The configuration or script to deploy the ZenML stack to the
StackDeploymentConfig

specified cloud provider.
Source code in src/zenml/stack_deployments/stack_deployment.py 
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
@abstractmethod
def get_deployment_config(
    self,
) -> StackDeploymentConfig:
    """Return the configuration to deploy the ZenML stack to the specified cloud provider.

    The configuration should include:

    * a cloud provider console URL where the user will be redirected to
    deploy the ZenML stack. The URL should include as many pre-filled
    URL query parameters as possible.
    * a textual description of the URL
    * some deployment providers may require additional configuration
    parameters or scripts to be passed to the cloud provider in addition to
    the deployment URL query parameters. Where that is the case, this method
    should also return a string that the user can copy and paste into the
    cloud provider console to deploy the ZenML stack (e.g. a set of
    environment variables, YAML configuration snippet, bash or Terraform
    script etc.).

    Returns:
        The configuration or script to deploy the ZenML stack to the
        specified cloud provider.
    """
get_deployment_info() -> StackDeploymentInfo classmethod

Return information about the ZenML Cloud Stack Deployment.

Returns:

Type Description
StackDeploymentInfo

Information about the ZenML Cloud Stack Deployment.
Source code in src/zenml/stack_deployments/stack_deployment.py 
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
@classmethod
def get_deployment_info(cls) -> StackDeploymentInfo:
    """Return information about the ZenML Cloud Stack Deployment.

    Returns:
        Information about the ZenML Cloud Stack Deployment.
    """
    return StackDeploymentInfo(
        provider=cls.provider,
        description=cls.description(),
        instructions=cls.instructions(),
        post_deploy_instructions=cls.post_deploy_instructions(),
        integrations=cls.integrations(),
        permissions=cls.permissions(),
        locations=cls.locations(),
        skypilot_default_regions=cls.skypilot_default_regions(),
    )
get_stack(date_start: Optional[datetime.datetime] = None) -> Optional[DeployedStack]

Return the ZenML stack that was deployed and registered.

This method is called to retrieve a ZenML stack matching the deployment provider.

Parameters:

Name Type Description Default
date_start Optional[datetime]

The date when the deployment started.

 None

Returns:

Type Description
Optional[DeployedStack]

The ZenML stack that was deployed and registered or None if a
Optional[DeployedStack]

matching stack was not found.
Source code in src/zenml/stack_deployments/stack_deployment.py 
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
def get_stack(
    self,
    date_start: Optional[datetime.datetime] = None,
) -> Optional[DeployedStack]:
    """Return the ZenML stack that was deployed and registered.

    This method is called to retrieve a ZenML stack matching the deployment
    provider.

    Args:
        date_start: The date when the deployment started.

    Returns:
        The ZenML stack that was deployed and registered or None if a
        matching stack was not found.
    """
    client = Client()

    # It's difficult to find a stack that matches the CloudFormation
    # deployment 100% because the user can change the stack name before they
    # deploy the stack in GCP.
    #
    # We try to find a full GCP stack that matches the deployment provider
    # that was registered after this deployment was created.

    # Get all stacks created after the start date

    if date_start and date_start.tzinfo:
        date_start = to_utc_timezone(date_start).replace(tzinfo=None)
    stacks = client.list_stacks(
        created=f"gt:{str(date_start.replace(microsecond=0))}"
        if date_start
        else None,
        sort_by="desc:created",
        size=50,
    )

    if not stacks.items:
        return None

    # Find a stack that best matches the deployment provider
    for stack in stacks.items:
        if not stack.labels:
            continue

        if stack.labels.get("zenml:provider") != self.provider.value:
            continue

        if stack.labels.get("zenml:deployment") != self.deployment_type:
            continue

        orchestrator = stack.components[StackComponentType.ORCHESTRATOR][0]

        if not orchestrator.connector:
            continue

        return DeployedStack(
            stack=stack,
            service_connector=orchestrator.connector,
        )

    return None
instructions() -> str abstractmethod classmethod

Return instructions on how to deploy the ZenML stack to the specified cloud provider.

This will be displayed before the user is prompted to deploy the ZenML stack.

Returns:

Type Description
str

MarkDown instructions on how to deploy the ZenML stack to the
str

specified cloud provider.
Source code in src/zenml/stack_deployments/stack_deployment.py 
57
58
59
60
61
62
63
64
65
66
67
68
@classmethod
@abstractmethod
def instructions(cls) -> str:
    """Return instructions on how to deploy the ZenML stack to the specified cloud provider.

    This will be displayed before the user is prompted to deploy the ZenML
    stack.

    Returns:
        MarkDown instructions on how to deploy the ZenML stack to the
        specified cloud provider.
    """
integrations() -> List[str] abstractmethod classmethod

Return the ZenML integrations required for the stack.

Returns:

Type Description
List[str]

The list of ZenML integrations that need to be installed for the
List[str]

stack to be usable.
Source code in src/zenml/stack_deployments/stack_deployment.py 
82
83
84
85
86
87
88
89
90
@classmethod
@abstractmethod
def integrations(cls) -> List[str]:
    """Return the ZenML integrations required for the stack.

    Returns:
        The list of ZenML integrations that need to be installed for the
        stack to be usable.
    """
locations() -> Dict[str, str] abstractmethod classmethod

Return the locations where the ZenML stack can be deployed.

Returns:

Type Description
Dict[str, str]

The regions where the ZenML stack can be deployed as a map of region
Dict[str, str]

names to region descriptions.
Source code in src/zenml/stack_deployments/stack_deployment.py 
102
103
104
105
106
107
108
109
110
@classmethod
@abstractmethod
def locations(cls) -> Dict[str, str]:
    """Return the locations where the ZenML stack can be deployed.

    Returns:
        The regions where the ZenML stack can be deployed as a map of region
        names to region descriptions.
    """
permissions() -> Dict[str, List[str]] abstractmethod classmethod

Return the permissions granted to ZenML to access the cloud resources.

Returns:

Type Description
Dict[str, List[str]]

The permissions granted to ZenML to access the cloud resources, as
Dict[str, List[str]]

a dictionary grouping permissions by resource.
Source code in src/zenml/stack_deployments/stack_deployment.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
@classmethod
@abstractmethod
def permissions(cls) -> Dict[str, List[str]]:
    """Return the permissions granted to ZenML to access the cloud resources.

    Returns:
        The permissions granted to ZenML to access the cloud resources, as
        a dictionary grouping permissions by resource.
    """
post_deploy_instructions() -> str abstractmethod classmethod

Return instructions on what to do after the deployment is complete.

This will be displayed after the deployment is complete.

Returns:

Type Description
str

MarkDown instructions on what to do after the deployment is
str

complete.
Source code in src/zenml/stack_deployments/stack_deployment.py 
70
71
72
73
74
75
76
77
78
79
80
@classmethod
@abstractmethod
def post_deploy_instructions(cls) -> str:
    """Return instructions on what to do after the deployment is complete.

    This will be displayed after the deployment is complete.

    Returns:
        MarkDown instructions on what to do after the deployment is
        complete.
    """
skypilot_default_regions() -> Dict[str, str] classmethod

Returns the regions supported by default for the Skypilot.

Returns:

Type Description
Dict[str, str]

The regions supported by default for the Skypilot.
Source code in src/zenml/stack_deployments/stack_deployment.py 
123
124
125
126
127
128
129
130
@classmethod
def skypilot_default_regions(cls) -> Dict[str, str]:
    """Returns the regions supported by default for the Skypilot.

    Returns:
        The regions supported by default for the Skypilot.
    """
    return cls.locations()
Functions

utils

Functionality to deploy a ZenML stack to a cloud provider.

Classes
Functions
get_stack_deployment_class(provider: StackDeploymentProvider) -> Type[ZenMLCloudStackDeployment]

Get the ZenML Cloud Stack Deployment class for the specified provider.

Parameters:

Name Type Description Default
provider StackDeploymentProvider

The stack deployment provider.

 required

Returns:

Type Description
Type[ZenMLCloudStackDeployment]

The ZenML Cloud Stack Deployment class for the specified provider.
Source code in src/zenml/stack_deployments/utils.py 
37
38
39
40
41
42
43
44
45
46
47
48
def get_stack_deployment_class(
    provider: StackDeploymentProvider,
) -> Type[ZenMLCloudStackDeployment]:
    """Get the ZenML Cloud Stack Deployment class for the specified provider.

    Args:
        provider: The stack deployment provider.

    Returns:
        The ZenML Cloud Stack Deployment class for the specified provider.
    """
    return STACK_DEPLOYMENT_PROVIDERS[provider]