Cluster erstellen

Sie können einen Job über eine Dataproc API als HTTP- oder programmatische Anfrage (clusters.create) an ein vorhandenes Dataproc-Cluster übergeben. Verwenden Sie dazu das gcloud-Befehlszeilentool von Cloud SDK in einem lokalen Terminalfenster oder in Cloud Shelloder aus der Google Cloud Console in einem lokalen Browser. Sie können Cluster auch programmatisch mit Cloud-Clientbibliotheken oder über API-Anfragen erstellen.

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 default-Netzwerk, das zum Erstellen eines Clusters verfügbar ist und normalerweise verwendet wird, trägt dazu bei, diesen Zugriff sicherzustellen. 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 & CMD LINE

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

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • 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 in etwa folgende JSON-Antwort 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 Seite Dataproc-Seite Cluster erstellen in der Cloud Console in Ihrem Browser.

Der oben dargestellte Screenshot zeigt die Seite Cluster erstellen. Die Standardfelder für einen neuen "cluster-1"-Cluster wurden automatisch ausgefüllt. Sie können das Fenster Erweiterte Optionen maximieren und einen oder mehrere Worker-Knoten auf Abruf, einen Staging-Bucket, ein Netzwerk, eine Cloud Dataproc-Image-Version, Initialisierungsaktionen und den Zugriff auf Projektebene für den Cluster festlegen. Die Angabe dieser Werte ist optional.

Der Standardcluster wird ohne Worker-Knoten auf Abruf, ohne einen automatisch erstellten Staging-Bucket, ohne Standardnetzwerk und ohne die zuletzt veröffentlichte Cloud Dataproc-Image-Version erstellt, sofern keine Einstellungen für diese Optionen festgelegt werden.

Überprüfen Sie, ob alle Felder auf der Seite ordnungsgemäß ausgefüllt sind. Klicken Sie dann auf Erstellen, um den Cluster anzulegen. Auf der Seite Cluster werden der Name des Clusters angezeigt und der zugehörige Status auf "Aktiv" aktualisiert.

Klicken Sie auf den Namen des Clusters, um die Seite mit den Clusterdetails zu öffnen. Auf dieser Seite sind der Tab "Übersicht" und die ausgewählte Grafik zur CPU-Nutzung bereits ausgewählt. Sie haben auch die Möglichkeit, Netzwerk- und Laufwerksgrafiken für den Cluster anzuzeigen.

Sie können Jobs, Instanzen und die Konfigurationseinstellungen für den Cluster auf den anderen Tabs überprüfen. Auf dem Tab "VM-Instanzen" können Sie beispielsweise eine SSH-Verbindung zum Master-Knoten des Clusters herstellen. Klicken Sie im Tab "Konfigurationen" auf Bearbeiten, um die Einstellungen für den Cluster zu bearbeiten. Um den Cluster beispielsweise hoch- oder herunterzuskalieren, ändern Sie die Anzahl der Standard- oder Worker-Knoten auf Abruf im Cluster.

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)
    	}
    
    	// 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-1",
    				},
    				WorkerConfig: &dataprocpb.InstanceGroupConfig{
    					NumInstances:   2,
    					MachineTypeUri: "n1-standard-1",
    				},
    			},
    		},
    	}
    
    	// 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-1")
                  .setNumInstances(1)
                  .build();
          InstanceGroupConfig workerConfig =
              InstanceGroupConfig.newBuilder()
                  .setMachineTypeUri("n1-standard-1")
                  .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-1',
        },
        workerConfig: {
          numInstances: 2,
          machineTypeUri: 'n1-standard-1',
        },
      },
    },
  };

  // 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-1"},
                "worker_config": {"num_instances": 2, "machine_type_uri": "n1-standard-1"},
            },
        }
    
        # 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}")