Configura i pool di connessione

Alcune librerie client di Cloud Bigtable ti consentono di configurare il numero di canali gRPC nel 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 ridimensionate automaticamente in base alle esigenze 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, consulta la panoramica dei pool di connessioni Bigtable per scoprire come funzionano e se devi modificarne uno.

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

• Libreria client Go per Cloud Bigtable
• Client HBase Cloud Bigtable per Java
• Libreria client 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 in contemporanea, è ottimale avere tra 10 e 50 richieste in attesa per connessione. Questo concetto è descritto in maggiore dettaglio in Pool di connessione.

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

I passaggi che seguono ti aiutano a calcolare il numero ottimale di connessioni nel 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 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 risultato del 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 del pool di canali ottimale.

Questi passaggi sono espressi nelle seguenti equazioni:

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

• (QPS sec ÷ (1000 ÷ latenza ms)) ÷ 10 stream = Numero ottimale massimo 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 in uscita contemporaneamente e l'utilizzo del canale target deve essere 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 e ottieni 50. Ciò significa che la dimensione del pool di canali per questo esempio deve essere compresa tra 10 e 50 collegamenti.

Imposta la dimensione del pool

I seguenti esempi di codice mostrano come configurare il numero di pool nelle librerie client che ti consentono di impostare la dimensione del pool.

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
}

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());
    }
  }
}

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());
    }
  }
}

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