Aller au contenu principal
Dernière mise à jour le

Créer un Workspace à moindre privilège

Un workspace à privilèges minimaux est un workspace Databricks sur Google Cloud que vous créez en accordant à Databricks uniquement un ensemble restreint et explicitement défini de permissions IAM. Au lieu d'accorder des rôles étendus et de laisser Databricks provisionnement et configurer automatiquement les Ressources cloud, vous créez des rôles IAM personnalisés, configurez vous-même les Ressources réseau et de chiffrement, et provisionnement le Workspace via l'API de compte.

Cette approche est destinée aux comptes soucieux de la sécurité et réglementés qui doivent minimiser les autorisations accordées aux services tiers. Étant donné que vous effectuez les étapes de configuration manuellement, la création d'un Workspace à privilège minimum demande plus d'efforts que le flux de création standard.

Pour la plupart des déploiements, Databricks recommande le flux de création de Workspace standard, qui utilise la console de compte et des autorisations plus étendues pour provisionner automatiquement les Ressources. Consultez Créer un Workspace classique.

remarque

Cette page décrit un workflow avancé, basé sur l'API, qui ne prend pas en charge les nouvelles tentatives. Effectuez et vérifiez chaque étape dans l'ordre. Si une étape est manquée ou mal configurée, vous devez supprimer le workspace et recommencer.

Fonctionnement de la création de workspace avec le moindre privilège​

La création de Workspace à moindres privilèges utilise deux ensembles distincts de rôles IAM, chacun étant attribué à un compte de service Google différent :

  • Créateur de Workspace : Un compte de service Google que vous possédez et utilisez pour appeler l'API de compte. Il a besoin d'autorisations de niveau lecture uniquement pour valider les paramètres lors de la création. Vous lui accordez les rôles de créateur de workspace décrits dans Rôles de créateur de Workspace.
  • Compte de service Workspace : un compte de service Google que Databricks crée dans son plan de contrôle régional et vous renvoie lors de la création du workspace. Vous lui accordez les rôles d'opérateur du workspace afin qu'il puisse exploiter et gérer le workspace.

Parce que Databricks retourne le compte de service du workspace en cours de création, le processus est divisé en deux phases : vous créez le workspace dans un état PROVISIONING, accordez les rôles d'opérateur au compte de service retourné, puis mettez à jour le workspace pour le faire passer à un état RUNNING. Vous effectuez ces appels directement à l'encontre de l'API de compte et créez les ressources Google Cloud de support avec la gcloud CLI.

Avant de commencer​

Effectuez les prérequis suivants avant de créer un workspace.

Créez les rôles IAM requis​

Avant de commencer, vous devez créer une série de rôles IAM dans vos projets GCP :

Configurez le compte de service du créateur de workspace​

  1. Créez un nouveau compte de service Google ou sélectionnez-en un existant.

  2. Attribuez le ou les rôles IAM de créateur de workspace que vous avez créés au compte de service, en liant chaque rôle au projet approprié :

    Pour accorder un rôle sur un projet, utilisez gcloud projects add-iam-policy-binding:

    Bash
    gcloud projects add-iam-policy-binding <project-id> \
      --member="serviceAccount:<creator-sa-email>" \
      --role="projects/<project-id>/roles/<creator-role-id>"

  3. Ajoutez le compte de service en tant qu'utilisateur dans la console du compte Databricks.

  4. Attribuez le compte de service au rôle d' administrateur de compte dans votre compte Databricks. See Service Principal.

Vérifier la règle de pare-feu Virtual Private Cloud (VPC)​

Confirmez que votre VPC dispose de la règle de pare-feu d'entrée intra-sous-réseau par default qui autorise la communication interne entre les instances de machines virtuelles au sein du même sous-réseau. Décrivez la règle pour confirmer son existence :

Bash
gcloud compute firewall-rules describe default-allow-internal \
  --project=<vpc-host-project-id>

