"Managed Service for Apache Spark" is the new name for the product formerly known as "Dataproc on Compute Engine" (cluster deployment) and "Google Cloud Serverless for Apache Spark" (serverless deployment).

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Créer un cluster mutualisé à l'aide de comptes de service

L'architecture mutualisée sécurisée basée sur un compte de service Managed Service pour Apache Spark vous permet de partager un cluster avec plusieurs utilisateurs, avec un ensemble de comptes utilisateur mappés à des comptes de service lors de la création du cluster. Les utilisateurs peuvent envoyer des charges de travail interactives, telles que des notebooks Jupyter, à des kernels exécutés sur le cluster mutualisé avec des environnements utilisateur isolés.

Lorsqu'un utilisateur envoie une tâche au cluster mutualisé, la tâche :

s'exécute en tant qu'utilisateur d'OS spécifique avec un compte principal Kerberos spécifique ;
accède aux Google Cloud ressources à l'aide d'un compte de service mappé.

Ce document vous explique comment créer un cluster mutualisé Managed Service pour Apache Spark, puis comment lancer et connecter un notebook Jupyter à un kernel PySpark exécuté sur le cluster.

Remarques et limites

Lorsque vous créez un cluster mutualisé, procédez comme suit :

Le cluster n'est disponible que pour les utilisateurs de comptes Google disposant de comptes de service mappés. Les groupes Google ne peuvent pas être mappés. Les utilisateurs non mappés ne peuvent pas exécuter de tâches sur le cluster.
Kerberos est activé et configuré sur le cluster pour permettre une communication sécurisée au sein des clusters. L'authentification de l'utilisateur final via Kerberos n'est pas prise en charge.
L'accès SSH direct au cluster et les fonctionnalités de Compute Engine, telles que l'exécution de scripts de démarrage sur les VM de cluster, sont bloqués. Par ailleurs, les tâches ne peuvent pas être exécutées avec des privilèges sudo.
Les workflows Managed Service pour Apache Spark ne sont pas compatibles.

Créer un cluster mutualisé

Vous activez la fonctionnalité mutualisée lorsque vous créez un cluster Managed Service pour Apache Spark.

Console

Créez un cluster à l'aide de la Google Cloud console, comme suit :

Dans la Google Cloud console, accédez à la pageCréer un cluster.
Cliquez sur Configuration supplémentaire pour développer cette section.
Modifiez les composants facultatifs.
1. Cochez la case Activer les composants dans l'interface utilisateur pour activer les interfaces utilisateur des composants, puis cochez la case Passerelle de kernel Jupyter.
2. Cliquez sur Enregistrer.

Modifiez Personnalisation et autres.

