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 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 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 compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. 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 serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). 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 serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). 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 zonal ou régional standard (non Autopilot) Google Kubernetes Engine (GKE) 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 Do you need to grant roles? (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 for 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 for 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 VM 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éez 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

La création d'un cluster Managed Service pour Apache Spark sur GKE n'est pas prise en charge dans la console Google Cloud .

gcloud

Définissez des variables d'environnement, puis exécutez la commande gcloud dataproc clusters gke create 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 for 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 version mineure 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 intermédiaire.
    • --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 effectuer la charge de travail. Liste des paramètres de 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 pool de nœuds name et role. 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 disposer du rôle default. Tous les pools de nœuds doivent se trouver au même emplacement.
    • --setup-workload-identity : cet indicateur active les liaisons Workload Identity. Ces liaisons permettent aux comptes de service Kubernetes (CSA) 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

Renseignez un virtualClusterConfig dans une requête API cluster.create.

Avant d'utiliser les données de requête, 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 intermédiaire. Laissez ce champ vide pour que Managed Service pour Apache Spark sur GKE crée un bucket intermédiaire.

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 console Google Cloud , de la CLI gcloud ou de l'API Managed Service pour Apache Spark jobs.submit (en utilisant des requêtes HTTP directes ou les bibliothèques clientes Cloud).

**Exemple de job Spark avec 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 avec gcloud CLI :**

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

Effectuer un nettoyage