Montando o armazenamento de objetos em nuvem no Databricks

O Databricks permite que os usuários montem o armazenamento de objetos de nuvens no Databricks File System (DBFS) para simplificar os padrões de acesso a dados para usuários que não estão familiarizados com os conceitos de nuvens. Os dados montados não funcionam com o Unity Catalog, e a Databricks recomenda a migração do uso de montagens e, em vez disso, o gerenciamento da governança de dados com o Unity Catalog.

Como o Databricks monta o armazenamento de objetos em nuvem?

As montagens do Databricks criam um link entre um workspace e o armazenamento de objetos cloud , o que permite que você interaja com o armazenamento de objetos cloud usando caminhos de arquivo familiares relativos ao sistema de arquivos Databricks. As montagens funcionam criando um alias local no diretório /mnt que armazena as seguintes informações:

  • Localização do armazenamento de objetos cloud .

  • Especificações do driver para se conectar à account de armazenamento ou contêiner.

  • Credenciais de segurança necessárias para acessar os dados.

Qual é a sintaxe para montar o armazenamento?

O source especifica o URI do armazenamento de objeto (e pode, opcionalmente, codificar credenciais de segurança). O mount_point especifica o caminho local no diretório /mnt . Algumas fontes de armazenamento de objeto suportam um argumento encryption_type opcional. Para alguns padrões de acesso, você pode passar especificações de configuração adicionais como um dicionário para extra_configs.

Observação

A Databricks recomenda definir a configuração específica do Spark e do Hadoop como opções usando extra_configs. Isso garante que as configurações estejam vinculadas à montagem e não aos clusters ou à sessão.

dbutils.fs.mount(
  source: str,
  mount_point: str,
  encryption_type: Optional[str] = "",
  extra_configs: Optional[dict[str:str]] = None
)

Verifique com seus administradores workspace e cloud antes de configurar ou alterar montagens de dados, pois uma configuração inadequada pode fornecer acesso não seguro a todos os usuários em seu workspace.

Observação

Além das abordagens descritas neste artigo, você pode automatizar a montagem de um bucket com o provedor Databricks Terraform e databricks_mount.

Desmontar um ponto de montagem

Para unmount um ponto de montagem, use o seguinte comando:

dbutils.fs.unmount("/mnt/<mount-name>")

Aviso

Para evitar erros, nunca modifique um ponto de montagem enquanto outro Job estiver lendo ou gravando nele. Depois de modificar uma montagem, sempre execute dbutils.fs.refreshMounts() em todos os outros clusters em execução para propagar quaisquer atualizações de montagem. Consulte o comando refreshMounts (dbutils.fs.refreshMounts).

Montar um balde S3

Você pode montar um bucket S3 por meio de O que é o Databricks File System (DBFS)?. A montagem é um ponteiro para um local do S3, portanto, os dados nunca são sincronizados localmente.

Depois que um ponto de montagem é criado por meio de clusters, os usuários desses clusters podem acessar imediatamente o ponto de montagem. Para usar o ponto de montagem em outros clusterss em execução, você deve executar dbutils.fs.refreshMounts() naquele clusterss em execução para disponibilizar o ponto de montagem recém-criado.

Você pode usar os seguintes métodos para montar um bucket S3:

Montar um bucket usando um instance profileda AWS

Você pode gerenciar a autenticação e a autorização para um bucket S3 usando um instance profile da AWS. O acesso aos objetos no bucket é determinado pelas permissões concedidas ao instance profile. Se a função tiver acesso de gravação, os usuários do ponto de montagem poderão gravar objetos no bucket. Se a função tiver acesso de leitura, os usuários do ponto de montagem poderão ler objetos no bucket.

  1. Configure seus clusters com um instance profile.

  2. Monte o balde.

    aws_bucket_name = "<aws-bucket-name>"
    mount_name = "<mount-name>"
    dbutils.fs.mount(f"s3a://{aws_bucket_name}", f"/mnt/{mount_name}")
    display(dbutils.fs.ls(f"/mnt/{mount_name}"))
    
    val AwsBucketName = "<aws-bucket-name>"
    val MountName = "<mount-name>"
    
    dbutils.fs.mount(s"s3a://$AwsBucketName", s"/mnt/$MountName")
    display(dbutils.fs.ls(s"/mnt/$MountName"))
    

Monte um bucket usando as chaves da AWS

Você pode montar um bucket usando key AWS.

Importante

Quando você monta um depósito S3 usando key, todos os usuários têm acesso de leitura e gravação a todos os objetos no depósito S3.