La règle doit avoir les propriétés suivantes : la plage source correspond à la plage de votre sous-réseau Databricks :

  • Direction : INGRESS
  • Priorité : 65534
  • Plages sources : votre plage de sous-réseaux Databricks
  • Protocoles autorisés : tous

Si une règle équivalente n’existe pas, créez-en une. Pour plus d’informations sur les règles de pare-feu default, consultez la documentation GCP.

Configurer l'authentification​

Les appels d'API de compte sur cette page s'authentifient à l'aide de jetons d'identité Google. Pour que les commandes de cette section restent lisibles, elles utilisent un modèle de compte unique : l'interface de ligne de commande (CLI) gcloud s'authentifie directement en tant que compte de service créateur de workspace, qui agit à la fois comme compte de service créateur de jetons et propriétaire des Ressources.

remarque

Pour les déploiements de production et réglementés, Databricks recommande un modèle à deux comptes de service, dans lequel un compte de service de création de jetons (SA-1) emprunte l'identité d'un compte de service propriétaire de ressources (SA-2) plutôt que de détenir une clé à long terme elle-même. Pour appliquer ce modèle ici, considérez le compte de service du créateur du workspace comme SA-2 et créez un SA-1 distinct pour en emprunter l'identité. Pour les étapes de configuration et les limites d'expiration des jetons, consultez Authentifiez-vous avec les jetons d'identité Google.

Les appels d'API sur cette page utilisent deux jetons de courte durée. Générez-les immédiatement avant d'effectuer des appels d'API afin d'éviter l'expiration :

  • Un jeton d'identité que Databricks utilise pour vérifier l'appelant (passé dans l'en-tête Authorization) :

    Bash
    gcloud auth print-identity-token --audiences="https://accounts.gcp.databricks.com"

  • Un **jeton d'accès OAuth Google** pour la transmission des identifiants (transmis dans X-Databricks-GCP-SA-Access-Token l'en-tête) :

    Bash
    gcloud auth print-access-token

Les exemples de cette page supposent que vous avez stocké ces valeurs dans les variables d'environnement ID_TOKEN et ACCESS_TOKEN. Pour plus de détails sur ces en-têtes, voir S'authentifier avec des jetons d'identification Google.

Étape 1 : créez la configuration réseau et les fonctionnalités facultatives​

Pré-créez votre configuration réseau, ainsi que toutes les ressources Private Service Connect ou clés gérées par le client facultatives, avant de créer le Workspace. Si vous utilisez Private Service Connect, enregistrez d'abord ses Endpoints afin que vous puissiez référencer leurs ID dans la configuration réseau. Chaque requête renvoie un ID que vous devez enregistrer et transmettre au Workspace à l'étape 5. Chaque ID apparaît également dans l'URL de la console de compte pour l'objet.

Par exemple, une URL de configuration réseau se présente sous la forme suivante :

Text
https://<account-console>/cloud-resources/networking/network-configurations/<network-id>/

(Facultatif) Enregistrez les Endpoint Private Service Connect​

Si vous créez un workspace compatible avec Private Service Connect, enregistrez les points de terminaison avant de créer la configuration réseau afin de pouvoir y référencer leurs ID. Créez les points de terminaison Private Service Connect requis dans Google Cloud et enregistrez-les auprès de Databricks. Pour les exigences et les instructions, consultez Activer Private Service Connect pour votre workspace.

Si vous n'utilisez pas Private Service Connect, passez à Créer la configuration réseau.

Enregistrez le point de terminaison Virtual Private Cloud (VPC) du Workspace :

Bash
curl -X POST \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/vpc-endpoints \
  -H "Authorization: Bearer $ID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "vpc_endpoint_name": "<frontend-endpoint-name>",
    "gcp_vpc_endpoint_info": {
      "project_id": "<vpc-host-project-id>",
      "psc_endpoint_name": "<workspace-psc-endpoint-name>",
      "endpoint_region": "us-central1"
    }
  }'

Enregistrer l'Endpoint (relais) Virtual Private Cloud (VPC) dorsal :

