Exécuter un job Spark sur Dataproc sur Google Kubernetes Engine

Avant de commencer

  1. Vous devez avoir créé un cluster régional ou régional standard Google Kubernetes Engine (GKE) sur lequel Workload Identity est activé sur le cluster.

Créer un cluster virtuel Dataproc sur GKE

Un cluster virtuel Dataproc sur GKE est créé en tant que plate-forme de déploiement pour les composants Dataproc. Il s'agit d'une ressource virtuelle, et contrairement à un cluster Dataproc sur Compute Engine, il n'inclut pas de VM maîtres et de calcul Dataproc distinctes.

  • Dataproc sur GKE crée des pools de nœuds dans un cluster GKE lorsque vous créez un cluster virtuel Dataproc sur GKE.

  • Les tâches Dataproc sur GKE sont exécutées en tant que pods sur ces pools de nœuds. Les pools de nœuds et la planification des pods qu'ils contiennent 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

  1. Dans la console Google Cloud, accédez à la page Dataproc Clusters.

    Accéder aux clusters

  2. Cliquez sur Créer un cluster.

  3. Dans la boîte de dialogue Créer un cluster Dataproc, sur la ligne Cluster sur GKE, cliquez sur Créer.

  4. Dans le panneau Configurer le cluster:

    1. Dans le champ Nom du cluster, saisissez un nom pour le cluster.
    2. Dans la liste Région, sélectionnez une région pour le cluster virtuel Dataproc sur GKE. Cette région doit correspondre à celle de 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. Dataproc sur GKE entreposera les artefacts dans le bucket. Ignorez ce champ pour que Dataproc 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 Dataproc sur GKE existant :
      1. Cliquez sur Réutiliser le 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 disposer du rôle PAR DÉFAUT.
      3. Cliquez sur OK.
    2. Pour créer un pool de nœuds Dataproc sur GKE :
      1. Cliquez sur Créer un pool de nœuds.
      2. Saisissez les valeurs de pool de nœuds suivantes :
        • Nom du pool de nœuds
        • Rôle: au moins un pool de nœuds doit disposer du rôle par défaut.
        • Emplacement: spécifiez une zone dans la région du cluster Dataproc sur GKE.
        • Type de machine du pool de nœuds
        • Plate-forme du processeur
        • Préemption
        • 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 disposer de l'emplacement. Vous pouvez ajouter un total de quatre pools de nœuds.

  6. (Facultatif) Si vous avez configuré un serveur d'historique persistant Dataproc (PHS) à utiliser pour afficher l'historique des tâches Spark, cliquez sur Personnaliser le cluster sur les clusters Dataproc sur GKE actifs et supprimés. Ensuite, dans le champ Cluster de serveurs de l'historique, recherchez et sélectionnez votre cluster PHS. Le cluster PHS doit être situé dans la même région que le cluster virtuel Dataproc sur GKE.

  7. Cliquez sur Créer pour créer le cluster Dataproc. Votre cluster Dataproc sur GKE apparaît dans une liste sur la page Clusters. Son état est Provisioning (Provisionnement) jusqu'à ce que le cluster soit prêt à être utilisé. Il passe ensuite à l'état Running (En cours d'exécution).

gcloud

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

  1. Définissez les variables d'environnement : 

    DP_CLUSTER=Dataproc on GKE  cluster-name \
  REGION=region \
  GKE_CLUSTER=GKE cluster-name \
  BUCKET=Cloud Storage bucket-name \
  DP_POOLNAME=node pool-name
  PHS_CLUSTER=Dataproc PHS server name
    Remarques :

    • DP_CLUSTER : définissez le nom du cluster virtuel Dataproc, 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 Dataproc utilisera pour organiser les artefacts. Si vous ne spécifiez pas de bucket, Dataproc 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 Dataproc à utiliser pour afficher l'historique des tâches Spark sur les clusters Dataproc actifs et supprimés sur GKE. Le cluster PHS doit se trouver dans la même région que le cluster virtuel Dataproc 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 Dataproc. Vous pouvez utiliser un identifiant, tel que 3, 3.1 ou latest, ou spécifier la version de correction complète, telle que 3.1-dataproc-5.
    • --staging-bucket: supprimez cette option pour que Dataproc sur GKE crée un bucket de préproduction.
    • --pools: cette option permet de spécifier un pool de nœuds nouveau ou existant que Dataproc créera ou utilisera pour exécuter la charge de travail. Répertoriez les paramètres du pool de nœuds Dataproc sur GKE, séparés par une virgule. Exemple: 
      --pools=name=dp-default,roles=default,machineType=e2-standard-4,min=0,max=10
      Vous devez spécifier les pools de nœuds name et role. Les autres paramètres du pool de nœuds sont facultatifs. Vous pouvez utiliser plusieurs options --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 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 Dataproc (identité de plan de données) par défaut du cluster virtuel.

REST

Complétez un virtualClusterConfig dans le cadre d'une requête cluster.create de l'API Dataproc.

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 de préproduction. Laissez ce champ vide pour que Dataproc 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 que votre cluster virtuel Dataproc sur GKE est en cours d'exécution, envoyez une tâche Spark à l'aide de la console Google Cloud, de la gcloud CLI ou de l'API Dataproc jobs.submit (à l'aide de requêtes HTTP directes ou des bibliothèques clientes Cloud).

Exemple de job Spark avec la CLI gcloud:

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 job gcloud CLI PySpark:

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

Exemple de job SparkR dans la CLI gcloud:

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

Effectuer un nettoyage