Utiliser gRPC avec la bibliothèque cliente Java

Le client Java pour le mode Datastore propose gRPC comme option de couche de transport. L'utilisation du regroupement de connexions gRPC permet de répartir les RPC sur plusieurs connexions, ce qui peut améliorer les performances.

Avant de commencer

Installez la dernière version de la bibliothèque google-cloud-datastore.

Activer le comportement de transport gRPC

Pour activer le comportement de transport gRPC, ajoutez setTransportOptions à l'instanciation de votre client :

Java
DatastoreOptions datastoreOptions =
       DatastoreOptions.newBuilder()
               .setProjectId("my-project")
               .setDatabaseId("my-database")
               .setTransportOptions(GrpcTransportOptions.newBuilder().build())
               .build();

Si vous définissez explicitement les options de transport sur GrpcTransportOptions, le client est configuré pour utiliser gRPC au lieu de HTTP lorsqu'il effectue des appels au serveur.

Désactiver le comportement du transport gRPC

Vous pouvez désactiver le comportement de transport gRPC en revenant au comportement de transport HTTP. Pour ce faire, supprimez la ligne de code .setTransportOptions ou remplacez GrpcTransportOptions par HttpTransportOptions. Vous devez également recompiler et redémarrer votre application.

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

Vérifier les options de transport

Pour vérifier le type de TransportOptions utilisé par le client, examinez le type d'options de transport :

Java
// Compares datastore transport options type

boolean isGRPC = datastore.getOptions().getTransportOptions() instanceof GrpcTransportOptions;

boolean isHTTP = datastore.getOptions().getTransportOptions() instanceof HTTPTransportOptions;

Configuration du pool de connexions

Un pool de connexions, également appelé pool de canaux, est un cache de connexions à la base de données que le client partage et réutilise pour améliorer la latence et les performances de connexion. Pour améliorer les performances de votre application, configurez le pool de connexions.

Cette section vous aide à déterminer la taille optimale du pool de connexions et vous montre comment le configurer dans la bibliothèque cliente Java.

Déterminer la taille appropriée des pools de connexions

La taille du pool de connexions par défaut convient à la majorité des applications. Dans la plupart des cas, il n'est donc pas nécessaire de la modifier. Toutefois, vous pouvez modifier la taille de votre pool de connexions en raison d'un débit élevé ou de requêtes mises en mémoire tampon.

Dans l'idéal, pour faire face aux fluctuations de trafic, un pool de connexions a environ deux fois plus de connexions qu'il n'en faut pour arriver à saturation. Étant donné qu'une connexion peut gérer jusqu'à 100 requêtes simultanées, nous vous recommandons d'avoir entre 10 et 50 requêtes en attente par connexion. La couche middleware applique la limite de 100 flux simultanés par connexion gRPC. Cette limite n'est pas configurable. Pour calculer le nombre optimal de connexions dans votre pool de connexions à l'aide d'une estimation du nombre de requêtes par seconde et de la latence moyenne par client, procédez comme suit :

À l'aide des métriques côté client, collectez les informations suivantes et effectuez les calculs suivants :

  1. Déterminez le nombre maximal de requêtes par seconde (RPS) par client lorsque votre application exécute une charge de travail.
  2. Déterminez la latence moyenne (temps de réponse d'une seule requête) en ms.
  3. Déterminez le nombre de requêtes que vous pouvez envoyer en série par seconde en divisant 1 000 par la valeur de latence moyenne.
  4. Divisez le RPS en secondes par le nombre de requêtes en série par seconde.
  5. Divisez le résultat par 50 requêtes par canal pour déterminer la taille minimale optimale du pool de connexions. (Si votre calcul est inférieur à 2, utilisez au moins deux canaux pour assurer la redondance.)
  6. Divisez le même résultat par 10 requêtes par canal pour déterminer la taille maximale optimale du pool de connexions.

Pour effectuer ces étapes, utilisez les équations suivantes :

(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

Par exemple, si votre application envoie généralement 50 000 requêtes par seconde et que la latence moyenne est de 10 ms, divisez 1 000 par 10 ms pour déterminer si vous pouvez envoyer 100 requêtes en série par seconde. Divisez ce nombre par 50 000 pour obtenir le parallélisme nécessaire pour envoyer 50 000 RPS : 500.

Chaque canal peut envoyer au maximum 100 requêtes simultanément, et votre utilisation du canal cible est comprise entre 10 et 50 flux simultanés. Par conséquent, pour calculer la taille minimale du pool de connexions, divisez 500 par 50 pour obtenir 10. Pour trouver la taille maximale du pool de connexions, divisez 500 par 10 pour obtenir 50.

Cela signifie que la taille de votre pool de connexions pour cet exemple est comprise entre 10 et 50 connexions. Il est également important de surveiller votre trafic après avoir apporté ces modifications et d'ajuster le nombre de connexions dans votre pool, si nécessaire.

Définir la taille du pool

L'exemple de code suivant montre comment configurer le pool de connexions dans les bibliothèques clientes à l'aide 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();

Étapes suivantes

Pour en savoir plus sur les pools de connexions et les bonnes pratiques en matière de performances, consultez les ressources suivantes :