Cluster erstellen

Managed Service for Apache Spark-Cluster erstellen

Voraussetzungen:

  • Name:Der Clustername muss mit einem Kleinbuchstaben beginnen, gefolgt von bis zu 51 Kleinbuchstaben, Ziffern und Bindestrichen. Das letzte Zeichen darf kein Bindestrich sein.

  • Clusterregion:Sie müssen eine Compute Engine-Region für den Cluster angeben, z. B. us-east1 oder europe-west1, um Clusterressourcen wie VM-Instanzen und Clustermetadaten, die in Cloud Storage gespeichert sind, innerhalb der Region zu isolieren.

    • Weitere Informationen zu Compute Engine-Regionen finden Sie unter Clusterregion.
    • Informationen zum Auswählen von Regionen finden Sie unter Verfügbare Regionen und Zonen. Sie können auch den Befehl gcloud compute regions list ausführen, um eine Liste der verfügbaren Regionen anzuzeigen.

  • Verbindung:Compute Engine-VM-Instanzen in einem Managed Service for Apache Spark-Cluster, die aus Master- und Worker-VMs bestehen, erfordern vollständige interne IP-Adressen-Netzwerkverbindungen. Das default-VPC-Netzwerk bietet diese Verbindung (siehe Netzwerkkonfiguration für Managed Service for Apache Spark-Cluster).

  • Maschinentyp (empfohlen): Die Angabe eines Maschinentyps ist zwar optional, Google empfiehlt jedoch, explizit einen Maschinentyp für die Master- und Worker-VMs in Ihrem Cluster auszuwählen. Wenn Sie keinen Maschinentyp angeben, wählt Managed Service for Apache Spark Maschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit aus. Diese dynamische Auswahl kann zu Schwankungen bei Kosten und Leistung führen.

    • Weitere Informationen zur Auswahl eines Maschinentyps finden Sie unter Unterstützte Maschinentypen.
    • Um potenzielle Probleme mit der Nichtverfügbarkeit von Ressourcen zu vermeiden, empfehlen wir die Verwendung von flexiblen VMs, mit denen Sie eine Liste akzeptabler Maschinentypen angeben können.

Console

Öffnen Sie die Seite Cluster erstellen für Managed Service for Apache Spark in der Google Cloud Console in Ihrem Browser und klicken Sie dann auf der Seite Dataproc-Cluster in Compute Engine erstellen in der Zeile für Compute Engine auf Erstellen. Der Bereich Cluster einrichten wird mit Feldern ausgewählt, die mit Standardwerten gefüllt sind. Sie können jedes Feld auswählen und Standardwerte prüfen oder ändern, um den Cluster anzupassen.

Klicken Sie auf Erstellen, um den Cluster zu erstellen. Der Clustername wird auf der Seite Cluster angezeigt und sein Status wird in „Aktiv“ aktualisiert, nachdem der Cluster bereitgestellt wurde. Klicken Sie auf den Clusternamen, um die Seite „Clusterdetails“ zu öffnen. Hier können Sie Jobs, Instanzen und Konfigurationseinstellungen für den Cluster überprüfen und eine Verbindung zu den Weboberflächen herstellen, die auf Ihrem Cluster ausgeführt werden.

gcloud

Führen Sie zum Erstellen eines Managed Service for Apache Spark-Clusters in der Befehlszeile den Befehl gcloud dataproc clusters create lokal in einem Terminalfenster oder in Cloud Shell aus.

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION \
    --master-machine-type=MASTER_MACHINE_TYPE \
    --worker-machine-type=WORKER_MACHINE_TYPE

Mit dem Befehl wird ein Cluster erstellt. Master- und Worker-Maschinentypen sind zwar optional, es wird jedoch empfohlen, sie explizit mit den Flags --master-machine-type und --worker-machine-type anzugeben (z. B. n4-standard-4), um konsistente Kosten und Leistung zu gewährleisten. Wenn Sie keine Maschinentypen angeben, werden Standardmaschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit ausgewählt. Weitere Informationen dazu, wie Sie mit Befehlszeilen-Flags Clustereinstellungen anpassen können, finden Sie im Befehl gcloud dataproc clusters create.

