Exécuter une tâche 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. Contrairement à un cluster Dataproc sur Compute Engine, il n'inclut pas de VM maître et de VM de nœud 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 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

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

    Accéder aux clusters

  2. Cliquez sur Créer un cluster.

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

  4. Dans le panneau Configurer le cluster:

    1. Dans le champ Cluster Name (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 être la même que celle de votre cluster GKE existant (que vous sélectionnez dans l'élément suivant).
    3. Dans le champ Kubernetes Cluster (Cluster Kubernetes), cliquez sur Browse (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 met en scène 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 des 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 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 DEFAULT.
      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 suivantes pour le pool de nœuds :
    3. Cliquez sur Ajouter un pool pour ajouter d'autres pools de nœuds. Tous les pools de nœuds doivent comporter 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) Dataproc à utiliser pour afficher l'historique des tâches Spark sur les clusters Dataproc actifs et supprimés sur GKE, cliquez sur Personnaliser le cluster. Dans le champ Cluster de serveurs d'historique, recherchez et sélectionnez votre cluster PHS. Le cluster PHS doit se trouver 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 (Clusters). Son état indique Provisioning (Provisionnement) jusqu'à ce qu'il soit prêt à être utilisé, puis passe à Running (En cours d'exécution).

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 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 sous-mineure complète, telle que 3.1-dataproc-5.
    • --staging-bucket: supprimez cet indicateur pour que Dataproc 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 Dataproc créera ou utilisera pour exécuter la charge de travail. Indiquez les paramètres du pool de nœuds Dataproc sur GKE, séparés par une virgule, 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 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 la même localisation.
    • --setup-workload-identity: cette option active les liaisons Workload Identity. Ces liaisons permettent aux comptes de service Kubernetes (KSA) d'agir en tant que compte de service de la 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 API Dataproc 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 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 votre cluster virtuel Dataproc sur GKE en cours d'exécution, envoyez une tâche Spark à l'aide de la console Google Cloud, de la CLI gcloud ou de l'API Dataproc jobs.submit (à l'aide de requêtes HTTP directes ou des bibliothèques clientes Cloud).

Exemple de tâche Spark avec la 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 avec 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 la 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