HTTP/2 para el balanceo de cargas con Ingress

En esta página, se muestra cómo usar objetos de Ingress y de Servicio de Kubernetes con el objetivo de configurar un balanceador de cargas HTTP(S) a fin de usar HTTP/2 para la comunicación con servicios de backend. Esta función está disponible a partir de la versión 1.11.2 de Google Kubernetes Engine.

Descripción general

Un balanceador de cargas HTTP(S) actúa como un 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 cargas. Sin embargo, la conexión del proxy del balanceador de cargas 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, es capaz de recibir solicitudes HTTP/2, configura el balanceador de cargas para que use HTTP/2 cuando reenvíe las solicitudes a tu aplicación.

Diagrama que muestra HTTP/2 desde el balanceador de cargas hasta el pod (haz clic para ampliar)

En este ejercicio, crearás una Implementación, un Servicio y un Ingress. Debes poner una anotación cloud.google.com/app-protocols en tu manifiesto de Servicio a fin de especificar que el balanceador de cargas debe usar HTTP/2 para comunicarse con tu aplicación. Luego, debes llamar a tu servicio y verificar que tu aplicación recibió una solicitud HTTP/2.

Antes de comenzar

Sigue estos pasos a fin de prepararte para esta tarea:

  • Asegúrate de que habilitaste la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de que instalaste el SDK de Cloud.
  • Establece tu ID del proyecto predeterminado:
    gcloud config set project [PROJECT_ID]
  • Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada:
    gcloud config set compute/region [COMPUTE_REGION]
  • Actualiza gcloud a la versión más reciente:
    gcloud components update
  • Obtén información sobre los recursos de Ingress y Service de Kubernetes.

Crea la Implementación

En el manifiesto de esta Implementación, se declara que deseas ejecutar dos réplicas de la aplicación web echoheaders:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: echoheaders
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: echoheaders
    spec:
      containers:
      - name: echoheaders
        image: k8s.gcr.io/echoserver:1.10
        ports:
        - containerPort: 8443

Copia el manifiesto a un archivo llamado my-deployment.yaml y crea la Implementación:

kubectl apply -f my-deployment.yaml

Crea el Servicio

A continuación, se muestra un manifiesto para el Servicio:

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

Guarda el manifiesto en un archivo llamado my-service.yaml y crea el Servicio:

kubectl apply -f my-service.yaml

Observa el Servicio:

kubectl get service echoheaders --output yaml

El resultado es similar al siguiente ejemplo:

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
...

A los fines de este ejercicio, estas son las cuestiones importantes que debes tener en cuenta sobre tu servicio:

  • El servicio es de tipo NodePort. Este tipo es obligatorio para los servicios que se asociarán a un Ingress.

  • Cualquier Pod que tenga la etiqueta app: echoheaders es miembro del Servicio. Esto se especifica en el campo selector.

  • El Servicio tiene un puerto, llamado my-port. La anotación cloud.google.com/app-protocols especifica que my-port debe usar el protocolo HTTP/2.

  • El tráfico que se dirige al servicio en el puerto TCP 443 se enruta al puerto TCP 8443 en uno de los Pods miembro. Esto se especifica en los campos port y targetPort.

Crea el Ingress

A continuación, se muestra un manifiesto para el Ingress:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: echomap
spec:
  backend:
    serviceName: echoheaders
    servicePort: 443

Copia el manifiesto a un archivo llamado my-ingress.yaml y crea el Ingress:

kubectl apply -f my-ingress.yaml

Espera unos minutos a que el controlador de Ingress de Kubernetes configure un balanceador de cargas HTTP(S) y luego observa el Ingress:

kubectl get ingress echomap --output yaml

El resultado es similar al siguiente ejemplo:

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

A los fines de este ejercicio, estas son las cuestiones importantes que debes tener en cuenta sobre tu Ingress:

  • La dirección IP para el tráfico entrante aparece en loadBalancer:ingress.

  • Las solicitudes entrantes se enrutan a un Pod que es un miembro del Servicio echoheaders. En este ejercicio, los pods miembro tienen la etiqueta app: echoheaders.

  • Las solicitudes se enrutan al Pod en el puerto de destino especificado en el manifiesto del Servicio echoheaders. En este ejercicio, el puerto de destino del Pod es 8443.

Verifica que tu balanceador de cargas admita HTTP/2

gcloud

  1. Haz una lista de tus servicios de backend:

    gcloud compute backend-services list
    
  2. Describe tu servicio de backend:

    gcloud beta compute backend-services describe [BACKEND_SERVICE_NAME] --global
    

    donde [BACKEND_SERVICE_NAME] es el nombre de tu servicio de backend.

  3. En el resultado, verifica que el protocolo sea HTTP/2:

    backends:
    ...
    description: '{...,"kubernetes.io/service-port":"443","x-features":["HTTP2"]}'
    ...
    kind: compute#backendService
    loadBalancingScheme: EXTERNAL
    protocol: HTTP2
    ...
    

Console

  1. Dirígete a la página de Balanceo de cargas de Google Cloud Platform Console.
    Ir a la página de Balanceo de cargas

  2. Bajo Name (Nombre), ubica tu balanceador de cargas.

    Captura de pantalla del balanceador de cargas HTTP que se muestra en Google Cloud Platform Console (haz clic para ampliar)
  3. Haz clic en el nombre de tu balanceador de cargas para ver tu servicio de backend.

  4. Verifica que el Endpoint protocol (Protocolo de extremos) para tu servicio de backend sea HTTP/2.

    Captura de pantalla del servicio de backend HTTP/2 que se muestra en Google Cloud Platform Console (haz clic para ampliar)

Llama a tu servicio

Espera unos minutos a que se configuren el balanceador de cargas y el servicio de backend. Ingresa la dirección IP externa de tu balanceador de cargas en la barra de direcciones de tu navegador.

El resultado muestra información sobre la solicitud del balanceador de cargas al Pod:

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
...

A los fines de este ejercicio, estas son las cuestiones importantes que debes tener en cuenta sobre el resultado anterior:

  • La línea request_version=2 indica que la solicitud entre el balanceador de cargas y el Pod usó HTTP/2.

  • La línea x-forwarded-proto=http indica que la solicitud entre tú y el balanceador de cargas usó HTTP 1.1, no HTTP/2.

¿Qué sigue?

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…