Personas et rôles IAM sans serveur

Ce guide explique aux développeurs, administrateurs et lecteurs Spark comment obtenir les autorisations dont ils ont besoin pour commencer à utiliser les charges de travail par lot et les sessions interactives Managed Service pour Apache Spark sans serveur.

Persona leur rôle dans l'organisation ; Ce dont ils ont besoin d'IAM
Développeur Spark Le créateur et le consommateur de la plate-forme. Écrire et exécuter des jobs PySpark et Spark, développer des notebooks et des sessions, lire et écrire des ensembles de données, et surveiller et résoudre les problèmes liés à leurs charges de travail Inclut les ingénieurs de données, les data scientists et les développeurs. Autorisations permettant d'envoyer, d'exécuter, de surveiller et de résoudre les problèmes liés aux charges de travail, ainsi que de lire et d'écrire les données auxquelles leurs jobs accèdent.
Administrateur Spark Propriétaire et administrateur de la plate-forme. Configure le projet, décide de la manière dont les charges de travail s'authentifient, intègre les développeurs Spark, gère les comptes de service partagés et applique les garde-fous et le principe du moindre privilège de l'organisation. Également appelé administrateur de la plate-forme. Autorisations permettant d'accorder l'accès à d'autres utilisateurs, de configurer l'identité d'exécution (identifiants de l'utilisateur final ou compte de service partagé) et de gérer les ressources serverless à l'échelle du projet.
Lecteur Spark Observateur et auditeur de la plate-forme. Suivez l'état d'avancement des jobs, l'historique d'exécution, les métriques et les tableaux de bord sans envoyer ni modifier les charges de travail. Cela inclut les analystes, les chefs de projet, les équipes FinOps et les auditeurs de conformité. Autorisations en lecture seule pour afficher les tableaux de bord des lots, des sessions, des opérations et de l'état.

Choisir une version d'exécution

La version d'exécution recommandée dépend de la version d'Apache Spark sur laquelle vos charges de travail s'exécutent.

  • Environnement d'exécution 3.x (recommandé) : utilise Spark 4 et offre une intégration et une utilisation plus simples. Par défaut, les charges de travail s'exécutent en tant qu'utilisateur qui les a envoyées, avec les identifiants de l'utilisateur final. Cela nécessite l'attribution d'un seul rôle IAM à l'utilisateur. Les administrateurs peuvent configurer des comptes de service personnalisés pour les charges de travail afin de bénéficier d'une utilisation plus avancée.

  • Runtime 2.x : utilise Spark 3.5 et des comptes d'envoi et de charge de travail distincts. Par défaut, le compte de service Compute Engine par défaut est l'identité de charge de travail, et l'identité de l'utilisateur est celle de l'auteur de l'envoi. Les administrateurs peuvent configurer des comptes de service de charge de travail personnalisés pour un contrôle des accès plus précis.

Pour en savoir plus, consultez Versions d'exécution Managed Service pour Apache Spark.

Comparatif des fonctionnalités

Les mises à niveau de l'environnement d'exécution 3.x mettent à niveau les composants et les fonctionnalités 2.x, et simplifient la configuration :

Fonctionnalité et workflow Environnement d'exécution 3.x (recommandé) Environnement d'exécution 2.x
Version d'Apache Spark Spark 4 Spark 3.5 (et versions antérieures 3.x)
Le développement interactif Sessions Spark Connect (client Spark interactif standard) Sessions Jupyter
Charges de travail par lot R sparklyr Lots SparkR
Identité d'exécution Identifiants de l'utilisateur final1 Compte de service 1
Stockage pour la préparation des jobs Non requis (géré en interne) Buckets de préproduction Cloud Storage
Format de sortie des journaux Format JSON structuré (jsonPayload) Format texte brut (textPayload)

1 Le 3.x d'exécution est défini par défaut sur les identifiants de l'utilisateur final (EUC) de l'auteur de l'envoi, sauf si un compte de service personnalisé est spécifié pour la charge de travail ou la session. Le runtime 2.x utilise par défaut le compte de service Compute Engine par défaut, sauf si un compte de service personnalisé est spécifié pour la charge de travail ou la session.

Rôles courants liés aux données et aux services

