Crea un cluster

Crea un cluster Dataproc

Requisiti:

  • Nome: il nome del cluster deve iniziare con una lettera minuscola seguita da un numero massimo di 51 lettere minuscole, numeri e trattini e non può terminare con un trattino.

  • Regione del cluster: devi specificare un'area geografica global o specifica per il cluster. L'area geografica globale è un endpoint speciale a più aree geografiche in grado di eseguire il deployment delle istanze in qualsiasi zona di Compute Engine specificata dall'utente. Puoi anche specificare regioni distinte, ad esempio us-east1 o europe-west1, per isolare le risorse del cluster, ad esempio istanze VM e metadati del cluster archiviati in Cloud Storage, all'interno della regione specificata dall'utente.

    • Per ulteriori informazioni sugli endpoint a livello di regione e globali, consulta Endpoint a livello di regione.
    • Per informazioni sulla selezione di un'area geografica, consulta Aree geografiche disponibili e zone. Puoi anche eseguire il comando gcloud compute regions list per visualizzare un elenco delle aree geografiche disponibili.

  • Connettività: le istanze di macchine virtuali Compute Engine (VM) in un cluster Dataproc, composte da VM master e worker, richiedono una connettività incrociata di rete IP interna completa. La rete VPC default fornisce questa connettività (vedi Configurazione di rete del cluster Dataproc).

gcloud

Per creare un cluster Dataproc sulla riga di comando, esegui il comando Cloud SDK gcloud dataproc clusters create in locale in una finestra del terminale o in Cloud Shell. 
gcloud dataproc clusters create cluster-name \
    --region=region

Il comando precedente crea un cluster con impostazioni di servizio Dataproc predefinite per le istanze di macchine virtuali master e worker, dimensioni e tipi di disco, tipo di rete, regione e zona in cui viene eseguito il deployment del cluster e altre impostazioni del cluster. Consulta il comando gcloud dataproc clusters create per informazioni sull'utilizzo dei flag della riga di comando per personalizzare le impostazioni del cluster.

Crea un cluster con un file YAML

  1. Esegui il comando gcloud che segue per esportare la configurazione di un cluster Dataproc esistente in un file YAML. 
    gcloud dataproc clusters export my-existing-cluster --destination cluster.yaml
  2. Crea un nuovo cluster importando la configurazione del file YAML. 
    gcloud dataproc clusters import my-new-cluster --source cluster.yaml

Nota:durante l'esportazione, i filtri specifici dei cluster, come il nome del cluster, i campi di solo output e le etichette applicate automaticamente, vengono filtrati. Questi campi non sono consentiti nel file YAML importato utilizzato per creare un cluster.

REST &AM; LINEA CMD

Questa sezione mostra come creare un cluster con i valori richiesti e la configurazione predefinita (1 master, 2 worker).

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

Metodo HTTP e URL: 

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

Corpo JSON richiesta: 

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

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

Apri la pagina Dataproc Crea un cluster nella console Google Cloud nel browser, quindi fai clic su Crea nel cluster sulla riga Compute Engine nella pagina Crea un cluster Dataproc su Compute Engine. Il riquadro Configura cluster viene selezionato con i campi compilati con valori predefiniti. Puoi selezionare ogni riquadro e confermare o modificare i valori predefiniti per personalizzare il cluster.

Fai clic su Crea per creare il cluster. Il nome del cluster viene visualizzato nella pagina Cluster e il suo stato viene aggiornato in esecuzione dopo il provisioning del cluster. Fai clic sul nome del cluster per aprire la pagina dei dettagli del cluster, in cui puoi esaminare job, istanze e impostazioni di configurazione del cluster e connetterti alle interfacce web in esecuzione nel cluster.

Go

  1. Installa la libreria client.

  2. Configurare le credenziali predefinite dell'applicazione.

  3. Esegui il codice.
    dataproc/create_cluster.go 
    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. Installa la libreria client.

  2. Configurare le credenziali predefinite dell'applicazione.

  3. Esegui il codice.
    samples/snippets/src/main/java/CreateCluster.java 
    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. Installa la libreria client.

  2. Configurare le credenziali predefinite dell'applicazione.

  3. Esegui il codice.
samples/createCluster.js 
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. Installa la libreria client.

  2. Configurare le credenziali predefinite dell'applicazione.

  3. Esegui il codice.
    samples/snippets/create_cluster.py 
    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}")