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
Montar um bucket usando keyAWS
Monte um bucket usando instance profile com a política AssumeRole

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.

Configure seus clusters com um instance profile.

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

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

Para gravar arquivos no bucket S3 correspondente com SSE-S3, execute:
```
dbutils.fs.put(s"/mnt/$MountName", "<file content>")
```

Gravar arquivos usando SSE-KMS

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

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 o senhor planeja gravar em uma determinada tabela armazenada em S3 a partir de várias clusters ou cargas de trabalho simultaneamente, Databricks recomenda que configure Databricks S3 commit serviço. Seu código Notebook deve montar o bucket e adicionar a configuração AssumeRole. Esse passo é necessário somente para montagens em DBFS, não para acessar o DBFS root armazenamento em seu bucket workspace's root S3. 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

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