Bash
curl -X POST \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/vpc-endpoints \
  -H "Authorization: Bearer $ID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "vpc_endpoint_name": "<backend-endpoint-name>",
    "gcp_vpc_endpoint_info": {
      "project_id": "<vpc-host-project-id>",
      "psc_endpoint_name": "<relay-psc-endpoint-name>",
      "endpoint_region": "us-central1"
    }
  }'

Enregistrer le vpc_endpoint_id de chaque réponse. Lorsque vous créez la configuration réseau dans la section suivante, utilisez l'ID frontal dans son champ rest_api et l'ID backend dans son champ dataplane_relay.

Créez également un objet de paramètres d'accès privé :

Bash
curl -X POST \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/private-access-settings \
  -H "Authorization: Bearer $ID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "private_access_settings_name": "<pas-name>",
    "region": "us-central1",
    "public_access_enabled": true,
    "private_access_level": "ACCOUNT"
  }'

Enregistrez le private_access_settings_id de la réponse.

Créer la configuration réseau​

Créez une configuration réseau qui représente votre VPC géré par le client et ses sous-réseaux. Pour connaître les exigences et les instructions de la console, consultez Configurer un Virtual Private Cloud (VPC) géré par le client.

La requête suivante crée une configuration réseau. Le network_name doit comporter entre 3 et 30 caractères et ne contenir que les caractères a-z, A-Z, - et _. Si vous utilisez Private Service Connect, incluez le champ vpc_endpoints avec les ID d'endpoints Virtual Private Cloud (VPC) que vous avez enregistrés dans Enregistrer les endpoints Private Service Connect; sinon, omettez-le.

Bash
curl -X POST \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/networks \
  -H "Authorization: Bearer $ID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "network_name": "<network-name>",
    "gcp_network_info": {
      "network_project_id": "<vpc-host-project-id>",
      "vpc_id": "<vpc-id>",
      "subnet_id": "<subnet-id>",
      "subnet_region": "us-central1"
    },
    "vpc_endpoints": {
      "dataplane_relay": ["<relay-vpc-endpoint-id>"],
      "rest_api": ["<workspace-vpc-endpoint-id>"]
    }
  }'

Enregistrez le network_id de la réponse.

(Facultatif) Configurer les clés gérées par le client​

Dans le cadre de la pré-création, si vous créez un Workspace géré par le client avec clés activées, configurez et enregistrez vos clés maintenant. Vous transmettez ultérieurement les identifiants de clé renvoyés au Workspace, à l'étape 5:

  1. Créez une clé Cloud KMS dans Google Cloud.

  2. Pour le chiffrement du stockage du workspace, accordez le rôle Cloud KMS CryptoKey Encrypter/Decrypter à l'agent de service Compute Engine par default et à l'agent de service Cloud Storage par default dans le projet du workspace :

    Bash
    gcloud kms keys add-iam-policy-binding KEY_NAME \
      --keyring=KEY_RING \
      --location=LOCATION \
      --role=roles/cloudkms.cryptoKeyEncrypterDecrypter \
      --member=serviceAccount:service-PROJECT_NUMBER@compute-system.iam.gserviceaccount.com \
      --member=serviceAccount:service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com

  3. Enregistrez la clé auprès de Databricks pour le stockage et les services gérés. Pour les exigences, consultez Configurer les clés gérées par le client pour le chiffrement.

    Bash
    curl -X POST \
      https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/customer-managed-keys \
      -H "Authorization: Bearer $ID_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "gcp_key_info": {
          "kms_key_id": "<kms-key-resource-id>",
          "manual": true
        },
        "use_cases": ["STORAGE", "MANAGED"]
      }'

    Enregistrez le customer_managed_key_id de la réponse.

    Définissez "manual": true afin que Databricks ne tente pas de s'octroyer l'accès à la clé KMS. Dans un workspace à privilèges minimaux, vous accordez cet accès vous-même : le rôle d'encrypteur/décrypteur pour le stockage est accordé ci-dessus, et le rôle pour les services gérés est accordé au compte de service du workspace plus tard, à l'étape 4.

