O cliente Java para o modo Datastore oferece o gRPC como uma opção de camada de transporte. A utilização do conjunto de ligações gRPC permite distribuir RPCs por várias ligações, o que pode melhorar o desempenho.
Antes de começar
Instale
a versão mais recente da biblioteca google-cloud-datastore.
Como ativar o comportamento de transporte gRPC
Para ativar o comportamento de transporte gRPC, adicione setTransportOptions à
instanciação do cliente:
Java
DatastoreOptions datastoreOptions = DatastoreOptions.newBuilder() .setProjectId("my-project") .setDatabaseId("my-database") .setTransportOptions(GrpcTransportOptions.newBuilder().build()) .build();
A definição explícita das opções de transporte para GrpcTransportOptions configura o cliente para usar o gRPC em vez do HTTP quando faz chamadas para o servidor.
Desative o comportamento de transporte gRPC
Pode desativar o comportamento de transporte gRPC revertendo para o comportamento de transporte HTTP. Para tal, remova a linha de código .setTransportOptions ou substitua GrpcTransportOptions por HttpTransportOptions.
Também tem de recriar e reiniciar a aplicação.
Java
// Use this code to deactivate the gRPC transport behavior // by reverting to the HTTP transport behavior. DatastoreOptions datastoreOptions = DatastoreOptions.newBuilder() .setProjectId("my-project") .setDatabaseId("my-database") .build(); // You can also use this code to revert to the HTTP transport behavior DatastoreOptions datastoreOptions = DatastoreOptions.newBuilder() .setProjectId("my-project") .setDatabaseId("my-database") .setTransportOptions(HttpTransportOptions.newBuilder() .setConnectTimeout(1000) .build()) .build();
Valide as opções de transporte
Para verificar que tipo de TransportOptions o cliente usa, examine o tipo de opções de transporte:
Java
// Compares datastore transport options type boolean isGRPC = datastore.getOptions().getTransportOptions() instanceof GrpcTransportOptions; boolean isHTTP = datastore.getOptions().getTransportOptions() instanceof HTTPTransportOptions;
Configuração do conjunto de ligações
Um conjunto de ligações, também conhecido como conjunto de canais, é uma cache de ligações à base de dados que o cliente partilha e reutiliza para melhorar a latência e o desempenho das ligações. Para melhorar o desempenho da sua aplicação, configure o conjunto de ligações.
Esta secção ajuda a determinar o tamanho ideal do conjunto de ligações e demonstra como configurá-lo na biblioteca de cliente Java.
Determine o melhor tamanho do conjunto de ligações
O tamanho predefinido do conjunto de ligações é adequado para a maioria das aplicações e, na maioria dos casos, não é necessário alterá-lo. No entanto, pode querer alterar o tamanho do conjunto de ligações devido ao elevado débito ou aos pedidos em buffer.
Idealmente, para deixar espaço para flutuações de tráfego, um conjunto de ligações tem cerca do dobro do número de ligações necessárias para a saturação máxima. Uma vez que uma ligação pode processar um máximo de 100 pedidos simultâneos, recomendamos que tenha entre 10 e 50 pedidos pendentes por ligação. A camada de middleware aplica o limite de 100 streams simultâneas por ligação gRPC, e este limite não é configurável. Para calcular o número ideal de ligações no seu conjunto de ligações, usando um QPS estimado por cliente e números de latência média, faça o seguinte:
A partir das métricas do lado do cliente, recolha as seguintes informações e faça os seguintes cálculos:
- Determine o número máximo de consultas por segundo (CPS) por cliente quando a sua aplicação executa uma carga de trabalho.
- Determine a latência média (o tempo de resposta para um único pedido) em ms.
- Determine o número de pedidos que pode enviar em série por segundo dividindo 1000 pelo valor de latência médio.
- Divida o CPS em segundos pelo número de pedidos em série por segundo.
- Divida o resultado por 50 pedidos por canal para determinar o tamanho mínimo ideal do conjunto de ligações. (Se o cálculo for inferior a 2, use, mesmo assim, pelo menos 2 canais para garantir a redundância.)
- Divida o mesmo resultado por 10 pedidos por canal para determinar o tamanho máximo ideal do conjunto de ligações.
Para realizar estes passos, use as seguintes equações:
(QPS sec ÷ (1,000 ÷ latency ms)) ÷ 50 streams = Minimum optimal number of
connections
(QPS sec ÷ (1,000 ÷ latency ms)) ÷ 10 streams = Maximum optimal number of
connections
Por exemplo, se a sua aplicação enviar normalmente 50 000 pedidos por segundo e a latência média for de 10 ms, divida 1000 por 10 ms para determinar que pode enviar 100 pedidos em série por segundo. Divida esse número por 50 000 para obter o paralelismo necessário para enviar 50 000 QPS: 500.
Cada canal pode ter, no máximo, 100 pedidos em simultâneo e a utilização do canal de destino está entre 10 e 50 streams simultâneas. Por conseguinte, para calcular o tamanho mínimo do conjunto de ligações, divida 500 por 50 para obter 10. Para encontrar o tamanho máximo do conjunto de ligações, divida 500 por 10 para obter 50.
Isto significa que o tamanho do conjunto de ligações para este exemplo está entre 10 e 50 ligações. Também é importante monitorizar o tráfego depois de fazer estas alterações e ajustar o número de ligações no seu conjunto, conforme necessário.
Defina o tamanho do conjunto
O exemplo de código seguinte demonstra como configurar o conjunto de ligações nas bibliotecas de cliente através de DatastoreOptions.
Java
InstantiatingGrpcChannelProvider channelProvider = DatastoreSettings.defaultGrpcTransportProviderBuilder() .setChannelPoolSettings( ChannelPoolSettings.builder() .setInitialChannelCount(MIN_VAL) .setMaxChannelCount(MAX_VAL) .build()) .build(); DatastoreOptions options = DatastoreOptions.newBuilder() .setProjectId("my-project") .setChannelProvider(channelProvider) .setTransportOptions(GrpcTransportOptions.newBuilder().build()) .build();
O que se segue?
Para mais informações sobre os conjuntos de ligações e as práticas recomendadas para o desempenho, consulte: