Esta página se ha traducido con Cloud Translation API.

Configurar grupos de conexión

Algunas bibliotecas de cliente de Cloud Bigtable te permiten configurar el número de canales gRPC en el grupo de conexiones de un cliente, también conocido como grupo de canales. En la mayoría de los casos, la configuración predeterminada es correcta y no es necesario cambiarla.

Los grupos de conexiones se redimensionan automáticamente según sea necesario cuando usas la biblioteca de cliente de Cloud Bigtable para Java versión 2.23.0 o posterior, y cuando usas el cliente de HBase de Cloud Bigtable para Java versión 2.9.1 o posterior.

En esta página se describe cómo determinar el tamaño óptimo del grupo de conexiones de tu aplicación y se muestran fragmentos de código que explican cómo configurar los grupos de conexiones.

Antes de leer esta página, consulta la descripción general de los grupos de conexiones de Bigtable para saber cómo funcionan y si deberías cambiar los tuyos.

Las siguientes bibliotecas de cliente ofrecen la agrupación de conexiones y te permiten configurar el número de grupos:

Determinar el tamaño óptimo del grupo de conexiones

Lo ideal es que un grupo de conexiones tenga aproximadamente el doble de conexiones de las que necesita para alcanzar la saturación máxima, de modo que haya margen para las fluctuaciones del tráfico. Como una conexión puede gestionar un máximo de 100 solicitudes simultáneas, lo ideal es que haya entre 10 y 50 solicitudes pendientes por conexión. Este concepto se describe con más detalle en Grupos de conexiones.

Monitoriza el tráfico después de hacer cambios y ajusta el número de conexiones de tu grupo si es necesario.

Los pasos que se indican a continuación te ayudarán a calcular el número óptimo de conexiones de tu grupo de canales mediante métricas del lado del cliente, como las que ofrece OpenCensus.

A partir de las métricas del lado del cliente, recopila la siguiente información:
1. El número máximo de consultas por segundo (CPS) por cliente cuando tu aplicación ejecuta una carga de trabajo típica.
2. Latencia media (tiempo de respuesta de una sola solicitud) en milisegundos.
Para determinar el número de solicitudes que puede enviar en serie por segundo,divida 1000 entre el valor de latencia medio.
Divide las consultas por segundo entre el número de solicitudes en serie por segundo.
Divide el resultado entre 50 solicitudes por canal para determinar el tamaño mínimo óptimo del grupo de canales. Si el resultado es inferior a 2, utiliza al menos 2 canales para asegurar la redundancia.
Divide el mismo resultado entre 10 solicitudes por canal para determinar el tamaño máximo óptimo del grupo de canales.

Estos pasos se expresan en las siguientes ecuaciones:

(QPS por segundo ÷ (1000 ÷ latencia en ms)) ÷ 50 flujos = número mínimo óptimo de conexiones
(CPS ÷ (1000 ÷ latencia en ms)) ÷ 10 flujos = número óptimo máximo de conexiones

Ejemplo

Tu aplicación suele enviar 50.000 solicitudes por segundo y la latencia media es de 10 ms. Divide 1000 entre 10 ms para determinar que puedes enviar 100 solicitudes en serie por segundo. Divide ese número entre 50.000 para obtener el paralelismo necesario para enviar 50.000 CPS: 500. Cada canal puede tener un máximo de 100 solicitudes simultáneas, y la utilización del canal de destino debe estar entre 10 y 50 transmisiones simultáneas. Por lo tanto, para calcular el mínimo, divide 500 entre 50 para obtener 10. Para encontrar el máximo, divide 500 entre 10 para obtener 50. Esto significa que el tamaño del grupo de canales de este ejemplo debe estar entre 10 y 50 conexiones.

Establecer el tamaño de la piscina

En los siguientes ejemplos de código se muestra cómo configurar el número de grupos en las bibliotecas de cliente que permiten definir el tamaño del grupo.

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

Esta muestra solo se aplica a las versiones de la biblioteca de cliente anteriores a la 2.9.1, cuando se introdujo el cambio de tamaño automático.



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

Este ejemplo solo se aplica a las versiones de la biblioteca de cliente anteriores a la 2.23.0, cuando se introdujo el cambio de tamaño automático.


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