Managed Service pour Apache Spark lit généralement des données et écrit des données dans d'autres servicesGoogle Cloud . Cette section répertorie les rôles associés aux services les plus fréquemment consultés.

  • Runtime 3.x (identité EUC par défaut) : accordez des rôles au développeur Spark (utilisateur ou groupe).
  • Environnement d'exécution 2.x : attribuez des rôles au compte de service de charge de travail (le compte de service Compute Engine par défaut ou un compte de service de charge de travail personnalisé).
Service ou API Rôle Objectif
Cloud Storage roles/storage.objectViewer
roles/storage.objectAdmin		 Lire les données d'entrée et les scripts intermédiaires.
Écrire les données de sortie.
Catalogue d'environnements d'exécution BigLake et Lakehouse roles/biglake.viewer
roles/biglake.editor
roles/biglake.admin		 Interrogez et gérez des formats de tables ouverts, tels qu'Apache Iceberg et Delta Lake, à l'aide du catalogue REST BigLake (catalogue REST Lakehouse (LRC)).
Bigtable roles/bigtable.reader
roles/bigtable.user		 Lire les tables Bigtable.
Lire et écrire des données Bigtable.
Dataproc Metastore (DPMS) roles/metastore.metadataViewer
roles/metastore.editor		 Lire les métadonnées Hive
Gérer les schémas et les tables de métadonnées

DPMS est un ancien métastore. Nous encourageons les clients à utiliser le catalogue REST BigLake Lakehouse (LRC).

BigQuery propose de nombreux rôles IAM précis et des LCA au niveau des ressources. Pour en savoir plus, consultez Rôles et autorisations IAM BigQuery.

Attribuer des rôles

La section suivante contient des instructions sur la façon d'attribuer des rôles pour chacune des personas associées à la configuration, à l'envoi et à la surveillance des charges de travail par lot et des sessions interactives Managed Service pour Apache Spark sans serveur 3.x et 2.x.

Environnement d'exécution 3.x

Par défaut, les charges de travail 3.x s'exécutent avec les identifiants utilisateur final (EUC) de l'utilisateur qui les envoie. Les administrateurs attribuent un seul rôle à l'utilisateur. Aucun compte de service ni bucket intermédiaire partagés ne sont requis. Les administrateurs peuvent configurer des comptes de service personnalisés lorsque des identités de service dédiées sont requises.

Développeur

