2861 lines
121 KiB
Python
2861 lines
121 KiB
Python
# Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
|
||
|
||
from __future__ import annotations
|
||
|
||
import logging
|
||
import random
|
||
import time
|
||
from dataclasses import dataclass
|
||
from datetime import timedelta
|
||
from enum import Enum
|
||
from typing import Any, Callable, Dict, Iterator, List, Optional
|
||
|
||
from databricks.sdk.service._internal import (Wait, _enum, _from_dict,
|
||
_repeated_dict, _repeated_enum)
|
||
|
||
from ..errors import OperationFailed
|
||
|
||
_LOG = logging.getLogger("databricks.sdk")
|
||
|
||
|
||
# all definitions in this file are in alphabetical order
|
||
|
||
|
||
@dataclass
|
||
class AwsCredentials:
|
||
sts_role: Optional[StsRole] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the AwsCredentials into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.sts_role:
|
||
body["sts_role"] = self.sts_role.as_dict()
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the AwsCredentials into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.sts_role:
|
||
body["sts_role"] = self.sts_role
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> AwsCredentials:
|
||
"""Deserializes the AwsCredentials from a dictionary."""
|
||
return cls(sts_role=_from_dict(d, "sts_role", StsRole))
|
||
|
||
|
||
@dataclass
|
||
class AwsKeyInfo:
|
||
key_arn: str
|
||
"""The AWS KMS key's Amazon Resource Name (ARN)."""
|
||
|
||
key_region: str
|
||
"""The AWS KMS key region."""
|
||
|
||
key_alias: Optional[str] = None
|
||
"""The AWS KMS key alias."""
|
||
|
||
reuse_key_for_cluster_volumes: Optional[bool] = None
|
||
"""This field applies only if the `use_cases` property includes `STORAGE`. If this is set to true
|
||
or omitted, the key is also used to encrypt cluster EBS volumes. If you do not want to use this
|
||
key for encrypting EBS volumes, set to false."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the AwsKeyInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.key_alias is not None:
|
||
body["key_alias"] = self.key_alias
|
||
if self.key_arn is not None:
|
||
body["key_arn"] = self.key_arn
|
||
if self.key_region is not None:
|
||
body["key_region"] = self.key_region
|
||
if self.reuse_key_for_cluster_volumes is not None:
|
||
body["reuse_key_for_cluster_volumes"] = self.reuse_key_for_cluster_volumes
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the AwsKeyInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.key_alias is not None:
|
||
body["key_alias"] = self.key_alias
|
||
if self.key_arn is not None:
|
||
body["key_arn"] = self.key_arn
|
||
if self.key_region is not None:
|
||
body["key_region"] = self.key_region
|
||
if self.reuse_key_for_cluster_volumes is not None:
|
||
body["reuse_key_for_cluster_volumes"] = self.reuse_key_for_cluster_volumes
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> AwsKeyInfo:
|
||
"""Deserializes the AwsKeyInfo from a dictionary."""
|
||
return cls(
|
||
key_alias=d.get("key_alias", None),
|
||
key_arn=d.get("key_arn", None),
|
||
key_region=d.get("key_region", None),
|
||
reuse_key_for_cluster_volumes=d.get("reuse_key_for_cluster_volumes", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class AzureKeyInfo:
|
||
disk_encryption_set_id: Optional[str] = None
|
||
"""The Disk Encryption Set id that is used to represent the key info used for Managed Disk BYOK use
|
||
case"""
|
||
|
||
key_access_configuration: Optional[KeyAccessConfiguration] = None
|
||
"""The structure to store key access credential This is set if the Managed Identity is being used
|
||
to access the Azure Key Vault key."""
|
||
|
||
key_name: Optional[str] = None
|
||
"""The name of the key in KeyVault."""
|
||
|
||
key_vault_uri: Optional[str] = None
|
||
"""The base URI of the KeyVault."""
|
||
|
||
tenant_id: Optional[str] = None
|
||
"""The tenant id where the KeyVault lives."""
|
||
|
||
version: Optional[str] = None
|
||
"""The current key version."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the AzureKeyInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.disk_encryption_set_id is not None:
|
||
body["disk_encryption_set_id"] = self.disk_encryption_set_id
|
||
if self.key_access_configuration:
|
||
body["key_access_configuration"] = self.key_access_configuration.as_dict()
|
||
if self.key_name is not None:
|
||
body["key_name"] = self.key_name
|
||
if self.key_vault_uri is not None:
|
||
body["key_vault_uri"] = self.key_vault_uri
|
||
if self.tenant_id is not None:
|
||
body["tenant_id"] = self.tenant_id
|
||
if self.version is not None:
|
||
body["version"] = self.version
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the AzureKeyInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.disk_encryption_set_id is not None:
|
||
body["disk_encryption_set_id"] = self.disk_encryption_set_id
|
||
if self.key_access_configuration:
|
||
body["key_access_configuration"] = self.key_access_configuration
|
||
if self.key_name is not None:
|
||
body["key_name"] = self.key_name
|
||
if self.key_vault_uri is not None:
|
||
body["key_vault_uri"] = self.key_vault_uri
|
||
if self.tenant_id is not None:
|
||
body["tenant_id"] = self.tenant_id
|
||
if self.version is not None:
|
||
body["version"] = self.version
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> AzureKeyInfo:
|
||
"""Deserializes the AzureKeyInfo from a dictionary."""
|
||
return cls(
|
||
disk_encryption_set_id=d.get("disk_encryption_set_id", None),
|
||
key_access_configuration=_from_dict(d, "key_access_configuration", KeyAccessConfiguration),
|
||
key_name=d.get("key_name", None),
|
||
key_vault_uri=d.get("key_vault_uri", None),
|
||
tenant_id=d.get("tenant_id", None),
|
||
version=d.get("version", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class AzureWorkspaceInfo:
|
||
resource_group: Optional[str] = None
|
||
"""Azure Resource Group name"""
|
||
|
||
subscription_id: Optional[str] = None
|
||
"""Azure Subscription ID"""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the AzureWorkspaceInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.resource_group is not None:
|
||
body["resource_group"] = self.resource_group
|
||
if self.subscription_id is not None:
|
||
body["subscription_id"] = self.subscription_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the AzureWorkspaceInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.resource_group is not None:
|
||
body["resource_group"] = self.resource_group
|
||
if self.subscription_id is not None:
|
||
body["subscription_id"] = self.subscription_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> AzureWorkspaceInfo:
|
||
"""Deserializes the AzureWorkspaceInfo from a dictionary."""
|
||
return cls(resource_group=d.get("resource_group", None), subscription_id=d.get("subscription_id", None))
|
||
|
||
|
||
@dataclass
|
||
class CloudResourceContainer:
|
||
gcp: Optional[CustomerFacingGcpCloudResourceContainer] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CloudResourceContainer into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.gcp:
|
||
body["gcp"] = self.gcp.as_dict()
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CloudResourceContainer into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.gcp:
|
||
body["gcp"] = self.gcp
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CloudResourceContainer:
|
||
"""Deserializes the CloudResourceContainer from a dictionary."""
|
||
return cls(gcp=_from_dict(d, "gcp", CustomerFacingGcpCloudResourceContainer))
|
||
|
||
|
||
@dataclass
|
||
class CreateAwsKeyInfo:
|
||
key_arn: str
|
||
"""The AWS KMS key's Amazon Resource Name (ARN)."""
|
||
|
||
key_alias: Optional[str] = None
|
||
"""The AWS KMS key alias."""
|
||
|
||
key_region: Optional[str] = None
|
||
"""The AWS KMS key region."""
|
||
|
||
reuse_key_for_cluster_volumes: Optional[bool] = None
|
||
"""This field applies only if the `use_cases` property includes `STORAGE`. If this is set to true
|
||
or omitted, the key is also used to encrypt cluster EBS volumes. If you do not want to use this
|
||
key for encrypting EBS volumes, set to false."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CreateAwsKeyInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.key_alias is not None:
|
||
body["key_alias"] = self.key_alias
|
||
if self.key_arn is not None:
|
||
body["key_arn"] = self.key_arn
|
||
if self.key_region is not None:
|
||
body["key_region"] = self.key_region
|
||
if self.reuse_key_for_cluster_volumes is not None:
|
||
body["reuse_key_for_cluster_volumes"] = self.reuse_key_for_cluster_volumes
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CreateAwsKeyInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.key_alias is not None:
|
||
body["key_alias"] = self.key_alias
|
||
if self.key_arn is not None:
|
||
body["key_arn"] = self.key_arn
|
||
if self.key_region is not None:
|
||
body["key_region"] = self.key_region
|
||
if self.reuse_key_for_cluster_volumes is not None:
|
||
body["reuse_key_for_cluster_volumes"] = self.reuse_key_for_cluster_volumes
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CreateAwsKeyInfo:
|
||
"""Deserializes the CreateAwsKeyInfo from a dictionary."""
|
||
return cls(
|
||
key_alias=d.get("key_alias", None),
|
||
key_arn=d.get("key_arn", None),
|
||
key_region=d.get("key_region", None),
|
||
reuse_key_for_cluster_volumes=d.get("reuse_key_for_cluster_volumes", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class CreateCredentialAwsCredentials:
|
||
sts_role: Optional[CreateCredentialStsRole] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CreateCredentialAwsCredentials into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.sts_role:
|
||
body["sts_role"] = self.sts_role.as_dict()
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CreateCredentialAwsCredentials into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.sts_role:
|
||
body["sts_role"] = self.sts_role
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CreateCredentialAwsCredentials:
|
||
"""Deserializes the CreateCredentialAwsCredentials from a dictionary."""
|
||
return cls(sts_role=_from_dict(d, "sts_role", CreateCredentialStsRole))
|
||
|
||
|
||
@dataclass
|
||
class CreateCredentialStsRole:
|
||
role_arn: Optional[str] = None
|
||
"""The Amazon Resource Name (ARN) of the cross account IAM role."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CreateCredentialStsRole into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.role_arn is not None:
|
||
body["role_arn"] = self.role_arn
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CreateCredentialStsRole into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.role_arn is not None:
|
||
body["role_arn"] = self.role_arn
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CreateCredentialStsRole:
|
||
"""Deserializes the CreateCredentialStsRole from a dictionary."""
|
||
return cls(role_arn=d.get("role_arn", None))
|
||
|
||
|
||
@dataclass
|
||
class CreateGcpKeyInfo:
|
||
kms_key_id: str
|
||
"""Globally unique kms key resource id of the form
|
||
projects/testProjectId/locations/us-east4/keyRings/gcpCmkKeyRing/cryptoKeys/cmk-eastus4"""
|
||
|
||
gcp_service_account: Optional[GcpServiceAccount] = None
|
||
"""Globally unique service account email that has access to the KMS key. The service account exists
|
||
within the Databricks CP project."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CreateGcpKeyInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.gcp_service_account:
|
||
body["gcp_service_account"] = self.gcp_service_account.as_dict()
|
||
if self.kms_key_id is not None:
|
||
body["kms_key_id"] = self.kms_key_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CreateGcpKeyInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.gcp_service_account:
|
||
body["gcp_service_account"] = self.gcp_service_account
|
||
if self.kms_key_id is not None:
|
||
body["kms_key_id"] = self.kms_key_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CreateGcpKeyInfo:
|
||
"""Deserializes the CreateGcpKeyInfo from a dictionary."""
|
||
return cls(
|
||
gcp_service_account=_from_dict(d, "gcp_service_account", GcpServiceAccount),
|
||
kms_key_id=d.get("kms_key_id", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class Credential:
|
||
account_id: Optional[str] = None
|
||
"""The Databricks account ID that hosts the credential."""
|
||
|
||
aws_credentials: Optional[AwsCredentials] = None
|
||
|
||
creation_time: Optional[int] = None
|
||
"""Time in epoch milliseconds when the credential was created."""
|
||
|
||
credentials_id: Optional[str] = None
|
||
"""Databricks credential configuration ID."""
|
||
|
||
credentials_name: Optional[str] = None
|
||
"""The human-readable name of the credential configuration object."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the Credential into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_credentials:
|
||
body["aws_credentials"] = self.aws_credentials.as_dict()
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.credentials_id is not None:
|
||
body["credentials_id"] = self.credentials_id
|
||
if self.credentials_name is not None:
|
||
body["credentials_name"] = self.credentials_name
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the Credential into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_credentials:
|
||
body["aws_credentials"] = self.aws_credentials
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.credentials_id is not None:
|
||
body["credentials_id"] = self.credentials_id
|
||
if self.credentials_name is not None:
|
||
body["credentials_name"] = self.credentials_name
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> Credential:
|
||
"""Deserializes the Credential from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
aws_credentials=_from_dict(d, "aws_credentials", AwsCredentials),
|
||
creation_time=d.get("creation_time", None),
|
||
credentials_id=d.get("credentials_id", None),
|
||
credentials_name=d.get("credentials_name", None),
|
||
)
|
||
|
||
|
||
class CustomerFacingComputeMode(Enum):
|
||
"""Corresponds to compute mode defined here:
|
||
https://src.dev.databricks.com/databricks/universe@9076536b18479afd639d1c1f9dd5a59f72215e69/-/blob/central/api/common.proto?L872
|
||
"""
|
||
|
||
HYBRID = "HYBRID"
|
||
SERVERLESS = "SERVERLESS"
|
||
|
||
|
||
@dataclass
|
||
class CustomerFacingGcpCloudResourceContainer:
|
||
project_id: Optional[str] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CustomerFacingGcpCloudResourceContainer into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.project_id is not None:
|
||
body["project_id"] = self.project_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CustomerFacingGcpCloudResourceContainer into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.project_id is not None:
|
||
body["project_id"] = self.project_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CustomerFacingGcpCloudResourceContainer:
|
||
"""Deserializes the CustomerFacingGcpCloudResourceContainer from a dictionary."""
|
||
return cls(project_id=d.get("project_id", None))
|
||
|
||
|
||
class CustomerFacingStorageMode(Enum):
|
||
|
||
CUSTOMER_HOSTED = "CUSTOMER_HOSTED"
|
||
DEFAULT_STORAGE = "DEFAULT_STORAGE"
|
||
|
||
|
||
@dataclass
|
||
class CustomerManagedKey:
|
||
account_id: Optional[str] = None
|
||
"""The Databricks account ID that holds the customer-managed key."""
|
||
|
||
aws_key_info: Optional[AwsKeyInfo] = None
|
||
|
||
azure_key_info: Optional[AzureKeyInfo] = None
|
||
|
||
creation_time: Optional[int] = None
|
||
"""Time in epoch milliseconds when the customer key was created."""
|
||
|
||
customer_managed_key_id: Optional[str] = None
|
||
"""ID of the encryption key configuration object."""
|
||
|
||
gcp_key_info: Optional[GcpKeyInfo] = None
|
||
|
||
use_cases: Optional[List[KeyUseCase]] = None
|
||
"""The cases that the key can be used for."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the CustomerManagedKey into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_key_info:
|
||
body["aws_key_info"] = self.aws_key_info.as_dict()
|
||
if self.azure_key_info:
|
||
body["azure_key_info"] = self.azure_key_info.as_dict()
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.customer_managed_key_id is not None:
|
||
body["customer_managed_key_id"] = self.customer_managed_key_id
|
||
if self.gcp_key_info:
|
||
body["gcp_key_info"] = self.gcp_key_info.as_dict()
|
||
if self.use_cases:
|
||
body["use_cases"] = [v.value for v in self.use_cases]
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the CustomerManagedKey into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_key_info:
|
||
body["aws_key_info"] = self.aws_key_info
|
||
if self.azure_key_info:
|
||
body["azure_key_info"] = self.azure_key_info
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.customer_managed_key_id is not None:
|
||
body["customer_managed_key_id"] = self.customer_managed_key_id
|
||
if self.gcp_key_info:
|
||
body["gcp_key_info"] = self.gcp_key_info
|
||
if self.use_cases:
|
||
body["use_cases"] = self.use_cases
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> CustomerManagedKey:
|
||
"""Deserializes the CustomerManagedKey from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
aws_key_info=_from_dict(d, "aws_key_info", AwsKeyInfo),
|
||
azure_key_info=_from_dict(d, "azure_key_info", AzureKeyInfo),
|
||
creation_time=d.get("creation_time", None),
|
||
customer_managed_key_id=d.get("customer_managed_key_id", None),
|
||
gcp_key_info=_from_dict(d, "gcp_key_info", GcpKeyInfo),
|
||
use_cases=_repeated_enum(d, "use_cases", KeyUseCase),
|
||
)
|
||
|
||
|
||
class EndpointUseCase(Enum):
|
||
|
||
DATAPLANE_RELAY_ACCESS = "DATAPLANE_RELAY_ACCESS"
|
||
GENERAL_ACCESS = "GENERAL_ACCESS"
|
||
WORKSPACE_ACCESS = "WORKSPACE_ACCESS"
|
||
|
||
|
||
class ErrorType(Enum):
|
||
"""ErrorType and WarningType are used to represent the type of error or warning by NetworkHealth
|
||
and NetworkWarning defined in central/api/accounts/accounts.proto"""
|
||
|
||
CREDENTIALS = "credentials"
|
||
NETWORK_ACL = "networkAcl"
|
||
SECURITY_GROUP = "securityGroup"
|
||
SUBNET = "subnet"
|
||
VPC = "vpc"
|
||
|
||
|
||
@dataclass
|
||
class GcpCommonNetworkConfig:
|
||
"""The shared network config for GCP workspace. This object has common network configurations that
|
||
are network attributions of a workspace. DEPRECATED. Use GkeConfig instead."""
|
||
|
||
gke_cluster_master_ip_range: Optional[str] = None
|
||
"""The IP range that will be used to allocate GKE cluster master resources from. This field must
|
||
not be set if gke_cluster_type=PUBLIC_NODE_PUBLIC_MASTER."""
|
||
|
||
gke_connectivity_type: Optional[GkeConfigConnectivityType] = None
|
||
"""The type of network connectivity of the GKE cluster."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GcpCommonNetworkConfig into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.gke_cluster_master_ip_range is not None:
|
||
body["gke_cluster_master_ip_range"] = self.gke_cluster_master_ip_range
|
||
if self.gke_connectivity_type is not None:
|
||
body["gke_connectivity_type"] = self.gke_connectivity_type.value
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GcpCommonNetworkConfig into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.gke_cluster_master_ip_range is not None:
|
||
body["gke_cluster_master_ip_range"] = self.gke_cluster_master_ip_range
|
||
if self.gke_connectivity_type is not None:
|
||
body["gke_connectivity_type"] = self.gke_connectivity_type
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GcpCommonNetworkConfig:
|
||
"""Deserializes the GcpCommonNetworkConfig from a dictionary."""
|
||
return cls(
|
||
gke_cluster_master_ip_range=d.get("gke_cluster_master_ip_range", None),
|
||
gke_connectivity_type=_enum(d, "gke_connectivity_type", GkeConfigConnectivityType),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class GcpKeyInfo:
|
||
kms_key_id: str
|
||
"""Globally unique kms key resource id of the form
|
||
projects/testProjectId/locations/us-east4/keyRings/gcpCmkKeyRing/cryptoKeys/cmk-eastus4"""
|
||
|
||
gcp_service_account: Optional[GcpServiceAccount] = None
|
||
"""Globally unique service account email that has access to the KMS key. The service account exists
|
||
within the Databricks CP project."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GcpKeyInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.gcp_service_account:
|
||
body["gcp_service_account"] = self.gcp_service_account.as_dict()
|
||
if self.kms_key_id is not None:
|
||
body["kms_key_id"] = self.kms_key_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GcpKeyInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.gcp_service_account:
|
||
body["gcp_service_account"] = self.gcp_service_account
|
||
if self.kms_key_id is not None:
|
||
body["kms_key_id"] = self.kms_key_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GcpKeyInfo:
|
||
"""Deserializes the GcpKeyInfo from a dictionary."""
|
||
return cls(
|
||
gcp_service_account=_from_dict(d, "gcp_service_account", GcpServiceAccount),
|
||
kms_key_id=d.get("kms_key_id", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class GcpManagedNetworkConfig:
|
||
"""The network configuration for the workspace."""
|
||
|
||
gke_cluster_pod_ip_range: Optional[str] = None
|
||
"""The IP range that will be used to allocate GKE cluster Pods from."""
|
||
|
||
gke_cluster_service_ip_range: Optional[str] = None
|
||
"""The IP range that will be used to allocate GKE cluster Services from."""
|
||
|
||
subnet_cidr: Optional[str] = None
|
||
"""The IP range which will be used to allocate GKE cluster nodes from. Note: Pods, services and
|
||
master IP range must be mutually exclusive."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GcpManagedNetworkConfig into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.gke_cluster_pod_ip_range is not None:
|
||
body["gke_cluster_pod_ip_range"] = self.gke_cluster_pod_ip_range
|
||
if self.gke_cluster_service_ip_range is not None:
|
||
body["gke_cluster_service_ip_range"] = self.gke_cluster_service_ip_range
|
||
if self.subnet_cidr is not None:
|
||
body["subnet_cidr"] = self.subnet_cidr
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GcpManagedNetworkConfig into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.gke_cluster_pod_ip_range is not None:
|
||
body["gke_cluster_pod_ip_range"] = self.gke_cluster_pod_ip_range
|
||
if self.gke_cluster_service_ip_range is not None:
|
||
body["gke_cluster_service_ip_range"] = self.gke_cluster_service_ip_range
|
||
if self.subnet_cidr is not None:
|
||
body["subnet_cidr"] = self.subnet_cidr
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GcpManagedNetworkConfig:
|
||
"""Deserializes the GcpManagedNetworkConfig from a dictionary."""
|
||
return cls(
|
||
gke_cluster_pod_ip_range=d.get("gke_cluster_pod_ip_range", None),
|
||
gke_cluster_service_ip_range=d.get("gke_cluster_service_ip_range", None),
|
||
subnet_cidr=d.get("subnet_cidr", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class GcpNetworkInfo:
|
||
network_project_id: str
|
||
"""The GCP project ID for network resources. This project is where the VPC and subnet resides."""
|
||
|
||
vpc_id: str
|
||
"""The customer-provided VPC ID."""
|
||
|
||
subnet_id: str
|
||
"""The customer-provided Subnet ID that will be available to Clusters in Workspaces using this
|
||
Network."""
|
||
|
||
subnet_region: str
|
||
|
||
pod_ip_range_name: str
|
||
"""Name of the secondary range within the subnet that will be used by GKE as Pod IP range. This is
|
||
BYO VPC specific. DB VPC uses network.getGcpManagedNetworkConfig.getGkeClusterPodIpRange"""
|
||
|
||
service_ip_range_name: str
|
||
"""Name of the secondary range within the subnet that will be used by GKE as Service IP range."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GcpNetworkInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.network_project_id is not None:
|
||
body["network_project_id"] = self.network_project_id
|
||
if self.pod_ip_range_name is not None:
|
||
body["pod_ip_range_name"] = self.pod_ip_range_name
|
||
if self.service_ip_range_name is not None:
|
||
body["service_ip_range_name"] = self.service_ip_range_name
|
||
if self.subnet_id is not None:
|
||
body["subnet_id"] = self.subnet_id
|
||
if self.subnet_region is not None:
|
||
body["subnet_region"] = self.subnet_region
|
||
if self.vpc_id is not None:
|
||
body["vpc_id"] = self.vpc_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GcpNetworkInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.network_project_id is not None:
|
||
body["network_project_id"] = self.network_project_id
|
||
if self.pod_ip_range_name is not None:
|
||
body["pod_ip_range_name"] = self.pod_ip_range_name
|
||
if self.service_ip_range_name is not None:
|
||
body["service_ip_range_name"] = self.service_ip_range_name
|
||
if self.subnet_id is not None:
|
||
body["subnet_id"] = self.subnet_id
|
||
if self.subnet_region is not None:
|
||
body["subnet_region"] = self.subnet_region
|
||
if self.vpc_id is not None:
|
||
body["vpc_id"] = self.vpc_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GcpNetworkInfo:
|
||
"""Deserializes the GcpNetworkInfo from a dictionary."""
|
||
return cls(
|
||
network_project_id=d.get("network_project_id", None),
|
||
pod_ip_range_name=d.get("pod_ip_range_name", None),
|
||
service_ip_range_name=d.get("service_ip_range_name", None),
|
||
subnet_id=d.get("subnet_id", None),
|
||
subnet_region=d.get("subnet_region", None),
|
||
vpc_id=d.get("vpc_id", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class GcpServiceAccount:
|
||
service_account_email: Optional[str] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GcpServiceAccount into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.service_account_email is not None:
|
||
body["service_account_email"] = self.service_account_email
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GcpServiceAccount into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.service_account_email is not None:
|
||
body["service_account_email"] = self.service_account_email
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GcpServiceAccount:
|
||
"""Deserializes the GcpServiceAccount from a dictionary."""
|
||
return cls(service_account_email=d.get("service_account_email", None))
|
||
|
||
|
||
@dataclass
|
||
class GcpVpcEndpointInfo:
|
||
project_id: str
|
||
|
||
psc_endpoint_name: str
|
||
|
||
endpoint_region: str
|
||
|
||
psc_connection_id: Optional[str] = None
|
||
|
||
service_attachment_id: Optional[str] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GcpVpcEndpointInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.endpoint_region is not None:
|
||
body["endpoint_region"] = self.endpoint_region
|
||
if self.project_id is not None:
|
||
body["project_id"] = self.project_id
|
||
if self.psc_connection_id is not None:
|
||
body["psc_connection_id"] = self.psc_connection_id
|
||
if self.psc_endpoint_name is not None:
|
||
body["psc_endpoint_name"] = self.psc_endpoint_name
|
||
if self.service_attachment_id is not None:
|
||
body["service_attachment_id"] = self.service_attachment_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GcpVpcEndpointInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.endpoint_region is not None:
|
||
body["endpoint_region"] = self.endpoint_region
|
||
if self.project_id is not None:
|
||
body["project_id"] = self.project_id
|
||
if self.psc_connection_id is not None:
|
||
body["psc_connection_id"] = self.psc_connection_id
|
||
if self.psc_endpoint_name is not None:
|
||
body["psc_endpoint_name"] = self.psc_endpoint_name
|
||
if self.service_attachment_id is not None:
|
||
body["service_attachment_id"] = self.service_attachment_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GcpVpcEndpointInfo:
|
||
"""Deserializes the GcpVpcEndpointInfo from a dictionary."""
|
||
return cls(
|
||
endpoint_region=d.get("endpoint_region", None),
|
||
project_id=d.get("project_id", None),
|
||
psc_connection_id=d.get("psc_connection_id", None),
|
||
psc_endpoint_name=d.get("psc_endpoint_name", None),
|
||
service_attachment_id=d.get("service_attachment_id", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class GkeConfig:
|
||
"""The configurations of the GKE cluster used by the GCP workspace."""
|
||
|
||
connectivity_type: Optional[GkeConfigConnectivityType] = None
|
||
"""The type of network connectivity of the GKE cluster."""
|
||
|
||
master_ip_range: Optional[str] = None
|
||
"""The IP range that will be used to allocate GKE cluster master resources from. This field must
|
||
not be set if gke_cluster_type=PUBLIC_NODE_PUBLIC_MASTER."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the GkeConfig into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.connectivity_type is not None:
|
||
body["connectivity_type"] = self.connectivity_type.value
|
||
if self.master_ip_range is not None:
|
||
body["master_ip_range"] = self.master_ip_range
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the GkeConfig into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.connectivity_type is not None:
|
||
body["connectivity_type"] = self.connectivity_type
|
||
if self.master_ip_range is not None:
|
||
body["master_ip_range"] = self.master_ip_range
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> GkeConfig:
|
||
"""Deserializes the GkeConfig from a dictionary."""
|
||
return cls(
|
||
connectivity_type=_enum(d, "connectivity_type", GkeConfigConnectivityType),
|
||
master_ip_range=d.get("master_ip_range", None),
|
||
)
|
||
|
||
|
||
class GkeConfigConnectivityType(Enum):
|
||
"""Specifies the network connectivity types for the GKE nodes and the GKE master network.
|
||
|
||
Set to `PRIVATE_NODE_PUBLIC_MASTER` for a private GKE cluster for the workspace. The GKE nodes
|
||
will not have public IPs.
|
||
|
||
Set to `PUBLIC_NODE_PUBLIC_MASTER` for a public GKE cluster. The nodes of a public GKE cluster
|
||
have public IP addresses."""
|
||
|
||
PRIVATE_NODE_PUBLIC_MASTER = "PRIVATE_NODE_PUBLIC_MASTER"
|
||
PUBLIC_NODE_PUBLIC_MASTER = "PUBLIC_NODE_PUBLIC_MASTER"
|
||
|
||
|
||
@dataclass
|
||
class KeyAccessConfiguration:
|
||
"""The credential ID that is used to access the key vault."""
|
||
|
||
credential_id: Optional[str] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the KeyAccessConfiguration into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.credential_id is not None:
|
||
body["credential_id"] = self.credential_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the KeyAccessConfiguration into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.credential_id is not None:
|
||
body["credential_id"] = self.credential_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> KeyAccessConfiguration:
|
||
"""Deserializes the KeyAccessConfiguration from a dictionary."""
|
||
return cls(credential_id=d.get("credential_id", None))
|
||
|
||
|
||
class KeyUseCase(Enum):
|
||
|
||
MANAGED_SERVICES = "MANAGED_SERVICES"
|
||
STORAGE = "STORAGE"
|
||
|
||
|
||
@dataclass
|
||
class Network:
|
||
account_id: Optional[str] = None
|
||
"""The Databricks account ID associated with this network configuration."""
|
||
|
||
creation_time: Optional[int] = None
|
||
"""Time in epoch milliseconds when the network was created."""
|
||
|
||
error_messages: Optional[List[NetworkHealth]] = None
|
||
"""Array of error messages about the network configuration."""
|
||
|
||
gcp_network_info: Optional[GcpNetworkInfo] = None
|
||
|
||
network_id: Optional[str] = None
|
||
"""The Databricks network configuration ID."""
|
||
|
||
network_name: Optional[str] = None
|
||
"""The human-readable name of the network configuration."""
|
||
|
||
security_group_ids: Optional[List[str]] = None
|
||
"""IDs of one to five security groups associated with this network. Security group IDs **cannot**
|
||
be used in multiple network configurations."""
|
||
|
||
subnet_ids: Optional[List[str]] = None
|
||
"""IDs of at least two subnets associated with this network. Subnet IDs **cannot** be used in
|
||
multiple network configurations."""
|
||
|
||
vpc_endpoints: Optional[NetworkVpcEndpoints] = None
|
||
|
||
vpc_id: Optional[str] = None
|
||
"""The ID of the VPC associated with this network configuration. VPC IDs can be used in multiple
|
||
networks."""
|
||
|
||
vpc_status: Optional[VpcStatus] = None
|
||
|
||
warning_messages: Optional[List[NetworkWarning]] = None
|
||
"""Array of warning messages about the network configuration."""
|
||
|
||
workspace_id: Optional[int] = None
|
||
"""Workspace ID associated with this network configuration."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the Network into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.error_messages:
|
||
body["error_messages"] = [v.as_dict() for v in self.error_messages]
|
||
if self.gcp_network_info:
|
||
body["gcp_network_info"] = self.gcp_network_info.as_dict()
|
||
if self.network_id is not None:
|
||
body["network_id"] = self.network_id
|
||
if self.network_name is not None:
|
||
body["network_name"] = self.network_name
|
||
if self.security_group_ids:
|
||
body["security_group_ids"] = [v for v in self.security_group_ids]
|
||
if self.subnet_ids:
|
||
body["subnet_ids"] = [v for v in self.subnet_ids]
|
||
if self.vpc_endpoints:
|
||
body["vpc_endpoints"] = self.vpc_endpoints.as_dict()
|
||
if self.vpc_id is not None:
|
||
body["vpc_id"] = self.vpc_id
|
||
if self.vpc_status is not None:
|
||
body["vpc_status"] = self.vpc_status.value
|
||
if self.warning_messages:
|
||
body["warning_messages"] = [v.as_dict() for v in self.warning_messages]
|
||
if self.workspace_id is not None:
|
||
body["workspace_id"] = self.workspace_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the Network into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.error_messages:
|
||
body["error_messages"] = self.error_messages
|
||
if self.gcp_network_info:
|
||
body["gcp_network_info"] = self.gcp_network_info
|
||
if self.network_id is not None:
|
||
body["network_id"] = self.network_id
|
||
if self.network_name is not None:
|
||
body["network_name"] = self.network_name
|
||
if self.security_group_ids:
|
||
body["security_group_ids"] = self.security_group_ids
|
||
if self.subnet_ids:
|
||
body["subnet_ids"] = self.subnet_ids
|
||
if self.vpc_endpoints:
|
||
body["vpc_endpoints"] = self.vpc_endpoints
|
||
if self.vpc_id is not None:
|
||
body["vpc_id"] = self.vpc_id
|
||
if self.vpc_status is not None:
|
||
body["vpc_status"] = self.vpc_status
|
||
if self.warning_messages:
|
||
body["warning_messages"] = self.warning_messages
|
||
if self.workspace_id is not None:
|
||
body["workspace_id"] = self.workspace_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> Network:
|
||
"""Deserializes the Network from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
creation_time=d.get("creation_time", None),
|
||
error_messages=_repeated_dict(d, "error_messages", NetworkHealth),
|
||
gcp_network_info=_from_dict(d, "gcp_network_info", GcpNetworkInfo),
|
||
network_id=d.get("network_id", None),
|
||
network_name=d.get("network_name", None),
|
||
security_group_ids=d.get("security_group_ids", None),
|
||
subnet_ids=d.get("subnet_ids", None),
|
||
vpc_endpoints=_from_dict(d, "vpc_endpoints", NetworkVpcEndpoints),
|
||
vpc_id=d.get("vpc_id", None),
|
||
vpc_status=_enum(d, "vpc_status", VpcStatus),
|
||
warning_messages=_repeated_dict(d, "warning_messages", NetworkWarning),
|
||
workspace_id=d.get("workspace_id", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class NetworkHealth:
|
||
error_message: Optional[str] = None
|
||
"""Details of the error."""
|
||
|
||
error_type: Optional[ErrorType] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the NetworkHealth into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.error_message is not None:
|
||
body["error_message"] = self.error_message
|
||
if self.error_type is not None:
|
||
body["error_type"] = self.error_type.value
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the NetworkHealth into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.error_message is not None:
|
||
body["error_message"] = self.error_message
|
||
if self.error_type is not None:
|
||
body["error_type"] = self.error_type
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> NetworkHealth:
|
||
"""Deserializes the NetworkHealth from a dictionary."""
|
||
return cls(error_message=d.get("error_message", None), error_type=_enum(d, "error_type", ErrorType))
|
||
|
||
|
||
@dataclass
|
||
class NetworkVpcEndpoints:
|
||
dataplane_relay: Optional[List[str]] = None
|
||
"""The VPC endpoint ID used by this network to access the Databricks secure cluster connectivity
|
||
relay."""
|
||
|
||
rest_api: Optional[List[str]] = None
|
||
"""The VPC endpoint ID used by this network to access the Databricks REST API."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the NetworkVpcEndpoints into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.dataplane_relay:
|
||
body["dataplane_relay"] = [v for v in self.dataplane_relay]
|
||
if self.rest_api:
|
||
body["rest_api"] = [v for v in self.rest_api]
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the NetworkVpcEndpoints into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.dataplane_relay:
|
||
body["dataplane_relay"] = self.dataplane_relay
|
||
if self.rest_api:
|
||
body["rest_api"] = self.rest_api
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> NetworkVpcEndpoints:
|
||
"""Deserializes the NetworkVpcEndpoints from a dictionary."""
|
||
return cls(dataplane_relay=d.get("dataplane_relay", None), rest_api=d.get("rest_api", None))
|
||
|
||
|
||
@dataclass
|
||
class NetworkWarning:
|
||
warning_message: Optional[str] = None
|
||
"""Details of the warning."""
|
||
|
||
warning_type: Optional[WarningType] = None
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the NetworkWarning into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.warning_message is not None:
|
||
body["warning_message"] = self.warning_message
|
||
if self.warning_type is not None:
|
||
body["warning_type"] = self.warning_type.value
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the NetworkWarning into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.warning_message is not None:
|
||
body["warning_message"] = self.warning_message
|
||
if self.warning_type is not None:
|
||
body["warning_type"] = self.warning_type
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> NetworkWarning:
|
||
"""Deserializes the NetworkWarning from a dictionary."""
|
||
return cls(warning_message=d.get("warning_message", None), warning_type=_enum(d, "warning_type", WarningType))
|
||
|
||
|
||
class PricingTier(Enum):
|
||
|
||
COMMUNITY_EDITION = "COMMUNITY_EDITION"
|
||
DEDICATED = "DEDICATED"
|
||
ENTERPRISE = "ENTERPRISE"
|
||
PREMIUM = "PREMIUM"
|
||
STANDARD = "STANDARD"
|
||
UNKNOWN = "UNKNOWN"
|
||
|
||
|
||
class PrivateAccessLevel(Enum):
|
||
|
||
ACCOUNT = "ACCOUNT"
|
||
ENDPOINT = "ENDPOINT"
|
||
|
||
|
||
@dataclass
|
||
class PrivateAccessSettings:
|
||
"""*"""
|
||
|
||
account_id: Optional[str] = None
|
||
"""The Databricks account ID that hosts the private access settings."""
|
||
|
||
allowed_vpc_endpoint_ids: Optional[List[str]] = None
|
||
"""An array of Databricks VPC endpoint IDs. This is the Databricks ID that is returned when
|
||
registering the VPC endpoint configuration in your Databricks account. This is not the ID of the
|
||
VPC endpoint in AWS. Only used when private_access_level is set to ENDPOINT. This is an allow
|
||
list of VPC endpoints that in your account that can connect to your workspace over AWS
|
||
PrivateLink. If hybrid access to your workspace is enabled by setting public_access_enabled to
|
||
true, this control only works for PrivateLink connections. To control how your workspace is
|
||
accessed via public internet, see IP access lists."""
|
||
|
||
private_access_level: Optional[PrivateAccessLevel] = None
|
||
"""The private access level controls which VPC endpoints can connect to the UI or API of any
|
||
workspace that attaches this private access settings object. `ACCOUNT` level access (the
|
||
default) allows only VPC endpoints that are registered in your Databricks account connect to
|
||
your workspace. `ENDPOINT` level access allows only specified VPC endpoints connect to your
|
||
workspace. For details, see allowed_vpc_endpoint_ids."""
|
||
|
||
private_access_settings_id: Optional[str] = None
|
||
"""Databricks private access settings ID."""
|
||
|
||
private_access_settings_name: Optional[str] = None
|
||
"""The human-readable name of the private access settings object."""
|
||
|
||
public_access_enabled: Optional[bool] = None
|
||
"""Determines if the workspace can be accessed over public internet. For fully private workspaces,
|
||
you can optionally specify false, but only if you implement both the front-end and the back-end
|
||
PrivateLink connections. Otherwise, specify true, which means that public access is enabled."""
|
||
|
||
region: Optional[str] = None
|
||
"""The AWS region for workspaces attached to this private access settings object."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the PrivateAccessSettings into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.allowed_vpc_endpoint_ids:
|
||
body["allowed_vpc_endpoint_ids"] = [v for v in self.allowed_vpc_endpoint_ids]
|
||
if self.private_access_level is not None:
|
||
body["private_access_level"] = self.private_access_level.value
|
||
if self.private_access_settings_id is not None:
|
||
body["private_access_settings_id"] = self.private_access_settings_id
|
||
if self.private_access_settings_name is not None:
|
||
body["private_access_settings_name"] = self.private_access_settings_name
|
||
if self.public_access_enabled is not None:
|
||
body["public_access_enabled"] = self.public_access_enabled
|
||
if self.region is not None:
|
||
body["region"] = self.region
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the PrivateAccessSettings into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.allowed_vpc_endpoint_ids:
|
||
body["allowed_vpc_endpoint_ids"] = self.allowed_vpc_endpoint_ids
|
||
if self.private_access_level is not None:
|
||
body["private_access_level"] = self.private_access_level
|
||
if self.private_access_settings_id is not None:
|
||
body["private_access_settings_id"] = self.private_access_settings_id
|
||
if self.private_access_settings_name is not None:
|
||
body["private_access_settings_name"] = self.private_access_settings_name
|
||
if self.public_access_enabled is not None:
|
||
body["public_access_enabled"] = self.public_access_enabled
|
||
if self.region is not None:
|
||
body["region"] = self.region
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> PrivateAccessSettings:
|
||
"""Deserializes the PrivateAccessSettings from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
allowed_vpc_endpoint_ids=d.get("allowed_vpc_endpoint_ids", None),
|
||
private_access_level=_enum(d, "private_access_level", PrivateAccessLevel),
|
||
private_access_settings_id=d.get("private_access_settings_id", None),
|
||
private_access_settings_name=d.get("private_access_settings_name", None),
|
||
public_access_enabled=d.get("public_access_enabled", None),
|
||
region=d.get("region", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class RootBucketInfo:
|
||
bucket_name: Optional[str] = None
|
||
"""Name of the S3 bucket"""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the RootBucketInfo into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.bucket_name is not None:
|
||
body["bucket_name"] = self.bucket_name
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the RootBucketInfo into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.bucket_name is not None:
|
||
body["bucket_name"] = self.bucket_name
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> RootBucketInfo:
|
||
"""Deserializes the RootBucketInfo from a dictionary."""
|
||
return cls(bucket_name=d.get("bucket_name", None))
|
||
|
||
|
||
@dataclass
|
||
class StorageConfiguration:
|
||
account_id: Optional[str] = None
|
||
"""The Databricks account ID associated with this storage configuration."""
|
||
|
||
creation_time: Optional[int] = None
|
||
"""Time in epoch milliseconds when the storage configuration was created."""
|
||
|
||
role_arn: Optional[str] = None
|
||
"""Optional IAM role that is used to access the workspace catalog which is created during workspace
|
||
creation for UC by Default. If a storage configuration with this field populated is used to
|
||
create a workspace, then a workspace catalog is created together with the workspace. The
|
||
workspace catalog shares the root bucket with internal workspace storage (including DBFS root)
|
||
but uses a dedicated bucket path prefix."""
|
||
|
||
root_bucket_info: Optional[RootBucketInfo] = None
|
||
"""The root bucket information for the storage configuration."""
|
||
|
||
storage_configuration_id: Optional[str] = None
|
||
"""Databricks storage configuration ID."""
|
||
|
||
storage_configuration_name: Optional[str] = None
|
||
"""The human-readable name of the storage configuration."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the StorageConfiguration into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.role_arn is not None:
|
||
body["role_arn"] = self.role_arn
|
||
if self.root_bucket_info:
|
||
body["root_bucket_info"] = self.root_bucket_info.as_dict()
|
||
if self.storage_configuration_id is not None:
|
||
body["storage_configuration_id"] = self.storage_configuration_id
|
||
if self.storage_configuration_name is not None:
|
||
body["storage_configuration_name"] = self.storage_configuration_name
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the StorageConfiguration into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.role_arn is not None:
|
||
body["role_arn"] = self.role_arn
|
||
if self.root_bucket_info:
|
||
body["root_bucket_info"] = self.root_bucket_info
|
||
if self.storage_configuration_id is not None:
|
||
body["storage_configuration_id"] = self.storage_configuration_id
|
||
if self.storage_configuration_name is not None:
|
||
body["storage_configuration_name"] = self.storage_configuration_name
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> StorageConfiguration:
|
||
"""Deserializes the StorageConfiguration from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
creation_time=d.get("creation_time", None),
|
||
role_arn=d.get("role_arn", None),
|
||
root_bucket_info=_from_dict(d, "root_bucket_info", RootBucketInfo),
|
||
storage_configuration_id=d.get("storage_configuration_id", None),
|
||
storage_configuration_name=d.get("storage_configuration_name", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class StsRole:
|
||
role_arn: Optional[str] = None
|
||
"""The Amazon Resource Name (ARN) of the cross account IAM role."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the StsRole into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.role_arn is not None:
|
||
body["role_arn"] = self.role_arn
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the StsRole into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.role_arn is not None:
|
||
body["role_arn"] = self.role_arn
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> StsRole:
|
||
"""Deserializes the StsRole from a dictionary."""
|
||
return cls(role_arn=d.get("role_arn", None))
|
||
|
||
|
||
@dataclass
|
||
class VpcEndpoint:
|
||
"""*"""
|
||
|
||
account_id: Optional[str] = None
|
||
"""The Databricks account ID that hosts the VPC endpoint configuration. TODO - This may signal an
|
||
OpenAPI diff; it does not show up in the generated spec"""
|
||
|
||
aws_account_id: Optional[str] = None
|
||
"""The AWS Account in which the VPC endpoint object exists."""
|
||
|
||
aws_endpoint_service_id: Optional[str] = None
|
||
"""The ID of the Databricks [endpoint service] that this VPC endpoint is connected to. For a list
|
||
of endpoint service IDs for each supported AWS region, see the [Databricks PrivateLink
|
||
documentation].
|
||
|
||
[Databricks PrivateLink documentation]: https://docs.databricks.com/administration-guide/cloud-configurations/aws/privatelink.html
|
||
[endpoint service]: https://docs.aws.amazon.com/vpc/latest/privatelink/endpoint-service.html"""
|
||
|
||
aws_vpc_endpoint_id: Optional[str] = None
|
||
"""The ID of the VPC endpoint object in AWS."""
|
||
|
||
gcp_vpc_endpoint_info: Optional[GcpVpcEndpointInfo] = None
|
||
"""The cloud info of this vpc endpoint. Info for a GCP vpc endpoint."""
|
||
|
||
region: Optional[str] = None
|
||
"""The AWS region in which this VPC endpoint object exists."""
|
||
|
||
state: Optional[str] = None
|
||
"""The current state (such as `available` or `rejected`) of the VPC endpoint. Derived from AWS. For
|
||
the full set of values, see [AWS DescribeVpcEndpoint documentation].
|
||
|
||
[AWS DescribeVpcEndpoint documentation]: https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-vpc-endpoints.html"""
|
||
|
||
use_case: Optional[EndpointUseCase] = None
|
||
"""This enumeration represents the type of Databricks VPC endpoint service that was used when
|
||
creating this VPC endpoint. If the VPC endpoint connects to the Databricks control plane for
|
||
either the front-end connection or the back-end REST API connection, the value is
|
||
WORKSPACE_ACCESS. If the VPC endpoint connects to the Databricks workspace for the back-end
|
||
secure cluster connectivity relay, the value is DATAPLANE_RELAY_ACCESS."""
|
||
|
||
vpc_endpoint_id: Optional[str] = None
|
||
"""Databricks VPC endpoint ID. This is the Databricks-specific name of the VPC endpoint. Do not
|
||
confuse this with the `aws_vpc_endpoint_id`, which is the ID within AWS of the VPC endpoint."""
|
||
|
||
vpc_endpoint_name: Optional[str] = None
|
||
"""The human-readable name of the storage configuration."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the VpcEndpoint into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_account_id is not None:
|
||
body["aws_account_id"] = self.aws_account_id
|
||
if self.aws_endpoint_service_id is not None:
|
||
body["aws_endpoint_service_id"] = self.aws_endpoint_service_id
|
||
if self.aws_vpc_endpoint_id is not None:
|
||
body["aws_vpc_endpoint_id"] = self.aws_vpc_endpoint_id
|
||
if self.gcp_vpc_endpoint_info:
|
||
body["gcp_vpc_endpoint_info"] = self.gcp_vpc_endpoint_info.as_dict()
|
||
if self.region is not None:
|
||
body["region"] = self.region
|
||
if self.state is not None:
|
||
body["state"] = self.state
|
||
if self.use_case is not None:
|
||
body["use_case"] = self.use_case.value
|
||
if self.vpc_endpoint_id is not None:
|
||
body["vpc_endpoint_id"] = self.vpc_endpoint_id
|
||
if self.vpc_endpoint_name is not None:
|
||
body["vpc_endpoint_name"] = self.vpc_endpoint_name
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the VpcEndpoint into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_account_id is not None:
|
||
body["aws_account_id"] = self.aws_account_id
|
||
if self.aws_endpoint_service_id is not None:
|
||
body["aws_endpoint_service_id"] = self.aws_endpoint_service_id
|
||
if self.aws_vpc_endpoint_id is not None:
|
||
body["aws_vpc_endpoint_id"] = self.aws_vpc_endpoint_id
|
||
if self.gcp_vpc_endpoint_info:
|
||
body["gcp_vpc_endpoint_info"] = self.gcp_vpc_endpoint_info
|
||
if self.region is not None:
|
||
body["region"] = self.region
|
||
if self.state is not None:
|
||
body["state"] = self.state
|
||
if self.use_case is not None:
|
||
body["use_case"] = self.use_case
|
||
if self.vpc_endpoint_id is not None:
|
||
body["vpc_endpoint_id"] = self.vpc_endpoint_id
|
||
if self.vpc_endpoint_name is not None:
|
||
body["vpc_endpoint_name"] = self.vpc_endpoint_name
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> VpcEndpoint:
|
||
"""Deserializes the VpcEndpoint from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
aws_account_id=d.get("aws_account_id", None),
|
||
aws_endpoint_service_id=d.get("aws_endpoint_service_id", None),
|
||
aws_vpc_endpoint_id=d.get("aws_vpc_endpoint_id", None),
|
||
gcp_vpc_endpoint_info=_from_dict(d, "gcp_vpc_endpoint_info", GcpVpcEndpointInfo),
|
||
region=d.get("region", None),
|
||
state=d.get("state", None),
|
||
use_case=_enum(d, "use_case", EndpointUseCase),
|
||
vpc_endpoint_id=d.get("vpc_endpoint_id", None),
|
||
vpc_endpoint_name=d.get("vpc_endpoint_name", None),
|
||
)
|
||
|
||
|
||
class VpcStatus(Enum):
|
||
|
||
BROKEN = "BROKEN"
|
||
UNATTACHED = "UNATTACHED"
|
||
VALID = "VALID"
|
||
WARNED = "WARNED"
|
||
|
||
|
||
class WarningType(Enum):
|
||
|
||
SECURITY_GROUP = "securityGroup"
|
||
SUBNET = "subnet"
|
||
|
||
|
||
@dataclass
|
||
class Workspace:
|
||
account_id: Optional[str] = None
|
||
"""Databricks account ID."""
|
||
|
||
aws_region: Optional[str] = None
|
||
|
||
azure_workspace_info: Optional[AzureWorkspaceInfo] = None
|
||
|
||
cloud: Optional[str] = None
|
||
"""The cloud name. This field can have values like `azure`, `gcp`."""
|
||
|
||
cloud_resource_container: Optional[CloudResourceContainer] = None
|
||
|
||
compute_mode: Optional[CustomerFacingComputeMode] = None
|
||
"""The compute mode of the workspace."""
|
||
|
||
creation_time: Optional[int] = None
|
||
"""Time in epoch milliseconds when the workspace was created."""
|
||
|
||
credentials_id: Optional[str] = None
|
||
"""ID of the workspace's credential configuration object."""
|
||
|
||
custom_tags: Optional[Dict[str, str]] = None
|
||
"""The custom tags key-value pairing that is attached to this workspace. The key-value pair is a
|
||
string of utf-8 characters. The value can be an empty string, with maximum length of 255
|
||
characters. The key can be of maximum length of 127 characters, and cannot be empty."""
|
||
|
||
deployment_name: Optional[str] = None
|
||
|
||
expected_workspace_status: Optional[WorkspaceStatus] = None
|
||
"""A client owned field used to indicate the workspace status that the client expects to be in. For
|
||
now this is only used to unblock Temporal workflow for GCP least privileged workspace."""
|
||
|
||
gcp_managed_network_config: Optional[GcpManagedNetworkConfig] = None
|
||
|
||
gke_config: Optional[GkeConfig] = None
|
||
|
||
location: Optional[str] = None
|
||
"""The Google Cloud region of the workspace data plane in your Google account (for example,
|
||
`us-east4`)."""
|
||
|
||
managed_services_customer_managed_key_id: Optional[str] = None
|
||
"""ID of the key configuration for encrypting managed services."""
|
||
|
||
network: Optional[WorkspaceNetwork] = None
|
||
"""The network configuration for the workspace.
|
||
|
||
DEPRECATED. Use `network_id` instead."""
|
||
|
||
network_connectivity_config_id: Optional[str] = None
|
||
"""The object ID of network connectivity config."""
|
||
|
||
network_id: Optional[str] = None
|
||
"""If this workspace is BYO VPC, then the network_id will be populated. If this workspace is not
|
||
BYO VPC, then the network_id will be empty."""
|
||
|
||
pricing_tier: Optional[PricingTier] = None
|
||
|
||
private_access_settings_id: Optional[str] = None
|
||
"""ID of the workspace's private access settings object. Only used for PrivateLink. You must
|
||
specify this ID if you are using [AWS PrivateLink] for either front-end (user-to-workspace
|
||
connection), back-end (data plane to control plane connection), or both connection types.
|
||
|
||
Before configuring PrivateLink, read the [Databricks article about PrivateLink].",
|
||
|
||
[AWS PrivateLink]: https://aws.amazon.com/privatelink/
|
||
[Databricks article about PrivateLink]: https://docs.databricks.com/administration-guide/cloud-configurations/aws/privatelink.html"""
|
||
|
||
storage_configuration_id: Optional[str] = None
|
||
"""ID of the workspace's storage configuration object."""
|
||
|
||
storage_customer_managed_key_id: Optional[str] = None
|
||
"""ID of the key configuration for encrypting workspace storage."""
|
||
|
||
storage_mode: Optional[CustomerFacingStorageMode] = None
|
||
"""The storage mode of the workspace."""
|
||
|
||
workspace_id: Optional[int] = None
|
||
"""A unique integer ID for the workspace"""
|
||
|
||
workspace_name: Optional[str] = None
|
||
"""The human-readable name of the workspace."""
|
||
|
||
workspace_status: Optional[WorkspaceStatus] = None
|
||
"""The status of a workspace"""
|
||
|
||
workspace_status_message: Optional[str] = None
|
||
"""Message describing the current workspace status."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the Workspace into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_region is not None:
|
||
body["aws_region"] = self.aws_region
|
||
if self.azure_workspace_info:
|
||
body["azure_workspace_info"] = self.azure_workspace_info.as_dict()
|
||
if self.cloud is not None:
|
||
body["cloud"] = self.cloud
|
||
if self.cloud_resource_container:
|
||
body["cloud_resource_container"] = self.cloud_resource_container.as_dict()
|
||
if self.compute_mode is not None:
|
||
body["compute_mode"] = self.compute_mode.value
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.credentials_id is not None:
|
||
body["credentials_id"] = self.credentials_id
|
||
if self.custom_tags:
|
||
body["custom_tags"] = self.custom_tags
|
||
if self.deployment_name is not None:
|
||
body["deployment_name"] = self.deployment_name
|
||
if self.expected_workspace_status is not None:
|
||
body["expected_workspace_status"] = self.expected_workspace_status.value
|
||
if self.gcp_managed_network_config:
|
||
body["gcp_managed_network_config"] = self.gcp_managed_network_config.as_dict()
|
||
if self.gke_config:
|
||
body["gke_config"] = self.gke_config.as_dict()
|
||
if self.location is not None:
|
||
body["location"] = self.location
|
||
if self.managed_services_customer_managed_key_id is not None:
|
||
body["managed_services_customer_managed_key_id"] = self.managed_services_customer_managed_key_id
|
||
if self.network:
|
||
body["network"] = self.network.as_dict()
|
||
if self.network_connectivity_config_id is not None:
|
||
body["network_connectivity_config_id"] = self.network_connectivity_config_id
|
||
if self.network_id is not None:
|
||
body["network_id"] = self.network_id
|
||
if self.pricing_tier is not None:
|
||
body["pricing_tier"] = self.pricing_tier.value
|
||
if self.private_access_settings_id is not None:
|
||
body["private_access_settings_id"] = self.private_access_settings_id
|
||
if self.storage_configuration_id is not None:
|
||
body["storage_configuration_id"] = self.storage_configuration_id
|
||
if self.storage_customer_managed_key_id is not None:
|
||
body["storage_customer_managed_key_id"] = self.storage_customer_managed_key_id
|
||
if self.storage_mode is not None:
|
||
body["storage_mode"] = self.storage_mode.value
|
||
if self.workspace_id is not None:
|
||
body["workspace_id"] = self.workspace_id
|
||
if self.workspace_name is not None:
|
||
body["workspace_name"] = self.workspace_name
|
||
if self.workspace_status is not None:
|
||
body["workspace_status"] = self.workspace_status.value
|
||
if self.workspace_status_message is not None:
|
||
body["workspace_status_message"] = self.workspace_status_message
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the Workspace into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.account_id is not None:
|
||
body["account_id"] = self.account_id
|
||
if self.aws_region is not None:
|
||
body["aws_region"] = self.aws_region
|
||
if self.azure_workspace_info:
|
||
body["azure_workspace_info"] = self.azure_workspace_info
|
||
if self.cloud is not None:
|
||
body["cloud"] = self.cloud
|
||
if self.cloud_resource_container:
|
||
body["cloud_resource_container"] = self.cloud_resource_container
|
||
if self.compute_mode is not None:
|
||
body["compute_mode"] = self.compute_mode
|
||
if self.creation_time is not None:
|
||
body["creation_time"] = self.creation_time
|
||
if self.credentials_id is not None:
|
||
body["credentials_id"] = self.credentials_id
|
||
if self.custom_tags:
|
||
body["custom_tags"] = self.custom_tags
|
||
if self.deployment_name is not None:
|
||
body["deployment_name"] = self.deployment_name
|
||
if self.expected_workspace_status is not None:
|
||
body["expected_workspace_status"] = self.expected_workspace_status
|
||
if self.gcp_managed_network_config:
|
||
body["gcp_managed_network_config"] = self.gcp_managed_network_config
|
||
if self.gke_config:
|
||
body["gke_config"] = self.gke_config
|
||
if self.location is not None:
|
||
body["location"] = self.location
|
||
if self.managed_services_customer_managed_key_id is not None:
|
||
body["managed_services_customer_managed_key_id"] = self.managed_services_customer_managed_key_id
|
||
if self.network:
|
||
body["network"] = self.network
|
||
if self.network_connectivity_config_id is not None:
|
||
body["network_connectivity_config_id"] = self.network_connectivity_config_id
|
||
if self.network_id is not None:
|
||
body["network_id"] = self.network_id
|
||
if self.pricing_tier is not None:
|
||
body["pricing_tier"] = self.pricing_tier
|
||
if self.private_access_settings_id is not None:
|
||
body["private_access_settings_id"] = self.private_access_settings_id
|
||
if self.storage_configuration_id is not None:
|
||
body["storage_configuration_id"] = self.storage_configuration_id
|
||
if self.storage_customer_managed_key_id is not None:
|
||
body["storage_customer_managed_key_id"] = self.storage_customer_managed_key_id
|
||
if self.storage_mode is not None:
|
||
body["storage_mode"] = self.storage_mode
|
||
if self.workspace_id is not None:
|
||
body["workspace_id"] = self.workspace_id
|
||
if self.workspace_name is not None:
|
||
body["workspace_name"] = self.workspace_name
|
||
if self.workspace_status is not None:
|
||
body["workspace_status"] = self.workspace_status
|
||
if self.workspace_status_message is not None:
|
||
body["workspace_status_message"] = self.workspace_status_message
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> Workspace:
|
||
"""Deserializes the Workspace from a dictionary."""
|
||
return cls(
|
||
account_id=d.get("account_id", None),
|
||
aws_region=d.get("aws_region", None),
|
||
azure_workspace_info=_from_dict(d, "azure_workspace_info", AzureWorkspaceInfo),
|
||
cloud=d.get("cloud", None),
|
||
cloud_resource_container=_from_dict(d, "cloud_resource_container", CloudResourceContainer),
|
||
compute_mode=_enum(d, "compute_mode", CustomerFacingComputeMode),
|
||
creation_time=d.get("creation_time", None),
|
||
credentials_id=d.get("credentials_id", None),
|
||
custom_tags=d.get("custom_tags", None),
|
||
deployment_name=d.get("deployment_name", None),
|
||
expected_workspace_status=_enum(d, "expected_workspace_status", WorkspaceStatus),
|
||
gcp_managed_network_config=_from_dict(d, "gcp_managed_network_config", GcpManagedNetworkConfig),
|
||
gke_config=_from_dict(d, "gke_config", GkeConfig),
|
||
location=d.get("location", None),
|
||
managed_services_customer_managed_key_id=d.get("managed_services_customer_managed_key_id", None),
|
||
network=_from_dict(d, "network", WorkspaceNetwork),
|
||
network_connectivity_config_id=d.get("network_connectivity_config_id", None),
|
||
network_id=d.get("network_id", None),
|
||
pricing_tier=_enum(d, "pricing_tier", PricingTier),
|
||
private_access_settings_id=d.get("private_access_settings_id", None),
|
||
storage_configuration_id=d.get("storage_configuration_id", None),
|
||
storage_customer_managed_key_id=d.get("storage_customer_managed_key_id", None),
|
||
storage_mode=_enum(d, "storage_mode", CustomerFacingStorageMode),
|
||
workspace_id=d.get("workspace_id", None),
|
||
workspace_name=d.get("workspace_name", None),
|
||
workspace_status=_enum(d, "workspace_status", WorkspaceStatus),
|
||
workspace_status_message=d.get("workspace_status_message", None),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class WorkspaceNetwork:
|
||
"""The network configuration for workspaces."""
|
||
|
||
gcp_common_network_config: Optional[GcpCommonNetworkConfig] = None
|
||
"""The shared network config for GCP workspace. This object has common network configurations that
|
||
are network attributions of a workspace. This object is input-only."""
|
||
|
||
gcp_managed_network_config: Optional[GcpManagedNetworkConfig] = None
|
||
"""The mutually exclusive network deployment modes. The option decides which network mode the
|
||
workspace will use. The network config for GCP workspace with Databricks managed network. This
|
||
object is input-only and will not be provided when listing workspaces. See
|
||
go/gcp-byovpc-alpha-design for interface decisions."""
|
||
|
||
network_id: Optional[str] = None
|
||
"""The ID of the network object, if the workspace is a BYOVPC workspace. This should apply to
|
||
workspaces on all clouds in internal services. In accounts-rest-api, user will use
|
||
workspace.network_id for input and output instead. Currently (2021-06-19) the network ID is only
|
||
used by GCP."""
|
||
|
||
def as_dict(self) -> dict:
|
||
"""Serializes the WorkspaceNetwork into a dictionary suitable for use as a JSON request body."""
|
||
body = {}
|
||
if self.gcp_common_network_config:
|
||
body["gcp_common_network_config"] = self.gcp_common_network_config.as_dict()
|
||
if self.gcp_managed_network_config:
|
||
body["gcp_managed_network_config"] = self.gcp_managed_network_config.as_dict()
|
||
if self.network_id is not None:
|
||
body["network_id"] = self.network_id
|
||
return body
|
||
|
||
def as_shallow_dict(self) -> dict:
|
||
"""Serializes the WorkspaceNetwork into a shallow dictionary of its immediate attributes."""
|
||
body = {}
|
||
if self.gcp_common_network_config:
|
||
body["gcp_common_network_config"] = self.gcp_common_network_config
|
||
if self.gcp_managed_network_config:
|
||
body["gcp_managed_network_config"] = self.gcp_managed_network_config
|
||
if self.network_id is not None:
|
||
body["network_id"] = self.network_id
|
||
return body
|
||
|
||
@classmethod
|
||
def from_dict(cls, d: Dict[str, Any]) -> WorkspaceNetwork:
|
||
"""Deserializes the WorkspaceNetwork from a dictionary."""
|
||
return cls(
|
||
gcp_common_network_config=_from_dict(d, "gcp_common_network_config", GcpCommonNetworkConfig),
|
||
gcp_managed_network_config=_from_dict(d, "gcp_managed_network_config", GcpManagedNetworkConfig),
|
||
network_id=d.get("network_id", None),
|
||
)
|
||
|
||
|
||
class WorkspaceStatus(Enum):
|
||
"""The different statuses of a workspace. The following represents the current set of valid
|
||
transitions from status to status: NOT_PROVISIONED -> PROVISIONING -> CANCELLED PROVISIONING ->
|
||
RUNNING -> FAILED -> CANCELLED (note that this transition is disallowed in the MultiWorkspace
|
||
Project) RUNNING -> PROVISIONING -> BANNED -> CANCELLED FAILED -> PROVISIONING -> CANCELLED
|
||
BANNED -> RUNNING -> CANCELLED Note that a transition from any state to itself is also valid.
|
||
TODO(PLAT-5867): add a transition from CANCELLED to some other value (e.g. RECOVERING)"""
|
||
|
||
BANNED = "BANNED"
|
||
CANCELLING = "CANCELLING"
|
||
FAILED = "FAILED"
|
||
NOT_PROVISIONED = "NOT_PROVISIONED"
|
||
PROVISIONING = "PROVISIONING"
|
||
RUNNING = "RUNNING"
|
||
|
||
|
||
class CredentialsAPI:
|
||
"""These APIs manage credential configurations for this workspace. Databricks needs access to a cross-account
|
||
service IAM role in your AWS account so that Databricks can deploy clusters in the appropriate VPC for the
|
||
new workspace. A credential configuration encapsulates this role information, and its ID is used when
|
||
creating a new workspace."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def create(self, credentials_name: str, aws_credentials: CreateCredentialAwsCredentials) -> Credential:
|
||
"""Creates a Databricks credential configuration that represents cloud cross-account credentials for a
|
||
specified account. Databricks uses this to set up network infrastructure properly to host Databricks
|
||
clusters. For your AWS IAM role, you need to trust the External ID (the Databricks Account API account
|
||
ID) in the returned credential object, and configure the required access policy.
|
||
|
||
Save the response's `credentials_id` field, which is the ID for your new credential configuration
|
||
object.
|
||
|
||
For information about how to create a new workspace with this API, see [Create a new workspace using
|
||
the Account API]
|
||
|
||
[Create a new workspace using the Account API]: http://docs.databricks.com/administration-guide/account-api/new-workspace.html
|
||
|
||
:param credentials_name: str
|
||
The human-readable name of the credential configuration object.
|
||
:param aws_credentials: :class:`CreateCredentialAwsCredentials`
|
||
|
||
:returns: :class:`Credential`
|
||
"""
|
||
|
||
body = {}
|
||
if aws_credentials is not None:
|
||
body["aws_credentials"] = aws_credentials.as_dict()
|
||
if credentials_name is not None:
|
||
body["credentials_name"] = credentials_name
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do("POST", f"/api/2.0/accounts/{self._api.account_id}/credentials", body=body, headers=headers)
|
||
return Credential.from_dict(res)
|
||
|
||
def delete(self, credentials_id: str) -> Credential:
|
||
"""Deletes a Databricks credential configuration object for an account, both specified by ID. You cannot
|
||
delete a credential that is associated with any workspace.
|
||
|
||
:param credentials_id: str
|
||
Databricks Account API credential configuration ID
|
||
|
||
:returns: :class:`Credential`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"DELETE", f"/api/2.0/accounts/{self._api.account_id}/credentials/{credentials_id}", headers=headers
|
||
)
|
||
return Credential.from_dict(res)
|
||
|
||
def get(self, credentials_id: str) -> Credential:
|
||
"""Gets a Databricks credential configuration object for an account, both specified by ID.
|
||
|
||
:param credentials_id: str
|
||
Credential configuration ID
|
||
|
||
:returns: :class:`Credential`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"GET", f"/api/2.0/accounts/{self._api.account_id}/credentials/{credentials_id}", headers=headers
|
||
)
|
||
return Credential.from_dict(res)
|
||
|
||
def list(self) -> Iterator[Credential]:
|
||
"""List Databricks credential configuration objects for an account, specified by ID.
|
||
|
||
|
||
:returns: Iterator over :class:`Credential`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/credentials", headers=headers)
|
||
return [Credential.from_dict(v) for v in res]
|
||
|
||
|
||
class EncryptionKeysAPI:
|
||
"""These APIs manage encryption key configurations for this workspace (optional). A key configuration
|
||
encapsulates the AWS KMS key information and some information about how the key configuration can be used.
|
||
There are two possible uses for key configurations:
|
||
|
||
* Managed services: A key configuration can be used to encrypt a workspace's notebook and secret data in
|
||
the control plane, as well as Databricks SQL queries and query history. * Storage: A key configuration can
|
||
be used to encrypt a workspace's DBFS and EBS data in the data plane.
|
||
|
||
In both of these cases, the key configuration's ID is used when creating a new workspace. This Preview
|
||
feature is available if your account is on the E2 version of the platform. Updating a running workspace
|
||
with workspace storage encryption requires that the workspace is on the E2 version of the platform. If you
|
||
have an older workspace, it might not be on the E2 version of the platform. If you are not sure, contact
|
||
your Databricks representative."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def create(
|
||
self,
|
||
use_cases: List[KeyUseCase],
|
||
*,
|
||
aws_key_info: Optional[CreateAwsKeyInfo] = None,
|
||
gcp_key_info: Optional[CreateGcpKeyInfo] = None,
|
||
) -> CustomerManagedKey:
|
||
"""Creates a customer-managed key configuration object for an account, specified by ID. This operation
|
||
uploads a reference to a customer-managed key to Databricks. If the key is assigned as a workspace's
|
||
customer-managed key for managed services, Databricks uses the key to encrypt the workspaces notebooks
|
||
and secrets in the control plane, in addition to Databricks SQL queries and query history. If it is
|
||
specified as a workspace's customer-managed key for workspace storage, the key encrypts the
|
||
workspace's root S3 bucket (which contains the workspace's root DBFS and system data) and, optionally,
|
||
cluster EBS volume data.
|
||
|
||
**Important**: Customer-managed keys are supported only for some deployment types, subscription types,
|
||
and AWS regions that currently support creation of Databricks workspaces.
|
||
|
||
This operation is available only if your account is on the E2 version of the platform or on a select
|
||
custom plan that allows multiple workspaces per account.
|
||
|
||
:param use_cases: List[:class:`KeyUseCase`]
|
||
The cases that the key can be used for.
|
||
:param aws_key_info: :class:`CreateAwsKeyInfo` (optional)
|
||
:param gcp_key_info: :class:`CreateGcpKeyInfo` (optional)
|
||
|
||
:returns: :class:`CustomerManagedKey`
|
||
"""
|
||
|
||
body = {}
|
||
if aws_key_info is not None:
|
||
body["aws_key_info"] = aws_key_info.as_dict()
|
||
if gcp_key_info is not None:
|
||
body["gcp_key_info"] = gcp_key_info.as_dict()
|
||
if use_cases is not None:
|
||
body["use_cases"] = [v.value for v in use_cases]
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"POST", f"/api/2.0/accounts/{self._api.account_id}/customer-managed-keys", body=body, headers=headers
|
||
)
|
||
return CustomerManagedKey.from_dict(res)
|
||
|
||
def delete(self, customer_managed_key_id: str) -> CustomerManagedKey:
|
||
"""Deletes a customer-managed key configuration object for an account. You cannot delete a configuration
|
||
that is associated with a running workspace.
|
||
|
||
:param customer_managed_key_id: str
|
||
Databricks encryption key configuration ID.
|
||
|
||
:returns: :class:`CustomerManagedKey`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"DELETE",
|
||
f"/api/2.0/accounts/{self._api.account_id}/customer-managed-keys/{customer_managed_key_id}",
|
||
headers=headers,
|
||
)
|
||
return CustomerManagedKey.from_dict(res)
|
||
|
||
def get(self, customer_managed_key_id: str) -> CustomerManagedKey:
|
||
"""Gets a customer-managed key configuration object for an account, specified by ID. This operation
|
||
uploads a reference to a customer-managed key to Databricks. If assigned as a workspace's
|
||
customer-managed key for managed services, Databricks uses the key to encrypt the workspaces notebooks
|
||
and secrets in the control plane, in addition to Databricks SQL queries and query history. If it is
|
||
specified as a workspace's customer-managed key for storage, the key encrypts the workspace's root S3
|
||
bucket (which contains the workspace's root DBFS and system data) and, optionally, cluster EBS volume
|
||
data.
|
||
|
||
**Important**: Customer-managed keys are supported only for some deployment types, subscription types,
|
||
and AWS regions.
|
||
|
||
This operation is available only if your account is on the E2 version of the platform.",
|
||
|
||
:param customer_managed_key_id: str
|
||
Databricks encryption key configuration ID.
|
||
|
||
:returns: :class:`CustomerManagedKey`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"GET",
|
||
f"/api/2.0/accounts/{self._api.account_id}/customer-managed-keys/{customer_managed_key_id}",
|
||
headers=headers,
|
||
)
|
||
return CustomerManagedKey.from_dict(res)
|
||
|
||
def list(self) -> Iterator[CustomerManagedKey]:
|
||
"""Lists Databricks customer-managed key configurations for an account.
|
||
|
||
|
||
:returns: Iterator over :class:`CustomerManagedKey`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/customer-managed-keys", headers=headers)
|
||
return [CustomerManagedKey.from_dict(v) for v in res]
|
||
|
||
|
||
class NetworksAPI:
|
||
"""These APIs manage network configurations for customer-managed VPCs (optional). Its ID is used when
|
||
creating a new workspace if you use customer-managed VPCs."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def create(
|
||
self,
|
||
*,
|
||
gcp_network_info: Optional[GcpNetworkInfo] = None,
|
||
network_name: Optional[str] = None,
|
||
security_group_ids: Optional[List[str]] = None,
|
||
subnet_ids: Optional[List[str]] = None,
|
||
vpc_endpoints: Optional[NetworkVpcEndpoints] = None,
|
||
vpc_id: Optional[str] = None,
|
||
) -> Network:
|
||
"""Creates a Databricks network configuration that represents an VPC and its resources. The VPC will be
|
||
used for new Databricks clusters. This requires a pre-existing VPC and subnets.
|
||
|
||
:param gcp_network_info: :class:`GcpNetworkInfo` (optional)
|
||
:param network_name: str (optional)
|
||
The human-readable name of the network configuration.
|
||
:param security_group_ids: List[str] (optional)
|
||
IDs of one to five security groups associated with this network. Security group IDs **cannot** be
|
||
used in multiple network configurations.
|
||
:param subnet_ids: List[str] (optional)
|
||
IDs of at least two subnets associated with this network. Subnet IDs **cannot** be used in multiple
|
||
network configurations.
|
||
:param vpc_endpoints: :class:`NetworkVpcEndpoints` (optional)
|
||
:param vpc_id: str (optional)
|
||
The ID of the VPC associated with this network configuration. VPC IDs can be used in multiple
|
||
networks.
|
||
|
||
:returns: :class:`Network`
|
||
"""
|
||
|
||
body = {}
|
||
if gcp_network_info is not None:
|
||
body["gcp_network_info"] = gcp_network_info.as_dict()
|
||
if network_name is not None:
|
||
body["network_name"] = network_name
|
||
if security_group_ids is not None:
|
||
body["security_group_ids"] = [v for v in security_group_ids]
|
||
if subnet_ids is not None:
|
||
body["subnet_ids"] = [v for v in subnet_ids]
|
||
if vpc_endpoints is not None:
|
||
body["vpc_endpoints"] = vpc_endpoints.as_dict()
|
||
if vpc_id is not None:
|
||
body["vpc_id"] = vpc_id
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do("POST", f"/api/2.0/accounts/{self._api.account_id}/networks", body=body, headers=headers)
|
||
return Network.from_dict(res)
|
||
|
||
def delete(self, network_id: str) -> Network:
|
||
"""Deletes a Databricks network configuration, which represents a cloud VPC and its resources. You cannot
|
||
delete a network that is associated with a workspace.
|
||
|
||
This operation is available only if your account is on the E2 version of the platform.
|
||
|
||
:param network_id: str
|
||
Databricks Account API network configuration ID.
|
||
|
||
:returns: :class:`Network`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("DELETE", f"/api/2.0/accounts/{self._api.account_id}/networks/{network_id}", headers=headers)
|
||
return Network.from_dict(res)
|
||
|
||
def get(self, network_id: str) -> Network:
|
||
"""Gets a Databricks network configuration, which represents a cloud VPC and its resources.
|
||
|
||
:param network_id: str
|
||
Databricks Account API network configuration ID.
|
||
|
||
:returns: :class:`Network`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/networks/{network_id}", headers=headers)
|
||
return Network.from_dict(res)
|
||
|
||
def list(self) -> Iterator[Network]:
|
||
"""Lists Databricks network configurations for an account.
|
||
|
||
|
||
:returns: Iterator over :class:`Network`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/networks", headers=headers)
|
||
return [Network.from_dict(v) for v in res]
|
||
|
||
|
||
class PrivateAccessAPI:
|
||
"""These APIs manage private access settings for this account."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def create(
|
||
self,
|
||
*,
|
||
allowed_vpc_endpoint_ids: Optional[List[str]] = None,
|
||
private_access_level: Optional[PrivateAccessLevel] = None,
|
||
private_access_settings_name: Optional[str] = None,
|
||
public_access_enabled: Optional[bool] = None,
|
||
region: Optional[str] = None,
|
||
) -> PrivateAccessSettings:
|
||
"""Creates a private access settings configuration, which represents network access restrictions for
|
||
workspace resources. Private access settings configure whether workspaces can be accessed from the
|
||
public internet or only from private endpoints.
|
||
|
||
:param allowed_vpc_endpoint_ids: List[str] (optional)
|
||
An array of Databricks VPC endpoint IDs. This is the Databricks ID returned when registering the VPC
|
||
endpoint configuration in your Databricks account. This is not the ID of the VPC endpoint in AWS.
|
||
Only used when private_access_level is set to ENDPOINT. This is an allow list of VPC endpoints
|
||
registered in your Databricks account that can connect to your workspace over AWS PrivateLink. Note:
|
||
If hybrid access to your workspace is enabled by setting public_access_enabled to true, this control
|
||
only works for PrivateLink connections. To control how your workspace is accessed via public
|
||
internet, see IP access lists.
|
||
:param private_access_level: :class:`PrivateAccessLevel` (optional)
|
||
The private access level controls which VPC endpoints can connect to the UI or API of any workspace
|
||
that attaches this private access settings object. `ACCOUNT` level access (the default) allows only
|
||
VPC endpoints that are registered in your Databricks account connect to your workspace. `ENDPOINT`
|
||
level access allows only specified VPC endpoints connect to your workspace. For details, see
|
||
allowed_vpc_endpoint_ids.
|
||
:param private_access_settings_name: str (optional)
|
||
The human-readable name of the private access settings object.
|
||
:param public_access_enabled: bool (optional)
|
||
Determines if the workspace can be accessed over public internet. For fully private workspaces, you
|
||
can optionally specify false, but only if you implement both the front-end and the back-end
|
||
PrivateLink connections. Otherwise, specify true, which means that public access is enabled.
|
||
:param region: str (optional)
|
||
The AWS region for workspaces attached to this private access settings object.
|
||
|
||
:returns: :class:`PrivateAccessSettings`
|
||
"""
|
||
|
||
body = {}
|
||
if allowed_vpc_endpoint_ids is not None:
|
||
body["allowed_vpc_endpoint_ids"] = [v for v in allowed_vpc_endpoint_ids]
|
||
if private_access_level is not None:
|
||
body["private_access_level"] = private_access_level.value
|
||
if private_access_settings_name is not None:
|
||
body["private_access_settings_name"] = private_access_settings_name
|
||
if public_access_enabled is not None:
|
||
body["public_access_enabled"] = public_access_enabled
|
||
if region is not None:
|
||
body["region"] = region
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"POST", f"/api/2.0/accounts/{self._api.account_id}/private-access-settings", body=body, headers=headers
|
||
)
|
||
return PrivateAccessSettings.from_dict(res)
|
||
|
||
def delete(self, private_access_settings_id: str) -> PrivateAccessSettings:
|
||
"""Deletes a Databricks private access settings configuration, both specified by ID.
|
||
|
||
:param private_access_settings_id: str
|
||
|
||
:returns: :class:`PrivateAccessSettings`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"DELETE",
|
||
f"/api/2.0/accounts/{self._api.account_id}/private-access-settings/{private_access_settings_id}",
|
||
headers=headers,
|
||
)
|
||
return PrivateAccessSettings.from_dict(res)
|
||
|
||
def get(self, private_access_settings_id: str) -> PrivateAccessSettings:
|
||
"""Gets a Databricks private access settings configuration, both specified by ID.
|
||
|
||
:param private_access_settings_id: str
|
||
|
||
:returns: :class:`PrivateAccessSettings`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"GET",
|
||
f"/api/2.0/accounts/{self._api.account_id}/private-access-settings/{private_access_settings_id}",
|
||
headers=headers,
|
||
)
|
||
return PrivateAccessSettings.from_dict(res)
|
||
|
||
def list(self) -> Iterator[PrivateAccessSettings]:
|
||
"""Lists Databricks private access settings for an account.
|
||
|
||
|
||
:returns: Iterator over :class:`PrivateAccessSettings`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/private-access-settings", headers=headers)
|
||
return [PrivateAccessSettings.from_dict(v) for v in res]
|
||
|
||
def replace(
|
||
self, private_access_settings_id: str, customer_facing_private_access_settings: PrivateAccessSettings
|
||
) -> PrivateAccessSettings:
|
||
"""Updates an existing private access settings object, which specifies how your workspace is accessed
|
||
over AWS PrivateLink. To use AWS PrivateLink, a workspace must have a private access settings object
|
||
referenced by ID in the workspace's private_access_settings_id property. This operation completely
|
||
overwrites your existing private access settings object attached to your workspaces. All workspaces
|
||
attached to the private access settings are affected by any change. If public_access_enabled,
|
||
private_access_level, or allowed_vpc_endpoint_ids are updated, effects of these changes might take
|
||
several minutes to propagate to the workspace API. You can share one private access settings object
|
||
with multiple workspaces in a single account. However, private access settings are specific to AWS
|
||
regions, so only workspaces in the same AWS region can use a given private access settings object.
|
||
Before configuring PrivateLink, read the Databricks article about PrivateLink.
|
||
|
||
:param private_access_settings_id: str
|
||
Databricks private access settings ID.
|
||
:param customer_facing_private_access_settings: :class:`PrivateAccessSettings`
|
||
Properties of the new private access settings object.
|
||
|
||
:returns: :class:`PrivateAccessSettings`
|
||
"""
|
||
|
||
body = customer_facing_private_access_settings.as_dict()
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"PUT",
|
||
f"/api/2.0/accounts/{self._api.account_id}/private-access-settings/{private_access_settings_id}",
|
||
body=body,
|
||
headers=headers,
|
||
)
|
||
return PrivateAccessSettings.from_dict(res)
|
||
|
||
|
||
class StorageAPI:
|
||
"""These APIs manage storage configurations for this workspace. A root storage S3 bucket in your account is
|
||
required to store objects like cluster logs, notebook revisions, and job results. You can also use the
|
||
root storage S3 bucket for storage of non-production DBFS data. A storage configuration encapsulates this
|
||
bucket information, and its ID is used when creating a new workspace."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def create(
|
||
self, storage_configuration_name: str, root_bucket_info: RootBucketInfo, *, role_arn: Optional[str] = None
|
||
) -> StorageConfiguration:
|
||
"""Creates a Databricks storage configuration for an account.
|
||
|
||
:param storage_configuration_name: str
|
||
The human-readable name of the storage configuration.
|
||
:param root_bucket_info: :class:`RootBucketInfo`
|
||
Root S3 bucket information.
|
||
:param role_arn: str (optional)
|
||
Optional IAM role that is used to access the workspace catalog which is created during workspace
|
||
creation for UC by Default. If a storage configuration with this field populated is used to create a
|
||
workspace, then a workspace catalog is created together with the workspace. The workspace catalog
|
||
shares the root bucket with internal workspace storage (including DBFS root) but uses a dedicated
|
||
bucket path prefix.
|
||
|
||
:returns: :class:`StorageConfiguration`
|
||
"""
|
||
|
||
body = {}
|
||
if role_arn is not None:
|
||
body["role_arn"] = role_arn
|
||
if root_bucket_info is not None:
|
||
body["root_bucket_info"] = root_bucket_info.as_dict()
|
||
if storage_configuration_name is not None:
|
||
body["storage_configuration_name"] = storage_configuration_name
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"POST", f"/api/2.0/accounts/{self._api.account_id}/storage-configurations", body=body, headers=headers
|
||
)
|
||
return StorageConfiguration.from_dict(res)
|
||
|
||
def delete(self, storage_configuration_id: str) -> StorageConfiguration:
|
||
"""Deletes a Databricks storage configuration. You cannot delete a storage configuration that is
|
||
associated with any workspace.
|
||
|
||
:param storage_configuration_id: str
|
||
|
||
:returns: :class:`StorageConfiguration`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"DELETE",
|
||
f"/api/2.0/accounts/{self._api.account_id}/storage-configurations/{storage_configuration_id}",
|
||
headers=headers,
|
||
)
|
||
return StorageConfiguration.from_dict(res)
|
||
|
||
def get(self, storage_configuration_id: str) -> StorageConfiguration:
|
||
"""Gets a Databricks storage configuration for an account, both specified by ID.
|
||
|
||
:param storage_configuration_id: str
|
||
|
||
:returns: :class:`StorageConfiguration`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"GET",
|
||
f"/api/2.0/accounts/{self._api.account_id}/storage-configurations/{storage_configuration_id}",
|
||
headers=headers,
|
||
)
|
||
return StorageConfiguration.from_dict(res)
|
||
|
||
def list(self) -> Iterator[StorageConfiguration]:
|
||
"""Lists Databricks storage configurations for an account, specified by ID.
|
||
|
||
|
||
:returns: Iterator over :class:`StorageConfiguration`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/storage-configurations", headers=headers)
|
||
return [StorageConfiguration.from_dict(v) for v in res]
|
||
|
||
|
||
class VpcEndpointsAPI:
|
||
"""These APIs manage VPC endpoint configurations for this account."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def create(
|
||
self,
|
||
*,
|
||
aws_vpc_endpoint_id: Optional[str] = None,
|
||
gcp_vpc_endpoint_info: Optional[GcpVpcEndpointInfo] = None,
|
||
region: Optional[str] = None,
|
||
vpc_endpoint_name: Optional[str] = None,
|
||
) -> VpcEndpoint:
|
||
"""Creates a VPC endpoint configuration, which represents a [VPC endpoint] object in AWS used to
|
||
communicate privately with Databricks over [AWS PrivateLink].
|
||
|
||
After you create the VPC endpoint configuration, the Databricks [endpoint service] automatically
|
||
accepts the VPC endpoint.
|
||
|
||
Before configuring PrivateLink, read the [Databricks article about PrivateLink].
|
||
|
||
[AWS PrivateLink]: https://aws.amazon.com/privatelink
|
||
[Databricks article about PrivateLink]: https://docs.databricks.com/administration-guide/cloud-configurations/aws/privatelink.html
|
||
[VPC endpoint]: https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints.html
|
||
[endpoint service]: https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-share-your-services.html
|
||
|
||
:param aws_vpc_endpoint_id: str (optional)
|
||
The ID of the VPC endpoint object in AWS.
|
||
:param gcp_vpc_endpoint_info: :class:`GcpVpcEndpointInfo` (optional)
|
||
The cloud info of this vpc endpoint.
|
||
:param region: str (optional)
|
||
The region in which this VPC endpoint object exists.
|
||
:param vpc_endpoint_name: str (optional)
|
||
The human-readable name of the storage configuration.
|
||
|
||
:returns: :class:`VpcEndpoint`
|
||
"""
|
||
|
||
body = {}
|
||
if aws_vpc_endpoint_id is not None:
|
||
body["aws_vpc_endpoint_id"] = aws_vpc_endpoint_id
|
||
if gcp_vpc_endpoint_info is not None:
|
||
body["gcp_vpc_endpoint_info"] = gcp_vpc_endpoint_info.as_dict()
|
||
if region is not None:
|
||
body["region"] = region
|
||
if vpc_endpoint_name is not None:
|
||
body["vpc_endpoint_name"] = vpc_endpoint_name
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"POST", f"/api/2.0/accounts/{self._api.account_id}/vpc-endpoints", body=body, headers=headers
|
||
)
|
||
return VpcEndpoint.from_dict(res)
|
||
|
||
def delete(self, vpc_endpoint_id: str) -> VpcEndpoint:
|
||
"""Deletes a Databricks VPC endpoint configuration. You cannot delete a VPC endpoint configuration that
|
||
is associated with any workspace.
|
||
|
||
:param vpc_endpoint_id: str
|
||
|
||
:returns: :class:`VpcEndpoint`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"DELETE", f"/api/2.0/accounts/{self._api.account_id}/vpc-endpoints/{vpc_endpoint_id}", headers=headers
|
||
)
|
||
return VpcEndpoint.from_dict(res)
|
||
|
||
def get(self, vpc_endpoint_id: str) -> VpcEndpoint:
|
||
"""Gets a VPC endpoint configuration, which represents a [VPC endpoint] object in AWS used to communicate
|
||
privately with Databricks over [AWS PrivateLink].
|
||
|
||
[AWS PrivateLink]: https://aws.amazon.com/privatelink
|
||
[VPC endpoint]: https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html
|
||
|
||
:param vpc_endpoint_id: str
|
||
Databricks VPC endpoint ID.
|
||
|
||
:returns: :class:`VpcEndpoint`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"GET", f"/api/2.0/accounts/{self._api.account_id}/vpc-endpoints/{vpc_endpoint_id}", headers=headers
|
||
)
|
||
return VpcEndpoint.from_dict(res)
|
||
|
||
def list(self) -> Iterator[VpcEndpoint]:
|
||
"""Lists Databricks VPC endpoint configurations for an account.
|
||
|
||
|
||
:returns: Iterator over :class:`VpcEndpoint`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/vpc-endpoints", headers=headers)
|
||
return [VpcEndpoint.from_dict(v) for v in res]
|
||
|
||
|
||
class WorkspacesAPI:
|
||
"""These APIs manage workspaces for this account. A Databricks workspace is an environment for accessing all
|
||
of your Databricks assets. The workspace organizes objects (notebooks, libraries, and experiments) into
|
||
folders, and provides access to data and computational resources such as clusters and jobs.
|
||
|
||
These endpoints are available if your account is on the E2 version of the platform or on a select custom
|
||
plan that allows multiple workspaces per account."""
|
||
|
||
def __init__(self, api_client):
|
||
self._api = api_client
|
||
|
||
def wait_get_workspace_running(
|
||
self, workspace_id: int, timeout=timedelta(minutes=20), callback: Optional[Callable[[Workspace], None]] = None
|
||
) -> Workspace:
|
||
deadline = time.time() + timeout.total_seconds()
|
||
target_states = (WorkspaceStatus.RUNNING,)
|
||
failure_states = (
|
||
WorkspaceStatus.BANNED,
|
||
WorkspaceStatus.FAILED,
|
||
)
|
||
status_message = "polling..."
|
||
attempt = 1
|
||
while time.time() < deadline:
|
||
poll = self.get(workspace_id=workspace_id)
|
||
status = poll.workspace_status
|
||
status_message = poll.workspace_status_message
|
||
if status in target_states:
|
||
return poll
|
||
if callback:
|
||
callback(poll)
|
||
if status in failure_states:
|
||
msg = f"failed to reach RUNNING, got {status}: {status_message}"
|
||
raise OperationFailed(msg)
|
||
prefix = f"workspace_id={workspace_id}"
|
||
sleep = attempt
|
||
if sleep > 10:
|
||
# sleep 10s max per attempt
|
||
sleep = 10
|
||
_LOG.debug(f"{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)")
|
||
time.sleep(sleep + random.random())
|
||
attempt += 1
|
||
raise TimeoutError(f"timed out after {timeout}: {status_message}")
|
||
|
||
def create(
|
||
self,
|
||
*,
|
||
aws_region: Optional[str] = None,
|
||
cloud: Optional[str] = None,
|
||
cloud_resource_container: Optional[CloudResourceContainer] = None,
|
||
compute_mode: Optional[CustomerFacingComputeMode] = None,
|
||
credentials_id: Optional[str] = None,
|
||
custom_tags: Optional[Dict[str, str]] = None,
|
||
deployment_name: Optional[str] = None,
|
||
gcp_managed_network_config: Optional[GcpManagedNetworkConfig] = None,
|
||
gke_config: Optional[GkeConfig] = None,
|
||
location: Optional[str] = None,
|
||
managed_services_customer_managed_key_id: Optional[str] = None,
|
||
network_connectivity_config_id: Optional[str] = None,
|
||
network_id: Optional[str] = None,
|
||
pricing_tier: Optional[PricingTier] = None,
|
||
private_access_settings_id: Optional[str] = None,
|
||
storage_configuration_id: Optional[str] = None,
|
||
storage_customer_managed_key_id: Optional[str] = None,
|
||
workspace_name: Optional[str] = None,
|
||
) -> Wait[Workspace]:
|
||
"""Creates a new workspace using a credential configuration and a storage configuration, an optional
|
||
network configuration (if using a customer-managed VPC), an optional managed services key
|
||
configuration (if using customer-managed keys for managed services), and an optional storage key
|
||
configuration (if using customer-managed keys for storage). The key configurations used for managed
|
||
services and storage encryption can be the same or different.
|
||
|
||
Important: This operation is asynchronous. A response with HTTP status code 200 means the request has
|
||
been accepted and is in progress, but does not mean that the workspace deployed successfully and is
|
||
running. The initial workspace status is typically PROVISIONING. Use the workspace ID (workspace_id)
|
||
field in the response to identify the new workspace and make repeated GET requests with the workspace
|
||
ID and check its status. The workspace becomes available when the status changes to RUNNING.
|
||
|
||
You can share one customer-managed VPC with multiple workspaces in a single account. It is not
|
||
required to create a new VPC for each workspace. However, you cannot reuse subnets or Security Groups
|
||
between workspaces. If you plan to share one VPC with multiple workspaces, make sure you size your VPC
|
||
and subnets accordingly. Because a Databricks Account API network configuration encapsulates this
|
||
information, you cannot reuse a Databricks Account API network configuration across workspaces.
|
||
|
||
For information about how to create a new workspace with this API including error handling, see
|
||
[Create a new workspace using the Account API].
|
||
|
||
Important: Customer-managed VPCs, PrivateLink, and customer-managed keys are supported on a limited
|
||
set of deployment and subscription types. If you have questions about availability, contact your
|
||
Databricks representative.
|
||
|
||
This operation is available only if your account is on the E2 version of the platform or on a select
|
||
custom plan that allows multiple workspaces per account.
|
||
|
||
[Create a new workspace using the Account API]: http://docs.databricks.com/administration-guide/account-api/new-workspace.html
|
||
|
||
:param aws_region: str (optional)
|
||
:param cloud: str (optional)
|
||
DEPRECATED: This field is being ignored by the server and will be removed in the future. The cloud
|
||
name. This field always has the value `gcp`.
|
||
:param cloud_resource_container: :class:`CloudResourceContainer` (optional)
|
||
:param compute_mode: :class:`CustomerFacingComputeMode` (optional)
|
||
If the compute mode is `SERVERLESS`, a serverless workspace is created that comes pre-configured
|
||
with serverless compute and default storage, providing a fully-managed, enterprise-ready SaaS
|
||
experience. This means you don't need to provide any resources managed by you, such as credentials,
|
||
storage, or network. If the compute mode is `HYBRID` (which is the default option), a classic
|
||
workspace is created that uses customer-managed resources.
|
||
:param credentials_id: str (optional)
|
||
ID of the workspace's credential configuration object.
|
||
:param custom_tags: Dict[str,str] (optional)
|
||
The custom tags key-value pairing that is attached to this workspace. The key-value pair is a string
|
||
of utf-8 characters. The value can be an empty string, with maximum length of 255 characters. The
|
||
key can be of maximum length of 127 characters, and cannot be empty.
|
||
:param deployment_name: str (optional)
|
||
The deployment name defines part of the subdomain for the workspace. The workspace URL for the web
|
||
application and REST APIs is <workspace-deployment-name>.cloud.databricks.com. For example, if the
|
||
deployment name is abcsales, your workspace URL will be https://abcsales.cloud.databricks.com.
|
||
Hyphens are allowed. This property supports only the set of characters that are allowed in a
|
||
subdomain. To set this value, you must have a deployment name prefix. Contact your Databricks
|
||
account team to add an account deployment name prefix to your account. Workspace deployment names
|
||
follow the account prefix and a hyphen. For example, if your account's deployment prefix is acme and
|
||
the workspace deployment name is workspace-1, the JSON response for the deployment_name field
|
||
becomes acme-workspace-1. The workspace URL would be acme-workspace-1.cloud.databricks.com. You can
|
||
also set the deployment_name to the reserved keyword EMPTY if you want the deployment name to only
|
||
include the deployment prefix. For example, if your account's deployment prefix is acme and the
|
||
workspace deployment name is EMPTY, the deployment_name becomes acme only and the workspace URL is
|
||
acme.cloud.databricks.com. This value must be unique across all non-deleted deployments across all
|
||
AWS regions. If a new workspace omits this property, the server generates a unique deployment name
|
||
for you with the pattern dbc-xxxxxxxx-xxxx.
|
||
:param gcp_managed_network_config: :class:`GcpManagedNetworkConfig` (optional)
|
||
:param gke_config: :class:`GkeConfig` (optional)
|
||
:param location: str (optional)
|
||
The Google Cloud region of the workspace data plane in your Google account (for example,
|
||
`us-east4`).
|
||
:param managed_services_customer_managed_key_id: str (optional)
|
||
The ID of the workspace's managed services encryption key configuration object. This is used to help
|
||
protect and control access to the workspace's notebooks, secrets, Databricks SQL queries, and query
|
||
history. The provided key configuration object property use_cases must contain MANAGED_SERVICES.
|
||
:param network_connectivity_config_id: str (optional)
|
||
The object ID of network connectivity config. Once assigned, the workspace serverless compute
|
||
resources use the same set of stable IP CIDR blocks and optional private link to access your
|
||
resources.
|
||
:param network_id: str (optional)
|
||
The ID of the workspace's network configuration object. To use AWS PrivateLink, this field is
|
||
required.
|
||
:param pricing_tier: :class:`PricingTier` (optional)
|
||
:param private_access_settings_id: str (optional)
|
||
ID of the workspace's private access settings object. Only used for PrivateLink. You must specify
|
||
this ID if you are using [AWS PrivateLink] for either front-end (user-to-workspace connection),
|
||
back-end (data plane to control plane connection), or both connection types. Before configuring
|
||
PrivateLink, read the [Databricks article about PrivateLink].",
|
||
|
||
[AWS PrivateLink]: https://aws.amazon.com/privatelink/
|
||
[Databricks article about PrivateLink]: https://docs.databricks.com/administration-guide/cloud-configurations/aws/privatelink.html
|
||
:param storage_configuration_id: str (optional)
|
||
ID of the workspace's storage configuration object.
|
||
:param storage_customer_managed_key_id: str (optional)
|
||
The ID of the workspace's storage encryption key configuration object. This is used to encrypt the
|
||
workspace's root S3 bucket (root DBFS and system data) and, optionally, cluster EBS volumes. The
|
||
provided key configuration object property use_cases must contain STORAGE.
|
||
:param workspace_name: str (optional)
|
||
The human-readable name of the workspace.
|
||
|
||
:returns:
|
||
Long-running operation waiter for :class:`Workspace`.
|
||
See :method:wait_get_workspace_running for more details.
|
||
"""
|
||
|
||
body = {}
|
||
if aws_region is not None:
|
||
body["aws_region"] = aws_region
|
||
if cloud is not None:
|
||
body["cloud"] = cloud
|
||
if cloud_resource_container is not None:
|
||
body["cloud_resource_container"] = cloud_resource_container.as_dict()
|
||
if compute_mode is not None:
|
||
body["compute_mode"] = compute_mode.value
|
||
if credentials_id is not None:
|
||
body["credentials_id"] = credentials_id
|
||
if custom_tags is not None:
|
||
body["custom_tags"] = custom_tags
|
||
if deployment_name is not None:
|
||
body["deployment_name"] = deployment_name
|
||
if gcp_managed_network_config is not None:
|
||
body["gcp_managed_network_config"] = gcp_managed_network_config.as_dict()
|
||
if gke_config is not None:
|
||
body["gke_config"] = gke_config.as_dict()
|
||
if location is not None:
|
||
body["location"] = location
|
||
if managed_services_customer_managed_key_id is not None:
|
||
body["managed_services_customer_managed_key_id"] = managed_services_customer_managed_key_id
|
||
if network_connectivity_config_id is not None:
|
||
body["network_connectivity_config_id"] = network_connectivity_config_id
|
||
if network_id is not None:
|
||
body["network_id"] = network_id
|
||
if pricing_tier is not None:
|
||
body["pricing_tier"] = pricing_tier.value
|
||
if private_access_settings_id is not None:
|
||
body["private_access_settings_id"] = private_access_settings_id
|
||
if storage_configuration_id is not None:
|
||
body["storage_configuration_id"] = storage_configuration_id
|
||
if storage_customer_managed_key_id is not None:
|
||
body["storage_customer_managed_key_id"] = storage_customer_managed_key_id
|
||
if workspace_name is not None:
|
||
body["workspace_name"] = workspace_name
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
op_response = self._api.do(
|
||
"POST", f"/api/2.0/accounts/{self._api.account_id}/workspaces", body=body, headers=headers
|
||
)
|
||
return Wait(
|
||
self.wait_get_workspace_running,
|
||
response=Workspace.from_dict(op_response),
|
||
workspace_id=op_response["workspace_id"],
|
||
)
|
||
|
||
def create_and_wait(
|
||
self,
|
||
*,
|
||
aws_region: Optional[str] = None,
|
||
cloud: Optional[str] = None,
|
||
cloud_resource_container: Optional[CloudResourceContainer] = None,
|
||
compute_mode: Optional[CustomerFacingComputeMode] = None,
|
||
credentials_id: Optional[str] = None,
|
||
custom_tags: Optional[Dict[str, str]] = None,
|
||
deployment_name: Optional[str] = None,
|
||
gcp_managed_network_config: Optional[GcpManagedNetworkConfig] = None,
|
||
gke_config: Optional[GkeConfig] = None,
|
||
location: Optional[str] = None,
|
||
managed_services_customer_managed_key_id: Optional[str] = None,
|
||
network_connectivity_config_id: Optional[str] = None,
|
||
network_id: Optional[str] = None,
|
||
pricing_tier: Optional[PricingTier] = None,
|
||
private_access_settings_id: Optional[str] = None,
|
||
storage_configuration_id: Optional[str] = None,
|
||
storage_customer_managed_key_id: Optional[str] = None,
|
||
workspace_name: Optional[str] = None,
|
||
timeout=timedelta(minutes=20),
|
||
) -> Workspace:
|
||
return self.create(
|
||
aws_region=aws_region,
|
||
cloud=cloud,
|
||
cloud_resource_container=cloud_resource_container,
|
||
compute_mode=compute_mode,
|
||
credentials_id=credentials_id,
|
||
custom_tags=custom_tags,
|
||
deployment_name=deployment_name,
|
||
gcp_managed_network_config=gcp_managed_network_config,
|
||
gke_config=gke_config,
|
||
location=location,
|
||
managed_services_customer_managed_key_id=managed_services_customer_managed_key_id,
|
||
network_connectivity_config_id=network_connectivity_config_id,
|
||
network_id=network_id,
|
||
pricing_tier=pricing_tier,
|
||
private_access_settings_id=private_access_settings_id,
|
||
storage_configuration_id=storage_configuration_id,
|
||
storage_customer_managed_key_id=storage_customer_managed_key_id,
|
||
workspace_name=workspace_name,
|
||
).result(timeout=timeout)
|
||
|
||
def delete(self, workspace_id: int) -> Workspace:
|
||
"""Deletes a Databricks workspace, both specified by ID.
|
||
|
||
:param workspace_id: int
|
||
|
||
:returns: :class:`Workspace`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"DELETE", f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}", headers=headers
|
||
)
|
||
return Workspace.from_dict(res)
|
||
|
||
def get(self, workspace_id: int) -> Workspace:
|
||
"""Gets information including status for a Databricks workspace, specified by ID. In the response, the
|
||
`workspace_status` field indicates the current status. After initial workspace creation (which is
|
||
asynchronous), make repeated `GET` requests with the workspace ID and check its status. The workspace
|
||
becomes available when the status changes to `RUNNING`. For information about how to create a new
|
||
workspace with this API **including error handling**, see [Create a new workspace using the Account
|
||
API].
|
||
|
||
[Create a new workspace using the Account API]: http://docs.databricks.com/administration-guide/account-api/new-workspace.html
|
||
|
||
:param workspace_id: int
|
||
|
||
:returns: :class:`Workspace`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do(
|
||
"GET", f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}", headers=headers
|
||
)
|
||
return Workspace.from_dict(res)
|
||
|
||
def list(self) -> Iterator[Workspace]:
|
||
"""Lists Databricks workspaces for an account.
|
||
|
||
|
||
:returns: Iterator over :class:`Workspace`
|
||
"""
|
||
|
||
headers = {
|
||
"Accept": "application/json",
|
||
}
|
||
|
||
res = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/workspaces", headers=headers)
|
||
return [Workspace.from_dict(v) for v in res]
|
||
|
||
def update(
|
||
self, workspace_id: int, customer_facing_workspace: Workspace, *, update_mask: Optional[str] = None
|
||
) -> Wait[Workspace]:
|
||
"""Updates a workspace.
|
||
|
||
:param workspace_id: int
|
||
A unique integer ID for the workspace
|
||
:param customer_facing_workspace: :class:`Workspace`
|
||
:param update_mask: str (optional)
|
||
The field mask must be a single string, with multiple fields separated by commas (no spaces). The
|
||
field path is relative to the resource object, using a dot (`.`) to navigate sub-fields (e.g.,
|
||
`author.given_name`). Specification of elements in sequence or map fields is not allowed, as only
|
||
the entire collection field can be specified. Field names must exactly match the resource field
|
||
names.
|
||
|
||
A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
|
||
fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the API
|
||
changes in the future.
|
||
|
||
:returns:
|
||
Long-running operation waiter for :class:`Workspace`.
|
||
See :method:wait_get_workspace_running for more details.
|
||
"""
|
||
|
||
body = customer_facing_workspace.as_dict()
|
||
query = {}
|
||
if update_mask is not None:
|
||
query["update_mask"] = update_mask
|
||
headers = {
|
||
"Accept": "application/json",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
op_response = self._api.do(
|
||
"PATCH",
|
||
f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}",
|
||
query=query,
|
||
body=body,
|
||
headers=headers,
|
||
)
|
||
return Wait(
|
||
self.wait_get_workspace_running,
|
||
response=Workspace.from_dict(op_response),
|
||
workspace_id=op_response["workspace_id"],
|
||
)
|
||
|
||
def update_and_wait(
|
||
self,
|
||
workspace_id: int,
|
||
customer_facing_workspace: Workspace,
|
||
*,
|
||
update_mask: Optional[str] = None,
|
||
timeout=timedelta(minutes=20),
|
||
) -> Workspace:
|
||
return self.update(
|
||
customer_facing_workspace=customer_facing_workspace, update_mask=update_mask, workspace_id=workspace_id
|
||
).result(timeout=timeout)
|