Criar um cluster

Criar um cluster

Requisitos:

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

  • Região do cluster: é preciso especificar 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 Região do cluster para mais informações sobre as regiões do Compute Engine.
    • Consulte informações sobre a seleção de uma região em Regiões e zonas disponíveis. Também é possível executar o comando gcloud compute regions list para exibir uma lista de regiões disponíveis.

  • Conectividade: as instâncias de máquina virtual (VM) do Compute Engine em um cluster do Managed Service para Apache Spark, que consiste em VMs mestre e de worker, exigem conectividade cruzada de rede IP interna completa. A rede VPC default fornece essa conectividade (consulte Configuração de rede do cluster do Serviço Gerenciado para Apache Spark).

  • Tipo de máquina (recomendado): embora a especificação de um tipo de máquina seja opcional, o Google recomenda que você selecione explicitamente um tipo de máquina para as VMs mestre e de worker no cluster. Se você não especificar um tipo de máquina, o Serviço Gerenciado para Apache Spark vai selecionar dinamicamente os tipos de máquina com base na disponibilidade de recursos. Essa seleção dinâmica pode resultar em variações de custo e desempenho.

    • Para mais informações sobre como escolher um tipo de máquina, consulte Tipos de máquina compatíveis.
    • Para reduzir possíveis problemas de indisponibilidade de recursos, recomendamos o uso de VMs flexíveis, que permitem especificar uma lista de tipos de máquina aceitáveis.

Console

Abra a página Criar cluster do console do Google Cloud para exibir as configurações padrão do cluster. É possível confirmar ou alterar as configurações padrão exibidas e clicar em Configuração adicional para personalizar ainda mais o cluster.

Clique em Criar cluster para criar o cluster. O nome do cluster aparece na página Clusters, e o status é atualizado para Running depois que o cluster é provisionado. Clique no nome do cluster para abrir a página de detalhes, em que é possível examinar jobs, instâncias e definições de configuração do cluster e se conectar a interfaces da Web em execução no cluster.

gcloud

Para criar um cluster do Serviço Gerenciado para Apache Spark na linha de comando, execute o comando gcloud dataproc clusters create localmente em uma janela do terminal ou no Cloud Shell.

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION \
    --master-machine-type=MASTER_MACHINE_TYPE \
    --worker-machine-type=WORKER_MACHINE_TYPE

O comando cria um cluster. Embora os tipos de máquina mestre e de worker sejam opcionais, recomendamos especificá-los explicitamente usando as flags --master-machine-type e --worker-machine-type (por exemplo, n4-standard-4) para garantir um custo e desempenho consistentes. Se você não especificar os tipos de máquina, os tipos padrão serão selecionados dinamicamente com base na disponibilidade de recursos. Consulte o comando gcloud dataproc clusters create para saber como usar flags de linha de comando para personalizar as configurações do cluster.

Criar um cluster com um arquivo YAML

  1. Execute o seguinte comando gcloud para exportar a configuração de um cluster do Serviço Gerenciado para Apache Spark 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 de 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. Embora a especificação de tipos de máquina seja opcional, recomendamos incluir explicitamente machine_type_uri em master_config e worker_config (por exemplo, n4-standard-4) para garantir custo e desempenho consistentes. Se você não especificar os tipos de máquina, os tipos padrão serão selecionados dinamicamente com base na disponibilidade de recursos.

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.
  • MASTER_MACHINE_TYPE: (recomendado) o tipo de máquina do nó mestre (por exemplo, n4-standard-4).
  • WORKER_MACHINE_TYPE: (recomendado) o tipo de máquina para nós de trabalho (por exemplo, n4-standard-4).

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":"MASTER_MACHINE_TYPE",
      "image_uri":""
    },
    "softwareConfig": {
      "imageVersion": "",
      "properties": {},
      "optionalComponents": []
    },
    "worker_config":{
      "num_instances":2,
      "machine_type_uri":"WORKER_MACHINE_TYPE",
      "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 ...""
    ]
  }
}

Go

  1. Instale a biblioteca de cliente.
  2. Configure o Application Default Credentials.
  3. Execute o código.

    Observação: embora a especificação de tipos de máquina seja opcional, é recomendável definir explicitamente os tipos de máquina mestre e de worker na configuração do cluster (por exemplo, como n4-standard-4) para garantir custo e desempenho consistentes. Se omitidos, os tipos de máquina padrão serão selecionados dinamicamente com base na disponibilidade de recursos.

    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 o Application Default Credentials.
  3. Execute o código.

    Observação: embora a especificação de tipos de máquina seja opcional, recomendamos definir explicitamente os tipos de máquina mestre e de worker na configuração do cluster (por exemplo, como n4-standard-4) para garantir custo e desempenho consistentes. Se omitidos, os tipos de máquina padrão serão selecionados dinamicamente com base na disponibilidade de recursos.

    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 o Application Default Credentials.
  3. Execute o código.

    Observação: embora a especificação de tipos de máquina seja opcional, é recomendável definir explicitamente os tipos de máquina mestre e de worker na configuração do cluster (por exemplo, como n4-standard-4) para garantir custo e desempenho consistentes. Se omitidos, os tipos de máquina padrão serão selecionados dinamicamente com base na disponibilidade de recursos.

    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 o Application Default Credentials.
  3. Execute o código.

    Observação: embora a especificação de tipos de máquina seja opcional, é recomendável definir explicitamente os tipos de máquina mestre e de worker na configuração do cluster (por exemplo, como n4-standard-4) para garantir custo e desempenho consistentes. Se omitidos, os tipos de máquina padrão serão selecionados dinamicamente com base na disponibilidade de recursos.

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