Configura el balanceo de cargas a través de Ingress

En esta página, se muestra cómo configurar un balanceador de cargas HTTP(S) mediante la creación de un objeto Ingress de Kubernetes. Un objeto Ingress debe estar asociado con uno o más objetos de servicio, cada uno de ellos está asociado con un conjunto de pods.

Un objeto de servicio tiene una o más estructuras servicePort. Cada servicePort que es objetivo de un Ingress está asociado con un recurso de servicio de backend de Google Cloud Platform.

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

Servicios de backend múltiples

Un balanceador de cargas de HTTP(S) proporciona una dirección IP estable que puedes usar para enrutar solicitudes a una variedad de servicios de backend.

En este ejercicio, configurarás el balanceador de cargas para enrutar las solicitudes a varios servicios de backend según la ruta de URL. Las solicitudes que tienen la ruta / se enrutan a un servicio de backend y las que tienen la ruta /kube se enrutan a otro servicio de backend distinto.

Este es el panorama general de los pasos que se deben seguir en este ejercicio:

  1. Crear una implementación y exponerla con un servicio llamado hello-world.
  2. Crear una segunda implementación y exponerla con un servicio llamado hello-kubernetes.
  3. Crear un Ingress que especifique las reglas para enrutar solicitudes a un servicio o a otro, según la ruta de URL en la solicitud. Cuando crees el Ingress, el controlador de Ingress de GKE creará y configurará un balanceador de cargas de HTTP(S).
  4. Probar el balanceador de cargas HTTP(S).

Este es un manifiesto para la primera implementación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
      department: world
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        department: world
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"

Copia el manifiesto en un archivo llamado hello-world-deployment.yaml y crea la implementación:

kubectl apply -f hello-world-deployment.yaml

Este es un manifiesto para un servicio que expone tu primera implementación:

apiVersion: v1
kind: Service
metadata:
  name: hello-world
spec:
  type: NodePort
  selector:
    greeting: hello
    department: world
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50000

Para los fines de este ejercicio, a continuación se presentan los puntos importantes que debes comprender sobre el servicio:

  • Cualquier pod que tenga las etiquetas greeting: hello y department: world es miembro del servicio.

  • Cuando se envía una solicitud al servicio en el puerto TCP 60000, se reenvía a uno de los pods miembros en el puerto TCP 50000.

Copia el manifiesto en un archivo llamado hello-world-service.yaml y crea el servicio:

kubectl apply -f hello-world-service.yaml

Este es un manifiesto para una segunda implementación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
      department: kubernetes
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        department: kubernetes
    spec:
      containers:
      - name: hello-again
        image: "gcr.io/google-samples/node-hello:1.0"
        env:
        - name: "PORT"
          value: "8080"

Copia el manifiesto en un archivo llamado hello-kubernetes-deployment y crea la implementación:

kubectl apply -f hello-kubernetes-deployment.yaml

Este es un manifiesto para un servicio que expone la segunda implementación:

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes
spec:
  type: NodePort
  selector:
    greeting: hello
    department: kubernetes
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Para los fines de este ejercicio, a continuación se presentan los puntos importantes que debes comprender sobre el servicio:

  • Cualquier pod que tenga las etiquetas greeting: hello y department: kubernetes es miembro del servicio.

  • Cuando se envía una solicitud al servicio en el puerto TCP 80, se reenvía a uno de los pods miembros en el puerto TCP 8080.

Copia el manifiesto en un archivo llamado hello-kubernetes-service.yaml y crea el servicio:

kubectl apply -f hello-kubernetes-service.yaml

