Contrôleur d'entrée Citrix ADC

Activer la prise en charge de gRPC à l’aide du Citrix ingress controller

gRPC est un framework RPC universel haute performance et open source créé par Google. Dans gRPC, une application cliente peut appeler directement des méthodes sur une application serveur à partir d’un serveur différent de la même manière que vous appelez des méthodes locales. Vous pouvez facilement créer des applications et des services distribués à l’aide de GRPC.

Activer le support gRPC

Effectuez les étapes suivantes pour activer la prise en charge GRPC à l’aide de HTTP2.

  1. Créez un fichier YAML cic-configmap.yaml et activez le paramètre global pour la prise en charge côté serveur HTTP2 à l’aide de l’entrée suivante dans ConfigMap. Pour plus d’informations sur l’utilisation de ConfigMap, consultez la documentation ConfigMap.

       NS_HTTP2_SERVER_SIDE: 'ON'
    
  2. Appliquez le ConfigMap à l’aide de la commande suivante.

       kubectl apply -f cic-configmap.yaml
    
  3. Modifiez le fichier cic.yaml pour déployer le Citrix ingress controller pour prendre en charge ConfigMap.

            args:
              - --ingress-classes
                citrix
              - --configmap
                default/cic-configmap
    
  4. Déployez le Citrix ingress controller en tant qu’espace autonome en appliquant le fichier YAML modifié.

    kubectl apply -f cic.yaml
    
  5. Pour tester le trafic gRPC, vous devrez peut-être installer grpcurl. Effectuez les étapes suivantes pour effectuer l’installation grpcurl sur un ordinateur Linux.

    go get github.com/fullstorydev/grpcurl
    go install github.com/fullstorydev/grpcurl/cmd/grpcurl
    
  6. Appliquez le fichier YAML du service de test gRPC (grpc-service.yaml).

    kubectl apply -f grpc-service.yaml
    

    Voici un exemple de contenu pour le fichier grpc-service.yaml.

      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: grpc-service
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: grpc-service
        template:
          metadata:
            labels:
              app: grpc-service
          spec:
            containers:
            - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/grpc-server:latest
              imagePullPolicy: Always
              name: grpc-service
              ports:
              - containerPort: 50051
                protocol: TCP
            restartPolicy: Always
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: grpc-service
      spec:
        ports:
        - port: 50051
          protocol: TCP
          targetPort: 50051
        selector:
          app: grpc-service
        sessionAffinity: None
        type: NodePort
    
  7. Créez un certificat pour la configuration d’entrée gRPC.

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=grpc.example.com/O=grpc.example.com"
           
    kubectl create secret tls grpc-secret --key tls.key --cert tls.crt
    
    secret "grpc-secret" created
    
  8. Activez HTTP2 à l’aide des annotations d’entrée. Consultez la section Prise en charge HTTP/2 pour connaître les étapes à suivre pour activer HTTP2 à l’aide du contrôleur

    • Créez un fichier YAML pour la configuration d’entrée frontale et appliquez-le pour activer HTTP/2 sur le serveur virtuel de commutation de contenu.

      kubectl apply -f frontend-ingress.yaml

    Le contenu du fichier frontend-ingress.yaml est fourni comme suit :

      apiVersion: networking.k8s.io/v1
      kind: Ingress
      metadata:
        annotations:
          ingress.citrix.com/frontend-httpprofile: '{"http2":"enabled", "http2direct" : "enabled"}'
          ingress.citrix.com/frontend-ip: 192.0.2.1
          ingress.citrix.com/secure-port: "443"
          kubernetes.io/ingress.class: citrix
        name: frontend-ingress
      spec:
        rules:
        - {}
        tls:
        - {}
    
    • Créez un fichier YAML pour la configuration d’entrée principale avec le contenu suivant et appliquez-le pour activer HTTP2 sur le back-end (groupe de services).

      kubectl apply -f backend-ingress.yaml

    Le contenu du fichier backend-ingress.yaml est fourni comme suit :

      apiVersion: networking.k8s.io/v1
      kind: Ingress
      metadata:
        annotations:
          ingress.citrix.com/backend-httpprofile: '{"grpc-service":{"http2": "enabled", "http2direct" : "enabled"}}'
          ingress.citrix.com/frontend-ip: 192.0.2.2
          ingress.citrix.com/secure-port: "443"
          kubernetes.io/ingress.class: citrix
        name: grpc-ingress
      spec:
        rules:
        - host: grpc.example.com
          http:
            paths:
            - backend:
                service:
                  name: grpc-service
                  port:
                    number: 50051
              path: /
              pathType: Prefix
        tls:
        - hosts:
          - grpc.example.com
          secretName: grpc-secret
    
  9. Testez le trafic gRPC à l’aide de la commande grpcurl.

    grpcurl -v -insecure -d '{"name": "gRPC"}' grpc.example.com:443 helloworld.Greeter.SayHello
    

    La sortie de la commande est affichée comme suit :

    Resolved method descriptor:
    rpc SayHello ( .helloworld.HelloRequest ) returns ( .helloworld.HelloReply );
    
    
    Request metadata to send:
    (empty)
     
    
    Response headers received:
    content-type: application/grpc
    
    
    Response contents:
    {
        "message": "Hello gRPC"
    }
     
    
    Response trailers received:
    (empty)
    Sent 1 request and received 1 response
    

