Questa pagina è stata tradotta dall'API Cloud Translation.

Configura i pool di connessione

Alcune librerie client di Cloud Bigtable consentono di configurare il numero di canali gRPC in un pool di connessioni client, noto anche come 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 necessità quando utilizzi la libreria client 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 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 devi modificarli.

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

Determinare le dimensioni migliori del pool di connessioni

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

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

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

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 workload tipico.
2. La latenza media (il tempo di risposta per una singola richiesta) in ms.
Determina il numero di richieste che puoi inviare in serie al secondo dividendo 1000 per il valore di latenza medio.
Dividi le QPS in secondi per il numero di richieste seriali al secondo.
Dividi il risultato per 50 richieste per canale per determinare la dimensione minima ottimale del pool di canali. (Se il risultato è inferiore a 2, utilizza comunque almeno 2 canali per garantire la ridondanza.)
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 stream = Numero minimo ottimale di connessioni
(QPS sec ÷ (1000 ÷ latenza ms)) ÷ 10 stream = Numero massimo ottimale di connessioni

Esempio

La tua 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 questo numero per 50.000 per ottenere il parallelismo necessario per inviare 50.000 QPS: 500. Ogni canale può avere al massimo 100 richieste in parallelo e l'utilizzo del canale di destinazione è compreso tra 10 e 50 stream simultanei. Pertanto, per calcolare il minimo, dividi 500 per 50 per ottenere 10. Per trovare il massimo, dividi 500 per 10 per ottenere 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.

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 è 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 della libreria 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";
}