Spark-Job in Dataproc in der Google Kubernetes Engine ausführen

Hinweise

  1. Sie müssen einen zonalen oder regionalen Google Kubernetes Engine (GKE)-Standardcluster (nicht Autopilot) erstellt haben, in dem Workload Identity aktiviert ist.

Virtuellen Dataproc-on-GKE-Cluster erstellen

Ein virtueller Dataproc-Cluster in GKE wird als Deployment-Plattform für Dataproc-Komponenten erstellt. Es handelt sich um eine virtuelle Ressource, die im Gegensatz zu einem Dataproc on Compute Engine-Cluster keine separaten Dataproc-Master- und Worker-VMs enthält.

  • Bei Dataproc on GKE werden Knotenpools in einem GKE-Cluster erstellt, wenn Sie einen virtuellen Dataproc on GKE-Cluster erstellen.

  • Dataproc on GKE-Jobs werden als Pods in diesen Knotenpools ausgeführt. Die Knotenpools und die Planung von Pods in den Knotenpools werden von GKE verwaltet.

  • Mehrere virtuelle Cluster erstellen: Sie können mehrere virtuelle Cluster in einem GKE-Cluster erstellen und ausführen, um die Ressourcennutzung zu verbessern, indem Sie Knotenpools für die virtuellen Cluster freigeben.

    • Jeder virtuelle Cluster:
      • wird mit separaten Eigenschaften erstellt, einschließlich der Spark-Engine-Version und der Arbeitslastidentität.
      • ist in einem separaten GKE-Namespace im GKE-Cluster isoliert.

Console

  1. Rufen Sie in der Google Cloud -Konsole die Seite Dataproc-Cluster auf.

    Zu den Clustern

  2. Klicken Sie auf Cluster erstellen.

  3. Klicken Sie im Dialogfeld Dataproc-Cluster erstellen in der Zeile Cluster in GKE auf Erstellen.

  4. Gehen Sie im Bereich Cluster einrichten so vor:

    1. Geben Sie im Feld Clustername einen Namen für den Cluster ein.
    2. Wählen Sie in der Liste Region eine Region für den virtuellen Dataproc on GKE-Cluster aus. Diese Region muss mit der Region übereinstimmen, in der sich Ihr vorhandener GKE-Cluster befindet (die Sie im nächsten Element auswählen).
    3. Klicken Sie im Feld Kubernetes-Cluster auf Durchsuchen, um die Region auszuwählen, in der sich Ihr vorhandener GKE-Cluster befindet.
    4. Optional: Klicken Sie im Feld Cloud Storage-Staging-Bucket auf Durchsuchen, um einen vorhandenen Cloud Storage-Bucket auszuwählen. Dataproc in GKE stellt Artefakte im Bucket bereit. Ignorieren Sie dieses Feld, damit Dataproc in GKE einen Staging-Bucket erstellt.
  5. Klicken Sie im linken Bereich auf Knotenpools konfigurieren und dann im Bereich Knotenpools auf Pool hinzufügen.

    1. So verwenden Sie einen vorhandenen Dataproc auf GKE-Knotenpool wieder:
      1. Klicken Sie auf Vorhandenen Knotenpool wiederverwenden.
      2. Geben Sie den Namen des vorhandenen Knotenpools ein und wählen Sie seine Rolle aus. Mindestens ein Knotenpool muss die Standardrolle (DEFAULT) haben.
      3. Klicken Sie auf Fertig.
    2. So erstellen Sie einen neuen Dataproc on GKE-Knotenpool:
      1. Klicken Sie auf Neuen Knotenpool erstellen.
      2. Geben Sie die folgenden Knotenpoolwerte ein:
        • Knotenpoolname
        • Rolle: Mindestens ein Knotenpool muss die Rolle „DEFAULT“ haben.
        • Standort: Geben Sie eine Zone innerhalb der Dataproc on GKE-Clusterregion an.
        • Maschinentyp des Knotenpools
        • CPU-Plattform
        • Unterbrechbarkeit
        • Min: Mindestanzahl von Knoten.
        • Max: Maximale Anzahl von Knoten. Die maximale Knotenzahl muss größer als 0 sein.
    3. Klicken Sie auf Pool hinzufügen, um weitere Knotenpools hinzuzufügen. Alle Knotenpools müssen den Standort haben. Sie können insgesamt vier Knotenpools hinzufügen.
  6. Optional: Wenn Sie einen Dataproc Persistent History Server (PHS) eingerichtet haben, um den Spark-Jobverlauf in aktiven und gelöschten Dataproc on GKE-Clustern aufzurufen, klicken Sie auf Cluster anpassen. Suchen Sie dann im Feld Verlaufsservercluster nach Ihrem PHS-Cluster und wählen Sie ihn aus. Der PHS-Cluster muss sich in derselben Region wie der virtuelle Dataproc on GKE-Cluster befinden.

  7. Klicken Sie auf Erstellen, um den Dataproc-Cluster zu erstellen. Ihr Dataproc on GKE-Cluster wird auf der Seite Cluster in einer Liste angezeigt. Der Status ist Wird bereitgestellt, bis der Cluster verwendet werden kann. Anschließend ändert sich der Status in Wird ausgeführt.