Os exemplos a seguir usam segredos do Databricks para armazenar a key. Você deve escapar da key secreta do URL .

access_key = dbutils.secrets.get(scope = "aws", key = "aws-access-key")
secret_key = dbutils.secrets.get(scope = "aws", key = "aws-secret-key")
encoded_secret_key = secret_key.replace("/", "%2F")
aws_bucket_name = "<aws-bucket-name>"
mount_name = "<mount-name>"

dbutils.fs.mount(f"s3a://{access_key}:{encoded_secret_key}@{aws_bucket_name}", f"/mnt/{mount_name}")
display(dbutils.fs.ls(f"/mnt/{mount_name}"))
val AccessKey = dbutils.secrets.get(scope = "aws", key = "aws-access-key")
// Encode the Secret Key as that can contain "/"
val SecretKey = dbutils.secrets.get(scope = "aws", key = "aws-secret-key")
val EncodedSecretKey = SecretKey.replace("/", "%2F")
val AwsBucketName = "<aws-bucket-name>"
val MountName = "<mount-name>"

dbutils.fs.mount(s"s3a://$AccessKey:$EncodedSecretKey@$AwsBucketName", s"/mnt/$MountName")
display(dbutils.fs.ls(s"/mnt/$MountName"))

Monte um bucket usando instance profile com a política AssumeRole

Você deve primeiro configurar os buckets do S3 entreaccount do Access com uma política AssumeRole.

Monte os depósitos ao definir as opções do S3 no extraConfigs:

dbutils.fs.mount("s3a://<s3-bucket-name>", "/mnt/<s3-bucket-name>",
  extra_configs = {
    "fs.s3a.credentialsType": "AssumeRole",
    "fs.s3a.stsAssumeRole.arn": "arn:aws:iam::<bucket-owner-acct-id>:role/MyRoleB",
    "fs.s3a.canned.acl": "BucketOwnerFullControl",
    "fs.s3a.acl.default": "BucketOwnerFullControl"
  }
)
dbutils.fs.mount("s3a://<s3-bucket-name>", "/mnt/<s3-bucket-name>",
  extraConfigs = Map(
    "fs.s3a.credentialsType" -> "AssumeRole",
    "fs.s3a.stsAssumeRole.arn" -> "arn:aws:iam::<bucket-owner-acct-id>:role/MyRoleB",
    "fs.s3a.canned.acl" -> "BucketOwnerFullControl",
    "fs.s3a.acl.default" -> "BucketOwnerFullControl"
  )
)

Criptografar dados em buckets S3

Databricks dá suporte à criptografia de uso de criptografia do lado do servidor de dados. Esta seção aborda como usar a criptografia do lado do servidor ao gravar arquivos no S3 por meio do DBFS. Databricks oferece suporte key de criptografia Amazon S3-gerenciar (SSE-S3) e key de criptografia AWS KMS-gerenciar (SSE-KMS).

Gravar arquivos usando SSE-S3

  1. Para montar seu bucket S3 com SSE-S3, execute o seguinte comando:

    dbutils.fs.mount(s"s3a://$AccessKey:$SecretKey@$AwsBucketName", s"/mnt/$MountName", "sse-s3")
    
  2. Para gravar arquivos no bucket S3 correspondente com SSE-S3, execute:

    dbutils.fs.put(s"/mnt/$MountName", "<file content>")
    

Gravar arquivos usando SSE-KMS

  1. Monte um diretório de origem passando sse-kms ou sse-kms:$KmsKey como o tipo de criptografia.

    • Para montar seu bucket S3 com SSE-KMS usando a key mestra KMS default, execute:

      dbutils.fs.mount(s"s3a://$AccessKey:$SecretKey@$AwsBucketName", s"/mnt/$MountName", "sse-kms")
      
    • Para montar seu bucket S3 com SSE-KMS usando uma key KMS específica, execute:

      dbutils.fs.mount(s"s3a://$AccessKey:$SecretKey@$AwsBucketName", s"/mnt/$MountName", "sse-kms:$KmsKey")
      
  2. Para gravar arquivos no bucket S3 com SSE-KMS, execute:

    dbutils.fs.put(s"/mnt/$MountName", "<file content>")
    

Montando baldes S3 com o serviço de confirmação Databricks

Se você planeja gravar em uma determinada tabela armazenada no S3 de vários clusters ou cargas de trabalho simultaneamente, o Databricks recomenda que você configure os serviços de confirmação do Databricks S3. Seu código Notebook deve montar o bucket e adicionar a configuração AssumeRole. Esta passo é necessária apenas para montagens DBFS, não para acessar o armazenamento DBFS raiz no bucket S3 raiz do seu workspace . O exemplo a seguir usa Python:


# If other code has already mounted the bucket without using the new role, unmount it first
dbutils.fs.unmount("/mnt/<mount-name>")

# mount the bucket and assume the new role
dbutils.fs.mount("s3a://<bucket-name>/", "/mnt/<mount-name>", extra_configs = {
    "fs.s3a.credentialsType": "AssumeRole",
    "fs.s3a.stsAssumeRole.arn": "<role-arn>"
})

Monte ADLS Gen2 ou Blob Storage com ABFS

Você pode montar dados em uma account de armazenamento do Azure usando uma entidade de serviço de aplicativo Microsoft Entra ID (anteriormente Azure Active Directory) para autenticação. Para obter mais informações, consulte Acessar o armazenamento com o Microsoft Entra ID (anteriormente Azure Active Directory) usando uma entidade de serviço.

Importante

  • Todos os usuários no workspace Databricks têm acesso à account ADLS Gen2 montada. A entidade de serviço que você usa para acessar a account ADLS Gen2 deve receber acesso apenas a essa account ADLS Gen2; ele não deve ter acesso a outros recursos do Azure.

  • Quando você cria um ponto de montagem por meio de clusters, os usuários clusters podem acessar imediatamente o ponto de montagem. Para usar o ponto de montagem em outros clusterss em execução, você deve executar dbutils.fs.refreshMounts() naquele clusterss em execução para disponibilizar o ponto de montagem recém-criado para uso.

  • unmount um ponto de montagem enquanto Job está em execução pode levar a erros. Certifique-se de que Job de produção não unmount o armazenamento como parte do processamento.

  • Os pontos de montagem que usam segredos não são atualizados automaticamente. Se o armazenamento montado depende de um segredo que é alternado, expira ou é excluído, podem ocorrer erros, como 401 Unauthorized. Para resolver esse erro, você deve unmount e remontar o armazenamento.

  • O namespace hierárquico (HNS) deve ser habilitado para montar com êxito uma account de armazenamento do Azure Data Lake Storage Gen2 usando o endpoint ABFS.

execute o seguinte em seu Notebook para autenticar e criar um ponto de montagem.

configs = {"fs.azure.account.auth.type": "OAuth",
          "fs.azure.account.oauth.provider.type": "org.apache.hadoop.fs.azurebfs.oauth2.ClientCredsTokenProvider",
          "fs.azure.account.oauth2.client.id": "<application-id>",
          "fs.azure.account.oauth2.client.secret": dbutils.secrets.get(scope="<scope-name>",key="<service-credential-key-name>"),
          "fs.azure.account.oauth2.client.endpoint": "https://login.microsoftonline.com/<directory-id>/oauth2/token"}

# Optionally, you can add <directory-name> to the source URI of your mount point.
dbutils.fs.mount(
  source = "abfss://<container-name>@<storage-account-name>.dfs.core.windows.net/",
  mount_point = "/mnt/<mount-name>",
  extra_configs = configs)
val configs = Map(
  "fs.azure.account.auth.type" -> "OAuth",
  "fs.azure.account.oauth.provider.type" -> "org.apache.hadoop.fs.azurebfs.oauth2.ClientCredsTokenProvider",
  "fs.azure.account.oauth2.client.id" -> "<application-id>",
  "fs.azure.account.oauth2.client.secret" -> dbutils.secrets.get(scope="<scope-name>",key="<service-credential-key-name>"),
  "fs.azure.account.oauth2.client.endpoint" -> "https://login.microsoftonline.com/<directory-id>/oauth2/token")
// Optionally, you can add <directory-name> to the source URI of your mount point.
dbutils.fs.mount(
  source = "abfss://<container-name>@<storage-account-name>.dfs.core.windows.net/",
  mountPoint = "/mnt/<mount-name>",
  extraConfigs = configs)

Substituir

  • <application-id> com a ID do aplicativo (cliente) para o aplicativo Azure Active Directory.

  • <scope-name> com o nome do Databricks Secret Scope .

  • <service-credential-key-name> com o nome da key que contém o segredo do cliente.

  • <directory-id> com a ID do diretório (tenant) para o aplicativo Azure Active Directory.

  • <container-name> com o nome de um contêiner na account de armazenamento ADLS Gen2.

  • <storage-account-name> com o nome account de armazenamento ADLS Gen2.

  • <mount-name> com o nome do ponto de montagem pretendido no DBFS.