Citrix ADC Ingress Controller

Ermöglichen der gRPC-Unterstützung mit dem Citrix Ingress Controller

gRPC ist ein leistungsstarkes, universelles Open-Source-RPC-Framework, das von Google entwickelt wurde. In gRPC kann eine Clientanwendung Methoden auf einer Serveranwendung direkt von einem anderen Server aus aufrufen, so wie Sie lokale Methoden aufrufen. Mit GRPC können Sie ganz einfach verteilte Anwendungen und Dienste erstellen.

gRPC-Unterstützung aktivieren

Führen Sie die folgenden Schritte aus, um die GRPC-Unterstützung mit HTTP2 zu aktivieren.

  1. Erstellen Sie eine YAML-Datei cic-configmap.yaml und aktivieren Sie den globalen Parameter für die serverseitige HTTP2-Unterstützung mithilfe des folgenden Eintrags in der ConfigMap. Weitere Informationen zur Verwendung von ConfigMap finden Sie in der ConfigMap-Dokumentation.

       NS_HTTP2_SERVER_SIDE: 'ON'
    
  2. Wenden Sie die ConfigMap mit dem folgenden Befehl an.

       kubectl apply -f cic-configmap.yaml
    
  3. Bearbeiten Sie die cic.yaml Datei für die Bereitstellung des Citrix Ingress Controller zur Unterstützung von ConfigMap.

            args:
              - --ingress-classes
                citrix
              - --configmap
                default/cic-configmap
    
  4. Stellen Sie den Citrix Ingress Controller als eigenständigen Pod bereit, indem Sie die bearbeitete YAML-Datei anwenden.

    kubectl apply -f cic.yaml
    
  5. Um den gRPC-Verkehr zu testen, müssen Sie möglicherweise installieren grpcurl. Führen Sie die folgenden Schritte aus, um grpcurl auf einem Linux-Computer zu installieren.

    go get github.com/fullstorydev/grpcurl
    go install github.com/fullstorydev/grpcurl/cmd/grpcurl
    
  6. Wenden Sie die gRPC-Testdienst-YAML-Datei (grpc-service.yaml) an.

    kubectl apply -f grpc-service.yaml
    

    Es folgt ein Beispiel für den Inhalt der grpc-service.yaml Datei.

      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. Erstellen Sie ein Zertifikat für die gRPC-Ingress-Konfiguration.

    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. Aktivieren Sie HTTP2 mithilfe von Ingress-Anmerkungen. Unter HTTP/2-Unterstützung finden Sie Schritte zum Aktivieren von HTTP2 mit dem Citrix Ingress Controller.

    • Erstellen Sie eine YAML-Datei für die Front-End-Ingress-Konfiguration und wenden Sie sie an, um HTTP/2 auf dem virtuellen Content Switching-Server zu aktivieren.

      kubectl wendet -f frontend-ingress.yaml an

    Der Inhalt der Datei frontend-ingress.yaml wird wie folgt bereitgestellt:

      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:
        - {}
    
    • Erstellen Sie eine YAML-Datei für die Back-End-Ingress-Konfiguration mit dem folgenden Inhalt und wenden Sie sie an, um HTTP2 im Back-End (Servicegruppe) zu aktivieren.

      kubectl wendet -f backend-ingress.yaml an

    Der Inhalt der Datei backend-ingress.yaml wird wie folgt bereitgestellt:

      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. Testen Sie den gRPC-Verkehr mit dem Befehl grpcurl.

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

    Die Ausgabe des Befehls wird wie folgt angezeigt:

    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
    

Validierung der CRD für das Ratenlimit

Führen Sie die folgenden Schritte aus, um die CRD für das Ratenlimit

  1. Wenden Sie die CRD für das Ratenlimit mithilfe der Datei ratelimit-crd.yaml an.

    kubectl create -f ratelimit-crd.yaml

  2. Erstellen Sie eine YAML-Datei (ratelimit-crd-object.yaml) mit folgendem Inhalt für die Ratenlimitrichtlinie.

      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. Wenden Sie die YAML-Datei mit dem folgenden Befehl an.

      kubectl create -f ratelimit-crd-object.yaml
    
  4. Testen Sie den gRPC-Verkehr mit dem Befehl grpcurl.

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

    Der Befehl gibt den folgenden Fehler als Antwort zurück, nachdem das Ratenlimit erreicht wurde:

    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
    

Validieren Sie die Rewrite- und Responder-CRD mit gRPC

Führen Sie die folgenden Schritte aus, um die Rewrite- und Responder-CRD zu validieren.

  1. Wenden Sie die Rewrite- und Responder-CRD mit der Datei rewrite-responder-policies-deployment.yaml an.

    kubectl create -f Rewrite-Responder-Policies-deployment.yaml

  2. Erstellen Sie eine YAML-Datei (rewrite-crd-object.yaml) mit dem folgenden Inhalt für die Rewrite-Richtlinie.

    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. Wenden Sie die YAML-Datei mit dem folgenden Befehl an.

    kubectl create -f rewrite-crd-object.yaml
    
  4. Testen Sie den gRPC-Verkehr mit dem Befehl grpcurl.

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

    Dieser Befehl fügt eine Sitzungskennung in der gRPC-Anforderungsantwort hinzu.

    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
    
Ermöglichen der gRPC-Unterstützung mit dem Citrix Ingress Controller