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

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.

In questa pagina viene descritto come determinare la dimensione ottimale del pool di connessioni per e presenta snippet di codice che mostrano come configurare pool di connessioni.

Prima di leggere questa pagina, leggi la panoramica di Pool di connessioni Bigtable per scoprire come e se devi cambiare la tua.

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

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 viene descritto in per maggiori dettagli 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 consentono di calcolare il numero ottimale di connessioni in il pool di canali utilizzando le metriche lato client come quelle disponibili OpenCensus.

Dalle metriche lato client, raccogli le seguenti informazioni:
1. Il numero massimo di query al secondo (QPS) per client quando dell'applicazione esegue un carico di lavoro tipico.
2. La latenza media (il tempo di risposta per una singola richiesta) in ms.
Per determinare il numero di richieste che puoi inviare in serie al secondo, dividendo 1000 per il valore di latenza media.
Dividi il 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 del calcolo è inferiore a 2, utilizza comunque almeno 2 canali per garantire la ridondanza.
Dividi lo stesso risultato per 10 richieste per canale in modo da determinare il numero massimo la dimensione ottimale del pool di canali.

Questi passaggi sono espressi nelle seguenti equazioni:

(QPS sec ÷ (1000 ÷ latenza ms)) ÷ 50 flussi = Minimo ottimale numero di connessioni
(QPS sec ÷ (1000 ÷ latenza ms)) ÷ 10 stream = Numero ottimale massimo di connessioni

Esempio

L'applicazione invia in genere 50.000 richieste al secondo e la latenza media è di 10 ms. Dividi 1000 per 10 ms per determinare che è possibile 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 per ottenere 50. Ciò significa che le dimensioni del pool di canali per questo esempio siano comprese tra 10 e 50 e connessioni a Internet.

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

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