Membuat cluster

Managed Service untuk Apache Spark mencegah pembuatan cluster dengan versi image sebelum 1.3.95, 1.4.77, 1.5.53, dan 2.0.27, yang terpengaruh oleh kerentanan keamanan Apache Log4j. Managed Service untuk Apache Spark juga mencegah pembuatan cluster untuk versi image Managed Service untuk Apache Spark 0.x, 1.0.x, 1.1.x, dan 1.2.x. Managed Service untuk Apache Spark menyarankan agar Anda membuat cluster Managed Service untuk Apache Spark dengan versi image sub-minor terbaru jika memungkinkan.

Versi image	Versi log4j	Panduan pelanggan
2.0.29, 1.5.55, dan 1.4.79, atau yang lebih baru dari setiap versi	log4j.2.17.1	Disarankan
2.0.28, 1.5.54, dan 1.4.78	log4j.2.17.0	Disarankan
2.0.27, 1.5.53, dan 1.4.77	log4j.2.16.0	Sangat direkomendasikan
2.0.26, 1.5.52, dan 1.4.76, atau yang lebih lama dari setiap versi	Versi lebih lama	Hentikan penggunaan

Lihat catatan rilis Managed Service untuk Apache Spark guna mengetahui informasi update image dan log4j tertentu.

Membuat cluster

Persyaratan:

• Nama: Nama cluster harus diawali dengan huruf kecil, diikuti hingga 51 huruf kecil, angka, dan tanda hubung, serta tidak boleh diakhiri dengan tanda hubung.

• Region cluster: Anda harus menentukan region Compute Engine untuk cluster, seperti us-east1 atau europe-west1, untuk mengisolasi resource cluster, seperti instance VM dan metadata cluster yang disimpan di Cloud Storage, dalam region tersebut.

  • Lihat Region cluster untuk mengetahui informasi selengkapnya tentang region Compute Engine.
  • Lihat Region & zona yang tersedia untuk mengetahui informasi tentang cara memilih region. Anda juga dapat menjalankan perintah gcloud compute regions list untuk menampilkan daftar region yang tersedia.

• Konektivitas: Instance Virtual Machine (VM) Compute Engine dalam cluster Managed Service untuk Apache Spark, yang terdiri dari VM master dan pekerja, memerlukan konektivitas silang jaringan IP internal penuh. Jaringan VPC default menyediakan konektivitas ini (lihat Konfigurasi Jaringan Cluster Managed Service untuk Apache Spark).

• Jenis mesin (direkomendasikan): Meskipun menentukan jenis mesin bersifat opsional, Google merekomendasikan agar Anda memilih jenis mesin secara eksplisit untuk VM master dan pekerja di cluster Anda. Jika Anda tidak menentukan jenis mesin, Managed Service untuk Apache Spark akan memilih jenis mesin secara dinamis berdasarkan ketersediaan resource. Pemilihan dinamis ini dapat menyebabkan variasi dalam biaya dan performa.

  • Untuk mengetahui informasi selengkapnya tentang cara memilih jenis mesin, lihat Jenis mesin yang didukung.
  • Untuk mengurangi potensi masalah ketidaktersediaan resource, sebaiknya gunakan VM Fleksibel, yang memungkinkan Anda menentukan daftar jenis mesin yang dapat diterima.

Lihat juga:

• Panduan praktik terbaik Managed Service untuk Apache Spark.
• Membuat cluster dengan jenis mesin ARM.

Konsol

Buka halaman Buat cluster di Google Cloud konsol untuk menampilkan setelan cluster default. Anda dapat mengonfirmasi atau mengubah setelan default yang ditampilkan, lalu klik Konfigurasi tambahan untuk menyesuaikan cluster lebih lanjut.

Klik Buat cluster untuk membuat cluster. Nama cluster akan muncul di halaman Cluster, dan statusnya akan diperbarui menjadi Running setelah cluster disediakan. Klik nama cluster untuk membuka halaman detail cluster tempat Anda dapat memeriksa tugas, instance, dan setelan konfigurasi untuk cluster Anda serta terhubung ke antarmuka web yang berjalan di cluster.

gcloud

Untuk membuat cluster Managed Service untuk Apache Spark di command line, jalankan perintah gcloud dataproc clusters create secara lokal di jendela terminal atau di Cloud Shell.

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

Perintah ini akan membuat cluster. Meskipun jenis mesin master dan pekerja bersifat opsional, sebaiknya tentukan jenis mesin secara eksplisit menggunakan flag --master-machine-type dan --worker-machine-type (misalnya, n4-standard-4) untuk memastikan biaya dan performa yang konsisten. Jika Anda tidak menentukan jenis mesin, jenis mesin default akan dipilih secara dinamis berdasarkan ketersediaan resource. Lihat perintah gcloud dataproc clusters create untuk mengetahui informasi tentang cara menggunakan flag command line untuk menyesuaikan setelan cluster.

