Crear un clúster

Crear una agrupación Dataproc

Requisitos:

  • Nombre: el nombre del clúster debe empezar por una letra minúscula, seguida de un máximo de 51 letras minúsculas, números y guiones, y no puede acabar con un guion.

  • Región del clúster: debes especificar una región de Compute Engine para el clúster, como us-east1 o europe-west1, para aislar los recursos del clúster, como las instancias de VM y los metadatos del clúster almacenados en Cloud Storage, en la región.

    • Consulta Puntos finales regionales para obtener más información sobre los puntos finales regionales.
    • Consulta Regiones y zonas disponibles para obtener información sobre cómo seleccionar una región. También puedes ejecutar el comando gcloud compute regions list para ver una lista de las regiones disponibles.

  • Conectividad: las instancias de máquina virtual de Compute Engine (VM) de un clúster de Dataproc, que consta de VMs maestras y de trabajador, requieren una conectividad cruzada completa de redes IP internas. La defaultred de VPC proporciona esta conectividad (consulta Configuración de red de clúster de Dataproc).

gcloud

Para crear un clúster de Dataproc en la línea de comandos, ejecuta el comando gcloud dataproc clusters create de forma local en una ventana de terminal o en Cloud Shell.

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION

El comando crea un clúster con la configuración predeterminada del servicio Dataproc para las instancias de máquina virtual maestra y de trabajador, los tamaños y tipos de disco, el tipo de red, la región y la zona en las que se implementa el clúster, así como otros ajustes del clúster. Consulte el comando gcloud dataproc clusters create para obtener información sobre cómo usar las marcas de la línea de comandos para personalizar la configuración del clúster.

Crear un clúster con un archivo YAML

  1. Ejecuta el siguiente comando gcloud para exportar la configuración de un clúster de Dataproc a un archivo cluster.yaml. 
    gcloud dataproc clusters export EXISTING_CLUSTER_NAME \
    --region=REGION \
    --destination=cluster.yaml
  2. Crea un clúster importando la configuración del archivo YAML. 
    gcloud dataproc clusters import NEW_CLUSTER_NAME \
    --region=REGION \
    --source=cluster.yaml

Nota: Durante la operación de exportación, se filtran los campos específicos del clúster, como el nombre del clúster, los campos de solo salida y las etiquetas aplicadas automáticamente. Estos campos no se permiten en el archivo YAML importado que se usa para crear un clúster.

REST

En esta sección se muestra cómo crear un clúster con los valores necesarios y la configuración predeterminada (1 maestro y 2 trabajadores).

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • CLUSTER_NAME: nombre del clúster
  • PROJECT: Google Cloud ID de proyecto
  • REGION: una región de Compute Engine disponible en la que se creará el clúster.
  • ZONE: una zona opcional de la región seleccionada en la que se creará el clúster.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud: 

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

Para enviar tu solicitud, despliega una de estas opciones:

Deberías recibir una respuesta JSON similar a la siguiente:

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

Consola

Abre la página de Dataproc Crear un clúster en la Google Cloud consola de tu navegador y, a continuación, haz clic en Crear en el clúster de la fila Compute Engine de la página Crear un clúster de Dataproc en Compute Engine. El panel Configurar clúster está seleccionado y los campos se han rellenado con los valores predeterminados. Puedes seleccionar cada panel y confirmar o cambiar los valores predeterminados para personalizar tu clúster.

Haz clic en Crear para que se genere el clúster. El nombre del clúster aparece en la página Clústeres y su estado se actualiza a En ejecución después de que se aprovisione el clúster. Haga clic en el nombre del clúster para abrir la página de detalles del clúster, donde puede examinar las tareas, las instancias y los ajustes de configuración del clúster, así como conectarse a las interfaces web que se ejecutan en él.

Go

  1. Instala la biblioteca de cliente.

  2. Configura las credenciales predeterminadas de la aplicación.

  3. Ejecuta el código. . 
    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. Instala la biblioteca de cliente.
  2. Configura las credenciales predeterminadas de la aplicación.
  3. Ejecuta el código. . 
    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. Instala la biblioteca de cliente.
  2. Configura las credenciales predeterminadas de la aplicación.
  3. Ejecuta el código. 
    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. Instala la biblioteca de cliente.

  2. Configura las credenciales predeterminadas de la aplicación.

  3. Ejecuta el código. . 
    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}")