Étape 2 : Créez le compte de service databricks-compute​

Créez le compte de service databricks-compute utilisé par toutes les ressources de compute dans le workspace qui n'ont pas de compte de service personnalisé attaché. Ce compte de service a des permissions minimales, limitées à la journalisation et aux métriques.

Bash
gcloud iam service-accounts create databricks-compute \
  --display-name="Databricks Compute Service Account" \
  --project=<workspace-project-id>

Étape 3 : créez le Workspace​

Créez le workspace dans un état PROVISIONING en appelant l'API de compte. Authentifiez-vous avec le jeton d'accès et le jeton d'identité à partir de Configurer l'authentification. Incluez uniquement les champs qui s'appliquent à votre workspace. Par exemple, omettez les champs Private Service Connect et clés gérées par le client si vous ne les utilisez pas.

Bash
curl -X POST \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/workspaces \
  -H "X-Databricks-GCP-SA-Access-Token: $ACCESS_TOKEN" \
  -H "Authorization: Bearer $ID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "workspace_name": "<workspace-name>",
    "cloud": "gcp",
    "cloud_resource_container": {
      "gcp": {
        "project_id": "<workspace-project-id>"
      }
    },
    "location": "us-central1",
    "pricing_tier": "ENTERPRISE",
    "expected_workspace_status": "PROVISIONING"
  }'

Une requête réussie renvoie une réponse 200 qui comprend l'ID du Workspace et le compte de service du Workspace :

JSON
{
  "account_id": "<account-id>",
  "cloud": "gcp",
  "cloud_resource_container": {
    "gcp": {
      "project_id": "my-gcp-project"
    }
  },
  "creation_time": 1643668346544,
  "deployment_name": "1614665312930232.2",
  "location": "us-central1",
  "pricing_tier": "ENTERPRISE",
  "workspace_id": 1614665312930232,
  "workspace_name": "example-workspace-name",
  "workspace_status": "PROVISIONING",
  "workspace_status_message": "Workspace resources are being set up.",
  "workspace_service_account": "<workspace-service-account>"
}

Enregistrer la valeur workspace_service_account de la réponse. Vous accordez les rôles d'opérateur à ce compte de service à l'étape suivante.

Étape 4 : Accordez des rôles au compte de service du workspace​

Accordez les rôles d'opérateur de workspace au compte de service du workspace renvoyé à l'étape 3, en utilisant la valeur workspace_service_account de cette réponse.

Accordez les rôles suivants au niveau du projet sur le projet de service (Workspace) :

  • lpw.databricks.project.role.v2
  • lpw.databricks.resource.role.v2Limitez cette autorisation au Workspace en ajoutant une condition IAM sur l'ID du Workspace.

Pour connaître les autorisations incluses dans chaque rôle, consultez les rôles d'opérateur Workspace à privilège minimal.

Liez le rôle réseau au sous-réseau​

Associez le rôle réseau au compte de service du workspace sur le sous-réseau Databricks. Ceci s'applique au sous-réseau principal utilisé par le workspace :

Bash
gcloud compute networks subnets add-iam-policy-binding <subnet> \
  --project=<vpc-host-project-id> \
  --region=us-central1 \
  --member="serviceAccount:<workspace-service-account>" \
  --role="projects/<vpc-host-project-id>/roles/lpw.databricks.network.role.v2"

(Facultatif) Accordez le rôle de chiffrement/déchiffrement des clés gérées par le client pour les services gérés​

Si vous utilisez des clés gérées par le client pour les services gérés, attribuez le rôle Chiffreur/Déchiffreur de clé de chiffrement Cloud KMS au compte de service du Workspace pour activer le chiffrement pour les services gérés :

Bash
gcloud kms keys add-iam-policy-binding KEY_NAME \
  --keyring=KEY_RING \
  --location=LOCATION \
  --role=roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --member=serviceAccount:db-WORKSPACEID@db-regional-cp-project.iam.gserviceaccount.com
