Exporter des données d’espace de travail

Cette page fournit une vue d’ensemble des outils et approches permettant d’exporter des données et de la configuration à partir de votre espace de travail Azure Databricks. Vous pouvez exporter des ressources d’espace de travail pour les exigences de conformité, la portabilité des données, les besoins de sauvegarde ou la migration de l’espace de travail.

Aperçu

Les espaces de travail Azure Databricks contiennent diverses ressources, notamment la configuration de l’espace de travail, les tables managées, les objets IA et ML et les données stockées dans le stockage cloud. Lorsque vous devez exporter des données d’espace de travail, vous pouvez utiliser une combinaison d’outils et d’API intégrés pour extraire systématiquement ces ressources.

Les raisons courantes d’exporter des données d’espace de travail sont les suivantes :

• Exigences de conformité : respecter les obligations de portabilité des données en vertu de réglementations telles que RGPD et CCPA.
• Sauvegarde et récupération d’urgence : création de copies de ressources d’espace de travail critiques pour la continuité de l’activité.
• Migration de l’espace de travail : déplacement de ressources entre des espaces de travail ou des fournisseurs de cloud.
• Audit et archivage : conservation des enregistrements historiques de la configuration et des données de l’espace de travail.

Planifier votre exportation

Avant de commencer à exporter des données d’espace de travail, créez un inventaire des ressources dont vous avez besoin pour exporter et comprendre les dépendances entre elles.

Comprendre les ressources de l’espace de travail

Votre espace de travail Azure Databricks contient plusieurs catégories de ressources que vous pouvez exporter :

• Configuration de l’espace de travail : notebooks, dossiers, dépôts, secrets, utilisateurs, groupes, listes de contrôle d’accès (ACL), configurations de cluster et définitions de travaux.
• Ressources de données : tables managées, bases de données, fichiers de système de fichiers Databricks et données stockées dans le stockage cloud.
• Ressources de calcul : configurations de cluster, stratégies et définitions de pool d’instances.
• Ressources IA et ML : expériences MLflow, exécutions, modèles, tables du Magasin de fonctionnalités, index recherche vectorielle et modèles catalogue Unity.
• Objets catalogue Unity : configuration du metastore, catalogues, schémas, tables, volumes et autorisations.

Définir l'étendue de votre exportation

Créez une liste de contrôle des ressources à exporter en fonction de vos besoins. Prenez en compte les questions suivantes :

• Avez-vous besoin d’exporter toutes les ressources ou uniquement des catégories spécifiques ?
• Existe-t-il des exigences de conformité ou de sécurité qui déterminent les ressources que vous devez exporter ?
• Avez-vous besoin de préserver les relations entre les ressources (par exemple, les travaux qui font référence aux carnets) ?
• Avez-vous besoin de recréer la configuration de l’espace de travail dans un autre environnement ?

La planification de votre étendue d’exportation vous permet de choisir les outils appropriés et d’éviter les dépendances critiques manquantes.

Exporter la configuration de l’espace de travail

L’exportateur Terraform est l’outil principal pour l’exportation de la configuration de l’espace de travail. Il génère des fichiers de configuration Terraform qui représentent vos ressources d’espace de travail en tant que code.

Utiliser l’exportateur Terraform

L’exportateur Terraform est intégré au fournisseur Azure Databricks Terraform et génère des fichiers de configuration Terraform pour les ressources de l’espace de travail, notamment les notebooks, les travaux, les clusters, les utilisateurs, les groupes, les secrets et les listes de contrôle d’accès. L’exportateur doit être exécuté séparément pour chaque espace de travail. Consultez le fournisseur Databricks Terraform.

Configuration requise :

• Terraform installé sur votre ordinateur
• L'authentification Azure Databricks configurée
• Privilèges d’administrateur sur l’espace de travail que vous souhaitez exporter

Pour exporter des ressources d’espace de travail :

1. Examinez la vidéo d'exemple d'utilisation pour une démonstration de l'exportateur.