gcloud

Legen Sie Umgebungsvariablen fest und führen Sie den Befehl gcloud dataproc clusters gke create lokal oder in Cloud Shell aus, um ein Dataproc-on-GKE-Cluster zu erstellen.

  1. Legen Sie Umgebungsvariablen fest:

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

    • DP_CLUSTER: Legen Sie den Namen des virtuellen Dataproc-Clusters fest. Er muss mit einem Kleinbuchstaben beginnen, gefolgt von bis zu 54 Kleinbuchstaben, Ziffern oder Bindestrichen. Sie darf nicht mit einem Bindestrich enden.
    • REGION: Die region muss mit der Region übereinstimmen, in der sich der GKE-Cluster befindet.
    • GKE_CLUSTER: Der Name Ihres vorhandenen GKE-Cluster.
    • BUCKET: (Optional) Sie können den Namen eines Cloud Storage-Buckets angeben, den Dataproc für das Staging von Artefakten verwendet. Wenn Sie keinen Bucket angeben, erstellt Dataproc on GKE einen Staging-Bucket.
    • DP_POOLNAME: Der Name eines Knotenpools, der im GKE-Cluster erstellt werden soll.
    • PHS_CLUSTER: (Optional) Dataproc PHS-Server, der zum Aufrufen des Spark-Jobverlaufs in aktiven und gelöschten Dataproc on GKE-Clustern verwendet werden soll. Der PHS-Cluster muss sich in derselben Region wie der virtuelle Dataproc on GKE-Cluster befinden.
  2. Führen Sie diesen Befehl aus:

    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}
    
    Hinweise:

    • --spark-engine-version: Die Spark-Image-Version, die im Dataproc-Cluster verwendet wird. Sie können eine Kennung wie 3, 3.1 oder latest verwenden oder die vollständige Subminor-Version angeben, z. B. 3.1-dataproc-5.
    • --staging-bucket: Löschen Sie dieses Flag, damit Dataproc auf GKE einen Staging-Bucket erstellt.
    • --pools: Mit diesem Flag wird ein neuer oder vorhandener Knotenpool angegeben, den Dataproc zum Ausführen des Arbeitslast verwendet. Liste der Dataproc on GKE-Knotenpooleinstellungen, durch Kommas getrennt, z. B.:
      --pools=name=dp-default,roles=default,machineType=e2-standard-4,min=0,max=10
      
      Sie müssen den Knotenpool name und role angeben. Andere Knotenpooleinstellungen sind optional. Sie können mehrere --pools-Flags verwenden, um mehrere Knotenpools anzugeben. Für mindestens einen Knotenpool muss die Rolle default angegeben werden. Alle Knotenpools müssen denselben Standort haben.
    • --setup-workload-identity: Mit diesem Flag werden Workload Identity-Bindungen aktiviert. Durch diese Bindungen können die Kubernetes-Dienstkonten (Kubernetes Service Accounts, KSAs) als Cloud Dataproc-VM-Dienstkonto (Identität der Datenebene) des virtuellen Clusters fungieren.

REST

Füllen Sie eine virtualClusterConfig als Teil einer Dataproc API-Anfrage cluster.create aus.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT: ID des Google Cloud-Projekts.
  • REGION: Region des virtuellen Dataproc-Clusters (dieselbe Region wie die vorhandene GKE-Clusterregion)
  • DP_CLUSTER: Name des Dataproc-Clusters
  • GKE_CLUSTER: GKE-Clustername
  • NODE_POOL: Name des Knotenpools
  • PHS_CLUSTER: Name des Persistent History Server-Clusters (PHS)
  • BUCKET: (Optional) Name des Staging-Buckets. Lassen Sie dieses Feld leer, damit Dataproc in GKE einen Staging-Bucket erstellt.

HTTP-Methode und URL:

POST https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Spark-Job senden

Nachdem Ihr virtueller Dataproc-Cluster in GKE ausgeführt wird, können Sie einen Spark-Job übermitteln. Verwenden Sie dazu die Google Cloud Console, die gcloud CLI oder die Dataproc-jobs.submitAPI (mit direkten HTTP-Anfragen oder den Cloud-Clientbibliotheken).

Beispiel für einen Spark-Job in der 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

Beispiel für einen PySpark-Job mit der gcloud CLI:

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

Beispiel für einen SparkR-Job in der gcloud CLI:

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

Bereinigen