attention

Arrêtez et vérifiez que vous avez terminé chaque étape précédente avant de continuer. Le flux de création de Workspace ne prend pas en charge les nouvelles tentatives. Si une étape est manquée ou mal configurée, la création du Workspace échoue et vous devez supprimer le Workspace et start over.

Étape 5 : Mettez à jour le workspace pour utiliser votre configuration réseau.​

Mettez à jour le workspace avec la configuration réseau et les ID de Private Service Connect et de clés gérées par le client facultatifs que vous avez enregistrés à l'étape 1. Cette requête start le provisionnement final, qui se poursuit ensuite de manière asynchrone.

Incluez uniquement les champs qui s'appliquent à votre workspace. Par exemple, omettez les champs des clés gérées par le client si vous ne les utilisez pas.

Bash
curl -X PATCH \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/workspaces/<workspace-id> \
  -H "X-Databricks-GCP-SA-Access-Token: $ACCESS_TOKEN" \
  -H "Authorization: Bearer $ID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "network_id": "<network-id>",
    "private_access_settings_id": "<private-access-settings-id>",
    "storage_customer_managed_key_id": "<storage-customer-managed-key-id>",
    "managed_services_customer_managed_key_id": "<managed-services-customer-managed-key-id>"
  }'

Une requête réussie renvoie une réponse 200. Le workspace_status est toujours PROVISIONING, pas RUNNING, car les opérations de provisionnement restantes s'exécutent de manière asynchrone après le retour de la requête :

JSON
{
  "workspace_id": 1614665312930232,
  "workspace_name": "example-workspace-name",
  "workspace_status": "PROVISIONING",
  "workspace_status_message": "Workspace resources are being set up.",
  "account_id": "<account-id>",
  "network_id": "<network-id>",
  "pricing_tier": "ENTERPRISE",
  "location": "us-central1",
  "cloud": "gcp"
}

Si la requête échoue, la réponse indique la cause. Par exemple :

  • Une erreur 400 BAD_REQUEST indique des autorisations insuffisantes sur le projet Google Cloud. Examinez les octrois de rôles d'opérateur à l'Étape 4.
  • Une erreur 404 RESOURCE_DOES_NOT_EXIST indique qu'un ID de configuration référencé, tel que l'ID réseau, n'existe pas. Confirmez les ID que vous avez enregistrés à l'étape 1.

Le provisionnement s'achève généralement en quelques minutes. Interrogez le Workspace jusqu'à ce que son workspace_status devienne RUNNING avant de continuer :

Bash
curl -X GET \
  https://accounts.gcp.databricks.com/api/2.0/accounts/<account-id>/workspaces/<workspace-id> \
  -H "Authorization: Bearer $ID_TOKEN"

Après avoir créé le workspace​

After the Workspace reaches the RUNNING state:

  • Configurer le système de noms de domaine (DNS) pour PSC. Si votre Workspace utilise Private Service Connect, terminez la configuration DNS. Voir Activer Private Service Connect pour votre Workspace.
  • Vérifiez le Workspace. Confirmez que le Workspace est configuré correctement en démarrant un cluster Databricks.

Créez un catalogue pris en charge par votre stockage cloud.​

Si un métastore Unity Catalog n'existe pas déjà dans la même région que le workspace, Databricks crée un métastore et l'assigne au workspace. Aucun catalogue par default n'est créé automatiquement.

Pour préparer le Workspace aux données, créez un catalogue adossé à votre stockage cloud :

  1. Créer un identifiant de stockage. Voir Créer un identifiant de stockage qui accède à GCS.
  2. Créer un emplacement externe. Voir Créer un emplacement externe pour un compartiment GCS.
  3. Créez un catalogue. Consultez Créer des catalogues.

Étapes suivantes​

Après avoir créé un Workspace à privilège minimum, vous pouvez start à élaborer votre stratégie de données. Databricks recommande les pages suivantes :

Sur cette page