Créer un cluster

Vous pouvez créer un cluster Dataproc via une requête HTTP ou une requête automatisée clusters.create de l'API Dataproc, à l'aide de l'outil de ligne de commande gcloud du SDK Cloud (en local dans une fenêtre de terminal ou dans Cloud Shell), ou encore à partir de Google Cloud Console dans un navigateur local. Vous pouvez également créer des clusters de manière automatisée à l'aide des bibliothèques clientes Cloud ou via des requêtes API.

Région du cluster : vous pouvez spécifier une région mondiale (global) ou une région spécifique pour votre cluster. La région mondiale est un point de terminaison multirégional spécial permettant de déployer des instances dans n'importe quelle zone de Compute Engine spécifiée par l'utilisateur. Vous pouvez également spécifier des régions distinctes, telles que us-east1 ou europe-west1 pour isoler les ressources (y compris les instances de VM et Cloud Storage) et les emplacements de stockage de métadonnées utilisés par Dataproc dans la région spécifiée par l'utilisateur. Consultez la page Points de terminaison régionaux pour en savoir plus sur la différence entre les points de terminaison mondiaux et régionaux. Consultez la page Régions et zones disponibles pour plus d'informations sur la sélection d'une région. Vous pouvez également exécuter la commande gcloud compute regions list pour afficher la liste des régions disponibles.

Les instances de machines virtuelles Compute Engine dans un cluster Dataproc, composé de VM maîtres et de VM de nœud de calcul, nécessitent un accès total au réseau IP interne des unes et des autres. Le réseau default disponible (et normalement utilisé) pour créer un cluster permet d'assurer cet accès. Pour en savoir plus sur la création de votre propre réseau pour votre cluster Dataproc, consultez la page Configuration du réseau du cluster Dataproc.

Créer un cluster Dataproc

gcloud

Pour créer un cluster Dataproc sur la ligne de commande, exécutez la commande gcloud dataproc clusters create du SDK Cloud en local dans une fenêtre de terminal ou dans Cloud Shell.

gcloud dataproc clusters create cluster-name \
    --region=region
La commande ci-dessus crée un cluster avec les paramètres de service par défaut Dataproc pour les instances de VM maîtres et de calcul, les tailles et types de disques, le type de réseau, la région et la zone où votre cluster est déployé, ainsi que d'autres paramètres de cluster. Consultez la commande gcloud dataproc clusters create pour en savoir plus sur l'utilisation des indicateurs de ligne de commande pour personnaliser les paramètres de cluster.

Créer un cluster avec un fichier YAML

  1. Exécutez la commande gcloud suivante pour exporter la configuration d'un cluster Dataproc existant vers un fichier YAML.
    gcloud dataproc clusters export my-existing-cluster --destination cluster.yaml
    
  2. Créez un cluster en important la configuration du fichier YAML.
    gcloud dataproc clusters import my-new-cluster --source cluster.yaml
    

Remarque : Au cours de l'opération d'exportation, les champs spécifiques au cluster (tels que son nom), les champs de sortie uniquement et les libellés appliqués automatiquement sont filtrés. Ces champs ne sont pas autorisés dans le fichier YAML importé utilisé pour créer un cluster.

API REST et ligne de commande

Cette section explique comment créer un cluster avec les valeurs requises et la configuration par défaut (un maître, deux nœuds de calcul).

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • project-id : ID du projet GCP
  • region : région du cluster
  • clusterName : nom du cluster

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

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

Ouvrez la page Dataproc Créer un cluster via Cloud Console dans votre navigateur.

La capture d'écran ci-dessus montre la page Create a cluster (Créer un cluster) avec les champs par défaut renseignés automatiquement pour un nouveau cluster "cluster-1". Vous pouvez développer le panneau Options avancées pour spécifier un ou plusieurs nœuds de calcul préemptifs, un bucket de préproduction, un réseau, la version de l'image Dataproc, des actions d'initialisation et l'accès au niveau du projet pour votre cluster. L'ajout de ces valeurs est facultatif.

Si vous ne fournissez pas de paramètres pour ces options, le cluster par défaut est créé sans nœuds de calcul préemptifs, et avec un bucket de préproduction créé automatiquement, un réseau par défaut et la dernière version publiée de l'image Dataproc.

Lorsque vous êtes sûr d'avoir correctement renseigné tous les champs de la page, cliquez sur Créer. Une fois le cluster créé, son nom apparaît sur la page Clusters et son état passe à "Running" (En cours d'exécution).

Cliquez sur le nom du cluster pour ouvrir la page des détails. Celle-ci affiche l'onglet "Aperçu" et le graphique d'utilisation du processeur. Vous pouvez également choisir d'afficher les graphiques de réseau et de disque pour le cluster.

Vous pouvez examiner les tâches, les instances et les paramètres de configuration de votre cluster dans les autres onglets. Vous pouvez par exemple utiliser l'onglet "Instances de VM" pour vous connecter via SSH au nœud maître de votre cluster. Cliquez sur Modifier dans l'onglet "Configurations" pour modifier les paramètres de votre cluster. Par exemple, vous pouvez agrandir ou réduire votre cluster en modifiant le nombre de nœuds de calcul standards ou préemptifs qu'il contient.

Go

  1. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code.
    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. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code
    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. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code
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. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code
    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}")