Créer un cluster

Créer un cluster Dataproc

Conditions requises :

  • Nom : le nom du cluster doit commencer par une lettre minuscule suivie de 1 à 51 caractères (lettres minuscules, chiffres et traits d'union), et ne peut pas se terminer par un trait d'union.

  • Région du cluster:vous devez spécifier une région Compute Engine pour le cluster, comme us-east1 ou europe-west1, pour isoler les ressources du cluster, telles que les instances de VM et les métadonnées de cluster stockées Cloud Storage dans cette région.

    • Pour en savoir plus, consultez la page Points de terminaison régionaux. sur les points de terminaison 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.

  • Connectivité:instances de machine virtuelle Compute Engine (VM) d'un cluster Dataproc, composé de VM maîtres et de nœuds de calcul, nécessitent une connectivité croisée entre les réseaux IP internes. Le réseau VPC default fournit cette connectivité (voir la section Configuration du réseau du cluster Dataproc).

gcloud

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

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION

La commande crée un cluster avec les paramètres de service Dataproc par défaut. pour vos instances de machines virtuelles maîtres et de calcul, tailles et types de disque, le type de réseau, la région et la zone dans lesquelles votre cluster est déployé, ainsi que les autres clusters paramètres. 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 cluster.yaml. 
    gcloud dataproc clusters export EXISTING_CLUSTER_NAME \
    --region=REGION \
    --destination=cluster.yaml
  2. Créez un cluster en important la configuration du fichier YAML. 
    gcloud dataproc clusters import NEW_CLUSTER_NAME \
    --region=REGION \
    --source=cluster.yaml

Remarque:Pendant l'opération d'exportation, les champs spécifiques au cluster, tels que le nom du cluster, les champs de sortie uniquement et les étiquettes appliquées automatiquement filtrée. Ces champs ne sont pas autorisés dans le fichier YAML importé utilisé pour créer un cluster.

REST

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 :

  • CLUSTER_NAME : nom du cluster
  • PROJECT : ID de projet Google Cloud
  • REGION: instance Compute Engine disponible région dans laquelle le cluster sera créé.
  • ZONE: zone facultative dans la région sélectionnée dans laquelle le cluster sera créé.

Méthode HTTP et URL : 

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

Corps JSON de la requête :

{
  "project_id":"PROJECT",
  "cluster_name":"CLUSTER_NAME",
  "config":{
    "master_config":{
      "num_instances":1,
      "machine_type_uri":"n1-standard-2",
      "image_uri":""
    },
    "softwareConfig": {
      "imageVersion": "",
      "properties": {},
      "optionalComponents": []
    },
    "worker_config":{
      "num_instances":2,
      "machine_type_uri":"n1-standard-2",
      "image_uri":""
    },
    "gce_cluster_config":{
      "zone_uri":"ZONE"
    }
  }
}

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/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 dans la console Google Cloud de votre navigateur, puis cliquez sur Créer dans le cluster sur la ligne Compute Engine de la page Créer un cluster Dataproc sur Compute Engine. Le panneau "Configurer le cluster" est sélectionné avec des champs remplis de valeurs par défaut. Toi vous pouvez sélectionner chaque panneau et confirmer ou modifier les valeurs par défaut pour personnaliser votre cluster.

Cliquez sur Créer pour créer le cluster. Le nom du cluster apparaît dans Clusters, et son état passe à "En cours d'exécution" le cluster est provisionné. Cliquez sur le nom du cluster pour ouvrir la page des détails. Vous pouvez y examiner les tâches, les instances et les paramètres de configuration de votre cluster, et vous connecter aux interfaces Web exécutées sur ce cluster.

Go

  1. Installez la bibliothèque cliente.

  2. Configurez les identifiants par défaut de l'application.

  3. Exécutez le code. 
    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. Installez la bibliothèque cliente.
  2. Configurez les identifiants par défaut de l'application.
  3. Exécutez 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-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. Installez la bibliothèque cliente.
  2. Configurez les identifiants par défaut de l'application.
  3. Exécutez 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-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. Installez la bibliothèque cliente.

  2. Configurez les identifiants par défaut de l'application.

  3. Exécutez 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-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}")