Cree un clúster

Puede crear un clúster de Dataproc a través de una solicitud HTTP o programática clusters.create a la API de Dataproc con la herramienta de línea de comandos de gcloud del SDK de Cloud en una ventana de terminal local o en Cloud Shell, o bien desde Google Cloud Console abierta en un navegador local. También puedes crear clústeres de manera programática con las bibliotecas cliente de Cloud o mediante solicitudes a la API.

Región de clúster: Puedes especificar una región global o una región específica para tu clúster. La región global es un extremo multirregión especial que puede implementar instancias en cualquier zona de Compute Engine especificada por el usuario. También puedes especificar regiones distintas, como us-east1 o europe-west1, para aislar los recursos (incluidas las instancias de VM y Cloud Storage) y las ubicaciones de almacenamiento de metadatos que usa Dataproc dentro de la región especificada por el usuario. Consulta Extremos regionales para obtener más información sobre la diferencia entre los extremos globales y 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.

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 acceso total a la red de IP interna entre sí. La red default disponible (y normalmente se usa) para crear un clúster ayuda a garantizar este acceso. Si deseas obtener información sobre cómo crear tu propia red para tu clúster de Dataproc, consulta Configuración de red del clúster de Dataproc.

Crea un clúster de Dataproc

Comando de gcloud

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

gcloud dataproc clusters create cluster-name \  
    --region=region
El comando anterior 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 YAML.
    gcloud dataproc clusters export my-existing-cluster --destination cluster.yaml
    
  2. Importa la configuración del archivo YAML para crear un clúster nuevo.
    gcloud dataproc clusters import my-new-cluster --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), las etiquetas aplicadas de forma automática y los campos de solo salida. Estos campos no están permitidos en el archivo YAML importado que se usa para crear un clúster.

LÍNEA DE CMD Y 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 siguientes, realiza los siguientes reemplazos:

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

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

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

Abre la página Crear un clúster de Dataproc en Cloud Console en tu navegador.

La captura de pantalla anterior muestra la página Create a cluster con los campos predeterminados rellenados de forma automática para un clúster nuevo llamado “cluster-1”. Puedes expandir el panel Opciones avanzadas para especificar uno o más nodos trabajadores interrumpibles, un depósito de etapa de pruebas, una red, una versión de imagen de Dataproc, acciones de inicialización y acceso a nivel de proyecto para tu clúster. Proporcionar estos valores es opcional.

El clúster predeterminado se crea sin nodos trabajadores interrumpibles, con un depósito de etapa de pruebas creado automáticamente, con una red predeterminada y con la versión de imagen de Dataproc más reciente si no proporcionas la configuración para estas opciones.

Una vez que estés satisfecho con el contenido de todos los campos de la página, haz clic en Create (Crear) para crear 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 la creación.

Haz clic en el nombre del clúster para abrir su página de detalles. Esta página se abre con la pestaña de Información general y el grafo de uso de CPU seleccionados. También puedes elegir mostrar los grafos de red y de disco para el clúster.

Puedes examinar los trabajos, las instancias y los ajustes de configuración de tu clúster desde las otras pestañas. Por ejemplo, puedes usar la pestaña de Instancias de VM para establecer una conexión SSH al nodo principal de tu clúster. Puedes hacer clic en Edit (Editar) en la pestaña de Opciones de configuración a fin de editar la configuración de tu clúster; por ejemplo, para aumentar o reducir la escala de tu clúster mediante un cambio en la cantidad de nodos trabajadores estándar o interrumpibles.

Go

  1. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el código.
    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. Instala la biblioteca cliente
  2. Configura 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-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. Instala la biblioteca cliente
  2. Configura 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-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. Instala la biblioteca cliente
  2. Configura 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-1'
                },
                'worker_config': {
                    'num_instances': 2,
                    'machine_type_uri': 'n1-standard-1'
                }
            }
        }
    
        # Create the cluster.
        operation = cluster_client.create_cluster(project_id, region, cluster)
        result = operation.result()
    
        # Output a success message.
        print(f'Cluster created successfully: {result.cluster_name}')