Membuat cluster dengan file YAML

1. Jalankan perintah gcloud berikut untuk mengekspor konfigurasi cluster Managed Service untuk Apache Spark yang ada ke dalam file cluster.yaml.

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

2. Buat cluster baru dengan mengimpor konfigurasi file YAML.

   gcloud dataproc clusters import NEW_CLUSTER_NAME \
       --region=REGION \
       --source=cluster.yaml
   

**Catatan:** Selama operasi ekspor, kolom khusus cluster, seperti nama cluster, kolom khusus output, dan label yang diterapkan secara otomatis akan difilter. Kolom ini tidak diizinkan dalam file YAML yang diimpor dan digunakan untuk membuat cluster.

Catatan: Di bagian bawah halaman Buat cluster, klik Command line yang setara atau REST yang setara agar Google Cloud konsol membuat perintah gcloud CLI atau permintaan REST API yang setara.

REST

Bagian ini menunjukkan cara membuat cluster. Meskipun menentukan jenis mesin bersifat opsional, sebaiknya sertakan machine_type_uri secara eksplisit dalam master_config dan worker_config (misalnya, n4-standard-4) untuk memastikan biaya dan performa yang konsisten. Jika Anda tidak menentukan jenis mesin, jenis mesin default akan dipilih secara dinamis berdasarkan ketersediaan resource.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

• CLUSTER_NAME: nama cluster
• PROJECT: Google Cloud project ID
• REGION: Region Compute Engine yang tersedia tempat cluster akan dibuat.
• ZONE: Zona opsional dalam region yang dipilih tempat cluster akan dibuat.
• MASTER_MACHINE_TYPE: (Direkomendasikan) Jenis mesin untuk node master (misalnya, n4-standard-4).
• WORKER_MACHINE_TYPE: (Direkomendasikan) Jenis mesin untuk node pekerja (misalnya, n4-standard-4).

Metode HTTP dan URL:

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

Meminta isi JSON:

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

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

curl (Linux, macOS, atau Cloud Shell)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI menggunakan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login, atau dengan menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke gcloud CLI. Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

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)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI menggunakan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login. Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

$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

Anda akan melihat respons JSON seperti berikut:

{
"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 ...""
    ]
  }
}

Catatan: Di bagian bawah halaman Buat cluster, klik Command line yang setara atau REST yang setara agar Google Cloud konsol membuat perintah gcloud CLI atau permintaan REST API yang setara.

Go

1. Instal library klien.
2. Siapkan kredensial default aplikasi.
3. Jalankan kode.
   Lihat Menyiapkan lingkungan pengembangan.

   Catatan: Meskipun menentukan jenis mesin bersifat opsional, sebaiknya tetapkan jenis mesin master dan pekerja secara eksplisit dalam konfigurasi cluster Anda (misalnya, ke n4-standard-4) untuk memastikan biaya dan performa yang konsisten. Jika dihilangkan, jenis mesin default akan dipilih secara dinamis berdasarkan ketersediaan resource.

   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. Instal library klien.
2. Siapkan kredensial default aplikasi.
3. Jalankan kode.
   Lihat Menyiapkan Lingkungan Pengembangan Java.

   Catatan: Meskipun menentukan jenis mesin bersifat opsional, sebaiknya tetapkan jenis mesin master dan pekerja secara eksplisit dalam konfigurasi cluster Anda (misalnya, ke n4-standard-4) untuk memastikan biaya dan performa yang konsisten. Jika dihilangkan, jenis mesin default akan dipilih secara dinamis berdasarkan ketersediaan resource.

   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. Instal library klien.
2. Siapkan kredensial default aplikasi.
3. Jalankan kode.
   Lihat Menyiapkan lingkungan pengembangan Node.js.

   Catatan: Meskipun menentukan jenis mesin bersifat opsional, sebaiknya tetapkan jenis mesin master dan pekerja secara eksplisit dalam konfigurasi cluster Anda (misalnya, ke n4-standard-4) untuk memastikan biaya dan performa yang konsisten. Jika dihilangkan, jenis mesin default akan dipilih secara dinamis berdasarkan ketersediaan resource.

   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. Instal library klien.
2. Siapkan kredensial default aplikasi.
3. Jalankan kode.
   Lihat Menyiapkan Lingkungan Pengembangan Python.

   Catatan: Meskipun menentukan jenis mesin bersifat opsional, sebaiknya tetapkan jenis mesin master dan pekerja secara eksplisit dalam konfigurasi cluster Anda (misalnya, ke n4-standard-4) untuk memastikan biaya dan performa yang konsisten. Jika dihilangkan, jenis mesin default akan dipilih secara dinamis berdasarkan ketersediaan resource.

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