Configura pool di connessioni

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

I pool di connessioni vengono ridimensionati 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 la dimensione ottimale del pool di connessioni per la tua applicazione e presenta gli snippet di codice che mostrano come configurare i pool di connessioni.

Prima di leggere questa pagina, leggi la panoramica dei pool di connessioni Bigtable per scoprire come funzionano e se dovresti modificare i tuoi.

Le seguenti librerie client offrono il pool di 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 la dimensione migliore del pool di connessioni

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

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

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

1. Dalle metriche lato client, raccogli le seguenti informazioni:
   1. Il numero massimo di query al secondo (QPS) per client quando la tua applicazione esegue un carico di lavoro 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 di latenza medio.
3. Dividi il valore QPS in secondi per il numero di richieste seriali al secondo.
4. Dividi il risultato per 50 richieste per canale per determinare la dimensione minima ottimale 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 la dimensione massima ottimale del pool di canali.

Questi passaggi sono espressi nelle seguenti equazioni:

• (QPS sec ÷ (1000 ÷ latenza ms)) ÷ 50 flussi = numero minimo ottimale di connessioni

• (QPS sec ÷ (1000 ÷ latenza ms)) ÷ 10 flussi = numero ottimale ottimale di connessioni

Esempio

L'applicazione in genere 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 quel numero in 50.000 per ottenere il parallelismo necessario per inviare 50.000 QPS: 500. Ogni canale può avere al massimo 100 richieste contemporaneamente e l'utilizzo del canale target è compreso tra 10 e 50 stream simultanei. Quindi, per calcolare il minimo, dividi 500 per 50 e ottieni 10. Per trovare il numero massimo, dividi 500 per 10 e ottieni 50. Ciò significa che la dimensione del pool di canali per questo esempio deve essere compresa tra 10 e 50 connessioni.

Imposta 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.

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

Questo esempio è applicabile solo alle versioni delle librerie client precedenti alla 2.9.1, quando è stato introdotto il ridimensionamento automatico.

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 delle librerie client precedenti alla 2.23.0, quando è stato introdotto il ridimensionamento automatico.

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