Configurazione di pool di connessione

Alcune librerie client di Cloud Bigtable consentono di configurare il numero di canali gRPC in un pool di connessioni di un client, noto anche come pool di canali. Nella maggior parte dei casi, la configurazione predefinita è corretta e non è necessario modificarla.

Le dimensioni dei pool di connessioni vengono modificate automaticamente in base alle esigenze quando utilizzi la libreria client di Cloud Bigtable per Java versione 2.23.0 o successive e quando utilizzi il client Cloud Bigtable HBase per Java versione 2.9.1 o successive.

Questa pagina descrive come determinare le dimensioni ottimali del pool di connessioni per la tua applicazione e presenta snippet di codice che mostrano come configurare i pool di connessioni.

Prima di leggere questa pagina, consulta la panoramica dei pool di connessioni Bigtable per scoprire come funzionano e se devi modificarli.

Le seguenti librerie client offrono il pooling delle connessioni e consentono di configurare il numero di pool:

• Libreria client Go per Cloud Bigtable
• Client Cloud Bigtable HBase per Java
• Libreria client di Cloud Bigtable per Java
• Libreria client C++ di Cloud Bigtable

Determinare le dimensioni ottimali del pool di connessioni

Idealmente, per lasciare spazio alle fluttuazioni del traffico, un pool di connessioni ha circa il doppio del numero di connessioni necessarie per la saturazione massima. Poiché una connessione può gestire un massimo di 100 richieste simultanee, è ottimale avere tra 10 e 50 richieste in sospeso per connessione. Questo concetto è descritto in modo più dettagliato in Pool di connessioni.

Monitora il traffico dopo aver apportato le modifiche e, se necessario, modifica il numero di connessioni nel pool.

I seguenti passaggi ti aiutano a calcolare il numero ottimale di connessioni nel pool di canali utilizzando metriche lato client come quelle disponibili da OpenCensus.

1. Dalle metriche lato client, raccogli le seguenti informazioni:
   1. Il numero massimo di query al secondo (QPS) per client quando l'applicazione esegue un workload tipico.
   2. La latenza media (il tempo di risposta per una singola richiesta) in ms.
2. Determina il numero di richieste che puoi inviare in serie al secondo dividendo 1000 per il valore della latenza media.
3. Dividi il QPS in secondi per il numero di richieste seriali al secondo.
4. Dividi il risultato per 50 richieste per canale per determinare le dimensioni minime ottimali del pool di canali. (Se il calcolo è inferiore a 2, utilizza comunque almeno 2 canali per garantire la ridondanza.)
5. Dividi lo stesso risultato per 10 richieste per canale per determinare le dimensioni massime ottimali del pool di canali.

Questi passaggi sono espressi nelle seguenti equazioni:

• (QPS sec ÷ (1000 ÷ latenza ms)) ÷ 50 stream = Numero minimo ottimale di connessioni

• (QPS sec ÷ (1000 ÷ latenza ms)) ÷ 10 stream = Numero massimo ottimale di connessioni

Esempio

In genere, la tua applicazione invia 50.000 richieste al secondo e la latenza media è di 10 ms. Dividi 1000 per 10 ms per determinare che puoi inviare 100 richieste in serie al secondo. Dividi questo numero per 50.000 per ottenere il parallelismo necessario per inviare 50.000 QPS: 500. Ogni canale può avere al massimo 100 richieste simultanee e l'utilizzo del canale target è compreso tra 10 e 50 stream simultanei. Pertanto, per calcolare il valore minimo, dividi 500 per 50 per ottenere 10. Per trovare il valore massimo, dividi 500 per 10 per ottenere 50. Ciò significa che le dimensioni del pool di canali per questo esempio devono essere comprese tra 10 e 50 connessioni.

Impostare le dimensioni del pool

I seguenti esempi di codice mostrano come configurare il numero di pool nelle librerie client che consentono di impostare le dimensioni del pool.

Vai

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

Questo esempio è applicabile solo alle versioni della libreria client precedenti alla 2.9.1, quando è stata introdotta la modifica automatica delle dimensioni.

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

Questo esempio è applicabile solo alle versioni della libreria client precedenti alla 2.23.0, quando è stata introdotta la modifica automatica delle dimensioni.

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