Exécuter une tâche Spark sur Google Kubernetes Engine

Ce document vous explique comment créer un cluster virtuel Managed Service pour Apache Spark sur GKE, puis comment exécuter un job Spark sur le cluster.

Présentation des options

Bien que Managed Service pour Apache Spark sur GKE offre un contrôle puissant pour les environnements conteneurisés, Google Cloud il propose également des options entièrement gérées et sans serveur qui peuvent simplifier les opérations et accélérer le développement. Pour comparer les options de déploiement de Spark Managed Service pour Apache Spark, consultez Choisir le meilleur service Spark.

Avant de commencer

  1. Connectez-vous à votre Google Cloud compte. Si vous n'avez jamais utilisé Google Cloud, créez un compte pour évaluer les performances de nos produits dans des scénarios réels. Les nouveaux clients bénéficient également de 300 $ de crédits sans frais pour exécuter, tester et déployer des charges de travail.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that you have the permissions required to complete this guide.

  4. Verify that billing is enabled for your Google Cloud project.

  5. Enable the Dataproc API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  6. Installez la Google Cloud CLI.

  7. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  8. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

  9. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  10. Verify that you have the permissions required to complete this guide.

  11. Verify that billing is enabled for your Google Cloud project.

  12. Enable the Dataproc API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  13. Installez la Google Cloud CLI.

  14. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  15. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

  16. Vous devez avoir créé un cluster standard Google Kubernetes Engine (GKE) zonal ou régional (et non un cluster Autopilot) sur lequel Workload Identity est activé.

Rôles requis

Certains rôles IAM sont requis pour exécuter les exemples de cette page. En fonction des règles d'administration, ces rôles peuvent déjà avoir été attribués. Pour vérifier les attributions de rôles, consultez la section Devez-vous attribuer des rôles ?.

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Rôles utilisateur

Pour obtenir les autorisations nécessaires pour créer un cluster Managed Service pour Apache Spark, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Rôle du compte de service

Pour vous assurer que le compte de service Compute Engine par défaut dispose des autorisations nécessaires pour créer un cluster Managed Service pour Apache Spark, demandez à votre administrateur d'accorder le rôle IAM Nœud de calcul Dataproc (roles/dataproc.worker) au compte de service Compute Engine par défaut sur le projet.

Créer un cluster virtuel

Un cluster virtuel Managed Service pour Apache Spark sur GKE est créé en tant que plate-forme de déploiement pour les composants Managed Service pour Apache Spark. Il s'agit d'une ressource virtuelle qui, contrairement à un cluster Managed Service pour Apache Spark sur Compute Engine, n'inclut pas de VM maître et de nœud de calcul Managed Service pour Apache Spark distinctes.

  • Managed Service pour Apache Spark sur GKE crée des pools de nœuds dans un cluster GKE lorsque vous créez un cluster virtuel Managed Service pour Apache Spark sur GKE.

  • Les jobs Managed Service pour Apache Spark sur GKE sont exécutés en tant que pods sur ces pools de nœuds. Les pools de nœuds et la planification des pods sur les pools de nœuds sont gérés par GKE.

  • Créer plusieurs clusters virtuels Vous pouvez créer et exécuter plusieurs clusters virtuels sur un cluster GKE pour améliorer l'utilisation des ressources en partageant des pools de nœuds entre les clusters virtuels.

    • Chaque cluster virtuel :
      • est créé avec des propriétés distinctes, comme la version de Spark et l'identité de la charge de travail.
      • est isolée dans un espace de noms GKE distinct sur le cluster GKE.