Erstellen Sie einen Cluster mit einer YAML-Datei

  1. Führen Sie den folgenden gcloud-Befehl aus, um die Konfiguration eines vorhandenen Managed Service for Apache Spark-Clusters in eine cluster.yaml-Datei zu exportieren. 
    gcloud dataproc clusters export EXISTING_CLUSTER_NAME \
    --region=REGION \
    --destination=cluster.yaml
  2. Erstellen Sie einen neuen Cluster. Dazu importieren Sie die Konfiguration der YAML-Datei. 
    gcloud dataproc clusters import NEW_CLUSTER_NAME \
    --region=REGION \
    --source=cluster.yaml

Hinweis:Während des Exportvorgangs werden clusterspezifische Felder (z. B. der Clustername), Nur-Ausgabe-Felder und automatisch angewendete Labels gefiltert. Diese Felder sind in der importierten YAML-Datei, die zum Erstellen eines Clusters verwendet wurde, nicht zulässig.

REST

In diesem Abschnitt wird beschrieben, wie Sie einen Cluster erstellen. Die Angabe von Maschinentypen ist zwar optional, es wird jedoch empfohlen, machine_type_uri explizit in Ihre master_config und worker_config (z. B. n4-standard-4) aufzunehmen, um konsistente Kosten und Leistung zu gewährleisten. Wenn Sie keine Maschinentypen angeben, werden Standardmaschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit ausgewählt.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • CLUSTER_NAME: Clustername
  • PROJECT: Google Cloud Projekt-ID
  • REGION: Eine verfügbare Compute Engine-Region, in der der Cluster erstellt wird.
  • ZONE: Eine optionale Zone in der ausgewählten Region, in der der Cluster erstellt wird.
  • MASTER_MACHINE_TYPE: (Empfohlen) Der Maschinentyp für den Masterknoten (z. B. n4-standard-4).
  • WORKER_MACHINE_TYPE: (Empfohlen) Der Maschinentyp für Worker-Knoten (z. B. n4-standard-4).

HTTP-Methode und URL: 

POST https://dataproc.googleapis.com/v1/projects/PROJECT/regions/REGION/clusters

JSON-Text anfordern:

{
  "project_id":"PROJECT",
  "cluster_name":"CLUSTER_NAME",
  "config":{
    "master_config":{
      "num_instances":1,
      "machine_type_uri":"MASTER_MACHINE_TYPE",
      "image_uri":""
    },
    "softwareConfig": {
      "imageVersion": "",
      "properties": {},
      "optionalComponents": []
    },
    "worker_config":{
      "num_instances":2,
      "machine_type_uri":"WORKER_MACHINE_TYPE",
      "image_uri":""
    },
    "gce_cluster_config":{
      "zone_uri":"ZONE"
    }
  }
}

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

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

{
"name": "projects/PROJECT/regions/REGION/operations/b5706e31......",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.dataproc.v1.ClusterOperationMetadata",
    "clusterName": "CLUSTER_NAME",
    "clusterUuid": "5fe882b2-...",
    "status": {
      "state": "PENDING",
      "innerState": "PENDING",
      "stateStartTime": "2019-11-21T00:37:56.220Z"
    },
    "operationType": "CREATE",
    "description": "Create cluster with 2 workers",
    "warnings": [
      "For PD-Standard without local SSDs, we strongly recommend provisioning 1TB ...""
    ]
  }
}
<

