Esta página foi traduzida pela API Cloud Translation.
Switch to English

Crie um cluster

É possível criar um cluster do Dataproc usando a ferramenta de linha de comando gcloud do SDK do Cloud, a API Dataproc ou o Console do Google Cloud. Também é possível criar clusters de maneira programática usando as bibliotecas de cliente do Cloud.

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

Região do cluster: é possível especificar uma região global ou uma região específica para o cluster. A região global é um endpoint de várias regiões especial capaz de implantar instâncias em qualquer zona do Compute Engine especificada pelo usuário. Também especifique regiões distintas, como us-east1 ou europe-west1, para isolar recursos, inclusive instâncias de VM e do Cloud Storage, e locais para armazenamento de metadados utilizados pelo Cloud Dataproc dentro da região especificada pelo usuário. Consulte Endpoints regionais para saber mais sobre a diferença entre os endpoints globais e regionais. 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 ver uma lista de regiões disponíveis.

As instâncias de máquina virtual do Compute Engine (VMs) em um cluster do Dataproc, que consistem em VMs mestras e workers, exigem acesso de rede IP interno completo entre si. A rede default, que está disponível para criar um cluster, ajuda a garantir esse acesso. Para informações sobre como criar sua própria rede para o cluster do Dataproc, consulte Configuração de rede de um cluster do Dataproc.

Como criar um cluster do Dataproc

gcloud

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

gcloud dataproc clusters create cluster-name \
    --region=region

O comando acima 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 YAML.
    gcloud dataproc clusters export my-existing-cluster --destination cluster.yaml
    
  2. Crie um novo cluster importando a configuração do arquivo YAML.
    gcloud dataproc clusters import my-new-cluster --source cluster.yaml
    

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

REST e LINHA DE CMD

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:

  • project-id: ID de projeto do GCP.
  • region: região do cluster
  • clusterName: nome do cluster

Método HTTP e URL:

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

Abra a página Criar um cluster do Dataproc no Console do Cloud no navegador. 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 criar o cluster. O nome do cluster é exibido 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. Instalar a biblioteca cliente
  2. Configurar as credenciais padrão do aplicativo
  3. Execute o 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-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: %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. Instalar a biblioteca cliente
  2. Configurar 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. Instalar a biblioteca cliente
  2. Configurar as credenciais padrão do aplicativo
  3. Executar 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. Instalar a biblioteca cliente
  2. Configurar 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}")