Pular para o conteúdo principal

Montagem do armazenamento de objetos em nuvem na Databricks

important

As montagens são um padrão de acesso legado. A Databricks recomenda o uso do Unity Catalog para gerenciar todo o acesso aos dados. Consulte Conectar-se ao serviço e armazenamento de objetos na nuvem usando Unity Catalog.

O Databricks permite que os usuários montem o armazenamento de objetos em cloud 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 cloud. Dados montados não funcionam com o Unity Catalog, e o Databricks recomenda migrar para o gerenciamento da governança de dados com o Unity Catalog em vez de usar montagens.

Como a Databricks monta o armazenamento de objetos na nuvem?​

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

  • Localização do armazenamento de objetos em cloud.
  • Especificações do driver para conectar-se à account de armazenamento ou ao 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 objetos (e pode, opcionalmente, codificar credenciais de segurança). mount_point especifica o caminho local no diretório /mnt . Algumas fontes de armazenamento de objetos 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.

nota

Databricks recomenda definir configurações específicas de Spark e Hadoop para o mount como opções usando extra_configs. Isso garante que as configurações estejam vinculadas ao mount e não ao cluster ou sessão.

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

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

nota

Além das abordagens descritas neste artigo, o senhor pode automatizar a montagem de um bucket com o provedorDatabricks Terraform e databricks_mount.

desmontar um ponto de montagem​

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

Python
dbutils.fs.unmount("/mnt/<mount-name>")
atenção

Para evitar erros, nunca modifique um ponto de montagem enquanto outros trabalhos estiverem 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 bucket S3​

O senhor pode montar um bucket S3 por meio do What is 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 um cluster, os usuários podem acessá-lo imediatamente. Para usar o ponto de montagem em outro cluster em execução, você deve executar dbutils.fs.refreshMounts() nesse cluster em execução para disponibilizar o ponto de montagem recém-criado.

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

Monte uma caçamba usando o site AWS instance profile​

O senhor pode gerenciar a autenticação e a autorização para um bucket S3 usando um AWS instance profile. 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. Configurar seu cluster com um instance profile.

  2. Monte o bucket.

Python
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}"))

Montar um bucket usando a chave AWS​

Você pode montar um bucket usando AWS keys.

important

Quando você monta um bucket do S3 usando keys, todos os usuários têm acesso de leitura e gravação a todos os objetos no bucket do S3.

Os exemplos a seguir usam Databricks secrets para armazenar a chave. O senhor deve escapar da URL a chave secreta.

Python
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}"))

Montar um bucket usando o perfil de instância com a política AssumeRole​

O senhor deve primeiro configurar o Access cross-account S3 buckets com uma política AssumeRole.

Monte buckets enquanto define as opções do S3 no extraConfigs:

Python
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"
  }
)

Criptografar dados em buckets S3​

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

Grave arquivos usando o SSE-S3​

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

    Scala
    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:

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

Grave arquivos usando o SSE-KMS​

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

    • Para montar seu bucket S3 com SSE-KMS usando a master key KMS padrão, execute:

      Scala
      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:

      Scala
      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:

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

Montagem de buckets S3 com o serviço de commit da Databricks​

Se o senhor planeja gravar em uma determinada tabela armazenada em S3 a partir de vários clusters ou cargas de trabalho simultaneamente, o Databricks recomenda que configure o Databricks S3 commit serviço. O código do Notebook deve montar o bucket e adicionar a configuração AssumeRole. Essa etapa é necessária somente para montagens em DBFS, não para acessar o armazenamento DBFS root armazenamento em seu bucket workspace's root S3. O exemplo a seguir usa Python:

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>"
})

Montar ADLS ou Blob Storage com ABFS​

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

important
  • Todos os usuários do site Databricks workspace têm acesso ao site ADLS account montado. A entidade de serviço que o senhor utiliza para acessar o ADLS account deve ter acesso apenas a esse ADLS account; não deve ter acesso a outros Azure recurso.
  • Quando você cria um ponto de montagem por meio de um cluster, os usuários do cluster podem acessá-lo imediatamente. Para usar o ponto de montagem em outro cluster em execução, você deve executar dbutils.fs.refreshMounts() nesse cluster em execução para disponibilizar o ponto de montagem recém-criado para uso.
  • Desmontar um ponto de montagem enquanto as tarefas estão em execução pode causar erros. Certifique-se de que os jobs de produção não desmontem o armazenamento como parte do processamento.
  • Os pontos de montagem que usam segredos não são atualizados automaticamente. Se o armazenamento montado depender de um segredo que é rotacionado, expira ou é excluído, podem ocorrer erros, como 401 Unauthorized. Para resolver esse erro, você deve desmontar e remontar o armazenamento.
  • O HNS (Hierarchical namespace, espaço de nomes hierárquico) deve estar ativado para montar com êxito um armazenamento Azure data lake Storage account usando o ABFS endpoint.

Execute o seguinte em seu notebook para autenticar e criar um ponto de montagem.

Python
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)
Scala
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> pelo ID da aplicação (cliente) para a aplicação Azure Active Directory.
  • <scope-name> pelo nome do secret scope do Databricks.
  • <service-credential-key-name> pelo nome da chave que contém o segredo do cliente.
  • <directory-id> pela ID do diretório (tenant) para a aplicação Azure Active Directory.
  • <container-name> com o nome de um contêiner no armazenamento ADLS account.
  • <storage-account-name> com o nome ADLS storage account.
  • <mount-name> com o nome do ponto de montagem pretendido no DBFS.
Última atualização em