Développeur Spark (environnement d'exécution 3.x)

En tant que développeur Spark, vous pouvez utiliser l'environnement d'exécution 3.x avec vos identifiants utilisateur pour développer, envoyer, surveiller et dépanner des charges de travail Spark, et pour accéder directement aux données.

  1. Demandez le rôle d'éditeur sans serveur. Demandez à votre administrateur de vous accorder roles/dataproc.serverlessEditor sur le projet.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/dataproc.serverlessEditor"

    Ce rôle vous permet d'envoyer, de surveiller, de dépanner et d'annuler des charges de travail par lot Spark et des sessions Spark Connect interactives.

  2. Accédez aux données et aux services. Étant donné que la charge de travail s'exécute en votre nom, votre identité doit avoir accès aux services et aux ensembles de données auxquels votre application Spark accède (voir Rôles courants pour les données et les services).

    Par exemple, accordez-vous l'accès en lecture à un bucket Cloud Storage d'entrée :

    gcloud storage buckets add-iam-policy-binding gs://INPUT_BUCKET \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/storage.objectViewer"

  3. Envoyez une charge de travail de test. Envoyez une charge de travail par lot de test pour confirmer votre configuration.

    gcloud dataproc batches submit spark \
  --region=REGION \
  --version=3.0 \
  --class=org.apache.spark.examples.SparkPi \
  --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
  -- 1000

    Remarques :

    • Si c'est la première fois que vous envoyez une charge de travail 3.x avec des identifiants d'utilisateur final, vous êtes invité à donner votre consentement OAuth unique. Accordez l'autorisation, puis renvoyez la charge de travail.

    • Si votre projet ne dispose pas d'un réseau VPC default, utilisez l'indicateur ou le champ subnet pour spécifier votre sous-réseau régional (consultez la configuration du réseau sans serveur Managed Service for Apache Spark).

    • Pour obtenir un exemple complet d'exécution de charges de travail PySpark et de configuration des autorisations requises dans Cloud Storage, BigLake et BigQuery, consultez Transformer des données et écrire dans une table Apache Iceberg.

Comptes de service de charge de travail personnalisés (runtime 3.x)

Utilisez un compte de service personnalisé avec l'exécution 3.x lorsque votre organisation exige que les charges de travail s'exécutent sous une identité dédiée et auditable au lieu d'informations d'identification de l'utilisateur final (consultez les bonnes pratiques concernant les comptes de service IAM).

  1. Obtenez l'autorisation d'exécuter des charges de travail en tant que compte de service personnalisé. Demandez à votre administrateur de vous attribuer roles/iam.serviceAccountUser sur le compte de service personnalisé.

    gcloud iam service-accounts add-iam-policy-binding \
  WORKLOAD_SA_EMAIL \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  2. Spécifiez le service personnalisé.

    gcloud dataproc batches submit spark \
  --region=REGION \
  --service-account=WORKLOAD_SA_EMAIL \
  --version=3.0 \
  --class=org.apache.spark.examples.SparkPi \
  --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
  -- 1000

  3. Accorder l'accès à l'ensemble de données. Lorsque vous utilisez un compte de service personnalisé, accordez des rôles au niveau des données directement à WORKLOAD_SA_EMAIL (consultez Rôles de données et de service courants).

Administrateur

Administrateur Spark (environnement d'exécution 3.x)

En tant qu'administrateur Spark, vous configurez le projet, décidez de la manière dont les charges de travail s'authentifient et accordez l'accès aux développeurs Spark.

Les charges de travail utilisent automatiquement le sous-réseau VPC nommé default. Si votre projet ne dispose pas de réseau default ou utilise des VPC personnalisés, consultez Configuration réseau sans serveur de Managed Service for Apache Spark pour configurer et spécifier un sous-réseau pour les charges de travail et les sessions.

Activer l'environnement d'exécution 3.x avec les identifiants de l'utilisateur final (recommandé)

Il s'agit de la configuration de moindre privilège qui nécessite le moins de maintenance. Chaque développeur Spark exécute des charges de travail avec son identité utilisateur. Les administrateurs n'ont pas besoin de configurer ni de gérer les comptes de service de charge de travail.

  1. Accorder roles/dataproc.serverlessEditor aux développeurs Spark.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/dataproc.serverlessEditor"

  2. Accorder roles/dataproc.serverlessViewer aux lecteurs en lecture seule.

    Attribuez ce rôle aux auditeurs, aux consommateurs de tableaux de bord et aux membres de l'équipe qui doivent surveiller l'état et les journaux des jobs sans envoyer ni modifier les charges de travail.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:VIEWER_EMAIL" \
  --role="roles/dataproc.serverlessViewer"

  3. Assurez-vous que les développeurs ont accès aux données.

    Par défaut, les charges de travail d'exécution 3.x s'exécutent en tant qu'utilisateur qui les envoie. Accordez des rôles d'accès aux données, tels que roles/storage.objectViewer ou roles/storage.objectAdmin, au développeur Spark ou au groupe Google qui inclut les développeurs Spark (voir Rôles courants pour les données et les services).

Activer les comptes de service personnalisés pour les charges de travail (runtime 3.x)

Utilisez un compte de service personnalisé avec le runtime 3.x lorsque vous avez besoin que les charges de travail s'exécutent sous une identité dédiée et auditable au lieu d'identifiants d'utilisateur final (consultez Bonnes pratiques concernant les comptes de service IAM).

  1. Accordez roles/iam.serviceAccountUser sur le compte de service personnalisé de la charge de travail.

    gcloud iam service-accounts add-iam-policy-binding \
  WORKLOAD_SA_EMAIL \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  2. Attribuez roles/dataproc.serverlessNode au compte de service personnalisé de la charge de travail.

    Ce rôle permet au compte de service de gérer les pools de nœuds de calcul et de communiquer avec les applications Spark lors de l'exécution des charges de travail :

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:WORKLOAD_SA_EMAIL" \
  --role="roles/dataproc.serverlessNode"

  3. Accorder l'accès aux données de l'application.

    Attribuez des rôles au niveau des données directement au compte de service de la charge de travail afin qu'il puisse lire et écrire des ensembles de données d'application (voir Rôles de données et de service courants). Si vos charges de travail utilisent des scripts par étapes ou des fichiers JAR personnalisés, accordez également l'accès en lecture aux buckets Cloud Storage correspondants.

Activer les comptes de service personnalisés des responsables de l'envoi (runtime 3.x)

Utilisez un compte de service personnalisé pour les systèmes automatisés (tels que Managed Service for Apache Airflow, Cloud Scheduler ou les pipelines CI ou CD) qui envoient des charges de travail sans utilisateur humain interactif.

  • Dans ce scénario, le compte de service de l'auteur de l'envoi exécute la commande gcloud qui démarre le job. Voici un exemple avec gcloud :

    gcloud dataproc batches submit spark \
  --service-account=WORKLOAD_SA_EMAIL \
  ...

  • Le compte de service de charge de travail exécute le code Spark sur les nœuds de calcul et accède aux ensembles de données d'application.

    1. Attribuez roles/dataproc.serverlessEditor au compte de service personnalisé de l'auteur de la demande.
    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:SUBMITTER_SA_EMAIL" \
  --role="roles/dataproc.serverlessEditor"

    Lorsque vous utilisez le runtime 3.x avec un compte de service personnalisé pour l'envoi, un compte de service de charge de travail personnalisé est nécessaire pour exécuter la charge de travail. Le runtime ne peut pas revenir aux identifiants de l'utilisateur final, car il n'y a pas d'utilisateur final interactif. Le job doit s'exécuter en tant que compte de service de charge de travail spécifié (--service-account).

  1. Accordez roles/iam.serviceAccountUser sur le compte de service personnalisé de la charge de travail.

    gcloud iam service-accounts add-iam-policy-binding \
  WORKLOAD_SA_EMAIL \
  --member="serviceAccount:SUBMITTER_SA_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  2. Configurez le compte de service personnalisé de la charge de travail. Attribuez les rôles roles/dataproc.serverlessNode et de données d'application à WORKLOAD_SA_EMAIL.

Référence des rôles d'administrateur Spark (environnement d'exécution 3.x)

Le tableau suivant récapitule les rôles à accorder avec l'exécution 3.x.

Auteur du signalement Workload Identity Accorder à l'auteur Accorder l'accès au compte de service de la charge de travail
Utilisateur final (par défaut) Utilisateur final (EUC) roles/dataproc.serverlessEditor (+ rôles de données sur l'utilisateur) (aucune, aucune SA n'a été utilisée)
Utilisateur final SA personnalisée roles/dataproc.serverlessEditor+roles/iam.serviceAccountUser sur une SA personnalisée roles/dataproc.serverlessNode + rôles de données
SA personnalisée (automatisation) SA personnalisée roles/dataproc.serverlessEditor+roles/iam.serviceAccountUser sur une SA personnalisée roles/dataproc.serverlessNode + rôles de données

Lecteur

Lecteur Spark (environnement d'exécution 3.x)

En tant que lecteur Spark, vous pouvez afficher les charges de travail par lot, les sessions interactives, les métriques d'exécution, les journaux et les tableaux de bord d'état sans envoyer ni modifier les charges de travail.

Demandez à votre administrateur de vous accorder roles/dataproc.serverlessViewer.

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:VIEWER_EMAIL" \
  --role="roles/dataproc.serverlessViewer"

Ce rôle permet d'afficher les charges de travail par lot sans serveur, les sessions interactives et l'état des opérations en lecture seule.

Autorisations détaillées

Autorisations détaillées (exécution 3.x)

Cette section liste les autorisations IAM incluses dans les rôles IAM associés au runtime 3.x.

Rôle Éditeur Serverless (roles/dataproc.serverlessEditor)

Ce rôle et ses autorisations permettent d'accéder en lecture et en écriture aux charges de travail par lot sans serveur 3.x et aux sessions interactives.

Autorisation Description
dataproc.batches.create Créez et envoyez des charges de travail par lot.
dataproc.batches.get Obtenez l'état et les détails des charges de travail par lot.
dataproc.batches.list Répertoriez toutes les charges de travail par lot dans un projet ou une région.
dataproc.batches.delete Supprimez les lots terminés ou résiliés.
dataproc.batches.cancel Annule une charge de travail par lot en cours d'exécution.
dataproc.sessions.create Créez des sessions Spark Connect interactives.
dataproc.sessions.get Obtenez l'état et les détails d'une session.
dataproc.sessions.list Répertoriez toutes les sessions d'un projet ou d'une région.
dataproc.sessions.delete Supprimez les sessions terminées.
dataproc.sessions.terminate Arrêtez une session interactive en cours.
dataproc.operations.get Interrogez l'état de l'opération asynchrone (obligatoire pour la CLI gcloud).

Rôle de nœud sans serveur (roles/dataproc.serverlessNode)

Fournit des autorisations de gestion des pools de nœuds et de communication Spark interne pour les comptes de service de charge de travail personnalisés 3.x du runtime.

Ce rôle et ses autorisations sont requis lorsque vous utilisez un compte de service de charge de travail personnalisé avec 3.x d'exécution. Les charges de travail exécutées avec les identifiants utilisateur final (EUC) 3.x par défaut n'utilisent pas de compte de service de charge de travail.

Autorisation Description
dataproc.batches.sparkApplicationWrite Communication des applications Spark pour les charges de travail par lot.
dataproc.sessions.sparkApplicationWrite Communication des applications Spark pour les sessions interactives.
dataprocrm.nodePools.create Créez des pools de nœuds de calcul.
dataprocrm.nodePools.delete Supprimez les pools de nœuds de calcul.
dataprocrm.nodePools.resize Faites évoluer les pools de nœuds de manière dynamique.
dataprocrm.nodePools.get État du pool de nœuds de lecture.
dataprocrm.nodePools.list Répertoriez les pools de nœuds.
dataprocrm.nodePools.update Mettez à jour la configuration du pool de nœuds.
dataprocrm.nodePools.deleteNodes Supprimez des nœuds spécifiques d'un pool.
dataprocrm.nodes.list Lister les nœuds d'un pool
dataprocrm.nodes.delete Supprimez les nœuds une fois la tâche terminée.
dataprocrm.nodes.get État du nœud de lecture.
dataprocrm.nodes.heartbeat Signalez l'état et les pulsations des nœuds.
dataprocrm.nodes.mintOAuthToken Générez des jetons OAuth pour les opérations de nœud.
dataprocrm.operations.get Vérifiez l'état des opérations d'infrastructure.

Rôle Lecteur Serverless (roles/dataproc.serverlessViewer)

Ce rôle et ses autorisations sont requis lorsque vous utilisez 3.x d'exécution avec un compte de service personnalisé pour l'envoi. Ils offrent un accès en lecture seule aux charges de travail par lot sans serveur 3.x, aux sessions interactives et à l'état des opérations.

Autorisation Description
dataproc.batches.get Lire l'état et les détails d'une charge de travail par lot
dataproc.batches.list Lister les charges de travail par lot.
dataproc.sessions.get Lire l'état et les détails d'une session.
dataproc.sessions.list Répertorier les sessions
dataproc.operations.get Lire l'état de l'opération.
dataproc.operations.list Répertorie les opérations.

Rôle de délégation de compte de service (roles/iam.serviceAccountUser)

Permet à un utilisateur ou à un système automatisé d'associer et d'exécuter des charges de travail en tant que compte de service personnalisé. La charge de travail s'exécute avec les autorisations et l'accès aux ressources accordés à ce compte de service, plutôt qu'avec les identifiants de l'utilisateur final (EUC) ayant soumis la demande.

Autorisation Description
iam.serviceAccounts.actAs Permet au responsable de l'envoi d'exécuter des charges de travail en tant que compte de service spécifié.

Runtime 2.x

Par défaut, les charges de travail 2.x du runtime s'exécutent en tant que compte de service Compute Engine par défaut. Le responsable de l'envoi (l'utilisateur ou le système automatisé) agit en tant que compte lorsqu'il exécute des charges de travail ou des sessions.

Développeur

Développeur Spark (runtime 2.x)

En tant que développeur Spark utilisant l'environnement d'exécution 2.x, vous développez, envoyez, surveillez et dépannez les charges de travail Spark, et accédez aux données. Étant donné que la charge de travail s'exécute en tant que compte de service plutôt qu'avec votre identité utilisateur, un administrateur vous attribue le rôle IAM Éditeur et le rôle Utilisateur du compte de service pour exécuter les charges de travail en tant que compte de service de charge de travail.

  1. Demandez le rôle Éditeur. Demandez à votre administrateur de vous accorder roles/dataproc.editor sur le projet :

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/dataproc.editor"

  2. Demandez l'autorisation de délégation. Demandez à votre administrateur de vous accorder l'autorisation roles/iam.serviceAccountUser sur le compte de service de charge de travail.

    Le compte de service de charge de travail par défaut est le compte de service Compute Engine par défaut, PROJECT_NUMBER-compute@developer.gserviceaccount.com :

    gcloud iam service-accounts add-iam-policy-binding \
  PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  3. Obtenez l'accès au bucket de préproduction. Le responsable de l'envoi de l'exécution 2.x doit être autorisé à importer des scripts et des fichiers JAR, et le compte de service de charge de travail doit être autorisé à gérer les fichiers temporaires et les journaux. Ces autorisations sont incluses dans le rôle roles/storage.objectAdmin.

    # Grant submitter access to upload staged files
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/storage.objectAdmin"

# Grant workload service account access for staging, temporary files, and logs
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

  4. Envoyez une charge de travail par lot de test. Envoyez une charge de travail par lot de test pour confirmer votre configuration.

    gcloud dataproc batches submit spark \
  --region=REGION \
  --version=2.2 \
  --class=org.apache.spark.examples.SparkPi \
  --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
  -- 1000

    Remarques :

Comptes de service personnalisés pour les charges de travail (runtime 2.x)

Utilisez un compte de service personnalisé lorsque votre organisation exige que les charges de travail s'exécutent sous une identité dédiée et auditable au lieu du compte de service Compute Engine par défaut partagé (consultez les bonnes pratiques concernant les comptes de service IAM).

  1. Obtenez l'autorisation d'exécuter des charges de travail en tant que compte de service personnalisé. Demandez à votre administrateur de vous accorder roles/iam.serviceAccountUser sur le compte de service personnalisé :

    gcloud iam service-accounts add-iam-policy-binding \
  WORKLOAD_SA_EMAIL \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  2. Spécifiez le compte de service personnalisé avec le flag --service-account lorsque vous envoyez des charges de travail.

    gcloud dataproc batches submit spark \
  --region=REGION \
  --service-account=WORKLOAD_SA_EMAIL \
  --version=2.2 \
  --class=org.apache.spark.examples.SparkPi \
  --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
  -- 1000

  3. Accès aux ensembles de données : si votre charge de travail ne peut pas accéder aux ensembles de données, accordez au compte de service personnalisé de la charge de travail (et non à votre compte utilisateur) les rôles d'accès aux données requis (consultez Rôles de données et de services courants).

Administrateur

Administrateur Spark (environnement d'exécution 2.x)

En tant qu'administrateur Spark, vous configurez le projet et les comptes de service, et vous accordez l'accès aux développeurs Spark.

Les charges de travail utilisent automatiquement le sous-réseau VPC nommé default. Si votre projet ne dispose pas de réseau default ou utilise des VPC personnalisés, consultez Configuration réseau sans serveur de Managed Service for Apache Spark pour configurer et spécifier un sous-réseau pour les charges de travail et les sessions.

Activer l'environnement d'exécution 2.x par défaut

Avec le 2.x d'exécution par défaut, les charges de travail s'exécutent en tant que compte de service Compute Engine par défaut.

  1. Accorder roles/dataproc.editor au développeur.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/dataproc.editor"

  2. Attribuez roles/iam.serviceAccountUser au compte de service par défaut.

    gcloud iam service-accounts add-iam-policy-binding \
  PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  3. Attribuez roles/dataproc.worker au compte de service de la charge de travail.

    Ce rôle permet au compte de service d'enregistrer l'agent de VM, de louer et d'exécuter des tâches de calcul, et d'émettre des journaux et des métriques vers Cloud Logging et Cloud Monitoring :

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --role="roles/dataproc.worker"

  4. Accordez roles/storage.objectAdmin pour le stockage du bucket de préproduction.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

  5. Accordez l'accès à l'ensemble de données au compte de service de la charge de travail.

    Attribuez des rôles au niveau des données au compte de service de charge de travail pour lui permettre d'accéder aux ensembles de données des applications Spark (consultez Rôles de données et de service courants).

Activer les comptes de service personnalisés pour les charges de travail (runtime 2.x)

Utilisez un compte de service personnalisé pour la charge de travail avec le runtime 2.x afin d'isoler les charges de travail au lieu d'utiliser le compte de service Compute Engine par défaut partagé.

  1. Accordez roles/iam.serviceAccountUser sur le compte de service personnalisé au développeur.

    gcloud iam service-accounts add-iam-policy-binding \
  WORKLOAD_SA_EMAIL \
  --member="user:DEVELOPER_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  2. Attribuez le rôle roles/dataproc.worker au compte de service personnalisé.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:WORKLOAD_SA_EMAIL" \
  --role="roles/dataproc.worker"

  3. Accorder l'accès aux données de l'application et à l'environnement de préproduction

    Attribuez des rôles au niveau des données directement au compte de service personnalisé de la charge de travail (consultez Rôles de service et de données courants) et accordez roles/storage.objectAdmin sur les buckets de préproduction et temporaires.

Activer les comptes de service personnalisés des responsables de l'envoi (runtime 2.x)

Utilisez un compte de service personnalisé pour les systèmes automatisés (tels que Managed Service for Apache Airflow, Cloud Scheduler ou les pipelines CI/CD) qui envoient des charges de travail sans utilisateur humain interactif.

  1. Accordez roles/dataproc.editor au compte de service de l'expéditeur.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:SUBMITTER_SA_EMAIL" \
  --role="roles/dataproc.editor"

  2. Accordez le rôle roles/iam.serviceAccountUser au compte de service de la charge de travail.

    gcloud iam service-accounts add-iam-policy-binding \
  WORKLOAD_SA_EMAIL \
  --member="serviceAccount:SUBMITTER_SA_EMAIL" \
  --role="roles/iam.serviceAccountUser"

  3. Configurez le compte de service de charge de travail. Accordez l'accès roles/dataproc.worker et l'accès aux ensembles de données à WORKLOAD_SA_EMAIL.

Référence des rôles d'administrateur Spark (runtime 2.x)

Le tableau suivant récapitule les rôles IAM à accorder avec l'exécution 2.x.

Auteur du signalement Workload Identity Accorder à l'auteur Accorder l'accès au compte de service de la charge de travail
Utilisateur final (par défaut) Compte de service Compute Engine par défaut roles/dataproc.editor + roles/iam.serviceAccountUser sur le compte de service par défaut roles/dataproc.worker + roles/storage.objectAdmin + rôles de données
Utilisateur final SA personnalisée roles/dataproc.editor+roles/iam.serviceAccountUser sur une SA personnalisée roles/dataproc.worker + roles/storage.objectAdmin + rôles de données
SA personnalisée (automatisation) SA personnalisée roles/dataproc.editor+roles/iam.serviceAccountUser sur une SA personnalisée roles/dataproc.worker + roles/storage.objectAdmin + rôles de données

Lecteur

Lecteur Spark (environnement d'exécution 2.x)

En tant que lecteur Spark, vous pouvez afficher les charges de travail par lot, les sessions interactives, les métriques d'exécution, les journaux et les tableaux de bord d'état sans envoyer ni modifier les charges de travail.

Demandez à votre administrateur de vous accorder roles/dataproc.viewer :

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:VIEWER_EMAIL" \
  --role="roles/dataproc.viewer"

Ce rôle accorde un accès en lecture seule aux ressources Managed Service pour Apache Spark, telles que les clusters, les jobs, les lots, les sessions et les opérations.

Autorisations détaillées

Autorisations détaillées (runtime 2.x)

Cette section liste les autorisations IAM incluses dans les rôles IAM associés au runtime 2.x.

Rôle Éditeur (roles/dataproc.editor)

Ce rôle permet de contrôler les charges de travail et les sessions sans serveur 2.x, ainsi que les clusters et les jobs Managed Service pour Apache Spark sur Compute Engine.

Autorisation Obligatoire pour le sans serveur Description
dataproc.batches.create Oui Créez et envoyez des charges de travail par lot.
dataproc.batches.get Oui Obtenez l'état et les détails des charges de travail par lot.
dataproc.batches.list Oui Répertoriez toutes les charges de travail par lot dans un projet ou une région.
dataproc.batches.delete Oui Supprimez les lots terminés ou résiliés.
dataproc.batches.cancel Oui Annule une charge de travail par lot en cours d'exécution.
dataproc.sessions.create Oui Créez des sessions interactives.
dataproc.sessions.get Oui Obtenez l'état et les détails d'une session.
dataproc.sessions.list Oui Répertoriez toutes les sessions d'un projet ou d'une région.
dataproc.sessions.delete Oui Supprimez les sessions terminées.
dataproc.sessions.terminate Oui Arrêtez une session interactive en cours.
dataproc.operations.get Oui Interrogez l'état de l'opération asynchrone (obligatoire pour la CLI gcloud).
compute.networks.get Oui Affichez la configuration du réseau VPC.
compute.networks.list Oui Lister les réseaux et sous-réseaux VPC disponibles
dataproc.clusters.* Non (clusters uniquement) Créez, gérez et utilisez des clusters Managed Service pour Apache Spark basés sur Compute Engine.
dataproc.jobs.* Non (clusters uniquement) Envoyez et gérez des jobs sur les clusters Managed Service pour Apache Spark basés sur Compute Engine.
dataproc.autoscalingPolicies.* Non (clusters uniquement) Règles d'autoscaling pour les clusters basés sur Compute Engine.
dataproc.nodeGroups.* Non (clusters uniquement) Groupes de nœuds personnalisés sur les clusters basés sur Compute Engine.
dataproc.workflowTemplates.* Non (clusters uniquement) Flux de travail de modèle pour les clusters basés sur Compute Engine.
compute.machineTypes.* Non (clusters uniquement) Métadonnées du type de machine pour les clusters basés sur Compute Engine.

Rôle Nœud de calcul (roles/dataproc.worker)

Ce rôle fournit des autorisations d'exécution de charge de travail pour le runtime 2.x.

Autorisation Description
dataproc.agents.create Enregistrez l'agent de VM sur la VM.
dataproc.agents.get Lire l'état de l'agent.
dataproc.agents.update Mettez à jour l'état de l'agent.
dataproc.agents.delete Désenregistrez l'agent une fois l'opération terminée.
dataproc.tasks.lease Louez des tâches de calcul pour l'exécution.
dataproc.tasks.reportStatus Signaler l'état d'exécution d'une tâche.
storage.objects.create Écrivez des données de préproduction, des fichiers temporaires et des journaux.
storage.objects.delete Nettoyez les fichiers temporaires.
storage.objects.get Lire les scripts de démarrage et les fichiers par étapes.
storage.objects.list Répertoriez le contenu des buckets de préproduction et temporaires.

Rôle Lecteur (roles/dataproc.viewer)

Ce rôle fournit un accès en lecture seule à toutes les ressources Managed Service pour Apache Spark.

Autorisation Obligatoire pour le sans serveur Description
dataproc.batches.get Oui Lire l'état et les détails d'une charge de travail par lot
dataproc.batches.list Oui Répertoriez toutes les charges de travail par lot dans un projet ou une région.
dataproc.sessions.get Oui Lire l'état et les détails d'une session.
dataproc.sessions.list Oui Répertoriez toutes les sessions d'un projet ou d'une région.
dataproc.operations.get Oui Lire l'état d'une opération asynchrone
dataproc.operations.list Oui Répertorier les opérations dans un projet ou une région
dataproc.clusters.get Non (clusters uniquement) Affichez la configuration et l'état du cluster.
dataproc.clusters.list Non (clusters uniquement) Répertorier les clusters d'un projet ou d'une région
dataproc.jobs.get Non (clusters uniquement) Affichez les détails et l'état des jobs sur les clusters.
dataproc.jobs.list Non (clusters uniquement) Lister les jobs sur les clusters.
dataproc.autoscalingPolicies.get Non (clusters uniquement) Affichez les détails de la règle d'autoscaling.
dataproc.autoscalingPolicies.list Non (clusters uniquement) Lister les règles d'autoscaling
dataproc.workflowTemplates.get Non (clusters uniquement) Affichez les détails du modèle de workflow.
dataproc.workflowTemplates.list Non (clusters uniquement) Répertorie les modèles de workflow.

Rôle de délégation de compte de service (roles/iam.serviceAccountUser)

Permet à un utilisateur ou à un système automatisé d'associer et d'exécuter des charges de travail en tant que compte de service Compute Engine par défaut ou compte de service personnalisé. La charge de travail s'exécute avec les autorisations et l'accès aux ressources accordés à ce compte de service.

Autorisation Description
iam.serviceAccounts.actAs Permet au responsable de l'envoi d'exécuter des charges de travail en tant que compte de service spécifié.

Étapes suivantes