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

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 :
         • 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 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 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 :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters" | Select-Object -Expand Content

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"
      }
    }
  }