Aller au contenu principal
Dernière mise à jour le

Montage du stockage d'objets cloud sur Databricks

important

Les montages DBFS sont un modèle obsolète et ne sont pas compatibles avec l'architecture de compute serverless Databricks. Les nouveaux comptes sont provisionnés sans accès à ces fonctionnalités. Databricks recommande d'utiliser plutôt les emplacements externes du Unity Catalog.

Databricks permet aux utilisateurs de monter le stockage d'objets cloud sur le Databricks File System (DBFS) afin de simplifier les modèles d'accès aux données pour les utilisateurs qui ne connaissent pas bien les concepts du cloud. Les données montées ne fonctionnent pas avec Unity Catalog, et Databricks recommande de ne plus utiliser les montages et de gérer plutôt la gouvernance des données avec Unity Catalog.

Comment Databricks monte-t-il le stockage d'objets cloud ?​

Les montages Databricks créent un Link entre un workspace et le stockage d'objets cloud, ce qui vous permet d'interagir avec le stockage d'objets cloud à l'aide de chemins de fichiers familiers relatifs au système de fichiers Databricks. Les montages fonctionnent en créant un alias local sous le répertoire /mnt qui stocke les informations suivantes :

  • Emplacement du stockage d'objets cloud.
  • Spécifications du Driver pour se connecter au compte de stockage ou au conteneur.
  • Des identifiants de sécurité sont requis pour accéder aux données.

Quelle est la syntaxe pour le montage du stockage ?​

Le source spécifie l’URI du stockage d’objets (et peut éventuellement encoder les identifiants de sécurité). Le mount_point spécifie le chemin local dans le répertoire /mnt. Certaines sources de stockage d’objets prennent en charge un argument encryption_type facultatif. Pour certains modèles d'accès, vous pouvez passer des spécifications de configuration supplémentaires sous forme de dictionnaire à extra_configs.

remarque

Databricks recommande de définir la configuration Spark et Hadoop spécifique au point de montage sous forme d’options à l’aide de extra_configs. Ceci garantit que les configurations sont liées au point de montage plutôt qu'au cluster ou à la session.

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

Veuillez vérifier auprès des administrateurs de votre Workspace et de votre cloud avant de configurer ou de modifier les montages de données, car une configuration incorrecte peut fournir un accès non sécurisé à tous les utilisateurs de votre Workspace.

remarque

En plus des approches décrites dans cet article, vous pouvez automatiser le montage d'un compartiment avec le fournisseur Databricks Terraform et databricks_mount.

Démonter un point de montage​

Pour démonter un point de montage, utilisez la commande suivante :

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

Pour éviter les erreurs, ne modifiez jamais un point de montage pendant que d'autres Jobs le lisent ou l'écrivent. Après avoir modifié un point de montage, exécutez toujours dbutils.fs.refreshMounts() sur tous les autres clusters en cours d'exécution pour propager toute mise à jour de point de montage. Voir la commande refreshMounts (dbutils.fs.refreshMounts).

Monter un compartiment S3​

Vous pouvez monter un compartiment S3 via Qu'est-ce que DBFS ?. Le point de montage est un pointeur vers un emplacement S3, ainsi les données ne sont jamais synchronisées localement.

Après la création d'un point de montage via un cluster, les utilisateurs de ce cluster peuvent y accéder immédiatement. Pour utiliser le point de montage dans un autre cluster en cours d'exécution, vous devez exécuter dbutils.fs.refreshMounts() sur ce cluster en cours d'exécution afin de rendre le point de montage nouvellement créé disponible.

Vous pouvez utiliser les méthodes suivantes pour monter un compartiment S3 :

Monter un bucket à l'aide d'un profil d'instance AWS​

Vous pouvez gérer l'authentification et l'autorisation pour un compartiment S3 à l'aide d'un profil d'instance AWS. L'accès aux objets du compartiment est déterminé par les autorisations accordées au profil d'instance. Si le rôle dispose d'un accès en écriture, les utilisateurs du point de montage peuvent écrire des objets dans le compartiment. Si le rôle dispose d'un accès en lecture, les utilisateurs du point de montage pourront lire les objets du compartiment.

  1. Configurez votre cluster avec un profil d'instance.
  2. Monter le compartiment.
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}"))

Monter un compartiment à l'aide de clés AWS​

Vous pouvez monter un bucket à l'aide de clés AWS.

important

Lorsque vous montez un compartiment S3 à l'aide de clés, tous les utilisateurs ont un accès en lecture et en écriture à tous les objets du compartiment S3.

Les exemples suivants utilisent les secrets Databricks pour stocker les clés. Vous devez échapper l'URL de la clé secrète.

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

Montez un compartiment à l’aide de profils d’instance avec la politique AssumeRole​

