Créer un cluster

Créer un cluster

Conditions requises :

  • Nom : le nom du cluster doit commencer par une lettre minuscule suivie de 1 à 51 caractères (lettres minuscules, chiffres ou 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, par exemple us-east1 ou europe-west1, afin d'isoler les ressources du cluster, telles que les instances de VM et les métadonnées du cluster stockées dans Cloud Storage, au sein de la région.

    • Pour en savoir plus sur les régions Compute Engine, consultez Région du cluster.
    • 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é : les instances de machines virtuelles (VM) Compute Engine d'un cluster Managed Service pour Apache Spark, composées de VM maîtres et de VM de nœuds de calcul, nécessitent une connectivité croisée complète au réseau IP interne. Le réseau VPC default fournit cette connectivité (voir Configuration réseau du cluster Managed Service pour Apache Spark).

  • Type de machine (recommandé) : bien que la spécification d'un type de machine soit facultative, Google vous recommande de sélectionner explicitement un type de machine pour les VM de nœud de calcul et de nœud maître de votre cluster. Si vous ne spécifiez pas de type de machine, Managed Service pour Apache Spark sélectionne dynamiquement les types de machines en fonction de la disponibilité des ressources. Cette sélection dynamique peut entraîner des variations de coût et de performances.

    • Pour en savoir plus sur le choix d'un type de machine, consultez Types de machines compatibles.
    • Pour limiter les problèmes potentiels d'indisponibilité des ressources, nous vous recommandons d'utiliser des VM flexibles, qui vous permettent de spécifier une liste de types de machines acceptables.

Console

Ouvrez la page Créer un cluster de la console Google Cloud pour afficher les paramètres de cluster par défaut. Vous pouvez confirmer ou modifier les paramètres par défaut affichés, puis cliquer sur Configuration supplémentaire pour personnaliser davantage le cluster.

Cliquez sur Créer un cluster pour créer le cluster. Le nom du cluster s'affiche sur la page Clusters, et son état passe à Running une fois le cluster provisionné. Cliquez sur le nom du cluster pour ouvrir la page d'informations sur le cluster, où vous pouvez examiner les jobs, les instances et les paramètres de configuration de votre cluster, et vous connecter aux interfaces Web exécutées sur le cluster.

gcloud

Pour créer un cluster Managed Service pour Apache Spark sur la ligne de commande, exécutez la commande gcloud dataproc clusters create localement dans une fenêtre de terminal ou dans Cloud Shell.

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

La commande crée un cluster. Bien que les types de machines maître et de calcul soient facultatifs, il est recommandé de les spécifier explicitement à l'aide des options --master-machine-type et --worker-machine-type (par exemple, n4-standard-4) pour garantir des coûts et des performances constants. Si vous ne spécifiez pas de types de machines, des types de machines par défaut sont sélectionnés de manière dynamique en fonction de la disponibilité des ressources. Pour en savoir plus sur l'utilisation des flags de ligne de commande permettant de personnaliser les paramètres du cluster, consultez la commande gcloud dataproc clusters create.

Créer un cluster avec un fichier YAML

  1. Exécutez la commande gcloud suivante pour exporter la configuration d'un cluster Managed Service pour Apache Spark existant dans 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 en sortie uniquement et les étiquettes appliquées automatiquement, sont filtrés. 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. Bien que la spécification des types de machines soit facultative, il est recommandé d'inclure explicitement machine_type_uri dans vos master_config et worker_config (par exemple, n4-standard-4) pour garantir des coûts et des performances cohérents. Si vous ne spécifiez pas de types de machines, des types de machines par défaut sont sélectionnés de manière dynamique en fonction de la disponibilité des ressources.

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

  • CLUSTER_NAME : nom du cluster
  • PROJECT : Google Cloud ID du projet
  • REGION : région Compute Engine disponible dans laquelle le cluster sera créé.
  • ZONE : zone facultative dans la région sélectionnée où le cluster sera créé.
  • MASTER_MACHINE_TYPE (recommandé) : type de machine pour le nœud maître (par exemple, n4-standard-4).
  • WORKER_MACHINE_TYPE (recommandé) : type de machine pour les nœuds de calcul (par exemple, n4-standard-4).

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

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

Go

  1. Installez la bibliothèque cliente.
  2. Configurez les identifiants par défaut de l'application.
  3. Exécutez le code.

    Remarque : Bien que la spécification des types de machines soit facultative, il est recommandé de définir explicitement les types de machines maître et de calcul dans la configuration de votre cluster (par exemple, sur n4-standard-4) pour garantir des coûts et des performances cohérents. Si ce champ est omis, les types de machines par défaut sont sélectionnés de manière dynamique en fonction de la disponibilité des ressources.

    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.

    Remarque : Bien que la spécification des types de machines soit facultative, il est recommandé de définir explicitement les types de machines maître et de calcul dans la configuration de votre cluster (par exemple, sur n4-standard-4) pour garantir des coûts et des performances cohérents. Si ce champ est omis, les types de machines par défaut sont sélectionnés de manière dynamique en fonction de la disponibilité des ressources.

    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.

    Remarque : Bien que la spécification des types de machines soit facultative, il est recommandé de définir explicitement les types de machines maître et de calcul dans la configuration de votre cluster (par exemple, sur n4-standard-4) pour garantir des coûts et des performances cohérents. Si ce champ est omis, les types de machines par défaut sont sélectionnés de manière dynamique en fonction de la disponibilité des ressources.

    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.

    Remarque : Bien que la spécification des types de machines soit facultative, il est recommandé de définir explicitement les types de machines maître et de calcul dans la configuration de votre cluster (par exemple, sur n4-standard-4) pour garantir des coûts et des performances cohérents. Si ce champ est omis, les types de machines par défaut sont sélectionnés de manière dynamique en fonction de la disponibilité des ressources.

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