Este es un manifiesto para un Ingress:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - http:
      paths:
      - path: /*
        backend:
          serviceName: hello-world
          servicePort: 60000
      - path: /kube
        backend:
          serviceName: hello-kubernetes
          servicePort: 80

Observa que el manifiesto de Ingress tiene dos pares (serviceName y servicePort). Cada uno (serviceName y servicePort) está asociado con un servicio de backend de GCP.

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

kubectl apply -f my-ingress.yaml

Cuando crees el Ingress, el controlador de Ingress de GKE creará un balanceador de cargas HTTP(S) y lo configurará como se muestra a continuación:

  • Cuando un cliente envía una solicitud al balanceador de cargas con la ruta de URL /, la solicitud se reenvía al servicio hello-world en el puerto 60000.

  • Cuando un cliente envía una solicitud al balanceador de cargas mediante la ruta de URL /kube, la solicitud se reenvía al servicio hello-kubernetes en el puerto 80.

Deberás esperar unos cinco minutos hasta que se configure el balanceador de cargas.

Ve el Ingress:

kubectl get ingress my-ingress --output yaml

El resultado muestra la dirección IP externa del balanceador de cargas de HTTP(S):

status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

Prueba la ruta /:

curl [LOAD_BALANCER_IP]/

en la que [LOAD_BALANCER_IP] es la dirección IP externa del balanceador de cargas.

El resultado muestra un mensaje Hello, world!:

Hello, world!
Version: 2.0.0
Hostname: ...

Prueba la ruta /kube:

curl [LOAD_BALANCER_IP]/kube

El resultado muestra un mensaje Hello Kubernetes:

Hello Kubernetes!

HTTPS entre el cliente y el balanceador de cargas

Un balanceador de cargas de HTTP(S) actúa como un proxy entre tus clientes y tu aplicación. Si deseas aceptar solicitudes HTTPS de los clientes, el balanceador de cargas debe contar con un certificado para que pueda demostrar su identidad a los clientes. El balanceador de cargas también debe tener una clave privada para completar el protocolo de enlace HTTPS. Para obtener más información, consulta estos vínculos:

Inhabilita HTTP

Puedes inhabilitar HTTP si deseas que todo el tráfico entre el cliente y el balanceador de cargas use HTTPS. Para obtener más información, consulta Inhabilita HTTP.

HTTPS entre el balanceador de cargas y el cliente

Si tu aplicación que se ejecuta en un pod de GKE es capaz de recibir solicitudes HTTPS, puedes configurar el balanceador de cargas para usar HTTPS cuando reenvíe solicitudes a tu aplicación. Para obtener más información, consulta HTTPS (TLS) entre el balanceador de cargas y la aplicación.

HTTP/2 entre el cliente y el balanceador de cargas

Los clientes pueden usar HTTP/2 para enviar solicitudes al balanceador de cargas. No se requiere configuración.

HTTP/2 entre el balanceador de cargas y la aplicación

Si la aplicación, que se ejecuta en un pod de GKE, puede recibir solicitudes HTTP/2, puedes configurar el balanceador de cargas para que use HTTP/2 cuando reenvíe las solicitudes a la aplicación. Si necesitas más información, consulta Usa HTTP/2 para el balanceo de cargas con Ingress.

Grupos de extremos de red

Si el clúster admite el balanceo de cargas nativo del contenedor, puedes configurar el balanceador de cargas para usar grupos de extremo de red. Para obtener más información, consulta Cómo usar el balanceo de cargas nativo del contenedor.

Resumen de las anotaciones sobre Ingress

kubernetes.io/ingress.allow-http
Especifica si se debe permitir el tráfico HTTP entre el cliente y el balanceador de cargas HTTP(S). Los valores posibles son "true" y "false". El valor predeterminado es "true". Consulta Inhabilita HTTP.
ingress.gcp.kubernetes.io/pre-shared-cert
Puedes subir certificados y claves a tu proyecto de GCP. Usa esta anotación para hacer referencia a los certificados y claves. Consulta Usa varios certificados SSL en el balanceo de cargas HTTP(S).
kubernetes.io/ingress.global-static-ip-name
Usa esta anotación para especificar que el balanceador de cargas debe usar la dirección IP externa estática que creaste antes. Consulta Direcciones IP estáticas para balanceadores de cargas de HTTP(S).
service.alpha.kubernetes.io/app-protocols
Usa esta anotación a fin de configurar el protocolo para la comunicación entre el balanceador de cargas y la aplicación. Los protocolos posibles son HTTP, HTTPS y HTTP/2. Consulta HTTPS entre el balanceador de cargas y la aplicación y HTTP/2 para el balanceo de cargas con Ingress.
beta.cloud.google.com/backend-config
Usa esta anotación para configurar el servicio de backend asociado con un servicePort. Consulta el recurso personalizado de BackendConfig.
cloud.google.com/neg
Usa esta anotación para especificar que el balanceador de cargas debe usar grupos de extremos de red. Consulta Usa el balanceo de cargas nativo del contenedor.

Qué sigue

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Documentación de Kubernetes Engine