Personas et rôles IAM sans serveur

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

Persona Leur rôle dans l'organisation Ce dont ils ont besoin de la part d'IAM
Développeur Spark Le créateur et le consommateur de la plate-forme. Écrit et exécute des jobs PySpark et Spark, développe dans des notebooks et des sessions, lit et écrit des ensembles de données, et surveille et dépanne ses charges de travail. Inclut les ingénieurs de données, les data scientists et les développeurs. Autorisations d'envoyer, d'exécuter, de surveiller et de dépanner des charges de travail, et de lire et d'écrire les données concernées par leurs jobs.
Administrateur Spark Le propriétaire et le gestionnaire 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 de l'organisation et le principe du moindre privilège. Également appelé "administrateur de 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 sans serveur à l'échelle du projet.
Lecteur Spark L'observateur et l'auditeur de la plate-forme. Suit l'achèvement des jobs, l'historique d'exécution, les métriques et les tableaux de bord sans envoyer ni modifier de charges de travail. Inclut les analystes, les chefs de projet, les FinOps et les auditeurs de conformité. Autorisations en lecture seule pour afficher les lots, les sessions, les opérations et les tableaux de bord d'é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 émetteur avec les identifiants de l'utilisateur final (EUC), ce qui 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 pour une utilisation plus avancée.

  • Environnement d'exécution 2.x : utilise Spark 3.5 et des comptes d'envoi et de charge de travail distincts. Par défaut, l'expéditeur est l'identité de l'utilisateur, et le compte de service Compute Engine par défaut est l'identité de la charge de travail. 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 de Managed Service pour Apache Spark.

Comparatif des fonctionnalités

L'environnement d'exécution 3.x met à niveau les composants et les fonctionnalités de 2.x, et fournit une configuration simplifiée :

Capacité 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 de 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 final (EUC)1 Compte de service 1
Stockage pour la préproduction des jobs Non requis (géré en interne) Buckets de préproduction Cloud Storage
Format de sortie du journal Format JSON structuré (jsonPayload) Format texte brut (textPayload)

1 L'environnement d'exécution 3.x utilise par défaut 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. L'environnement d'exécution 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, généralement pour lire et écrire dans d'autres servicesGoogle Cloud . Cette section répertorie les rôles associés aux services couramment utilisés.

  • Environnement d'exécution 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 la 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 préparés.
É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 (Lakehouse REST Catalog, LRC).
Bigtable roles/bigtable.reader
roles/bigtable.user
Lire des 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 metastore ancien. 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 explique comment attribuer des rôles pour chacun des profils associés à la configuration, à l'envoi et à la surveillance des charges de travail par lot et des sessions interactives sans serveur 3.x et 2.x de Managed Service pour Apache Spark.

Environnement d'exécution 3.x

Par défaut, les charges de travail 3.x s'exécutent sous les identifiants de l'utilisateur final (EUC) de l'utilisateur qui les envoie. Les administrateurs attribuent un seul rôle à l'utilisateur, et aucun compte de service partagé ni bucket de préproduction n'est 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 le rôle 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 tant que vous, votre identité doit avoir accès aux services et aux ensembles de données que votre application Spark touche (voir Rôles de données et de services courants).

    Par exemple, accordez-vous un 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 vous envoyez une charge de travail 3.x pour la première fois avec des identifiants d'utilisateur final, vous êtes invité à donner votre consentement OAuth une seule fois. Accordez l'autorisation, puis renvoyez la charge de travail.

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

    • Si vous utilisez la console Google Cloud pour créer des profils d'exécution, des sessions interactives ou des charges de travail par lot, ou si vous utilisez Google Cloud Data Agent Kit dans un IDE, vous devez également disposer des autorisations nécessaires pour lister les sous-réseaux et vérifier l'état de l'API (voir Autorisations supplémentaires pour la console Google Cloud et les IDE).

    • 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 les écrire dans une table Apache Iceberg.

Comptes de service de charge de travail personnalisés (environnement d'exécution 3.x)

Utilisez un compte de service personnalisé avec l'environnement d'exécution 3.x lorsque votre organisation exige que les charges de travail s'exécutent sous une identité dédiée et vérifiable, plutôt qu'avec les identifiants 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 le rôle 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 à un 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 default nommé. Si votre projet ne dispose pas d'un réseau default ou s'il utilise des VPC personnalisés, consultez Configuration du réseau sans serveur Managed Service pour 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é)

