Crea un cluster

Managed Service for Apache Spark impedisce la creazione di cluster con versioni immagine precedenti alla 1.3.95, 1.4.77, 1.5.53 e 2.0.27, che erano interessate dalle vulnerabilità di sicurezza di Apache Log4j. Managed Service for Apache Spark impedisce anche la creazione di cluster per le versioni immagine di Managed Service for Apache Spark 0.x, 1.0.x, 1.1.x e 1.2.x. Managed Service for Apache Spark consiglia, se possibile, di creare cluster Managed Service for Apache Spark con le versioni immagine secondarie più recenti.

Versione immagine	Versione log4j	Assistenza clienti
2.0.29, 1.5.55 e 1.4.79 o versioni successive di ciascuno	log4j.2.17.1	Consigliato
2.0.28, 1.5.54 e 1.4.78	log4j.2.17.0	Consigliato
2.0.27, 1.5.53 e 1.4.77	log4j.2.16.0	Vivamente consigliato
2.0.26, 1.5.52 e 1.4.76 o versioni precedenti di ciascuna	Versione precedente	Interrompi l'utilizzo

Consulta le note di rilascio di Managed Service for Apache Spark per informazioni specifiche sugli aggiornamenti delle immagini e di log4j.

Crea un cluster

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 di 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 Compute Engine (VM) in un cluster Managed Service for Apache Spark, costituito da VM master e VM worker, richiedono una connettività incrociata completa della rete IP interna. La rete VPC default fornisce questa connettività (consulta Configurazione di rete del cluster Managed Service for Apache Spark).

• Tipo di macchina (consigliato): sebbene la specifica di un tipo di macchina sia 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 nei costi che nelle prestazioni.

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

Vedi anche:

• Guida alle best practice di Managed Service for Apache Spark.
• Crea un cluster con un tipo di macchina ARM.

Console

Apri la pagina Crea cluster della console Google Cloud per visualizzare le impostazioni predefinite del cluster. Puoi confermare o modificare le impostazioni predefinite visualizzate, quindi fare clic su Configurazione aggiuntiva per personalizzare ulteriormente il cluster.

Fai clic su Crea cluster per creare il cluster. Il nome del cluster viene visualizzato nella pagina Cluster e il suo stato viene aggiornato a Running 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 del 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 esplicitamente 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, i tipi di macchina predefiniti vengono selezionati dinamicamente 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 questo 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, vengono filtrati i campi specifici del cluster, come il nome del cluster, i campi di solo output e le etichette applicate automaticamente. Questi campi non sono consentiti nel file YAML importato utilizzato per creare un cluster.

Nota: nella parte inferiore della pagina Crea cluster, fai clic su Riga di comando equivalente o REST equivalente per fare in modo che la console Google Cloud crei un comando gcloud CLI o una richiesta API REST equivalente.

REST

Questa sezione mostra come creare un cluster. Sebbene la specifica dei tipi di macchina 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, i tipi di macchina predefiniti vengono selezionati dinamicamente in base alla disponibilità delle risorse.

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

• CLUSTER_NAME: il nome del cluster
• PROJECT: Google Cloud ID progetto
• REGION: una regione di 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:

curl (Linux, macOS o Cloud Shell)

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dataproc.googleapis.com/v1/projects/PROJECT/regions/REGION/clusters"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dataproc.googleapis.com/v1/projects/PROJECT/regions/REGION/clusters" | Select-Object -Expand Content

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

Nota: nella parte inferiore della pagina Crea cluster, fai clic su Riga di comando equivalente o REST equivalente per fare in modo che la console Google Cloud crei un comando gcloud CLI o una richiesta API REST equivalente.

Go

1. Installa la libreria client.
2. Configura le credenziali predefinite dell'applicazione.
3. Esegui il codice.
   Consulta Configurazione dell'ambiente di sviluppo.

   Nota: sebbene la specifica dei tipi di macchine sia facoltativa, è consigliabile impostare in modo esplicito i tipi di macchine master e worker nella configurazione del cluster (ad esempio, su n4-standard-4) per garantire costi e prestazioni coerenti. Se omesso, i tipi di macchina predefiniti vengono selezionati dinamicamente 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.
   Consulta Configurazione di un ambiente di sviluppo Java.

   Nota: sebbene la specifica dei tipi di macchine sia facoltativa, è consigliabile impostare in modo esplicito i tipi di macchine master e worker nella configurazione del cluster (ad esempio, su n4-standard-4) per garantire costi e prestazioni coerenti. Se omesso, i tipi di macchina predefiniti vengono selezionati dinamicamente 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.
   Consulta Configurazione di un ambiente di sviluppo Node.js.

   Nota: sebbene la specifica dei tipi di macchine sia facoltativa, è consigliabile impostare in modo esplicito i tipi di macchine master e worker nella configurazione del cluster (ad esempio, su n4-standard-4) per garantire costi e prestazioni coerenti. Se omesso, i tipi di macchina predefiniti vengono selezionati dinamicamente 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.
   Consulta Configurazione di un ambiente di sviluppo Python.

   Nota: sebbene la specifica dei tipi di macchine sia facoltativa, è consigliabile impostare in modo esplicito i tipi di macchine master e worker nella configurazione del cluster (ad esempio, su n4-standard-4) per garantire costi e prestazioni coerenti. Se omesso, i tipi di macchina predefiniti vengono selezionati dinamicamente 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}")