Mengonfigurasi kumpulan koneksi

Beberapa library klien Cloud Bigtable memungkinkan Anda mengonfigurasi jumlah saluran gRPC di kumpulan koneksi klien, yang juga dikenal sebagai kumpulan saluran. Dalam sebagian besar kasus, konfigurasi default sudah benar, dan Anda tidak perlu mengubahnya.

Ukuran kumpulan koneksi akan otomatis diubah sesuai kebutuhan saat Anda menggunakan library klien Cloud Bigtable untuk Java versi 2.23.0 atau yang lebih baru, dan saat Anda menggunakan klien HBase Cloud Bigtable untuk Java versi 2.9.1 atau yang lebih baru.

Halaman ini menjelaskan cara menentukan ukuran kumpulan koneksi yang optimal untuk aplikasi Anda, dan menampilkan cuplikan kode yang menunjukkan cara mengonfigurasi kumpulan koneksi.

Sebelum membaca halaman ini, baca ringkasan tentang kumpulan koneksi Bigtable untuk mempelajari cara kerja kumpulan koneksi tersebut dan apakah Anda harus mengubahnya.

Library klien berikut menawarkan penggabungan koneksi dan memungkinkan Anda mengonfigurasi jumlah kumpulan:

Menentukan ukuran kumpulan koneksi terbaik

Idealnya, untuk memberikan ruang bagi fluktuasi traffic, kumpulan koneksi memiliki jumlah koneksi yang diperlukan untuk saturasi maksimum, yaitu sekitar dua kali lipat. Karena koneksi dapat menangani maksimum 100 permintaan serentak, antara 10 dan 50 permintaan yang belum terselesaikan per koneksi adalah optimal. Konsep ini dijelaskan lebih mendetail dalam Kumpulan koneksi.

Pantau traffic Anda setelah melakukan perubahan dan sesuaikan jumlah koneksi di kumpulan Anda jika diperlukan.

Langkah-langkah berikut membantu Anda menghitung jumlah koneksi yang optimal di kumpulan saluran menggunakan metrik sisi klien seperti yang tersedia dari OpenCensus.

  1. Dari metrik sisi klien, kumpulkan informasi berikut:
    1. Jumlah maksimum kueri per detik (QPS) per klien saat aplikasi Anda menjalankan beban kerja standar.
    2. Latensi rata-rata (waktu respons untuk satu permintaan) dalam md.
  2. Tentukan jumlah permintaan yang dapat Anda kirim secara serial per detik dengan membagi 1.000 dengan nilai latensi rata-rata.
  3. Bagi QPS dalam detik dengan jumlah permintaan serial per detik.
  4. Bagi hasilnya dengan 50 permintaan per saluran untuk menentukan ukuran kumpulan saluran minimum yang optimal. (Jika penghitungan Anda kurang dari 2, gunakan setidaknya 2 saluran untuk memastikan redundansi.)
  5. Bagi hasil yang sama dengan 10 permintaan per saluran untuk menentukan ukuran kumpulan saluran optimal maksimum.

Langkah-langkah ini dinyatakan dalam persamaan berikut:

  • (QPS detik ÷ (1.000 ÷ latensi md)) ÷ 50 streaming = Jumlah koneksi optimal minimum

  • (QPS detik ÷ (1.000 ÷ latensi md)) ÷ 10 streaming = Jumlah koneksi optimal maksimum

Contoh

Aplikasi Anda biasanya mengirim 50.000 permintaan per detik, dan latensi rata-ratanya adalah 10 md. Bagi 1.000 dengan 10 md untuk menentukan bahwa Anda dapat mengirim 100 permintaan secara serial per detik. Bagi angka tersebut menjadi 50.000 untuk mendapatkan paralelisme yang diperlukan untuk mengirim 50.000 QPS: 500. Setiap saluran dapat memiliki maksimal 100 permintaan secara serentak, dan penggunaan saluran target Anda adalah antara 10 dan 50 streaming serentak. Oleh karena itu, untuk menghitung minimum, bagi 500 dengan 50 untuk mendapatkan 10. Untuk menemukan nilai maksimum, bagi 500 dengan 10 untuk mendapatkan 50. Artinya, ukuran kumpulan saluran Anda untuk contoh ini harus antara 10 dan 50 koneksi.

