Crea un cluster

Crea un cluster Managed Service for Apache Spark

Requisiti:

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

  • Regione del cluster:devi specificare una regione Compute Engine per il cluster, ad esempio us-east1 o europe-west1, per isolare le risorse del cluster, come le istanze VM e i metadati del cluster archiviati in Cloud Storage, all'interno della regione.

    • Per saperne di più sulle regioni di Compute Engine, consulta Regione del cluster.
    • Per informazioni sulla selezione di una regione, consulta Regioni e zone disponibili. Puoi anche eseguire il comando gcloud compute regions list per visualizzare un elenco delle regioni disponibili.

  • Connettività:le istanze di macchine virtuali (VM) Compute Engine in un cluster Managed Service for Apache Spark, costituito da VM master e worker, richiedono una connettività incrociata completa della rete IP interna. La rete VPC defaultfornisce questa connettività (vedi Configurazione di rete del cluster Managed Service for Apache Spark).

  • Tipo di macchina (consigliato): anche se la specifica di un tipo di macchina è facoltativa, Google consiglia di selezionare esplicitamente un tipo di macchina per le VM master e worker nel cluster. Se non specifichi un tipo di macchina, Managed Service for Apache Spark seleziona dinamicamente i tipi di macchina in base alla disponibilità delle risorse. Questa selezione dinamica può comportare variazioni sia di costi che di prestazioni.

    • Per saperne di più sulla scelta di un tipo di macchina, consulta Tipi di macchina supportati.
    • Per ridurre i potenziali problemi di mancata disponibilità delle risorse, ti consigliamo di utilizzare le VM flessibili, che ti consentono di specificare un elenco di tipi di macchine accettabili.

Console

Apri la pagina Crea un cluster di Managed Service for Apache Spark nella console Google Cloud nel browser, poi fai clic su Crea nella riga del cluster su Compute Engine nella pagina Crea un cluster Dataproc su Compute Engine. Il Il riquadro Configura cluster è selezionato con i campi compilati con i valori predefiniti. Puoi selezionare ogni pannello 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 a In esecuzione dopo il provisioning del cluster. Fai clic sul nome del cluster per aprire la pagina dei dettagli del cluster, dove puoi esaminare job, istanze e impostazioni di configurazione per il tuo cluster e connetterti alle interfacce web in esecuzione sul cluster.

gcloud

Per creare un cluster Managed Service for Apache Spark dalla riga di comando, esegui il comando gcloud dataproc clusters create localmente in una finestra del terminale o in Cloud Shell.

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

Il comando crea un cluster. Sebbene i tipi di macchine master e worker siano facoltativi, è consigliabile specificarli in modo esplicito utilizzando i flag --master-machine-type e --worker-machine-type (ad esempio, n4-standard-4) per garantire costi e prestazioni coerenti. Se non specifichi i tipi di macchina, quelli predefiniti vengono selezionati in modo dinamico in base alla disponibilità delle risorse. 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 seguente comando gcloud per esportare la configurazione di un cluster Managed Service for Apache Spark esistente in un file cluster.yaml. 
    gcloud dataproc clusters export EXISTING_CLUSTER_NAME \
    --region=REGION \
    --destination=cluster.yaml
  2. Crea un nuovo cluster importando la configurazione del file YAML. 
    gcloud dataproc clusters import NEW_CLUSTER_NAME \
    --region=REGION \
    --source=cluster.yaml

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

REST

Questa sezione mostra come creare un cluster. Sebbene la specifica dei tipi di macchine sia facoltativa, è consigliabile includere esplicitamente machine_type_uri in master_config e worker_config (ad esempio, n4-standard-4) per garantire costi e prestazioni coerenti. Se non specifichi i tipi di macchina, quelli predefiniti vengono selezionati in modo dinamico in base alla disponibilità delle risorse.

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

  • CLUSTER_NAME: nome del cluster
  • PROJECT: Google Cloud ID progetto
  • REGION: una regione Compute Engine disponibile in cui verrà creato il cluster.
  • ZONE: una zona facoltativa all'interno della regione selezionata in cui verrà creato il cluster.
  • MASTER_MACHINE_TYPE: (consigliato) il tipo di macchina per il nodo master (ad esempio n4-standard-4).
  • WORKER_MACHINE_TYPE: (consigliato) il tipo di macchina per i nodi worker (ad esempio n4-standard-4).

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
"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 ...""
    ]
  }
}
<0x0

Go

  1. Installa la libreria client.
  2. Configura le credenziali predefinite dell'applicazione.
  3. Esegui il codice.

    Nota:anche se la specifica dei tipi di macchine è facoltativa, ti consigliamo di impostare esplicitamente i tipi di macchine master e worker nella configurazione del cluster (ad esempio su n4-standard-4) per garantire costi e prestazioni coerenti. Se omessi, i tipi di macchine predefiniti vengono selezionati in modo dinamico in base alla disponibilità delle risorse.

    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. Installa la libreria client.
  2. Configura le credenziali predefinite dell'applicazione.
  3. Esegui il codice.

    Nota:anche se la specifica dei tipi di macchine è facoltativa, ti consigliamo di impostare esplicitamente i tipi di macchine master e worker nella configurazione del cluster (ad esempio su n4-standard-4) per garantire costi e prestazioni coerenti. Se omessi, i tipi di macchine predefiniti vengono selezionati in modo dinamico in base alla disponibilità delle risorse.

    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. Configura le credenziali predefinite dell'applicazione.
  3. Esegui il codice.

    Nota:anche se la specifica dei tipi di macchine è facoltativa, ti consigliamo di impostare esplicitamente i tipi di macchine master e worker nella configurazione del cluster (ad esempio su n4-standard-4) per garantire costi e prestazioni coerenti. Se omessi, i tipi di macchine predefiniti vengono selezionati in modo dinamico in base alla disponibilità delle risorse.

    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. Configura le credenziali predefinite dell'applicazione.
  3. Esegui il codice.

    Nota:anche se la specifica dei tipi di macchine è facoltativa, ti consigliamo di impostare esplicitamente i tipi di macchine master e worker nella configurazione del cluster (ad esempio su n4-standard-4) per garantire costi e prestazioni coerenti. Se omessi, i tipi di macchine predefiniti vengono selezionati in modo dinamico in base alla disponibilità delle risorse.

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