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 que estén asociados con un conjunto de pods.

Un objeto de servicio tiene una o más estructuras servicePort. Cada servicePort que se orienta mediante 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 habilitar la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de instalar el SDK de Cloud.
  • Configura el ID del proyecto predeterminado:
    gcloud config set project [PROJECT_ID]
  • Si trabajas con clústeres zonales, configura tu zona de procesamiento predeterminada:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres regionales, configura 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 tengan la ruta / se enrutan a un servicio de backend y las que tienen la ruta /kube se enrutan a otro servicio de backend.

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

  1. Crea una implementación y exponla con un servicio denominado hello-world.
  2. Crea una segunda implementación y exponla con un servicio denominado hello-kubernetes.
  3. Crea 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 entrada de GKE creará y configurará un balanceador de cargas de HTTP(S).
  4. Prueba el balanceador de cargas de 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 a un archivo con el nombre 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, se presentan a continuación 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 a un archivo con el nombre 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 a un archivo con el nombre 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, se presentan a continuación 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 a un archivo con el nombre 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 del Ingress tenga dos pares (serviceName, servicePort). Cada (serviceName, servicePort) está asociado con un servicio de backend de GCP.

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

kubectl apply -f my-ingress.yaml

Cuando crees el Ingress, el Ingress Controller 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 con la ruta de URL /kube, la solicitud se reenvía al servicio hello-kubernetes en el puerto 80.

Espera unos cinco minutos para 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]/

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

El resultado muestra el mensaje Hello, world! :

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

Prueba la ruta /kube:

curl [LOAD_BALANCER_IP]/kube

El resultado muestra el 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:

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 Cómo inhabilitar HTTP.

HTTPS entre el balanceador de cargas y el cliente

Si la aplicación, que se ejecuta en un pod de GKE, puede recibir solicitudes HTTPS, puedes configurar el balanceador de cargas para usar HTTPS cuando reenvíe las solicitudes a la 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 usar 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 Cómo inhabilitar HTTP.
ingress.gcp.kubernetes.io/pre-shared-cert
Puedes subir certificados y claves para el proyecto de GCP. Usa esta anotación para hacer referencia a los certificados y claves. Consulta Cómo usar 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 una dirección IP externa y estática que creaste anteriormente. Consulta las 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 Cómo usar el balanceo de cargas nativo del contenedor.

¿Qué sigue?

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

Enviar comentarios sobre...