Menetapkan ukuran kumpulan

Contoh kode berikut menunjukkan cara mengonfigurasi jumlah kumpulan di library klien yang memungkinkan Anda menetapkan ukuran kumpulan.

Go

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigtable"
	"google.golang.org/api/option"
)

func configureConnectionPool(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance-id"
	ctx := context.Background()

	// Set up Bigtable data operations client.
	poolSize := 10
	client, err := bigtable.NewClient(ctx, projectID, instanceID, option.WithGRPCConnectionPool(poolSize))
	defer client.Close()

	if err != nil {
		return fmt.Errorf("bigtable.NewClient: %w", err)
	}

	fmt.Fprintf(w, "Connected with pool size of %d", poolSize)

	return nil
}

HBase

Contoh ini hanya berlaku untuk versi library klien sebelum 2.9.1, saat pengubahan ukuran otomatis diperkenalkan.



import static com.google.cloud.bigtable.hbase.BigtableOptionsFactory.BIGTABLE_DATA_CHANNEL_COUNT_KEY;

import com.google.cloud.bigtable.hbase.BigtableConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.Connection;

public class ConfigureConnectionPool {

  public static void configureConnectionPool(String projectId, String instanceId) {
    // String projectId = "my-project-id";
    // String instanceId = "my-instance-id";
    Configuration config = BigtableConfiguration.configure(projectId, instanceId);
    config.setInt(BIGTABLE_DATA_CHANNEL_COUNT_KEY, 10);
    try (Connection connection = BigtableConfiguration.connect(config)) {
      int poolSize = connection.getConfiguration().getInt(BIGTABLE_DATA_CHANNEL_COUNT_KEY, 0);

      System.out.println(String.format("Connected with pool size of %d", poolSize));
    } catch (Exception e) {
      System.out.println("Error during ConfigureConnectionPool: \n" + e.toString());
    }
  }
}

Java

Contoh ini hanya berlaku untuk versi library klien sebelum 2.23.0, saat pengubahan ukuran otomatis diperkenalkan.


import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider;
import com.google.cloud.bigtable.data.v2.BigtableDataClient;
import com.google.cloud.bigtable.data.v2.BigtableDataSettings;
import com.google.cloud.bigtable.data.v2.stub.EnhancedBigtableStubSettings;
import java.io.IOException;

public class ConfigureConnectionPool {

  public static void configureConnectionPool(String projectId, String instanceId) {
    // String projectId = "my-project-id";
    // String instanceId = "my-instance-id";

    BigtableDataSettings.Builder settingsBuilder =
        BigtableDataSettings.newBuilder().setProjectId(projectId).setInstanceId(instanceId);

    settingsBuilder
        .stubSettings()
        .setTransportChannelProvider(
            EnhancedBigtableStubSettings.defaultGrpcTransportProviderBuilder()
                .setPoolSize(10)
                .build());

    BigtableDataSettings settings = settingsBuilder.build();
    try (BigtableDataClient dataClient = BigtableDataClient.create(settings)) {
      InstantiatingGrpcChannelProvider provider =
          (InstantiatingGrpcChannelProvider)
              settings.getStubSettings().getTransportChannelProvider();

      int poolSize = provider.toBuilder().getPoolSize();

      System.out.println(String.format("Connected with pool size of %d", poolSize));
    } catch (IOException e) {
      System.out.println("Error during ConfigureConnectionPool: \n" + e.toString());
    }
  }
}

C++

namespace cbt = ::google::cloud::bigtable;
namespace gc = ::google::cloud;
[](std::string const& project_id, std::string const& instance_id,
   std::string const& table_id) {
  auto constexpr kPoolSize = 10;
  auto options = gc::Options{}.set<gc::GrpcNumChannelsOption>(kPoolSize);
  cbt::Table table(cbt::MakeDataConnection(options),
                   cbt::TableResource(project_id, instance_id, table_id));
  std::cout << "Connected with channel pool size of " << kPoolSize << "\n";
}