Pour autoriser l'ajout ou la suppression d'utilisateurs mutualisés sans recréer le cluster (consultez Mettre à jour les utilisateurs d'un cluster mutualisé), dans la section Propriétés du cluster, cliquez sur + Ajouter des propriétés.

Ajoutez la propriété suivante : Préfixe : dataproc, Clé : dataproc.dynamic.multi.tenancy.enabled, Valeur : true

Recommandation : Étant donné que YARN consomme des ressources de cluster importantes pour chaque kernel de notebook exécuté sur un cluster mutualisé, ajoutez des propriétés Spark et YARN pour augmenter l'allocation de ressources.

Exemple :

Préfixe	Clé	Valeur
spark	spark.driver.memory	5g
spark	spark.executor.memory	5g
spark	spark.executor.cores	2
capacity-scheduler	yarn.scheduler.capacity.maximum-am-resource-percent	0,5

Cliquez sur Enregistrer.

Modifiez Sécurité.
- Sous Accès au projet, cochez la case Active le champ d'application cloud-platform pour ce cluster.
- Sous Architecture mutualisée sécurisée, sélectionnez Activer.
- Sous Mappage mutualisé, cliquez sur Ajouter un mappage mutualisé pour mapper des comptes utilisateur à des comptes de service.
Cliquez sur Enregistrer.
Vérifiez les autres paramètres, puis cliquez sur Créer un cluster.

gcloud

Utilisez le gcloud dataproc clusters create command avec l' --secure-multi-tenancy-user-mapping option pour spécifier une liste de mappages entre des comptes utilisateur et des comptes de service.

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION \
    --secure-multi-tenancy-user-mapping=USER_MAPPINGS: \
    --properties "dataproc:dataproc.dynamic.multi.tenancy.enabled=true" \
    --service-account=CLUSTER_SERVICE_ACCOUNT@iam.gserviceaccount.com \
    --scopes=https://www.googleapis.com/auth/iam \
    --optional-components=JUPYTER_KERNEL_GATEWAY \
    --enable-component-gateway \
    other args ...

Remarques :

USER_MAPPINGS : spécifiez une liste d'éléments séparés par une virgule qui mappe des comptes utilisateur à des comptes de service.
```
--secure-multi-tenancy-user-mapping=UserA@my-company.com:SERVICE_ACCOUNT_FOR_USERA@iam.gserviceaccount.com,UserB@my-company.com:SERVICE_ACCOUNT_FOR_USERB@iam.gserviceaccount.com,UserC@my-company.com:SERVICE_ACCOUNT_FOR_USERC@iam.gserviceaccount.com
```
Utiliser un fichier de mappage YAML : au lieu d'utiliser l'option --secure-multi-tenancy-user-mapping pour spécifier les mappages entre les comptes utilisateur et les comptes de service, vous pouvez utiliser l'option --identity-config-file pour spécifier un fichier YAML local ou Cloud Storage contenant les mappages.
```
--identity-config-file=LOCAL_FILE or gs://BUCKET/FOLDER/FILENAME
```
Chaque ligne du fichier de mappage mappe un compte utilisateur à un compte de service. La première ligne contient l'en-tête user_service_account_mapping:.
```
user_service_account_mapping:
UserA@my-company.com:SERVICE_ACCOUNT_FOR_USERA@iam.gserviceaccount.com
UserB@my-company.com:SERVICE_ACCOUNT_FOR_USERB@iam.gserviceaccount.com
UserC@my-company.com:SERVICE_ACCOUNT_FOR_USERC@iam.gserviceaccount.com
```
--properties "dataproc:dataproc.dynamic.multi.tenancy.enabled=true" : cette propriété permet d'ajouter ou de supprimer des utilisateurs de cluster mutualisé sans recréer le cluster (consultez Mettre à jour les utilisateurs d'un cluster mutualisé).

Recommandation : Étant donné que YARN consomme des ressources de cluster importantes pour chaque kernel de notebook exécuté sur un cluster mutualisé, ajoutez des propriétés Spark et YARN pour augmenter l'allocation de ressources.

Exemple :
```
--properties=" \
spark:spark.driver.memory=5g,\
spark:spark.executor.memory=5g,\
spark:spark.executor.cores=200, \
capacity-scheduler:yarn.scheduler.capacity.maximum-am-resource-percent=0.5"
```
CLUSTER_SERVICE_ACCOUNT (facultatif) : vous pouvez utiliser l'option --service-account flag pour spécifier un compte de service de VM personnalisé pour le cluster. Si vous omettez cette option, le compte de service de VM de cluster par défaut, PROJECT_NUMBER-compute@developer.gserviceaccount.com, est utilisé.

Recommandation : Utilisez des comptes de service de cluster différents pour différents clusters afin de permettre à chaque compte de service de VM de cluster d'emprunter l'identité d'un groupe limité de comptes de service utilisateur mappés.
--scopes=https://www.googleapis.com/auth/iam est nécessaire pour que le compte de service du cluster puisse effectuer l'emprunt d'identité.
--enable-component-gateway et --optional-components=JUPYTER_KERNEL_GATEWAY: L'activation de la passerelle de composants Managed Service pour Apache Spark et de la passerelle de kernel Jupyter permet à plusieurs utilisateurs de connecter leurs notebooks Jupyter au cluster mutualisé.

API

Utilisez le SecurityConfig.IdentityConfig.userServiceAccountMapping field pour spécifier une liste de mappages entre des comptes utilisateur et des comptes de service.

Accorder des autorisations Identity and Access Management

Pour connecter des notebooks utilisateur à des kernels de notebook exécutés sur un cluster mutualisé, les utilisateurs mappés, les comptes de service mappés et le compte de service de VM de cluster doivent disposer des autorisations IAM nécessaires pour accéder aux ressources.

