Ingress Controller de Citrix ADC

Habilitar la compatibilidad con gRPC mediante el Citrix Ingress Controller

gRPC es un marco RPC universal de alto rendimiento y código abierto creado por Google. En gRPC, una aplicación cliente puede llamar directamente a los métodos en una aplicación de servidor desde un servidor diferente de la misma manera que se llama a los métodos locales. Puede crear aplicaciones y servicios distribuidos fácilmente con GRPC.

Habilitar el soporte gRPC

Realice los siguientes pasos para habilitar la compatibilidad con GRPC mediante HTTP2.

  1. Cree un archivo YAML cic-configmap.yaml y habilite el parámetro global para la compatibilidad del lado del servidor HTTP2 mediante la siguiente entrada en ConfigMap. Para obtener más información sobre el uso de ConfigMap, consulta la documentación de ConfigMap.

       NS_HTTP2_SERVER_SIDE: 'ON'
    
  2. Aplique el ConfigMap mediante el siguiente comando.

       kubectl apply -f cic-configmap.yaml
    
  3. Modifique el archivo cic.yaml para implementar el Citrix Ingress Controller para admitir ConfigMap.

            args:
              - --ingress-classes
                citrix
              - --configmap
                default/cic-configmap
    
  4. Implemente el Citrix Ingress Controller como un pod independiente aplicando el archivo YAML modificado.

    kubectl apply -f cic.yaml
    
  5. Para probar el tráfico de gRPC, es posible que necesite instalar grpcurl. Realice los siguientes pasos para instalar grpcurl en una máquina Linux.

    go get github.com/fullstorydev/grpcurl
    go install github.com/fullstorydev/grpcurl/cmd/grpcurl
    
  6. Aplique el archivo YAML del servicio de prueba gRPC (grpc-service.yaml).

    kubectl apply -f grpc-service.yaml
    

    A continuación se muestra un ejemplo de contenido para el archivo 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. Cree un certificado para la configuración de gRPC Ingress.

    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. Habilite HTTP2 mediante anotaciones de entrada. Consulte Compatibilidad con HTTP/2 para ver los pasos para habilitar HTTP2 mediante el Citrix Ingress Controller.

    • Cree un archivo YAML para la configuración de Ingress front-end y aplíquelo para habilitar HTTP/2 en el servidor virtual de conmutación de contenido.

      kubectl aplica -f frontend-ingress.yaml

    El contenido del archivo frontend-ingress.yaml se proporciona de la siguiente manera:

      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:
        - {}
    
    • Cree un archivo YAML para la configuración de Ingress de back-end con el siguiente contenido y aplíquelo para habilitar HTTP2 en el back-end (grupo de servicios).

      kubectl apply -f backend-ingress.yaml

    El contenido del archivo backend-ingress.yaml se proporciona de la siguiente manera:

      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. Pruebe el tráfico de gRPC con el comando grpcurl.

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

    El resultado del comando se muestra de la siguiente manera:

    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
    

Validar la CRD de límite de velocidad

Realice los siguientes pasos para validar el CRD de límite de velocidad.

  1. Aplica el CRD de límite de velocidad mediante el archivo ratelimit-crd.yaml.

    kubectl crea -f ratelimit-crd.yaml

  2. Crea un archivo YAML (ratelimit-crd-object.yaml) con el siguiente contenido para la directiva de límite de velocidad.

      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. Aplique el archivo YAML mediante el siguiente comando.

      kubectl create -f ratelimit-crd-object.yaml
    
  4. Pruebe el tráfico de gRPC con el comando grpcurl.

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

    El comando devuelve el siguiente error en respuesta una vez que se alcanza el límite de velocidad:

    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
    

Validar la CRD de reescritura y respuesta con gRPC

Realice los siguientes pasos para validar la CRD de reescritura y respuesta.

  1. Aplique la CRD de reescritura y respuesta mediante el archivo rewrite-responder-policies-deployment.yaml.

    kubectl create -f rewrite-responder-policies-deployment.yaml

  2. Crea un archivo YAML (rewrite-crd-object.yaml) con el siguiente contenido para la directiva de reescritura.

    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. Aplique el archivo YAML mediante el siguiente comando.

    kubectl create -f rewrite-crd-object.yaml
    
  4. Pruebe el tráfico de gRPC con el comando grpcurl.

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

    Este comando agrega un identificador de sesión en la respuesta a la solicitud de 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
    
Habilitar la compatibilidad con gRPC mediante el Citrix Ingress Controller