2. Téléchargez et installez le fournisseur Terraform avec l’outil d’exportation :

   wget -q -O terraform-provider-databricks.zip $(curl -s https://api.github.com/repos/databricks/terraform-provider-databricks/releases/latest|grep browser_download_url|grep linux_amd64|sed -e 's|.*: "\([^"]*\)".*$|\1|')
   unzip -d terraform-provider-databricks terraform-provider-databricks.zip
   

3. Configurez les variables d’environnement d’authentification pour votre espace de travail :

   export DATABRICKS_HOST=https://your-workspace-url
   export DATABRICKS_TOKEN=your-token
   

4. Exécutez l’exportateur pour générer des fichiers de configuration Terraform :

   terraform-provider-databricks exporter \
     -directory ./exported-workspace \
     -listing notebooks,jobs,clusters,users,groups,secrets
   

   Options d’exportation courantes :

   • -listing: Spécifier les types de ressources à exporter (séparés par des virgules)
   • -services: Alternative à la liste des ressources de filtrage
   • -directory: répertoire de sortie pour les fichiers générés .tf
   • -incremental: Exécuter en mode incrémentiel pour les migrations intermédiaires

5. Passez en revue les fichiers générés .tf dans le répertoire de sortie. L’exportateur crée un fichier pour chaque type de ressource.

Exporter des types de ressources spécifiques

Pour les ressources non entièrement couvertes par l’exportateur Terraform, utilisez ces approches :

• Blocs-notes : téléchargez des blocs-notes individuellement à partir de l’interface utilisateur de l’Espace de travail ou utilisez l’API Espace de travail pour exporter des blocs-notes de manière programmée. Consultez Gérer les objets d’espace de travail.
• Secrets : les secrets ne peuvent pas être exportés directement pour des raisons de sécurité. Vous devez recréer manuellement des secrets dans l’environnement cible. Noms et portées des secrets des documents pour référence.
• Objets MLflow : utilisez l’outil mlflow-export-import pour exporter des expériences, des exécutions et des modèles. Consultez la section ressources ML ci-dessous.

Exporter des données

Les données client résident généralement dans votre stockage de compte cloud, et non dans Azure Databricks. Vous n’avez pas besoin d’exporter des données déjà dans votre stockage cloud. Toutefois, vous devez exporter des données stockées dans des emplacements gérés par Azure Databricks.

Exporter des tables managées

Bien que les tables managées se trouvent dans votre stockage cloud, elles sont stockées dans une hiérarchie basée sur UUID qui peut être difficile à analyser. Vous pouvez utiliser la DEEP CLONE commande pour réécrire des tables managées en tant que tables externes à un emplacement spécifié, ce qui facilite leur utilisation.

Exemples de DEEP CLONE commandes :

CREATE TABLE delta.`abfss://container@storage.dfs.core.windows.net/path/to/storage/`
DEEP CLONE my_catalog.my_schema.my_table

Pour obtenir un script complet pour cloner toutes les tables dans une liste de catalogues, consultez l’exemple de script ci-dessous.

Exporter le stockage par défaut de Databricks

Pour les espaces de travail serverless, Azure Databricks offre un stockage par défaut, qui est une solution de stockage entièrement managée au sein du compte Azure Databricks. Les données dans le stockage par défaut doivent être exportées dans des conteneurs de stockage appartenant au client avant la suppression ou la désaffectation de l’espace de travail. Pour plus d’informations sur les espaces de travail serverless, consultez Créer un espace de travail serverless.

Pour les tables dans le stockage par défaut, utilisez cette option DEEP CLONE pour écrire des données dans un conteneur de stockage appartenant au client. Pour les volumes et les fichiers arbitraires, suivez les mêmes modèles décrits dans la section d’exportation racine DBFS ci-dessous.

Exporter la racine du système de fichiers Databricks

La racine du système de fichiers Databricks est l’emplacement de stockage hérité de votre compte de stockage d’espace de travail qui peut contenir des ressources appartenant au client, des chargements utilisateur, des scripts init, des bibliothèques et des tables. Bien que la racine du système de fichiers Databricks soit un modèle de stockage déconseillé, les espaces de travail hérités peuvent toujours avoir des données stockées dans cet emplacement qui doivent être exportées. Pour plus d’informations sur l’architecture de stockage de l’espace de travail, consultez Stockage d’espace de travail.

Exporter la racine du système de fichiers Databricks :

Étant donné que les compartiments racines sur Azure sont privés, vous ne pouvez pas utiliser des outils natifs Azure comme azcopy déplacer des données entre des comptes de stockage. Au lieu de cela, utilisez dbutils fs cp et Delta DEEP CLONE dans Azure Databricks. Cela peut prendre beaucoup de temps, en fonction du volume de données.

# Copy DBFS files to a local path
dbutils.fs.cp("dbfs:/path/to/remote/folder", "/path/to/local/folder", recurse=True)

Pour les tables dans le stockage racine du système de fichiers Databricks, utilisez DEEP CLONE:

CREATE TABLE delta.`abfss://container@storage.dfs.core.windows.net/path/to/external/storage/`
DEEP CLONE delta.`dbfs:/path/to/dbfs/location`

Défis courants liés à l’exportation

Secrets:

Les secrets ne peuvent pas être exportés directement pour des raisons de sécurité. Lorsque vous utilisez l’exportateur Terraform avec l’option -export-secrets , l’exportateur génère une variable vars.tf portant le même nom que le secret. Vous devez mettre à jour manuellement ce fichier avec les valeurs de secret réelles ou exécuter l’exportateur Terraform avec l’option -export-secrets (uniquement pour les secrets gérés par Azure Databricks).

Azure Databricks recommande d’utiliser un magasin de secrets soutenu par Azure Key Vault.

Exporter des ressources IA et ML

Certaines ressources IA et ML nécessitent différents outils et approches pour l’exportation. Les modèles Unity Catalog sont exportés dans le cadre de l'exportation Terraform.

Objets MLflow

MLflow n’est pas couvert par l’exportateur Terraform en raison de lacunes dans l’API et de la difficulté de sérialisation. Pour exporter des expériences MLflow, des exécutions, des modèles et des artefacts, utilisez l’outil mlflow-export-import . Cet outil open source fournit une couverture semi-complète de la migration MLflow.

Pour les scénarios d’exportation uniquement, vous pouvez stocker toutes les ressources MLflow dans un compartiment appartenant au client sans avoir à effectuer l’étape d’importation. Pour plus d’informations sur la gestion de MLflow, consultez Gérer le cycle de vie du modèle dans le catalogue Unity.

Magasin de fonctionnalités et recherche vectorielle

Indices de recherche vectorielle : les index de recherche vectorielle ne sont pas dans l’étendue des procédures d’exportation de données de l’UE. Si vous souhaitez toujours les exporter, ils doivent être écrits dans une table standard, puis exportés à l’aide DEEP CLONEde .

Tables du Magasin de fonctionnalités : le Magasin de fonctionnalités doit être traité de la même façon que les index de recherche vectorielle. À l’aide de SQL, sélectionnez les données pertinentes et écrivez-les dans une table standard, puis exportez à l’aide DEEP CLONEde .

Valider les données exportées

Après l’exportation des données de l’espace de travail, vérifiez que les travaux, les utilisateurs, les notebooks et d’autres ressources ont été exportés correctement avant de désaffecter l’ancien environnement. Utilisez la liste de contrôle que vous avez créée pendant la phase d’étendue et de planification pour vérifier que tout ce que vous attendiez à exporter a été correctement exporté.

Liste de vérification

Utilisez cette liste de contrôle pour vérifier votre exportation :

• Fichiers de configuration générés : les fichiers de configuration Terraform sont créés pour toutes les ressources d’espace de travail requises.
• Notebooks exportés : tous les blocs-notes sont exportés avec leur contenu et leurs métadonnées intacts.
• Tables clonées : les tables managées sont correctement clonées à l’emplacement d’exportation.
• Fichiers de données copiés : les données de stockage cloud sont copiées complètement sans erreurs.
• Objets MLflow exportés : les expériences, les exécutions et les modèles sont exportés avec leurs artefacts.
• Autorisations documentées : les listes de contrôle d’accès et les autorisations sont capturées dans la configuration Terraform.
• Dépendances identifiées : les relations entre les ressources (par exemple, les tâches référençant des notebooks) sont conservées lors de l’exportation.

Meilleures pratiques post-exportation

Les tests de validation et d’acceptation sont largement pilotés par vos besoins et peuvent varier largement. Toutefois, ces meilleures pratiques générales s’appliquent :

• Définissez un testbed : créez un banc d'essai de tâches ou de notebooks qui valident que les secrets, les données, les montures, les connecteurs et d’autres dépendances fonctionnent correctement dans l’environnement exporté.
• Commencez par les environnements de développement : si vous passez d’une manière intermédiaire, commencez par l’environnement de développement et travaillez jusqu’à la production. Cela pose des problèmes majeurs au début et évite les impacts sur la production.
• Tirez parti des dossiers Git : dans la mesure du possible, utilisez des dossiers Git, car ils se trouvent dans un dépôt Git externe. Cela évite l’exportation manuelle et garantit que le code est identique dans les environnements.
• Documentez le processus d’exportation : enregistrez les outils utilisés, les commandes exécutées et tous les problèmes rencontrés.
• Sécuriser les données exportées : assurez-vous que les données exportées sont stockées en toute sécurité avec les contrôles d’accès appropriés, en particulier si elles contiennent des informations sensibles ou personnellement identifiables.
• Maintenir la conformité : si vous exportez à des fins de conformité, vérifiez que l’exportation répond aux exigences réglementaires et aux stratégies de rétention.

Exemples de scripts et d’automatisation

Vous pouvez automatiser les exportations d’espace de travail à l’aide de scripts et de travaux planifiés.

Script d’exportation Deep Clone

Le script suivant exporte les tables gérées de Unity Catalog à l’aide de DEEP CLONE. Ce code doit être exécuté dans l’espace de travail source pour exporter un catalogue donné vers un compartiment intermédiaire. Mettez à jour les variables catalogs_to_copy et dest_bucket.

import pandas as pd

# define catalogs and destination bucket
catalogs_to_copy = ["my_catalog_name"]
dest_bucket = "<cloud-storage-path>://my-intermediate-bucket"
manifest_name = "manifest"

# initialize vars
system_info = sql("SELECT * FROM system.information_schema.tables")
copied_table_names = []
copied_table_types = []
copied_table_schemas = []
copied_table_catalogs = []
copied_table_locations = []

# loop through all catalogs to copy, then copy all non-system tables
# note: this would likely be parallelized using thread pooling in prod
for catalog in catalogs_to_copy:
  filtered_tables = system_info.filter((system_info.table_catalog == catalog) & (system_info.table_schema != "information_schema"))
  for table in filtered_tables.collect():
    schema = table['table_schema']
    table_name = table['table_name']
    table_type = table['table_type']
    print(f"Copying table {schema}.{table_name}...")
    target_location = f"{dest_bucket}/{catalog}_{schema}_{table_name}"
    sqlstring = f"CREATE TABLE delta.`{target_location}` DEEP CLONE {catalog}.{schema}.{table_name}"
    sql(sqlstring)

    # lists used to create manifest table DF
    copied_table_names.append(table_name)
    copied_table_types.append(table_type)
    copied_table_schemas.append(schema)
    copied_table_catalogs.append(catalog)
    copied_table_locations.append(target_location)

# create the manifest as a df and write to a table in dr target
# this contains catalog, schema, table and location
manifest_df = pd.DataFrame({"catalog": copied_table_catalogs,
                            "schema": copied_table_schemas,
                            "table": copied_table_names,
                            "location": copied_table_locations,
    "type": copied_table_types})

spark.createDataFrame(manifest_df).write.mode("overwrite").format("delta").save(f"{dest_bucket}/{manifest_name}")
display(manifest_df)

Considérations relatives à l’automatisation

Lors de l’automatisation des exportations :

• Utilisez des travaux planifiés : créez des travaux Azure Databricks qui exécutent des scripts d’exportation selon une planification régulière.
• Surveiller les travaux d’exportation : configurez des alertes pour vous avertir si les exportations échouent ou prennent plus de temps que prévu.
• Gérer les informations d’identification : stockez les informations d’identification de stockage cloud et les jetons d’API en toute sécurité à l’aide des secrets Azure Databricks. Consultez la gestion des secrets.
• Exportations de versions : utilisez des horodatages ou des numéros de version dans les chemins d’exportation pour conserver les exportations historiques.
• Nettoyer les anciennes exportations : implémentez des stratégies de rétention pour supprimer les anciennes exportations et gérer les coûts de stockage.
• Exportations incrémentielles : pour les espaces de travail volumineux, envisagez d’implémenter des exportations incrémentielles qui exportent uniquement les données modifiées depuis la dernière exportation.