Autorisations utilisateur mappées

Chaque utilisateur mappé doit disposer des autorisations dataproc.clusters.get et dataproc.clusters.use, qui sont nécessaires pour que l'utilisateur puisse accéder aux kernels de notebook exécutés sur le cluster mutualisé et s'y connecter. Vous pouvez attribuer le rôle Éditeur Managed Service pour Apache Spark (roles/dataproc.editor), qui contient ces autorisations (consultez Attribuer un seul rôle IAM), ou créer un rôle personnalisé avec ces autorisations.

Autorisations de compte de service mappées

Chaque compte de service mappé doit disposer des autorisations requises par l'application de notebook de l'utilisateur mappé, telles que l'accès à un bucket Cloud Storage ou à une table BigQuery (consultez Gérer l'accès aux comptes de service).

Autorisations de compte de service de VM

Le compte de service de VM du cluster mutualisé doit disposer de l'autorisation iam.serviceAccounts.getAccessToken sur chaque compte de service mappé. Vous pouvez attribuer le rôle Créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator), qui contient cette autorisation (consultez Gérer l'accès aux comptes de service), ou créer un rôle personnalisé avec cette autorisation. Pour en savoir plus sur les autres rôles de compte de service de VM, consultez Compte de service de VM Managed Service pour Apache Spark.

Connecter des notebooks Jupyter à un kernel de cluster mutualisé

Les utilisateurs de clusters mutualisés mappés peuvent connecter leur notebook Jupyter Vertex AI Workbench ou géré par l'utilisateur aux kernels installés sur le cluster mutualisé.

Notebook Vertex AI

Pour créer et connecter un notebook Jupyter au cluster mutualisé, procédez comme suit :

Créer une instance Vertex AI Workbench.
Dans l'onglet "Instances Workbench", cliquez sur le lien "Ouvrir JupyterLab" pour votre instance.
Sous Notebooks de cluster Dataproc, cliquez sur la fiche PySpark (cluster YARN) sur MULTI_TENANCY_CLUSTER_NAME pour vous connecter et lancer un nouveau notebook Jupyter PySpark.

Notebook géré par l'utilisateur

Pour créer et connecter un notebook Jupyter géré par l'utilisateur à votre cluster mutualisé Managed Service pour Apache Spark, suivez les étapes pour installer l'extension JupyterLab sur votre VM gérée par l'utilisateur.

Mettre à jour les utilisateurs d'un cluster mutualisé (bêta)

Si vous définissez la propriété de cluster dataproc:dataproc.dynamic.multi.tenancy.enabled sur true lorsque vous créez un cluster mutualisé, vous pouvez ajouter, supprimer ou remplacer des utilisateurs de cluster mutualisé après la création du cluster.

Ajouter des utilisateurs

La commande de mise à jour suivante utilise l'option --add-user-mappings pour ajouter deux nouveaux mappages entre des comptes utilisateur et des comptes de service au cluster mutualisé sécurisé.

gcloud dataproc clusters update CLUSTER_NAME \
    --region=REGION \
    --add-user-mappings=new-user1@my-company.com=SERVICE_ACCOUNT_FOR_NEW_USER1@iam.gserviceaccount.com,new-user2@my-company.com=SERVICE_ACCOUNT_FOR_NEW_USER2@iam.gserviceaccount.com

Supprimer des utilisateurs

La commande de mise à jour suivante utilise l'option --remove-user-mappings pour supprimer deux utilisateurs du cluster mutualisé. L'option accepte les comptes utilisateur des utilisateurs à supprimer.

gcloud dataproc clusters update CLUSTER_NAME \
    --region=REGION \
    --remove-user-mappings=UserB@my-company.com,UserC@my-company.com

Remplacer des utilisateurs

Vous pouvez utiliser la commande update avec l'option --identity-config-file pour remplacer l'ensemble d'utilisateurs existant par un nouvel ensemble. Cette option est utile pour ajouter et supprimer des utilisateurs avec une seule commande de mise à jour.

gcloud dataproc clusters update CLUSTER_NAME \
    --region=REGION \
    --identity-config-file=identity-config.yaml