Cette configuration est basée sur le principe du moindre privilège et nécessite un minimum de maintenance. Chaque développeur Spark exécute des charges de travail en tant qu'identité utilisateur. Les administrateurs n'ont pas besoin de configurer ni de gérer les comptes de service de charge de travail.

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

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/dataproc.serverlessEditor"
    
  2. Accordez roles/dataproc.serverlessViewer aux lecteurs en lecture seule.

    Attribuez ce rôle aux auditeurs, aux utilisateurs de tableaux de bord et aux membres de l'équipe qui doivent surveiller l'état et les journaux des jobs sans envoyer ni modifier de 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 de l'environnement d'exécution 3.x s'exécutent en tant qu'utilisateur émetteur. 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 des développeurs Spark (consultez Rôles de données et de service courants).

Activer les comptes de service personnalisés de charge de travail (environnement d'exécution 3.x)

Utilisez un compte de service personnalisé avec l'environnement d'exécution 3.x lorsque vous avez besoin que les charges de travail s'exécutent sous une identité dédiée et vérifiable au lieu des identifiants de l'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 le rôle 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 pendant l'exécution de la charge 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 (consultez Rôles de données et de service courants). Si vos charges de travail utilisent des scripts préparés ou des fichiers JAR personnalisés, accordez également un accès en lecture aux buckets Cloud Storage correspondants.

Activer les comptes de service personnalisés des émetteurs (environnement d'exécution 3.x)

Utilisez un compte de service personnalisé d'envoi lorsque des systèmes automatisés (tels que Managed Service pour Apache Airflow, Cloud Scheduler ou des pipelines d'intégration ou de déploiement continus) envoient des charges de travail sans utilisateur humain interactif.

  • Dans ce scénario, le compte de service de l'expéditeur exécute la commande gcloud qui démarre le job. Voici un exemple utilisant la méthode 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 de l'application.

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

    Lorsque vous utilisez l'environnement d'exécution 3.x avec un compte de service personnalisé d'envoi, un compte de service de charge de travail personnalisé est nécessaire pour exécuter la charge de travail. L'environnement d'exécution ne peut pas utiliser les 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 à attribuer avec l'environnement d'exécution 3.x.

Auteur du signalement Workload Identity Octroi à l'auteur Accorder 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) (none—no SA used)
Utilisateur final Compte de service personnalisé roles/dataproc.serverlessEditor + roles/iam.serviceAccountUser sur un compte de service personnalisé roles/dataproc.serverlessNode + rôles de données
SA personnalisée (automatisation) Compte de service personnalisé roles/dataproc.serverlessEditor + roles/iam.serviceAccountUser sur un compte de service personnalisé 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 de charges de travail.

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

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

Ce rôle accorde un accès en lecture seule pour afficher les charges de travail par lot sans serveur, les sessions interactives et l'état des opérations.

Autorisations détaillées

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

Cette section liste les autorisations IAM incluses dans les rôles IAM associés à l'environnement d'exécution 3.x.

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

Ce rôle et ses autorisations fournissent un accès en lecture et en écriture aux charges de travail par lot sans serveur et aux sessions interactives de l'environnement d'exécution 3.x.

Autorisation Description
dataproc.batches.create Créez et envoyez de nouvelles charges de travail par lot.
dataproc.batches.get Obtenez l'état et les détails de la charge de travail par lot.
dataproc.batches.list Répertoriez toutes les charges de travail par lot d'un projet ou d'une région.
dataproc.batches.delete Supprimez les lots terminés ou arrêtés.
dataproc.batches.cancel Annuler une charge de travail par lot en cours d'exécution.
dataproc.sessions.create Créer des sessions Spark Connect interactives
dataproc.sessions.get Obtenez l'état et les détails de la session.
dataproc.sessions.list Répertorier toutes les sessions d'un projet ou d'une région.
dataproc.sessions.delete Supprimez les sessions arrêtées.
dataproc.sessions.terminate Arrêtez une session interactive en cours d'exécution.
dataproc.sessionTemplates.create Créer des profils d'exécution (modèles de session)
dataproc.sessionTemplates.get Obtenez les détails du profil d'exécution.
dataproc.sessionTemplates.list Répertorier les profils d'exécution d'un projet ou d'une région.
dataproc.sessionTemplates.update Mettre à jour les profils d'exécution.
dataproc.sessionTemplates.delete Supprimer des profils d'exécution
dataproc.operations.get Interroger l'état de l'opération asynchrone (requis par 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 de l'environnement d'exécution 3.x.

Ce rôle et ses autorisations sont requis lorsque vous utilisez un compte de service de charge de travail personnalisé avec l'environnement d'exécution 3.x. Les charges de travail exécutées avec les identifiants d'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 de l'application Spark pour les charges de travail par lot.
dataproc.sessions.sparkApplicationWrite Communication de l'application Spark pour les sessions interactives.
dataprocrm.nodePools.create Créer des pools de nœuds de calcul
dataprocrm.nodePools.delete Supprimer des pools de nœuds de calcul.
dataprocrm.nodePools.resize Effectuez un scaling dynamique des pools de nœuds.
dataprocrm.nodePools.get Lire l'état du pool de nœuds.
dataprocrm.nodePools.list Répertorier 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 Répertorier les nœuds d'un pool.
dataprocrm.nodes.delete Supprimez les nœuds une fois la tâche terminée.
dataprocrm.nodes.get Lire l'état du nœud.
dataprocrm.nodes.heartbeat Signaler l'état et les pulsations des nœuds.
dataprocrm.nodes.mintOAuthToken Générer des jetons OAuth pour les opérations de nœud.
dataprocrm.operations.get Vérifiez l'état de l'opération d'infrastructure.

Rôle Lecteur sans serveur (roles/dataproc.serverlessViewer)

Ce rôle et ses autorisations sont requis lorsque vous utilisez l'environnement d'exécution 3.x avec un compte de service personnalisé d'envoi. Ils fournissent 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 de la charge de travail par lot.
dataproc.batches.list Répertorier les charges de travail par lot.
dataproc.sessions.get Lire l'état et les détails de la session.
dataproc.sessions.list Répertorier les sessions
dataproc.operations.get Lisez l'état de l'opération.
dataproc.operations.list Répertorier 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) de l'utilisateur ayant envoyé la requête.

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

Environnement d'exécution 2.x

Par défaut, les charges de travail de l'environnement d'exécution 2.x s'exécutent en tant que compte de service Compute Engine par défaut. L'auteur de l'envoi (l'utilisateur ou le système automatisé) agit en tant que ce compte lors de l'exécution de charges de travail ou de sessions.