Go

  1. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus.

    Hinweis:Die Angabe von Maschinentypen ist zwar optional, es wird jedoch empfohlen, die Master- und Worker-Maschinentypen in der Clusterkonfiguration explizit festzulegen (z. B. auf n4-standard-4), um konsistente Kosten und Leistung zu gewährleisten. Wenn sie nicht angegeben werden, werden Standardmaschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit ausgewählt.

    import (
	"context"
	"fmt"
	"io"

	dataproc "cloud.google.com/go/dataproc/apiv1"
	"cloud.google.com/go/dataproc/apiv1/dataprocpb"
	"google.golang.org/api/option"
)

func createCluster(w io.Writer, projectID, region, clusterName string) error {
	// projectID := "your-project-id"
	// region := "us-central1"
	// clusterName := "your-cluster"
	ctx := context.Background()

	// Create the cluster client.
	endpoint := region + "-dataproc.googleapis.com:443"
	clusterClient, err := dataproc.NewClusterControllerClient(ctx, option.WithEndpoint(endpoint))
	if err != nil {
		return fmt.Errorf("dataproc.NewClusterControllerClient: %w", err)
	}
	defer clusterClient.Close()

	// Create the cluster config.
	req := &dataprocpb.CreateClusterRequest{
		ProjectId: projectID,
		Region:    region,
		Cluster: &dataprocpb.Cluster{
			ProjectId:   projectID,
			ClusterName: clusterName,
			Config: &dataprocpb.ClusterConfig{
				MasterConfig: &dataprocpb.InstanceGroupConfig{
					NumInstances:   1,
					MachineTypeUri: "n1-standard-2",
				},
				WorkerConfig: &dataprocpb.InstanceGroupConfig{
					NumInstances:   2,
					MachineTypeUri: "n1-standard-2",
				},
			},
		},
	}

	// Create the cluster.
	op, err := clusterClient.CreateCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateCluster: %w", err)
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("CreateCluster.Wait: %w", err)
	}

	// Output a success message.
	fmt.Fprintf(w, "Cluster created successfully: %s", resp.ClusterName)
	return nil
}

Java

  1. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus.

    Hinweis:Die Angabe von Maschinentypen ist zwar optional, es wird jedoch empfohlen, die Master- und Worker-Maschinentypen in der Clusterkonfiguration explizit festzulegen (z. B. auf n4-standard-4), um konsistente Kosten und Leistung zu gewährleisten. Wenn sie nicht angegeben werden, werden Standardmaschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit ausgewählt.

    import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.dataproc.v1.Cluster;
import com.google.cloud.dataproc.v1.ClusterConfig;
import com.google.cloud.dataproc.v1.ClusterControllerClient;
import com.google.cloud.dataproc.v1.ClusterControllerSettings;
import com.google.cloud.dataproc.v1.ClusterOperationMetadata;
import com.google.cloud.dataproc.v1.InstanceGroupConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCluster {

  public static void createCluster() throws IOException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String region = "your-project-region";
    String clusterName = "your-cluster-name";
    createCluster(projectId, region, clusterName);
  }

  public static void createCluster(String projectId, String region, String clusterName)
      throws IOException, InterruptedException {
    String myEndpoint = String.format("%s-dataproc.googleapis.com:443", region);

    // Configure the settings for the cluster controller client.
    ClusterControllerSettings clusterControllerSettings =
        ClusterControllerSettings.newBuilder().setEndpoint(myEndpoint).build();

    // Create a cluster controller client with the configured settings. The client only needs to be
    // created once and can be reused for multiple requests. Using a try-with-resources
    // closes the client, but this can also be done manually with the .close() method.
    try (ClusterControllerClient clusterControllerClient =
        ClusterControllerClient.create(clusterControllerSettings)) {
      // Configure the settings for our cluster.
      InstanceGroupConfig masterConfig =
          InstanceGroupConfig.newBuilder()
              .setMachineTypeUri("n1-standard-2")
              .setNumInstances(1)
              .build();
      InstanceGroupConfig workerConfig =
          InstanceGroupConfig.newBuilder()
              .setMachineTypeUri("n1-standard-2")
              .setNumInstances(2)
              .build();
      ClusterConfig clusterConfig =
          ClusterConfig.newBuilder()
              .setMasterConfig(masterConfig)
              .setWorkerConfig(workerConfig)
              .build();
      // Create the cluster object with the desired cluster config.
      Cluster cluster =
          Cluster.newBuilder().setClusterName(clusterName).setConfig(clusterConfig).build();

      // Create the Cloud Dataproc cluster.
      OperationFuture<Cluster, ClusterOperationMetadata> createClusterAsyncRequest =
          clusterControllerClient.createClusterAsync(projectId, region, cluster);
      Cluster response = createClusterAsyncRequest.get();

      // Print out a success message.
      System.out.printf("Cluster created successfully: %s", response.getClusterName());

    } catch (ExecutionException e) {
      System.err.println(String.format("Error executing createCluster: %s ", e.getMessage()));
    }
  }
}