Vous devez d'abord configurer l'accès aux compartiments S3 inter-comptes avec une politique AssumeRole.

Monter les compartiments lors de la définition des options S3 dans le 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"
  }
)

Chiffrer les données dans les compartiments S3​

Databricks prend en charge le chiffrement des données à l’aide du chiffrement côté serveur. Cette section explique comment utiliser le chiffrement côté serveur lors de l’écriture de fichiers dans S3 via DBFS. Databricks prend en charge les clés de chiffrement gérées par Amazon S3 (SSE-S3) et les clés de chiffrement gérées par AWS KMS (SSE-KMS).

Écrire des fichiers à l'aide de SSE-S3​

  1. Pour monter votre compartiment S3 avec SSE-S3, exécutez la commande suivante :

    Scala
    dbutils.fs.mount(s"s3a://$AccessKey:$SecretKey@$AwsBucketName", s"/mnt/$MountName", "sse-s3")

  2. Pour écrire des fichiers dans le compartiment S3 correspondant avec SSE-S3, exécutez :

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

Écrire des fichiers à l'aide de SSE-KMS​

  1. Montez un répertoire source en passant sse-kms ou sse-kms:$KmsKey comme type de chiffrement.

    • Pour monter votre compartiment S3 avec SSE-KMS à l'aide de la clé principale KMS default, exécutez :

      Scala
      dbutils.fs.mount(s"s3a://$AccessKey:$SecretKey@$AwsBucketName", s"/mnt/$MountName", "sse-kms")

    • Pour monter votre compartiment S3 avec SSE-KMS en utilisant une clé KMS spécifique, exécutez :

      Scala
      dbutils.fs.mount(s"s3a://$AccessKey:$SecretKey@$AwsBucketName", s"/mnt/$MountName", "sse-kms:$KmsKey")

  2. Pour écrire des fichiers dans le compartiment S3 avec SSE-KMS, exécutez :

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

Montage de compartiments S3 avec le service de commit Databricks​

Si vous prévoyez d'écrire dans une table donnée stockée dans S3 à partir de plusieurs clusters ou charges de travail simultanément, Databricks vous recommande de configurer les services de commit S3 de Databricks. Votre code de notebook doit monter le compartiment et ajouter la configuration AssumeRole. Cette étape est nécessaire uniquement pour les montages DBFS, pas pour l’accès au stockage de la racine DBFS dans le compartiment S3 racine de votre workspace. L'exemple suivant utilise 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>"
})

Monter ADLS ou le stockage Blob avec ABFS​

Vous pouvez monter des données dans un compte de stockage Azure en utilisant un service principal d'application Microsoft Entra ID pour l'authentification. Pour plus d'informations, consultez Se connecter à Azure Data Lake Storage et à Stockage Blob.

important
  • Tous les utilisateurs du workspace Databricks ont accès au compte ADLS monté. Le Service Principal que vous utilisez pour accéder au compte ADLS ne devrait avoir accès qu’à ce compte ADLS ; il ne devrait pas avoir accès à d'autres ressources Azure.
  • Lorsque vous créez un point de montage via un cluster, les utilisateurs du cluster peuvent immédiatement accéder au point de montage. Pour utiliser le point de montage dans un autre cluster en cours d'exécution, vous devez exécuter dbutils.fs.refreshMounts() sur ce cluster en cours d'exécution pour rendre le point de montage nouvellement créé disponible à l'utilisation.
  • Démonter un point de montage pendant l'exécution de jobs peut entraîner des erreurs. Assurez-vous que les jobs de production ne démontent pas le stockage dans le cadre du traitement.
  • Les points de montage qui utilisent des secrets ne sont pas actualisés automatiquement. Si le stockage monté repose sur un secret qui est modifié, expire ou est supprimé, des erreurs peuvent se produire, telles que 401 Unauthorized. Pour résoudre une telle erreur, vous devez démonter et remonter le stockage.
  • L'espace de noms hiérarchique (HNS) doit être activé pour monter correctement un compte de stockage Azure Data Lake Storage à l'aide de l'endpoint ABFS.

Exécutez ce qui suit dans votre Notebook pour vous authentifier et créer un point de montage.

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)

Remplacer

  • <application-id> avec l' ID d'application (client) de l'application Azure Active Directory.
  • <scope-name> avec le nom du Secret Scope Databricks.
  • <service-credential-key-name> avec le nom de la clé contenant le secret client.
  • <directory-id> avec l’ ID du répertoire (tenant) pour l’application Azure Active Directory.
  • <container-name> avec le nom d’un conteneur dans le compte de stockage ADLS.
  • <storage-account-name> avec le nom du compte de stockage ADLS.
  • <mount-name> avec le nom du point de montage prévu dans DBFS.
Sur cette page