Console

  1. Dans la Google Cloud console, accédez à la page Clusters de Managed Service pour Apache Spark.

    accéder aux clusters

  2. Cliquez sur Créer un cluster.

  3. Dans la boîte de dialogue Créer un cluster Managed Service pour Apache Spark, cliquez sur Créer dans la ligne Cluster sur GKE.

  4. Dans le panneau Configurer le cluster :

    1. Dans le champ Nom du cluster, saisissez le nom du cluster.
    2. Dans la liste Région, sélectionnez une région pour le cluster virtuel Managed Service pour Apache Spark sur GKE. Cette région doit être la même que celle dans laquelle se trouve votre cluster GKE existant (que vous sélectionnez dans l'élément suivant).
    3. Dans le champ Cluster Kubernetes, cliquez sur Parcourir pour sélectionner la région dans laquelle se trouve votre cluster GKE existant.
    4. Facultatif : Dans le champ Bucket de préproduction Cloud Storage, vous pouvez cliquer sur Parcourir pour sélectionner un bucket Cloud Storage existant. Managed Service pour Apache Spark sur GKE préproduira les artefacts dans le bucket. Ignorez ce champ pour que Managed Service pour Apache Spark sur GKE crée un bucket de préproduction.

  5. Dans le panneau de gauche, cliquez sur Configurer les pools de nœuds, puis, dans le panneau Pools de nœuds , cliquez sur Ajouter un pool.

    1. Pour réutiliser un pool de nœuds Managed Service pour Apache Spark sur GKE existant :
      1. Cliquez sur Réutiliser un pool de nœuds existant.
      2. Saisissez le nom du pool de nœuds existant et sélectionnez son rôle. Au moins un pool de nœuds doit avoir le rôle par défaut.
      3. Cliquez sur OK.
    2. Pour créer un pool de nœuds Managed Service pour Apache Spark sur GKE :
      1. Cliquez sur Créer un pool de nœuds.
      2. Saisissez les valeurs suivantes pour le pool de nœuds :
        • Nom du pool de nœuds
        • Rôle : au moins un pool de nœuds doit avoir le rôle par défaut.
        • Emplacement : spécifiez une zone dans la région du cluster Managed Service pour Apache Spark sur GKE.
        • Type de machine du pool de nœuds
        • Plate-forme du processeur
        • Préemptibilité
        • Min : nombre minimal de nœuds.
        • Max : nombre maximal de nœuds. Le nombre maximal de nœuds doit être supérieur à 0.
    3. Cliquez sur Ajouter un pool pour ajouter d'autres pools de nœuds. Tous les pools de nœuds doivent avoir l'emplacement. Vous pouvez ajouter un total de quatre pools de nœuds.

  6. (Facultatif) Si vous avez configuré un serveur d'historique persistant (PHS) Managed Service pour Apache Spark afin d'afficher l'historique des jobs Spark sur les clusters Managed Service pour Apache Spark sur GKE actifs et supprimés, cliquez sur Personnaliser le cluster. Ensuite, dans le champ Cluster du serveur d'historique , recherchez et choisissez votre cluster PHS. Le cluster PHS doit se trouver dans la même région que le cluster virtuel Managed Service pour Apache Spark sur GKE.

  7. Cliquez sur Créer pour créer le cluster Managed Service pour Apache Spark. Votre cluster Managed Service pour Apache Spark sur GKE s'affiche dans une liste sur la page Clusters. Son état est Provisionnement jusqu'à ce qu'il soit prêt à être utilisé, puis il passe à En cours d'exécution.

gcloud

Définissez des variables d'environnement, puis exécutez la gcloud dataproc clusters gke create commande en local ou dans Cloud Shell pour créer un cluster Managed Service pour Apache Spark sur GKE.

  1. Définissez les variables d'environnement : 

    DP_CLUSTER=Managed Service for Apache Spark on GKE  cluster-name \
  REGION=region \
  GKE_CLUSTER=GKE cluster-name \
  BUCKET=Cloud Storage bucket-name \
  DP_POOLNAME=node pool-name
  PHS_CLUSTER=Managed Service for Apache Spark PHS server name
    Remarques :

    • DP_CLUSTER: définissez le nom du cluster virtuel Managed Service pour Apache Spark, qui doit commencer par une lettre minuscule, suivie de 54 caractères (lettres minuscules, chiffres ou traits d'union). Il ne peut pas se terminer par un trait d'union.
    • REGION : le champ region doit être identique à la région où se trouve le cluster GKE.
    • GKE_CLUSTER : le nom de votre cluster GKE existant.
    • BUCKET : (facultatif) vous pouvez spécifier le nom d'un bucket Cloud Storage, que Managed Service pour Apache Spark utilisera pour organiser les artefacts. Si vous ne spécifiez pas de bucket, Managed Service pour Apache Spark sur GKE crée un bucket de préproduction.
    • DP_POOLNAME : le nom d'un pool de nœuds à créer sur le cluster GKE.
    • PHS_CLUSTER : (facultatif) le Serveur PHS Managed Service pour Apache Spark à utiliser pour afficher l'historique des tâches Spark sur les clusters Managed Service pour Apache Spark actifs et supprimés sur GKE. Le cluster PHS doit se trouver dans la même région que le cluster virtuel Managed Service pour Apache Spark sur GKE.

  2. Exécutez la commande suivante : 

    gcloud dataproc clusters gke create ${DP_CLUSTER} \
    --region=${REGION} \
    --gke-cluster=${GKE_CLUSTER} \
    --spark-engine-version=latest \
    --staging-bucket=${BUCKET} \
    --pools="name=${DP_POOLNAME},roles=default" \
    --setup-workload-identity \
    --history-server-cluster=${PHS_CLUSTER}
    Remarques :

    • --spark-engine-version : version de l'image Spark utilisée sur le cluster Managed Service pour Apache Spark. Vous pouvez utiliser un identifiant, tel que 3, 3.1 ou latest, ou spécifier la sous-version complète, telle que 3.1-dataproc-5.
    • --staging-bucket : supprimez cet indicateur pour que Managed Service pour Apache Spark sur GKE crée un bucket de préproduction.
    • --pools: cet indicateur permet de spécifier un pool de nœuds nouveau ou existant que Managed Service pour Apache Spark créera ou utilisera pour exécuter la charge de travail. Affichez la liste des paramètres du pool de nœuds Managed Service pour Apache Spark sur GKE , séparés par des virgules, par exemple : 
      --pools=name=dp-default,roles=default,machineType=e2-standard-4,min=0,max=10
      Vous devez spécifier le name et le role du pool de nœuds. Les autres paramètres du pool de nœuds sont facultatifs. Vous pouvez utiliser plusieurs indicateurs --pools pour spécifier plusieurs pools de nœuds. Au moins un pool de nœuds doit avoir le rôle default. Tous les pools de nœuds doivent avoir le même emplacement.
    • --setup-workload-identity : cet indicateur active les liaisons Workload Identity. Ces liaisons permettent aux comptes de service Kubernetes (KSA) d'agir en tant que compte de service de VM Managed Service pour Apache Spark par défaut (identité du plan de données) du cluster virtuel.

REST

Remplissez un virtualClusterConfig dans le cadre d'une requête API cluster.create.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT : l'ID du projet Google Cloud
  • REGION : la région de cluster virtuel Dataproc (même région que le cluster GKE existant)
  • DP_CLUSTER : le nom du cluster Dataproc
  • GKE_CLUSTER : le nom du cluster GKE
  • NODE_POOL : le nom du pool de nœuds
  • PHS_CLUSTER : le nom du cluster du serveur d'historique persistant (PHS)
  • BUCKET : (facultatif) nom du bucket de préproduction. Laissez ce champ vide pour que Managed Service pour Apache Spark sur GKE crée un bucket de préproduction.

Méthode HTTP et URL : 

POST https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters

Corps JSON de la requête : 

{
  "clusterName":"DP_CLUSTER",
  "projectId":"PROJECT",
  "virtualClusterConfig":{
    "auxiliaryServicesConfig":{
      "sparkHistoryServerConfig":{
        "dataprocCluster":"projects/PROJECT/regions/REGION/clusters/PHS_CLUSTER"
      }
    },
    "kubernetesClusterConfig":{
      "gkeClusterConfig":{
        "gkeClusterTarget":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER",
        "nodePoolTarget":[
          {
"nodePool":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER/nodePools/NODE_POOL",
            "roles":[
              "DEFAULT"
            ]
          }
        ]
      },
      "kubernetesSoftwareConfig":{
        "componentVersion":{
          "SPARK":"latest"
        }
      }
    },
    "stagingBucket":"BUCKET"
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "projectId":"PROJECT",
  "clusterName":"DP_CLUSTER",
  "status":{
    "state":"RUNNING",
    "stateStartTime":"2022-04-01T19:16:39.865716Z"
  },
  "clusterUuid":"98060b77-...",
  "statusHistory":[
    {
      "state":"CREATING",
      "stateStartTime":"2022-04-01T19:14:27.340544Z"
    }
  ],
  "labels":{
    "goog-dataproc-cluster-name":"DP_CLUSTER",
    "goog-dataproc-cluster-uuid":"98060b77-...",
    "goog-dataproc-location":"REGION",
    "goog-dataproc-environment":"prod"
  },
  "virtualClusterConfig":{
    "stagingBucket":"BUCKET",
    "kubernetesClusterConfig":{
      "kubernetesNamespace":"dp-cluster",
      "gkeClusterConfig":{
"gkeClusterTarget":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER",
        "nodePoolTarget":[
          {
"nodePool":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER/nodePools/NODE_POOL",
            "roles":[
              "DEFAULT"
            ]
          }
        ]
      },
      "kubernetesSoftwareConfig":{
        "componentVersion":{
          "SPARK":"3.1-..."
        },
        "properties":{
          "dpgke:dpgke.unstable.outputOnly.endpoints.sparkHistoryServer":"https://...",
          "spark:spark.eventLog.dir":"gs://BUCKET/.../spark-job-history",
          "spark:spark.eventLog.enabled":"true"
        }
      }
    },
    "auxiliaryServicesConfig":{
      "sparkHistoryServerConfig":{
        "dataprocCluster":"projects/PROJECT/regions/REGION/clusters/PHS_CLUSTER"
      }
    }
  }

Envoyer une tâche Spark

Une fois votre cluster virtuel Managed Service pour Apache Spark sur GKE en cours d'exécution, envoyez un job Spark à l'aide de la Google Cloud console, gcloud CLIou de l'API Managed Service pour Apache Spark jobs.submit (à l'aide de requêtes HTTP directes ou des bibliothèques clientes Cloud).

Exemple de tâche Spark gcloud CLI :

gcloud dataproc jobs submit spark \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    --class=org.apache.spark.examples.SparkPi \
    --jars=local:///usr/lib/spark/examples/jars/spark-examples.jar \
    -- 1000

Exemple de tâche PySpark gcloud CLI :

gcloud dataproc jobs submit pyspark \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    local:///usr/lib/spark/examples/src/main/python/pi.py \
    -- 10

Exemple de tâche SparkR gcloud CLI :

gcloud dataproc jobs submit spark-r \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    local:///usr/lib/spark/examples/src/main/r/dataframe.R

Libérer de l'espace