Criar um cluster

Criar um cluster do Dataproc

Requisitos:

  • Nome:o nome do cluster precisa começar com uma letra minúscula seguida de até 51 letras minúsculas, números e hifens, mas não pode terminar com um hífen.

  • Região do cluster:especifique uma região do Compute Engine para o cluster, como us-east1 ou europe-west1, para isolar os recursos do cluster, como instâncias de VM e metadados do cluster armazenados no Cloud Storage, dentro da região.

    • Consulte Endpoints regionais para mais informações.
    • Consulte informações sobre a seleção de uma região em Regiões e zonas disponíveis. Você também pode executar o comando gcloud compute regions list para mostrar uma lista de regiões disponíveis.

  • Conectividade:as instâncias de máquina virtual do Compute Engine (VMs) em um cluster do Dataproc, que consistem em VMs mestras e workers, exigem conectividade cruzada de rede IP interna completa. A rede VPC default oferece essa conectividade. Consulte Configuração de rede de cluster do Dataproc.

gcloud

Para criar um cluster do Dataproc na linha de comando, execute o comando gcloud dataproc clusters create localmente em uma janela de terminal ou no Cloud Shell.

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION

O comando cria um cluster com configurações padrão do serviço do Dataproc para as instâncias mestre e de trabalho da máquina virtual, além de tamanhos e tipos de disco, tipo de rede, região e zona onde o cluster está implantado e outras configurações do cluster. Consulte o comando gcloud dataproc clusters create para ver informações sobre como usar sinalizações da linha de comando a fim de personalizar configurações do cluster.

Criar um cluster com um arquivo YAML

  1. Execute o comando gcloud a seguir para exportar a configuração de um cluster do Dataproc existente para um arquivo cluster.yaml. 
    gcloud dataproc clusters export EXISTING_CLUSTER_NAME \
    --region=REGION \
    --destination=cluster.yaml
  2. Crie um novo cluster importando a configuração do arquivo YAML. 
    gcloud dataproc clusters import NEW_CLUSTER_NAME \
    --region=REGION \
    --source=cluster.yaml

Observação:durante a operação de exportação, os campos específicos do cluster, como nome do cluster, campos somente saída e rótulos aplicados automaticamente, são filtrados. Esses campos não são permitidos no arquivo YAML importado usado para criar um cluster.

REST

Nesta seção, mostramos como criar um cluster com valores obrigatórios e a configuração padrão (1 mestre, 2 workers).

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • CLUSTER_NAME: nome do cluster
  • PROJECT: Google Cloud ID do projeto
  • REGION: uma região disponível do Compute Engine em que o cluster será criado.
  • ZONE: uma zona opcional na região selecionada em que o cluster será criado.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
  "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 a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

Abra a página Criar um cluster do Dataproc no console do Google Cloud no navegador e clique em Criar na linha do cluster no Compute Engine na página Criar um cluster do Dataproc no Compute Engine. O painel "Configurar cluster" é selecionado com campos preenchidos com valores padrão. É possível selecionar cada painel e confirmar ou alterar os valores padrão para personalizar o cluster.

Clique em Criar para gerar o cluster. O nome do cluster aparece na página Clusters, e o status é atualizado para "Em execução" depois que o cluster é provisionado. Clique no nome do cluster para abrir a página de detalhes do cluster, em que você pode examinar jobs, instâncias e configurações do cluster, além de se conectar às interfaces da Web em execução no cluster.

Go

  1. Instale a biblioteca de cliente.

  2. Configure as credenciais padrão do aplicativo.

  3. Execute o 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. Instale a biblioteca de cliente.
  2. Configure as credenciais padrão do aplicativo.
  3. Execute o 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. Instale a biblioteca de cliente.
  2. Configure as credenciais padrão do aplicativo.
  3. Execute o 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. Instale a biblioteca de cliente.

  2. Configure as credenciais padrão do aplicativo.

  3. Execute o 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}")