Node.js

  1. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus.

    Hinweis:Die Angabe von Maschinentypen ist zwar optional, es wird jedoch empfohlen, die Master- und Worker-Maschinentypen in der Clusterkonfiguration explizit festzulegen (z. B. auf n4-standard-4), um konsistente Kosten und Leistung zu gewährleisten. Wenn sie nicht angegeben werden, werden Standardmaschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit ausgewählt.

    const dataproc = require('@google-cloud/dataproc');

// TODO(developer): Uncomment and set the following variables
// projectId = 'YOUR_PROJECT_ID'
// region = 'YOUR_CLUSTER_REGION'
// clusterName = 'YOUR_CLUSTER_NAME'

// Create a client with the endpoint set to the desired cluster region
const client = new dataproc.v1.ClusterControllerClient({
  apiEndpoint: `${region}-dataproc.googleapis.com`,
  projectId: projectId,
});

async function createCluster() {
  // Create the cluster config
  const request = {
    projectId: projectId,
    region: region,
    cluster: {
      clusterName: clusterName,
      config: {
        masterConfig: {
          numInstances: 1,
          machineTypeUri: 'n1-standard-2',
        },
        workerConfig: {
          numInstances: 2,
          machineTypeUri: 'n1-standard-2',
        },
      },
    },
  };

  // Create the cluster
  const [operation] = await client.createCluster(request);
  const [response] = await operation.promise();

  // Output a success message
  console.log(`Cluster created successfully: ${response.clusterName}`);

Python

  1. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus.

    Hinweis:Die Angabe von Maschinentypen ist zwar optional, es wird jedoch empfohlen, die Master- und Worker-Maschinentypen in der Clusterkonfiguration explizit festzulegen (z. B. auf n4-standard-4), um konsistente Kosten und Leistung zu gewährleisten. Wenn sie nicht angegeben werden, werden Standardmaschinentypen dynamisch basierend auf der Ressourcenverfügbarkeit ausgewählt.

    from google.cloud import dataproc_v1 as dataproc


def create_cluster(project_id, region, cluster_name):
    """This sample walks a user through creating a Cloud Dataproc cluster
    using the Python client library.

    Args:
        project_id (string): Project to use for creating resources.
        region (string): Region where the resources should live.
        cluster_name (string): Name to use for creating a cluster.
    """

    # Create a client with the endpoint set to the desired cluster region.
    cluster_client = dataproc.ClusterControllerClient(
        client_options={"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
    )

    # Create the cluster config.
    cluster = {
        "project_id": project_id,
        "cluster_name": cluster_name,
        "config": {
            "master_config": {"num_instances": 1, "machine_type_uri": "n1-standard-2"},
            "worker_config": {"num_instances": 2, "machine_type_uri": "n1-standard-2"},
        },
    }

    # Create the cluster.
    operation = cluster_client.create_cluster(
        request={"project_id": project_id, "region": region, "cluster": cluster}
    )
    result = operation.result()

    # Output a success message.
    print(f"Cluster created successfully: {result.cluster_name}")