Container Compute Service:Deploy a gRPC Service in Knative

Prérequis

Avant de commencer, assurez-vous que :

• Knative est déployé dans votre cluster ACS. Consultez la rubrique Déployer Knative.

Fonctionnement

1. Déployez un service Knative avec un port de conteneur nommé h2c. Knative Ingress détecte cette configuration et active le routage HTTP/2 pour le trafic gRPC.

2. Associez le nom de domaine par défaut du service à l'adresse IP de la passerelle dans votre fichier hosts local.

3. Envoyez une requête gRPC au nom de domaine sur le port 80. Knative la dirige alors vers le conteneur approprié.

Le chemin gRPC suit le format {package}.{ServiceName}/{MethodName}. Par exemple, grpcbin.GRPCBin/Index correspond à la méthode Index du service GRPCBin dans le package grpcbin.

Déployer un service gRPC

1. Connectez-vous à la console ACS. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Sur la page Clusters, localisez le cluster à gérer et cliquez sur son ID. Dans le volet de navigation de gauche de la page de détails du cluster, choisissez Applications > Knative.

3. Sur la page Knative, cliquez sur l'onglet Services. Définissez le Namespace sur default, cliquez sur Create from Template, puis sélectionnez Custom dans la liste déroulante Sample Template.

4. Copiez le code YAML suivant dans l'éditeur de modèle, puis cliquez sur Create. L'élément essentiel de la configuration gRPC est name: h2c dans la section ports. Cela indique à Knative Ingress d'acheminer le trafic via HTTP/2.

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: helloworld-grpc
   spec:
     template:
       metadata:
         annotations:
           autoscaling.knative.dev/class: mpa.autoscaling.knative.dev
       spec:
         containers:
         - image: docker.io/moul/grpcbin
           env:
           - name: TARGET
             value: "Knative"
           ports:
           - containerPort: 9000
             name: h2c  # Required: tells Knative to use HTTP/2 for gRPC routing
             protocol: TCP

5. Une fois le service créé, ajoutez une entrée dans votre fichier hosts pour associer le nom de domaine par défaut du service à l'adresse IP de la passerelle. Sous l'onglet Services, repérez les colonnes Default Domain et Gateway correspondant au service helloworld-grpc. Ajoutez ensuite une entrée à votre fichier hosts local en respectant le format suivant :

   <gateway-ip> <default-domain>

   Exemple :

   121.xx.xxx.xx helloworld-grpc.default.example.com

Vérifier le service gRPC

Utilisez BloomRPC pour envoyer une requête de test et confirmer que le service répond correctement.

1. Accédez à la page grpcbin et installez la version de BloomRPC adaptée à votre système d'exploitation.

2. Enregistrez la définition proto suivante dans un fichier nommé gRPC.proto sur votre machine locale :

   syntax = "proto3";
   
   package grpcbin;
   
   service GRPCBin {
     rpc Index(EmptyMessage) returns (IndexReply) {}
     // Unary: takes an empty message, returns an empty message
     rpc Empty(EmptyMessage) returns (EmptyMessage) {}
     // Unary: takes a DummyMessage, returns a DummyMessage
     rpc DummyUnary(DummyMessage) returns (DummyMessage) {}
     // Server streaming: takes a DummyMessage, streams 10 DummyMessages
     rpc DummyServerStream(DummyMessage) returns (stream DummyMessage) {}
     // Client streaming: streams DummyMessages, returns a DummyMessage
     rpc DummyClientStream(stream DummyMessage) returns (DummyMessage) {}
     // Bidirectional streaming: streams DummyMessages in both directions
     rpc DummyBidirectionalStreamStream(stream DummyMessage) returns (stream DummyMessage) {}
     // Returns a specific gRPC error
     rpc SpecificError(SpecificErrorRequest) returns (EmptyMessage) {}
     // Returns a random gRPC error
     rpc RandomError(EmptyMessage) returns (EmptyMessage) {}
     // Unary: returns response headers
     rpc HeadersUnary(EmptyMessage) returns (HeadersMessage) {}
     // Unary: sends a message but returns no response
     rpc NoResponseUnary(EmptyMessage) returns (EmptyMessage) {}
   }
   
   message HeadersMessage {
     message Values {
       repeated string values = 1;
     }
     map<string, Values> Metadata = 1;
   }
   
   message SpecificErrorRequest {
     uint32 code = 1;
     string reason = 2;
   }
   
   message EmptyMessage {}
   
   message DummyMessage {
     message Sub {
       string f_string = 1;
     }
     enum Enum {
       ENUM_0 = 0;
       ENUM_1 = 1;
       ENUM_2 = 2;
     }
     string f_string = 1;
     repeated string f_strings = 2;
     int32 f_int32 = 3;
     repeated int32 f_int32s = 4;
     Enum f_enum = 5;
     repeated Enum f_enums = 6;
     Sub f_sub = 7;
     repeated Sub f_subs = 8;
     bool f_bool = 9;
     repeated bool f_bools = 10;
     int64 f_int64 = 11;
     repeated int64 f_int64s= 12;
     bytes f_bytes = 13;
     repeated bytes f_bytess = 14;
     float f_float = 15;
     repeated float f_floats = 16;
   }
   
   message IndexReply {
     message Endpoint {
       string path = 1;
       string description = 2;
     }
     string description = 1;
     repeated Endpoint endpoints = 2;
   }

3. Importez le fichier gRPC.proto dans BloomRPC.

4. Dans le volet de navigation de gauche de BloomRPC, cliquez sur DummyUnary. Dans la barre d'adresse supérieure, saisissez helloworld-grpc.default.example.com:80.

5. Cliquez sur le bouton d'exécution vert. Si le serveur renvoie une réponse, le service gRPC fonctionne correctement.

Étapes suivantes

Configurez un certificat TLS pour exposer votre service Knative via HTTPS avec un nom de domaine personnalisé. Consultez la rubrique Configurer un certificat pour accéder aux services Knative via HTTPS.