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 à Dataproc sur le cluster Compute Engine, n'inclut pas de Dataproc distinct des VM maîtres et des VM de nœud de calcul.

  • Dataproc sur GKE crée des pools de nœuds dans un environnement 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ées par GKE.

  • Créez plusieurs clusters virtuels. Vous pouvez créer et exécuter plusieurs instances sur un cluster GKE pour obtenir 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 à 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, 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 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 région où se trouve votre cluster GKE existant que vous sélectionnerez à l'étape suivante.
    3. Dans le champ Cluster Kubernetes, cliquez sur Parcourir pour sélectionner le dans la région où se trouve votre cluster GKE existant.
    4. (Facultatif) Dans le champ Bucket de préproduction Cloud Storage, vous pouvez cliquer sur Parcourez pour sélectionner un bucket Cloud Storage existant. Dataproc sur GKE préproduit les artefacts dans le bucket. Ignorer 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 accédez à la section Pools de nœuds. cliquez sur Ajouter un pool.

    1. Pour réutiliser un pool de nœuds Dataproc sur GKE existant: <ph type="x-smartling-placeholder">
        </ph>
      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 disposer du rôle PAR DÉFAUT.
      3. Cliquez sur OK.
    2. Pour créer un pool de nœuds Dataproc sur GKE, procédez comme suit: <ph type="x-smartling-placeholder">
        </ph>
      1. Cliquez sur Créer un pool de nœuds.
      2. Saisissez les valeurs de pool de nœuds suivantes: <ph type="x-smartling-placeholder">
          </ph>
        • 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: le 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. Tout doivent disposer de cet emplacement. Vous pouvez ajouter quatre pools de nœuds au total.
  6. (Facultatif) Si vous avez configuré un serveur d'historique persistant (PHS) Dataproc à utiliser pour afficher l'historique des jobs Spark sur Dataproc actif et supprimé sur GKE clusters, cliquez sur Personnaliser le cluster. Ensuite, dans le 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 Le cluster Dataproc sur GKE apparaît dans une liste sur la page Clusters. Son état est Provisionnement jusqu'à ce que le cluster soit prêt à être utilisé. l'état passe à Running (En cours d'exécution).

gcloud

Définissez les variables d'environnement, puis exécutez la 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) Serveur PHS Dataproc à utiliser pour afficher l'historique des jobs Spark sur Dataproc actif et supprimé sur GKE clusters. 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: le Version de l'image Spark utilisées sur le cluster Dataproc. Vous pouvez utilisez un identifiant, tel que 3, 3.1 ou latest, ou vous pouvez spécifier la version de correction complète, telle que 3.1-dataproc-5
    • --staging-bucket: supprimez cette option pour disposer de Dataproc sur GKE. créer 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. Liste Paramètres des pools 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 les valeurs name et role du pool de nœuds. Autre pool de nœuds sont facultatifs. Vous pouvez utiliser plusieurs options --pools pour spécifier plusieurs pools de nœuds. Vous devez ajouter au moins un pool de nœuds qui disposent du rôle default. Tous les pools de nœuds doivent avoir le même l'emplacement.
    • --setup-workload-identity: cette option active Workload Identity et liaisons IAM. Ces liaisons permettent aux comptes de service Kubernetes (KSA) est utilisée par défaut Compte de service de VM Dataproc (identité de plan de données) du cluster virtuel.

REST

Suivez une virtualClusterConfig dans le cadre d'une API Dataproc cluster.create requête.

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 exécuté, Envoyer un job Spark à l'aide de la console Google Cloud, gcloud CLI ou Dataproc jobs.submit API (à l'aide de requêtes HTTP directes ou bibliothèques clientes Cloud).

Exemple de job Spark pour 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 de la CLI gcloud:

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 gcloud CLI SparkR:

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

Effectuer un nettoyage