Cluster erstellen

Sie können einen Dataproc-Cluster mit dem gcloud-Befehlszeilentool des Cloud SDK, der Dataproc API oder der Google Cloud Console erstellen. Sie können Cluster auch programmatisch mit Cloud-Clientbibliotheken erstellen.

Clustername: Der Cluster muss mit einem Kleinbuchstaben beginnen, gefolgt von bis zu 54 Kleinbuchstaben, Ziffern oder Bindestrichen. Das letzte Zeichen darf kein Bindestrich sein.

Cluster-Region: Sie können eine global-Region oder eine bestimmte Region für Ihren Cluster angeben. Die globale Region ist ein spezieller Endpunkt für mehrere Regionen, der Instanzen in jeder benutzerdefinierten Compute Engine-Zone bereitstellen kann. Sie können auch verschiedene Regionen wie us-east1 oder europe-west1 angeben, um Ressourcen (einschließlich VM-Instanzen und Cloud Storage) und Metadatenspeicherorte zu isolieren, die von Dataproc innerhalb der benutzerdefinierten Region verwendet werden. Weitere Informationen zum Unterschied zwischen globalen und regionalen Endpunkten finden Sie unter Regionale Endpunkte. 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.

Die Compute Engine-VM-Instanzen in einem Dataproc-Cluster, die aus Master- und Worker-VMs bestehen, müssen uneingeschränkten internen IP-Netzwerkzugriff aufeinander haben. Das zum Erstellen eines Clusters verfügbare default-Netzwerk trägt dazu bei, dass dieser Zugriff gewährleistet wird. Informationen zum Erstellen eines eigenen Netzwerks für Ihren Dataproc-Cluster finden Sie unter Dataproc-Cluster-Netzwerkkonfiguration.

Dataproc-Cluster erstellen

gcloud

Führen Sie zum Erstellen eines Dataproc-Clusters in der Befehlszeile den Cloud SDK-Befehl gcloud dataproc clusters create lokal in einem Terminalfenster oder in Cloud Shell aus.

gcloud dataproc clusters create cluster-name \
    --region=region

Der obige Befehl erstellt einen Cluster mit standardmäßigen Dataproc-Diensteinstellungen für Ihre Master- und Worker-VM-Instanzen, Laufwerksgrößen und -typen, Netzwerktyp, Region und Zone, in der Ihr Cluster bereitgestellt wird, und andere Clustereinstellungen. 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 Dataproc-Clusters in eine YAML-Datei zu exportieren.
    gcloud dataproc clusters export my-existing-cluster --destination cluster.yaml
    
  2. Erstellen Sie einen neuen Cluster. Dazu importieren Sie die Konfiguration der YAML-Datei.
    gcloud dataproc clusters import my-new-cluster --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 UND BEFEHLSZEILE

In diesem Abschnitt wird erläutert, wie Sie einen Cluster mit erforderlichen Werten und der Standardkonfiguration (1 Hauptcluster, 2 Worker) erstellen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • project-id: GCP-Projekt-ID
  • region: Cluster-Region
  • clusterName: Clustername

HTTP-Methode und URL:

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

JSON-Text anfordern:

{
  "clusterName": "cluster-name",
  "config": {}
}

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-id/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 ...""
    ]
  }
}

Console

Öffnen Sie die Dataproc-Seite Cluster erstellen in der Cloud Console in Ihrem Browser. Das Feld "Cluster einrichten" ist ausgewählt und die Felder enthalten Standardwerte. Sie können jedes Feld auswählen und Standardwerte bestätigen oder ändern, um Ihren Cluster anzupassen.

Klicken Sie auf CREATE, 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.

Go

  1. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus.
    import (
    	"context"
    	"fmt"
    	"io"
    
    	dataproc "cloud.google.com/go/dataproc/apiv1"
    	"google.golang.org/api/option"
    	dataprocpb "google.golang.org/genproto/googleapis/cloud/dataproc/v1"
    )
    
    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: %v", 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: %v", err)
    	}
    
    	resp, err := op.Wait(ctx)
    	if err != nil {
    		return fmt.Errorf("CreateCluster.Wait: %v", 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
    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. Code ausführen
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
    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}")