Usar HTTP/2 para el balanceo de carga con Ingress

En esta página se muestra cómo usar objetos Ingress yService de Kubernetes para configurar un balanceador de carga de aplicaciones externo que use HTTP/2 para comunicarse con los servicios de backend.

Información general

Un balanceador de carga de aplicaciones actúa como proxy entre tus clientes y tu aplicación. Los clientes pueden usar HTTP/1.1 o HTTP/2 para comunicarse con el proxy del balanceador de carga. Sin embargo, la conexión del proxy del balanceador de carga a tu aplicación usa HTTP/1.1 de forma predeterminada. Si tu aplicación, que se ejecuta en un pod de Google Kubernetes Engine (GKE), puede recibir solicitudes HTTP/2, puedes configurar el balanceador de carga externo para que use HTTP/2 cuando reenvíe solicitudes a tu aplicación.

En este ejercicio, crearás un Deployment, un Service y un Ingress. Añade una anotación cloud.google.com/app-protocols al manifiesto de tu servicio para especificar que el balanceador de carga debe usar HTTP/2 para comunicarse con tu aplicación. Después, llama a tu servicio y verifica que tu aplicación haya recibido una solicitud HTTP/2.

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.

• Consulta información sobre los recursos Ingress y Service de Kubernetes.
• Consulta las limitaciones de HTTP/2 para un balanceador de carga de aplicaciones externo.

Crear el despliegue

1. Copia el siguiente manifiesto en un archivo llamado my-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: echoheaders
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: echoheaders
     template:
       metadata:
         labels:
           app: echoheaders
       spec:
         containers:
         - name: echoheaders
           image: registry.k8s.io/echoserver:1.10
           ports:
           - containerPort: 8443
   

   Este manifiesto describe un Deployment con dos réplicas de la aplicación web echoheaders.

2. Aplica el manifiesto a tu clúster:

   kubectl apply -f my-deployment.yaml
   

Crear el servicio

1. Copia el siguiente manifiesto en un archivo llamado my-service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     annotations:
       cloud.google.com/app-protocols: '{"my-port":"HTTP2"}'
     name: echoheaders
     labels:
       app: echoheaders
   spec:
     type: NodePort
     ports:
     - port: 443
       targetPort: 8443
       protocol: TCP
       name: my-port
     selector:
       app: echoheaders
   

   Este manifiesto describe un servicio con las siguientes propiedades:

   • type: NodePort: especifica que se trata de un servicio de tipo NodePort.
   • app: echoheaders: especifica que cualquier pod que tenga esta etiqueta es miembro del servicio.
   • cloud.google.com/app-protocols: especifica que my-port debe usar el protocolo HTTP/2.
   • port: 443, protocol: TCP y targetPort: 8433: especifica que el tráfico dirigido al servicio en el puerto TCP 443 se debe enrutar al puerto TCP 8443 en uno de los pods miembros.

2. Aplica el manifiesto a tu clúster:

   kubectl apply -f my-service.yaml
   

3. Ver el servicio:

   kubectl get service echoheaders --output yaml
   

   El resultado debería ser similar al siguiente:

   apiVersion: v1
   kind: Service
   metadata:
     annotations:
       cloud.google.com/app-protocols: '{"my-port":"HTTP2"}'
       ...
     labels:
       app: echoheaders
     name: echoheaders
     ...
   spec:
     clusterIP: 10.39.251.148
     ...
     ports:
     - name: my-port
       nodePort: 30647
       port: 443
       protocol: TCP
       targetPort: 8443
     selector:
       app: echoheaders
     ...
     type: NodePort
   ...
   

Crear el Ingress

1. Copia el siguiente manifiesto en un archivo llamado my-ingress.yaml:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: echomap
   spec:
     defaultBackend:
       service:
         name: echoheaders
         port:
           number: 443
   

   Este manifiesto describe un Ingress que especifica que las solicitudes entrantes se envían a un Pod que es miembro del servicio echoheaders. Las solicitudes se dirigen al pod de la targetPort que se especifica en el manifiesto del servicio echoheaders. En este ejercicio, el Pod targetPort es 8443.

2. Aplica el manifiesto a tu clúster:

   kubectl apply -f my-ingress.yaml
   

   Este comando puede tardar varios minutos en completarse mientras el controlador de entrada de Kubernetes configura el balanceador de carga de aplicaciones.

3. Ver el Ingress:

   kubectl get ingress echomap --output yaml
   

   El resultado debería ser similar al siguiente:

   kind: Ingress
   metadata:
     ...
     name: echomap
     ...
   spec:
     backend:
       serviceName: echoheaders
       servicePort: 443
   status:
     loadBalancer:
       ingress:
       - ip: 203.0.113.2
   

   En este resultado, la dirección IP del Ingress es 203.0.113.2.

Probar el balanceador de carga

Llamar a tu servicio

Espera unos minutos a que GKE configure el balanceador de carga y el servicio de backend. A continuación, introduce la dirección IP externa del balanceador de carga en la barra de direcciones de tu navegador.

El resultado debería ser similar al siguiente:

Hostname: echoheaders-7886d5bc68-xnrwj
...
Request Information:
  ...
  method=GET
  real path=/
  query=
  request_version=2
  request_scheme=https
  ...

Request Headers:
  ...
  x-forwarded-for=[YOUR_IP_ADDRESS], 203.0.113.2
  x-forwarded-proto=http
...

Esta información de salida sobre la solicitud del balanceador de carga al pod:

• request_version=2: indica que la solicitud entre el balanceador de carga y el pod ha usado HTTP/2.
• x-forwarded-proto=http: indica que la solicitud entre el navegador y el balanceador de carga ha usado HTTP 1.1, no HTTP/2.

Siguientes pasos

• Configura un balanceador de carga de aplicación externo con Ingress.

• Configura una dirección IP estática y un nombre de dominio para tu aplicación mediante Ingress.

• Configura los certificados SSL de tu balanceador de carga de entrada.