Crea un clúster

Dataproc impide la creación de clústeres con versiones de imágenes anteriores a 1.3.95, 1.4.77, 1.5.53 y 2.0.27, que se vieron afectadas por vulnerabilidades de seguridad de Apache Log4j. Dataproc también impide la creación de clústeres para las versiones de imágenes 0.x, 1.0.x, 1.1.x y 1.2.x de Dataproc. Dataproc recomienda que, cuando sea posible, crees clústeres de Dataproc con las versiones de imágenes secundarias más recientes.

Versión de la imagen	Versión de Log4j	Orientación al cliente
2.0.29, 1.5.55 y 1.4.79, o versiones posteriores de cada uno	log4j.2.17.1	Asesorado
2.0.28, 1.5.54 y 1.4.78	log4j.2.17.0	Asesorado
2.0.27, 1.5.53 y 1.4.77	log4j.2.16.0	Muy recomendado
2.0.26, 1.5.52 y 1.4.76, o versiones anteriores de cada uno	Versión ant.	Suspende el uso

Consulta las notas de la versión de Dataproc para obtener información específica sobre las actualizaciones de imágenes y log4j.

Crea un clúster de Dataproc

Requisitos:

• Nombre: El nombre del clúster debe comenzar con una letra minúscula seguida por un máximo de 51 letras minúsculas, números y guiones, y no puede terminar 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, dentro de la región.

  • Consulta Extremos regionales para obtener más información sobre los extremos 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 mostrar una lista de las regiones disponibles.

• Conectividad: Las instancias de máquina virtual de Compute Engine (VM) en un clúster de Dataproc, que constan de VM principales y de trabajador, requieren conectividad cruzada total de redes de IP internas. La red de VPC default proporciona esta conectividad (consulta Configuración de la red de un clúster de Dataproc).

Consulta también:

• La guía de prácticas recomendadas de Dataproc.
• Crea un clúster con un tipo de máquina ARM.

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 de Dataproc para las instancias de máquina virtual principal y trabajadora, tamaños y tipos de disco, tipo de red, región y zona donde se implementa el clúster y otras configuraciones de clúster. Consulta el comando gcloud dataproc clusters create si deseas obtener información sobre el uso de marcas de línea de comandos para personalizar la configuración de los clústeres.

Crea un clúster con un archivo YAML

1. Ejecuta el siguiente comando de gcloud para exportar la configuración de un clúster de Dataproc existente a un archivo cluster.yaml.

   gcloud dataproc clusters export EXISTING_CLUSTER_NAME \
       --region=REGION \
       --destination=cluster.yaml
   

2. Importa la configuración del archivo YAML para crear un clúster nuevo.

   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 están permitidos en el archivo YAML importado que se usa para crear un clúster.

Nota: Puedes hacer clic en los vínculos Equivalent REST or command line (REST o línea de comandos equivalentes) en la parte inferior del panel izquierdo de la consola de Dataproc Google Cloud en la página Create a cluster si deseas que Console construya una solicitud a la API de REST o un comando de la herramienta de gcloud equivalentes para usar en tu código o desde la línea de comandos a fin de crear un clúster.

REST

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

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

• CLUSTER_NAME: nombre del clúster
• PROJECT: Google Cloud ID del proyecto
• REGION: Es una región de Compute Engine disponible en la que se creará el clúster.
• ZONE: Es una zona opcional dentro 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, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
"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: Puedes hacer clic en los vínculos Equivalent REST or command line (REST o línea de comandos equivalentes) en la parte inferior del panel izquierdo de la consola de Dataproc Google Cloud en la página Create a cluster para que Console construya una solicitud a la API de REST o un comando de la herramienta de gcloud equivalentes para usar en tu código o desde la línea de comandos a fin de crear un clúster.

Console

Abre la página de Dataproc Create a cluster (Crear un clúster) en la consola de Google Cloud en tu navegador y, luego, haz clic en Crear en la fila del clúster en Compute Engine en la página Crea un clúster de Dataproc en Compute Engine. El panel Configura el clúster se selecciona con campos completados con valores predeterminados. Puedes seleccionar cada panel y confirmar o cambiar los valores predeterminados para personalizar tu clúster.

Haz clic en Crear para generar 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 aprovisionar el clúster. Haz clic en el nombre del clúster para abrir su página de detalles, en la que podrás examinar los trabajos, las instancias y los ajustes de configuración de tu clúster, y conectarte a las interfaces web que se ejecutan en él.

Go

1. Instala la biblioteca cliente.
2. Configura credenciales predeterminadas de la aplicación.
3. Ejecuta el código.
   Consulta Configura tu entorno de desarrollo.
   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 cliente.
2. Configura credenciales predeterminadas de la aplicación.
3. Ejecuta el código.
   Consulta Configura un entorno de desarrollo de Java.
   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 cliente.
2. Configura credenciales predeterminadas de la aplicación.
3. Ejecuta el código.
   Consulta Configura un entorno de desarrollo de Node.js.
   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 cliente.
2. Configura credenciales predeterminadas de la aplicación.
3. Ejecuta el código.
   Consulta Configura un entorno de desarrollo de Python.
   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}")