Développeur

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

En tant que développeur Spark utilisant l'environnement d'exécution 2.x, vous développez, envoyez, surveillez et dépannez des 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'en tant qu'identité utilisateur, un administrateur vous attribue les rôles IAM "Éditeur" et "Utilisateur du compte de service" pour exécuter des 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 le rôle 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 la 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. L'auteur de l'envoi de l'environnement d'exécution 2.x doit disposer des autorisations nécessaires pour importer des scripts et des fichiers JAR, et le compte de service de la charge de travail doit disposer des autorisations nécessaires pour 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 personnalisées (environnement d'exécution 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 vérifiable, plutôt que sous le 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 attribuer le rôle 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 l'option --service-account lors de l'envoi 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 (voir Rôles de données et de service courants).

Administrateur

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

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

Les charges de travail utilisent automatiquement le sous-réseau VPC default nommé. Si votre projet ne dispose pas d'un réseau default ou s'il utilise des VPC personnalisés, consultez Configuration du réseau sans serveur Managed Service pour 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 par défaut 2.x

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

  1. Attribuez le rôle roles/dataproc.editor au développeur.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/dataproc.editor"
    
  2. Accordez roles/iam.serviceAccountUser sur le 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. Accordez 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 la charge de travail pour lui permettre d'accéder aux ensembles de données de l'application Spark (consultez Rôles de données et de service courants).

Activer les comptes de service personnalisés de charge de travail (environnement d'exécution 2.x)

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

  1. Accordez le rôle roles/iam.serviceAccountUser au développeur 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. 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. Accordez l'accès aux données de l'application et à la préproduction.

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

Activer les comptes de service personnalisés des émetteurs (environnement d'exécution 2.x)

Utilisez un compte de service personnalisé d'envoi lorsque des systèmes automatisés (comme Managed Service pour Apache Airflow, Cloud Scheduler ou des pipelines CI/CD) 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 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 la charge de travail. Accordez l'accès roles/dataproc.worker et l'accès à l'ensemble de données à WORKLOAD_SA_EMAIL.

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

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

Auteur du signalement Workload Identity Octroi à l'auteur Accorder 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 Compte de service personnalisé roles/dataproc.editor + roles/iam.serviceAccountUser sur un compte de service personnalisé roles/dataproc.worker + roles/storage.objectAdmin + rôles de données
SA personnalisée (automatisation) Compte de service personnalisé roles/dataproc.editor + roles/iam.serviceAccountUser sur un compte de service personnalisé 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 de 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 (environnement d'exécution 2.x)

Cette section liste les autorisations IAM incluses dans les rôles IAM associés à l'environnement d'exécution 2.x.

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

Ce rôle permet de contrôler les charges de travail et les sessions sans serveur de l'environnement d'exécution 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 de nouvelles charges de travail par lot.
dataproc.batches.get Oui Obtenez l'état et les détails de la charge de travail par lot.
dataproc.batches.list Oui Répertoriez toutes les charges de travail par lot d'un projet ou d'une région.
dataproc.batches.delete Oui Supprimez les lots terminés ou arrêtés.
dataproc.batches.cancel Oui Annuler une charge de travail par lot en cours d'exécution.
dataproc.sessions.create Oui Créer des sessions interactives
dataproc.sessions.get Oui Obtenez l'état et les détails de la session.
dataproc.sessions.list Oui Répertorier toutes les sessions d'un projet ou d'une région.
dataproc.sessions.delete Oui Supprimez les sessions arrêtées.
dataproc.sessions.terminate Oui Arrêtez une session interactive en cours d'exécution.
dataproc.operations.get Oui Interroger l'état de l'opération asynchrone (requis par la CLI gcloud)
compute.networks.get Oui Afficher la configuration du réseau VPC.
compute.networks.list Oui Répertoriez les réseaux VPC du projet. Ne liste pas les sous-réseaux. Pour lister les sous-réseaux dans la console Google Cloud ou les IDE, vous devez disposer de l'autorisation compute.subnetworks.list (voir Autorisations supplémentaires pour la console Google Cloud et les IDE).
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 des 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) Workflows de modèles pour les clusters basés sur Compute Engine.
compute.machineTypes.* Non (clusters uniquement) Métadonnées de type de machine pour les clusters basés sur Compute Engine.

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

Ce rôle fournit des autorisations d'exécution de charge de travail pour l'environnement d'exécution 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 Mettre à jour l'état de l'agent.
dataproc.agents.delete Désenregistrez l'agent une fois l'opération terminée.
dataproc.tasks.lease Louer des tâches de calcul pour exécution.
dataproc.tasks.reportStatus Signaler l'état d'exécution de la tâche.
storage.objects.create Écrire 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 Lister 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 de la charge de travail par lot.
dataproc.batches.list Oui Répertoriez toutes les charges de travail par lot d'un projet ou d'une région.
dataproc.sessions.get Oui Lire l'état et les détails de la session.
dataproc.sessions.list Oui Répertorier 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 d'un projet ou d'une région
dataproc.clusters.get Non (clusters uniquement) Afficher 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) Afficher les détails et l'état des jobs sur les clusters.
dataproc.jobs.list Non (clusters uniquement) Répertorier 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) Répertoriez les règles d'autoscaling.
dataproc.workflowTemplates.get Non (clusters uniquement) Afficher les détails d'un modèle de workflow
dataproc.workflowTemplates.list Non (clusters uniquement) Répertorier 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 à l'auteur de l'envoi d'exécuter des charges de travail en tant que compte de service spécifié.

Autorisations supplémentaires pour la console Google Cloud et les IDE

Lorsque vous envoyez des charges de travail avec la Google Cloud CLI ou l'API Dataproc, le plan de contrôle de Managed Service pour Apache Spark résout automatiquement le réseau et le sous-réseau VPC default du projet sans vérifier les autorisations de sous-réseau Compute Engine ou Service Usage au niveau de l'appelant.

Toutefois, lorsque vous créez ou modifiez des profils d'exécution, des sessions interactives ou des charges de travail par lot dans la console Google Cloud , ou lorsque vous utilisez Google Cloud Data Agent Kit dans un IDE tel que VS Code, le client effectue des vérifications de lecture supplémentaires avec vos identifiants utilisateur :

Autorisation Workflow client Objectif
compute.subnetworks.list Google Cloud Console et Data Agent Kit Répertoriez les sous-réseaux VPC régionaux pour vérifier que le réseau default dispose d'un sous-réseau avec l'accès privé à Google activé, et pour renseigner les menus des réseaux et des sous-réseaux.
compute.subnetworks.get Google Cloud Console et Data Agent Kit Inspectez les métadonnées du sous-réseau lorsque vous affichez, clonez ou modifiez un profil d'exécution, une session ou une charge de travail par lot.
compute.networks.list Google Cloud Console et Data Agent Kit Lister les réseaux VPC du projet (inclus dans roles/dataproc.editor et roles/dataproc.admin, mais pas dans roles/dataproc.serverlessEditor).
compute.networks.get Google Cloud Console et Data Agent Kit Afficher les détails du réseau VPC (inclus dans roles/dataproc.editor et roles/dataproc.admin, mais pas dans roles/dataproc.serverlessEditor)
serviceusage.services.get Data Agent Kit et IDE Vérifiez si l'API Dataproc (dataproc.googleapis.com) est activée dans le projet sélectionné avant de charger l'arborescence des ressources Spark.
serviceusage.services.list ConsoleGoogle Cloud et IDE Répertoriez les API activées dans le projet.

Accorder un rôle personnalisé minimal (recommandé)

Pour respecter le principe du moindre privilège, créez un rôle IAM personnalisé qui n'accorde que les autorisations requises pour les workflows de la console et de l'IDE Google Cloud , et associez-le à vos développeurs Spark en plus de roles/dataproc.serverlessEditor ou roles/dataproc.editor :

  1. Créez le rôle personnalisé dans votre projet :

    gcloud iam roles create sparkConsoleAndIdeUser \
      --project=PROJECT_ID \
      --title="Managed Spark Console and IDE User" \
      --description="Read-only network and Service Usage permissions for Managed Spark console and IDE workflows" \
      --permissions=compute.networks.get,compute.networks.list,compute.subnetworks.get,compute.subnetworks.list,serviceusage.services.get,serviceusage.services.list \
      --stage=GA
    
  2. Attribuez le rôle personnalisé au développeur Spark :

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

Au lieu de gérer un rôle personnalisé, vous pouvez accorder les rôles prédéfinis Lecteur de réseau Compute (roles/compute.networkViewer) et Lecteur Service Usage (roles/serviceusage.serviceUsageViewer). L'utilisation de rôles prédéfinis évite la maintenance des rôles personnalisés, car Google Cloud gère automatiquement leurs autorisations. Toutefois, les rôles de lecteur prédéfinis accordent un accès en lecture plus large que celui requis par Managed Service pour Apache Spark : roles/compute.networkViewer permet aux utilisateurs d'afficher toutes les ressources réseau Compute Engine du projet (y compris les règles de pare-feu, les routes, les routeurs Cloud, les tunnels VPN, les règles de transfert et les groupes de points de terminaison du réseau), et roles/serviceusage.serviceUsageViewer permet aux utilisateurs d'afficher les quotas et les règles client pour tous les services du projet. N'accordez pas roles/compute.networkUser ou roles/serviceusage.serviceUsageConsumer aux utilisateurs finaux uniquement pour l'accès à la console ou à l'IDE Google Cloud , car ces rôles accordent également des autorisations de rattachement de ressources et de quota (compute.subnetworks.use et serviceusage.services.use) dont les utilisateurs finaux n'ont pas besoin.

Étapes suivantes