Valider la limite de taux CRD

Effectuez les étapes suivantes pour valider la limite de taux CRD.

  1. Appliquez le CRD de limite de taux à l’aide du fichier ratelimit-crd.yaml .

    kubectl crée -f limite de débit -crd.yaml

  2. Créez un fichier YAML (ratelimit-crd-object.yaml) avec le contenu suivant pour la stratégie de limite de débit.

      apiVersion: citrix.com/v1beta1
      kind: ratelimit
      metadata:
        name: throttle-req-per-clientip
      spec:
        servicenames:
          - grpc-service
        selector_keys:
        basic:
          path:
          - "/"
          per_client_ip: true
        req_threshold: 5
        timeslice: 60000
        throttle_action: "RESPOND"
    
  3. Appliquez le fichier YAML à l’aide de la commande suivante.

      kubectl create -f ratelimit-crd-object.yaml
    
  4. Testez le trafic gRPC à l’aide de la commande grpcurl.

    grpcurl -v -insecure -d '{"name": "gRPC"}' grpc.example.com:443 helloworld.Greeter.SayHello
    

    La commande renvoie l’erreur suivante en réponse une fois la limite de débit atteinte :

    Error invoking method "helloworld.Greeter.SayHello": failed to query for service descriptor "helloworld.Greeter": rpc error: code = Unavailable desc =
    
    Too Many Requests: HTTP status code 429; transport: missing content-type field
    

Valider le CRD de réécriture et de répondeur avec gRPC

Effectuez les étapes suivantes pour valider le CRD de réécriture et de répondeur.

  1. Appliquez le CRD de réécriture et de répondeur à l’aide du fichier rewrite-responder-policies-deployment.yaml .

    kubectl create -f réécrite-répondeur-stratégies-déploiement.yaml

  2. Créez un fichier YAML (rewrite-crd-object.yaml) avec le contenu suivant pour la stratégie de réécriture.

    apiVersion: citrix.com/v1
    kind: rewritepolicy
    metadata:
      name: addcustomheaders
    spec:
      rewrite-policies:
        - servicenames:
            - grpc-service
          rewrite-policy:
            operation: insert_http_header
            target: 'sessionID'
            modify-expression: '"48592th42gl24456284536tgt2"'
            comment: 'insert SessionID in header'
            direction: RESPONSE
            rewrite-criteria: 'http.res.is_valid'
    
  3. Appliquez le fichier YAML à l’aide de la commande suivante.

    kubectl create -f rewrite-crd-object.yaml
    
  4. Testez le trafic gRPC à l’aide de la commande grpcurl.

    grpcurl -v -insecure -d '{"name": "gRPC"}' grpc.example.com:443 helloworld.Greeter.SayHello
    

    Cette commande ajoute un identifiant de session dans la réponse à la demande gRPC.

    Resolved method descriptor:
    rpc SayHello ( .helloworld.HelloRequest ) returns ( .helloworld.HelloReply );
    
    Request metadata to send:
    (empty)
    
    Response headers received:
    content-type: application/grpc
    sessionid: 48592th42gl24456284536tgt2
    
    Response contents:
    {
      "message": "Hello gRPC"
    }
    
    Response trailers received:
    (empty)
    Sent 1 request and received 1 response
    
Activer la prise en charge de gRPC à l’aide du Citrix ingress controller