NetScaler Ingress Controller

Habilite la compatibilidad con gRPC mediante el controlador NetScaler Ingress

May 10, 2023

Contribución de:

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.

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'
```
Aplique el ConfigMap mediante el siguiente comando.
```
   kubectl apply -f cic-configmap.yaml
```

Edite el cic.yaml archivo para implementar el controlador NetScaler Ingress para que sea compatible con ConfigMap.

        args:
          - --ingress-classes
            citrix
          - --configmap
            default/cic-configmap

Implemente el NetScaler Ingress Controller como un pod independiente mediante la aplicación del archivo YAML editado.
```
kubectl apply -f cic.yaml
```
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
```

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

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

Habilite HTTP2 mediante anotaciones de entrada. Consulte la compatibilidad con HTTP/2 para conocer los pasos para habilitar HTTP/2 mediante el controlador NetScaler Ingress.

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

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.

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

kubectl crea -f ratelimit-crd.yaml

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"

Aplique el archivo YAML mediante el siguiente comando.
```
  kubectl create -f ratelimit-crd-object.yaml
```

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.

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

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

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'

Aplique el archivo YAML mediante el siguiente comando.
```
kubectl create -f rewrite-crd-object.yaml
```

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

La versión oficial de este contenido está en inglés. Para mayor comodidad, parte del contenido de la documentación de Cloud Software Group solo tiene traducción automática. Cloud Software Group no puede controlar el contenido con traducción automática, que puede contener errores, imprecisiones o un lenguaje inadecuado. No se ofrece ninguna garantía, ni implícita ni explícita, en cuanto a la exactitud, la fiabilidad, la idoneidad o la precisión de las traducciones realizadas del original en inglés a cualquier otro idioma, o que su producto o servicio de Cloud Software Group se ajusten a cualquier contenido con traducción automática, y cualquier garantía provista bajo el contrato de licencia del usuario final o las condiciones de servicio, o cualquier otro contrato con Cloud Software Group, de que el producto o el servicio se ajusten a la documentación no se aplicará en cuanto dicha documentación se ha traducido automáticamente. Cloud Software Group no se hace responsable de los daños o los problemas que puedan surgir del uso del contenido traducido automáticamente.

¿Le ha resultado útil?

Habilite la compatibilidad con gRPC mediante el controlador NetScaler Ingress

May 10, 2023

Contribución de:

May 10, 2023

Contribución de:

En este artículo

Habilitar el soporte gRPC
Validar la CRD de límite de velocidad
Validar la CRD de reescritura y respuesta con gRPC

¿Le ha resultado útil?