Implementa Ingress en clústeres

En esta página, se muestra cómo implementar un Ingress que entrega una aplicación en varios clústeres de GKE.

Instructivo para la implementación

En las tareas siguientes, implementarás una app ficticia llamada zoneprinter, además de Ingress de varios clústeres, en dos clústeres. El Ingress proporciona una dirección IP virtual (VIP) compartida para las implementaciones de la aplicación.

Esta página se basa en el trabajo realizado en Configura Ingress de varios clústeres, en el que creaste y registraste dos clústeres. Confirma que tienes dos clústeres que también estén registrados en una flota:

gcloud container clusters list

El resultado es similar a este:

NAME    LOCATION        MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION     NUM_NODES  STATUS
gke-eu  europe-west1-c  1.16.8-gke.9    ***             e2-medium      1.16.8-gke.9     2          RUNNING
gke-us  us-central1-a   1.16.8-gke.9    ***             e2-medium      1.16.6-gke.13 *  2          RUNNING

Crea el espacio de nombres

Debido a que las flotas tienen la propiedad de similitud de espacio de nombres, recomendamos que coordines la creación y administración de los espacios de nombres entre los clústeres para que el mismo grupo sea propietario y administrador de los espacios de nombres idénticos. Puedes crear espacios de nombres por equipo, por entorno, por aplicación o por componente de la aplicación. Los espacios de nombres pueden ser tan detallados como sea necesario, siempre que un espacio de nombres ns1 en un clúster tenga el mismo significado y uso que ns1 en otro clúster.

En este ejemplo, crearás un espacio de nombres zoneprinter para cada aplicación en cada clúster.

  1. Crea un archivo llamado namespace.yaml que tenga el siguiente contenido:

    apiVersion: v1
    kind: Namespace
    metadata:
      name: zoneprinter
    
  2. Cambia al contexto de gke-us:

    kubectl config use-context gke-us
    
  3. Crea el espacio de nombres:

    kubectl apply -f namespace.yaml
    
  4. Cambia al contexto de gke-eu:

    kubectl config use-context gke-eu
    
  5. Crea el espacio de nombres:

    kubectl apply -f namespace.yaml
    

    El resultado es similar a este:

    namespace/zoneprinter created
    

Implementa la app.

  1. Crea un archivo llamado deploy.yaml que tenga el siguiente contenido:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: zone-ingress
      namespace: zoneprinter
      labels:
        app: zoneprinter
    spec:
      selector:
        matchLabels:
          app: zoneprinter
      template:
        metadata:
          labels:
            app: zoneprinter
        spec:
          containers:
          - name: frontend
            image: gcr.io/google-samples/zone-printer:0.2
            ports:
            - containerPort: 8080
    
  2. Cambia al contexto de gke-us:

    kubectl config use-context gke-us
    
  3. Implementa la aplicación zoneprinter:

    kubectl apply -f deploy.yaml
    
  4. Cambia al contexto de gke-eu:

    kubectl config use-context gke-eu
    
  5. Implementa la aplicación zoneprinter:

    kubectl apply -f deploy.yaml
    
  6. Verifica que la aplicación zoneprinter se haya implementado correctamente en cada clúster:

    kubectl get deployment --namespace zoneprinter
    

    El resultado debería ser similar al siguiente en ambos clústeres:

    NAME           READY   UP-TO-DATE   AVAILABLE   AGE
    zone-ingress   1/1     1            1           12m
    

Implementa a través del clúster de configuración

Ahora que la aplicación se implementa en gke-us y gke-eu, implementarás un balanceador de cargas mediante la implementación de los recursos MultiClusterIngress (MCI) y MultiClusterService (MCS) en el clúster de configuración. MCI y MCS son recursos personalizados (CRD) que son los equivalentes de varios clústeres a los recursos Ingress y Service.

En los pasos de la guía de configuración, configuraste el clúster gke-us como el clúster de configuración. El clúster de configuración se usa para implementar y configurar Ingress en todos los clústeres.

  1. Configura el contexto en el clúster de configuración.

    kubectl config use-context gke-us
    

MultiClusterService

  1. Crea un archivo llamado mcs.yaml que tenga el siguiente contenido:

    apiVersion: networking.gke.io/v1
    kind: MultiClusterService
    metadata:
      name: zone-mcs
      namespace: zoneprinter
    spec:
      template:
        spec:
          selector:
            app: zoneprinter
          ports:
          - name: web
            protocol: TCP
            port: 8080
            targetPort: 8080
    
  2. Implementa el recurso MultiClusterService que coincida con la aplicación zoneprinter:

    kubectl apply -f mcs.yaml
    
  3. Verifica que el recurso zone-mcs se haya implementado correctamente en el clúster de configuración:

    kubectl get mcs -n zoneprinter
    

    El resultado es similar a este:

    NAME       AGE
    zone-mcs   9m26s
    

    Este MCS crea un Service sin interfaz gráfica derivado en cada clúster que coincida con pods con app: zoneprinter. Puedes ver que existe uno en el clúster kubectl get service -n zoneprinter de gke-us.

    El resultado es similar a este:

    NAME                                TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)          AGE
    mci-zone-mcs-svc-lgq966x5mxwwvvum   ClusterIP   None          <none>        8080/TCP         4m59s
    

También habrá un Service sin interfaz gráfica similar en gke-eu. Estos Services locales se usan para seleccionar de forma dinámica los extremos del pod a fin de programar el balanceador de cargas del Ingress global con backends.

MultiClusterIngress

  1. Crea un archivo llamado mci.yaml que tenga el siguiente contenido:

    apiVersion: networking.gke.io/v1
    kind: MultiClusterIngress
    metadata:
      name: zone-ingress
      namespace: zoneprinter
    spec:
      template:
        spec:
          backend:
            serviceName: zone-mcs
            servicePort: 8080
    

    Ten en cuenta que esta configuración enruta todo el tráfico al MultiClusterService llamado zone-mcs que existe en el espacio de nombres zoneprinter.

  2. Implementa el recurso MultiClusterIngress que hace referencia a zone-mcs como un backend:

    kubectl apply -f mci.yaml
    

    El resultado es similar a este:

    multiclusteringress.networking.gke.io/zone-ingress created
    

    Ten en cuenta que MultiClusterIngress tiene el mismo esquema que el Ingress de Kubernetes. La semántica del recurso Ingress también es la misma, salvo el campo backend.serviceName.

El campo backend.serviceName en un MultiClusterIngress hace referencia a un MultiClusterService en la API de Fleet en lugar de un servicio en un clúster de Kubernetes. Esto significa que cualquiera de las opciones de configuración para Ingress, como la finalización de TLS, se puede establecer de la misma manera.

Valida un estado de implementación exitosa

La implementación del balanceador de cargas de Google Cloud puede tardar varios minutos en implementarse para los balanceadores de cargas nuevos. La actualización de los balanceadores de cargas existentes se completa más rápido porque no es necesario implementar los recursos nuevos. El recurso MCI detalla los recursos subyacentes de Compute Engine que se crearon en su nombre.

  1. Verifica que la implementación se haya realizado correctamente:

    kubectl describe mci zone-ingress -n zoneprinter
    

    El resultado es similar a este:

    Name:         zone-ingress
    Namespace:    zoneprinter
    Labels:       <none>
    Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                    {"apiVersion":"networking.gke.io/v1","kind":"MultiClusterIngress","metadata":{"annotations":{},"name":"zone-ingress","namespace":"zon...
    API Version:  networking.gke.io/v1
    Kind:         MultiClusterIngress
    Metadata:
      Creation Timestamp:  2020-04-10T23:35:10Z
      Finalizers:
        mci.finalizer.networking.gke.io
      Generation:        2
      Resource Version:  26458887
      Self Link:         /apis/networking.gke.io/v1/namespaces/zoneprinter/multiclusteringresses/zone-ingress
      UID:               62bec0a4-8a08-4cd8-86b2-d60bc2bda63d
    Spec:
      Template:
        Spec:
          Backend:
            Service Name:  zone-mcs
            Service Port:  8080
    Status:
      Cloud Resources:
        Backend Services:
          mci-8se3df-8080-zoneprinter-zone-mcs
        Firewalls:
          mci-8se3df-default-l7
        Forwarding Rules:
          mci-8se3df-fw-zoneprinter-zone-ingress
        Health Checks:
          mci-8se3df-8080-zoneprinter-zone-mcs
        Network Endpoint Groups:
          zones/europe-west1-c/networkEndpointGroups/k8s1-e4adffe6-zoneprint-mci-zone-mcs-svc-lgq966x5m-808-88670678
          zones/us-central1-a/networkEndpointGroups/k8s1-a6b112b6-zoneprint-mci-zone-mcs-svc-lgq966x5m-808-609ab6c6
        Target Proxies:
          mci-8se3df-zoneprinter-zone-ingress
        URL Map:  mci-8se3df-zoneprinter-zone-ingress
      VIP:        34.98.102.37
    Events:
      Type    Reason  Age                    From                              Message
      ----    ------  ----                   ----                              -------
      Normal  ADD     3m35s                  multi-cluster-ingress-controller  zoneprinter/zone-ingress
      Normal  UPDATE  3m10s (x2 over 3m34s)  multi-cluster-ingress-controller  zoneprinter/zone-ingress
    

    Hay varios campos que indican el estado de la implementación de este Ingress:

    • Events es el primer lugar para buscar. Si se produjo un error, aparecerá aquí.

    • Cloud Resource enumera los recursos de Compute Engine, como las reglas de reenvío, los servicios de backend y las reglas de firewall que creó el controlador de Ingress de Anthos. Si no aparecen en la lista, significa que aún no se crearon. Puedes inspeccionar recursos individuales de Compute Engine mediante Console o el comando gcloud para obtener el estado.

    • VIP muestra una dirección IP una vez que se asignó una. Ten en cuenta que es posible que el balanceador de cargas aún no procese tráfico, aunque exista la VIP. Si no ves una VIP después de un par de minutos o si el balanceador de cargas no entrega una respuesta 200 en 10 minutos, consulta la página sobre solución de problemas y operaciones.

    Si los eventos de salida son Normal, es probable que la implementación del MCI sea correcta, pero la única manera de determinar si toda la ruta del tráfico es funcional es probándola.

  2. Valida que la aplicación realiza las entregas en la VIP con el extremo /ping:

    curl INGRESS_VIP/ping
    

    Reemplaza INGRESS_VIP por la dirección IP virtual (VIP).

    El resultado es similar a este:

    {"Hostname":"34.98.102.37","Version":"1.0","GCPZone":"us-central1-a","Backend":"zone-ingress-5554bb95b4-svv5d"}
    

    El resultado debe indicar la región y el backend de la aplicación.

  3. También puedes ir a la URL http://INGRESS_VIP en tu navegador para ver una versión gráfica de la aplicación que muestra la región desde la que se entrega.

    El clúster al que se reenvía el tráfico depende de tu ubicación. El GCLB está diseñado para reenviar el tráfico del cliente al backend disponible con capacidad más cercano.

Especificaciones de los recursos

Especificaciones de MultiClusterService

La definición de MultiClusterService consta de dos partes:

  1. Una sección template, que define el servicio que se creará en los clústeres de Kubernetes. Ten en cuenta que, si bien la sección template contiene campos compatibles con un servicio típico, solo hay dos campos compatibles con MultiClusterService: selector y ports. Los otros campos se ignoran.

  2. Una sección clusters opcional, que define qué clústeres recibirán el tráfico y las propiedades del balanceo de cargas para cada clúster. Si no se especifica una sección clusters o si no se enumera ningún clúster, se usarán todos los clústeres de forma predeterminada.

En el siguiente manifiesto, se describe un MCS estándar:

apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: NAME
  namespace: NAMESPACE
spec:
  template:
    spec:
      selector:
        app: POD_LABEL
      ports:
      - name: web
        protocol: TCP
        port: PORT
        targetPort: TARGET_PORT

Reemplaza lo siguiente:

  • NAME: el nombre del MCS. El campo serviceName hace referencia a este nombre en los recursos MCI.
  • NAMESPACE es el espacio de nombres de Kubernetes en el que se implementa el MCS. Debe estar en el mismo espacio de nombres que el MCI y los pods en todos los clústeres del entorno.
  • POD_LABEL es la etiqueta que determina qué pods se seleccionan como backends para este MCS en todos los clústeres de la flota.
  • PORT debe coincidir con el puerto al que hace referencia el MCI que hace referencia a este MCS.
  • TARGET_PORT es el puerto que se usa para enviar tráfico al pod desde el GCLB. Se crea un NEG en cada clúster con este puerto como su puerto de entrega.

Especificaciones de MultiClusterIngress

En el siguiente mci.yaml, se describe el frontend del balanceador de cargas:

apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
  name: NAME
  namespace: NAMESPACE
spec:
  template:
    spec:
      backend:
       serviceName: DEFAULT_SERVICE
       servicePort: PORT
      rules:
        - host: HOST_HEADER
          http:
            paths:
            - path: PATH
              backend:
                serviceName: SERVICE
                servicePort: PORT

Reemplaza lo siguiente:

  • NAME: El nombre del recurso de MCI.
  • NAMESPACE es el espacio de nombres de Kubernetes en el que se implementa el MCI. Debe estar en el mismo espacio de nombres que el MCS y los pods en todos los clústeres del entorno.
  • DEFAULT_SERVICE actúa como el backend predeterminado para todo el tráfico que no coincide con ninguna regla de host ni de ruta de acceso. Este es un campo obligatorio y se debe especificar un backend predeterminado en el MCI, incluso si hay otras coincidencias de host o de ruta de acceso configuradas.
  • PORT: cualquier número de puerto válido. Este debe coincidir con el campo port de los recursos MCS.
  • HOST_HEADER coincide con el tráfico según el campo del encabezado del host HTTP. El campo host es opcional.
  • PATH coincide con el tráfico según la ruta de acceso de la URL HTTP. El campo path es opcional.
  • SERVICE es el nombre de un MCS que se implementa en el mismo espacio de nombres y clúster de configuración que este MCI.

Características de Ingress de varios clústeres

En esta sección, se muestra cómo configurar características adicionales de Ingress de varios clústeres.

Selección de clústeres

De forma predeterminada, los servicios derivados de Multi Cluster Ingress se programan en cada clúster miembro. Sin embargo, es posible que desees aplicar reglas de entrada a clústeres específicos. Estos son algunos casos prácticos:

  • Aplica Ingress de varios clústeres a todos los clústeres, excepto al clúster de configuración para aislarlo.
  • Migra cargas de trabajo entre clústeres de manera azul-verde.
  • Enruta a los backends de aplicaciones que solo existen en un subconjunto de clústeres.
  • Usa una solo VIP L7 para el enrutamiento del host o de la ruta de acceso a backends que se alojan en clústeres diferentes.

La selección de clústeres te permite seleccionarlos por región o nombre en el objeto MultiClusterService. Esto controla a qué clústeres apunta tu Ingress de varios clústeres y dónde están programados los servicios derivados. Los clústeres dentro de la misma flota y la misma región no deben tener el mismo nombre para que se pueda hacer referencia a los clústeres de manera única.

  1. Abre mcs.yaml

    apiVersion: networking.gke.io/v1
    kind: MultiClusterService
    metadata:
      name: zone-mcs
      namespace: zoneprinter
    spec:
      template:
        spec:
          selector:
            app: zoneprinter
          ports:
          - name: web
            protocol: TCP
            port: 8080
            targetPort: 8080
    

    Actualmente, esta especificación crea servicios derivados en todos los clústeres, que es el comportamiento predeterminado.

  2. Agrega las siguientes líneas en la sección de clústeres:

    apiVersion: networking.gke.io/v1
    kind: MultiClusterService
    metadata:
      name: zone-mcs
      namespace: zoneprinter
    spec:
      template:
        spec:
          selector:
            app: zoneprinter
          ports:
          - name: web
            protocol: TCP
            port: 8080
            targetPort: 8080
      clusters:
      - link: "us-central1-a/gke-us"
      - link: "europe-west1-c/gke-eu"
    

    En este ejemplo, se crean recursos Service derivados solo en clústeres de gke-us y gke-eu. Debes seleccionar clústeres para aplicar reglas de entrada de manera selectiva. Si no se especifica la sección “clústeres” del MultiClusterService, o si no se enumera ningún clúster, se interpretará como “todos” los clústeres de forma predeterminada.

Compatibilidad con HTTPS

El secreto de Kubernetes admite HTTPS. Antes de habilitar la compatibilidad con HTTPS, debes crear una dirección IP estática. Esta IP estática permite que HTTP y HTTPS compartan la misma dirección IP. Para obtener más información, consulta cómo crear una IP estática.

Una vez que creaste una dirección IP estática, puedes crear un secreto.

  1. Crea un secreto:

    kubectl -n prod create secret tls SECRET_NAME --key PATH_TO_KEYFILE --cert PATH_TO_CERTFILE
    

    Reemplaza lo siguiente:

    • SECRET_NAME por el nombre del Secret.
    • PATH_TO_KEYFILE es la ruta de acceso al archivo de claves TLS.
    • PATH_TO_CERTFILE es la ruta de acceso al archivo del certificado TLS.
  2. Actualiza el archivo mci.yaml con el nombre del Secret:

    apiVersion: networking.gke.io/v1
    kind: MultiClusterIngress
    metadata:
      name: zone-ingress
      namespace: zoneprinter
      annotations:
        networking.gke.io/static-ip: STATIC_IP_ADDRESS
    spec:
      template:
        spec:
          backend:
            serviceName: zone-mcs
            servicePort: 8080
          tls:
          - secretName: SECRET_NAME
    

    Reemplaza SECRET_NAME por el nombre del Secret. STATIC_IP_ADDRESS es la dirección IP o la URL completa de la dirección que asignaste en la sección Crea una IP estática.

  3. Vuelve a implementar el recurso MultiClusterIngress:

    kubectl apply -f mci.yaml
    

    El resultado es similar a este:

    multiclusteringress.networking.gke.io/zone-ingress configured
    

Compatibilidad con BackendConfig

La CRD de BackendConfig te permite personalizar la configuración en el recurso de BackendService de Compute Engine. La especificación compatible es la siguiente:

apiVersion: cloud.google.com/v1beta1
kind: BackendConfig
metadata:
  name: zone-health-check-cfg
  namespace: zoneprinter
spec:
  healthCheck:
    checkIntervalSec: [int]
    timeoutSec: [int]
    healthyThreshold: [int]
    unhealthyThreshold: [int]
    type: [HTTP | HTTPS | HTTP2 | TCP]
    port: [int]
    requestPath: [string]
  timeoutSec: [int]
  connectionDraining:
    drainingTimeoutSec: [int]
  sessionAffinity:
    affinityType: [CLIENT_IP | CLIENT_IP_PORT_PROTO | CLIENT_IP_PROTO | GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | NONE]
    affinityCookieTtlSec: [int]
  cdn:
    enabled: [bool]
    cachePolicy:
      includeHost: [bool]
      includeQueryString: [bool]
      includeProtocol: [bool]
      queryStringBlacklist: [string list]
      queryStringWhitelist: [string list]
  securityPolicy:
    name: ca-how-to-security-policy
  logging:
    enable: [bool]
    sampleRate: [float]
  iap:
    enabled: [bool]
    oauthclientCredentials:
      secretName: [string]

Para usar BackendConfig, conéctalo a tu recurso MultiClusterService mediante una anotación:

apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: zone-mcs
  namespace: zoneprinter
  annotations:
    beta.cloud.google.com/backend-config: '{"ports": {"8080":"zone-health-check-cfg"}}'
spec:
 template:
   spec:
     selector:
       app: zoneprinter
     ports:
     - name: web
       protocol: TCP
       port: 8080
       targetPort: 8080

Para obtener más información sobre la semántica de BackendConfig, consulta la sección Asocia un puerto de servicio a un BackendConfig.

Compatibilidad con gRPC

La configuración de aplicaciones de gRPC en Ingress de varios clústeres requiere una configuración muy específica. A continuación, te mostramos algunas sugerencias para asegurarte de que el balanceador de cargas esté configurado de forma correcta:

  1. Asegúrate de que el tráfico del balanceador de cargas que va a tu aplicación sea HTTP/2. Usa los protocolos de aplicación para configurarlo.
  2. Asegúrate de que tu aplicación esté configurada correctamente para SSL, ya que este es un requisito de HTTP/2. Ten en cuenta que se acepta el uso de certificados autofirmados.
  3. Debes desactivar mTLS en tu aplicación porque este no es compatible con balanceadores de cargas externos de L7.

Ciclo de vida de los recursos

Cambios de configuración

Los recursos MultiClusterIngress y MultiClusterService se comportan como objetos estándar de Kubernetes, por lo que los cambios en los objetos se reflejan de forma asíncrona en el sistema. Cualquier cambio que dé como resultado una configuración no válida hace que los objetos de Google Cloud asociados permanezcan sin cambios y se genere un error en la transmisión de eventos del objeto. Los errores asociados con la configuración se informarán como eventos.

Administra recursos de Kubernetes

Si borras el objeto Ingress se elimina el balanceador de cargas HTTP(S), por lo que el tráfico ya no se reenviará a ningún MultiClusterService definido.

Si borras MultiClusterService, se quitarán los servicios derivados asociados de cada clúster.

Administra clústeres

Puedes cambiar el conjunto de clústeres al que apunta el balanceador de cargas si agregas o quitas una membresía.

Por ejemplo, para quitar el clúster gke-eu como backend de un Ingress, ejecuta lo siguiente:

gcloud container hub memberships unregister CLUSTER_NAME \
  --gke-uri=URI

Reemplaza lo siguiente:

  • CLUSTER_NAME: El nombre de tu clúster.
  • URI es el URI del clúster de GKE.

Para agregar un clúster en Europa, ejecuta lo siguiente:

gcloud container hub memberships register europe-cluster \
  --context=europe-cluster --service-account-key-file=PATH_TO_SERVICE_ACCOUNT_KEY_FILE

Reemplaza PATH_TO_SERVICE_ACCOUNT_KEY_FILE por la ruta de acceso al archivo de claves de la cuenta de servicio.

Ten en cuenta que registrar o cancelar el registro de un clúster cambia su estado como backend para todos los Ingress. En el caso anterior, cancelar el registro del clúster gke-eu lo quita como backend disponible para todos los Ingress que crees. Si se registra un clúster nuevo, sucede lo contrario.

Inhabilita Ingress de varios clústeres

Antes de inhabilitar Ingress de varios clústeres, debes asegurarte de borrar tus recursos MultiClusterIngress y MultiClusterService y verificar que se borren todos los recursos de red asociados.

Luego, para inhabilitar el Ingress de clústeres múltiples, usa el siguiente comando:

gcloud alpha container hub ingress disable

Si no borras los recursos MultiClusterIngress y MultiClusterService antes de inhabilitar el Ingress de varios clústeres, es posible que veas un error similar al siguiente:

Feature has associated resources that should be cleaned up before deletion.

Si deseas forzar la inhabilitación de Ingress de varios clústeres, usa el siguiente comando:

gcloud alpha container hub ingress disable --force

Anotaciones

Las siguientes anotaciones son compatibles con los recursos MultiClusterIngress y MultiClusterService.

Anotaciones de MultiClusterIngress

Anotación Description
networking.gke.io/frontend-config Hace referencia a un recurso FrontendConfig en el mismo espacio de nombres que el recurso MultiClusterIngress.
networking.gke.io/static-ip Se refiere a la dirección IP literal de una IP estática global.
networking.gke.io/pre-shared-certs Se refiere a un recurso SSLCertificate.

Anotaciones de MultiClusterService

Anotación Description
networking.gke.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. Para obtener más información, consulta Funciones de Ingress.

Políticas de SSL y redireccionamientos HTTPS

Puedes usar el recurso FrontendConfig para configurar las políticas de SSL y los redireccionamientos HTTPS. Las políticas de SSL te permiten especificar qué conjuntos de cifrado y versiones de TLS acepta el balanceador de cargas. Los redireccionamientos HTTPS te permiten aplicar el redireccionamiento de HTTP/port 80 a HTTPS/port 443. En los siguientes pasos, se configura una política de SSL y un redireccionamiento HTTPS juntos. Ten en cuenta que también se pueden configurar de forma independiente.

  1. Crea una política de SSL que rechace las solicitudes con una versión anterior a TLS v1.2.

    gcloud compute ssl-policies create tls-12-policy \
     --profile MODERN \
     --min-tls-version 1.2 \
     --project=PROJECT_ID
    

    Reemplaza PROJECT_ID por el ID del proyecto en el que se ejecutan los clústeres de GKE.

  2. Consulta tu política para asegurarte de que se haya creado.

    gcloud compute ssl-policies list --project=PROJECT_ID
    

    El resultado es similar a este:

    NAME           PROFILE  MIN_TLS_VERSION
    tls-12-policy  MODERN   TLS_1_2
    
  3. Crea un certificado para foo.example.com como en este ejemplo. Una vez que tengas los key.pem y cert.pem, almacena estas credenciales como un secreto al que hará referencia el recurso MultiClusterIngress.

    kubectl -n multi-cluster-demo create secret tls SECRET_NAME --key key.pem --cert cert.pem
    
  4. Guarda el siguiente recurso FrontendConfig como frontendconfig.yaml. Consulta Configura recursos FrontendConfig para obtener más información sobre los campos compatibles dentro de FrontendConfig.

    apiVersion: networking.gke.io/v1beta1
    kind: FrontendConfig
    metadata:
      name: frontend-redirect-tls-policy
      namespace: multi-cluster-demo
    spec:
      sslPolicy: tls-12-policy
      redirectToHttps:
        enabled: true
    

    Este FrontendConfig habilitará los redireccionamientos HTTPS y una política de SSL que aplique una versión mínima de TLS de 1.2.

  5. Implementa frontendconfig.yaml en el clúster de configuración.

    kubectl apply -f frontendconfig.yaml --context MCI_CONFIG_CLUSTER
    

    Reemplaza MCI_CONFIG_CLUSTER por el nombre de tu clúster de configuración.

  6. Guarda el siguiente MultiClusterIngress como mci-frontendconfig.yaml.

    apiVersion: networking.gke.io/v1
    kind: MultiClusterIngress
    metadata:
      name: foo-ingress
      namespace: multi-cluster-demo
      annotations:
        networking.gke.io/frontend-config: frontend-redirect-tls-policy
        networking.gke.io/static-ip: STATIC_IP_ADDRESS
    spec:
      template:
        spec:
          backend:
            serviceName: default-backend
            servicePort: 8080
          rules:
          - host: foo.example.com
            http:
              paths:
                - backend:
                    serviceName: foo
                    servicePort: 8080
          tls:
          - secretName: SECRET_NAME
    
    • Reemplaza STATIC_IP_ADDRESS por una dirección IP global estática que ya hayas aprovisionado.
    • Reemplaza SECRET_NAME por el Secret en el que se almacena el certificado foo.example.com.

    Cuando se habilitan los redireccionamientos a HTTPS, existen dos requisitos:

    • Se debe habilitar TLS, ya sea a través del campo spec.tls o a través de la anotación del certificado ya compartido networking.gke.io/pre-shared-certs. MultiClusterIngress no se implementará si los redireccionamientos HTTPS están habilitados, pero HTTPS no.
    • Se debe hacer referencia a una IP estática a través de la anotación networking.gke.io/static-ip. Las IP estáticas son necesarias cuando se habilita HTTPS en un MultiClusterIngress.
  7. Implementa MultiClusterIngress en tu clúster de configuración.

    kubectl apply -f mci-frontendconfig.yaml --context MCI_CONFIG_CLUSTER
    
  8. Espera uno o dos minutos y, luego, inspecciona foo-ingress.

    kubectl describe mci foo-ingress --context MCI_CONFIG_CLUSTER
    

    Un resultado correcto se parece al siguiente:

    • El estado Cloud Resources se propaga con nombres de recursos
    • El campo VIP se propaga con la dirección IP del balanceador de cargas
    Name:         foobar-ingress
    Namespace:    multi-cluster-demo
    
    ...
    
    Status:
      Cloud Resources:
        Backend Services:
          mci-otn9zt-8080-multi-cluster-demo-bar
          mci-otn9zt-8080-multi-cluster-demo-default-backend
          mci-otn9zt-8080-multi-cluster-demo-foo
        Firewalls:
          mci-otn9zt-default-l7
        Forwarding Rules:
          mci-otn9zt-fw-multi-cluster-demo-foobar-ingress
          mci-otn9zt-fws-multi-cluster-demo-foobar-ingress
        Health Checks:
          mci-otn9zt-8080-multi-cluster-demo-bar
          mci-otn9zt-8080-multi-cluster-demo-default-backend
          mci-otn9zt-8080-multi-cluster-demo-foo
        Network Endpoint Groups:
          zones/europe-west1-b/networkEndpointGroups/k8s1-1869d397-multi-cluste-mci-default-backend-svc--80-9e362e3d
          zones/europe-west1-b/networkEndpointGroups/k8s1-1869d397-multi-cluster--mci-bar-svc-067a3lzs8-808-89846515
          zones/europe-west1-b/networkEndpointGroups/k8s1-1869d397-multi-cluster--mci-foo-svc-820zw3izx-808-8bbcb1de
          zones/us-central1-b/networkEndpointGroups/k8s1-a63e24a6-multi-cluste-mci-default-backend-svc--80-a528cc75
          zones/us-central1-b/networkEndpointGroups/k8s1-a63e24a6-multi-cluster--mci-bar-svc-067a3lzs8-808-36281739
          zones/us-central1-b/networkEndpointGroups/k8s1-a63e24a6-multi-cluster--mci-foo-svc-820zw3izx-808-ac733579
        Target Proxies:
          mci-otn9zt-multi-cluster-demo-foobar-ingress
          mci-otn9zt-multi-cluster-demo-foobar-ingress
        URL Map:  mci-otn9zt-rm-multi-cluster-demo-foobar-ingress
      VIP:        34.149.29.76
    Events:
      Type     Reason  Age                From                              Message
      ----     ------  ----               ----                              -------
      Normal   UPDATE  38m (x5 over 62m)  multi-cluster-ingress-controller  multi-cluster-demo/foobar-ingress
    
  9. Envía una solicitud HTTP a través de curl para verificar que los redireccionamientos HTTPS funcionen de forma correcta.

    curl VIP
    

    Reemplaza VIP por la dirección IP de MultiClusterIngress.

    El resultado debería mostrar que la solicitud se redireccionó al puerto HTTPS, lo que indica que los redireccionamientos funcionan de forma correcta.

  10. Envía una solicitud HTTPS con la versión 1.1 de TLS para verificar que la política de TLS funcione de forma correcta. Debido a que el DNS no está configurado para este dominio, usa la opción --resolve para indicarle a curl que resuelva la dirección IP directamente.

    curl https://foo.example.com --resolve foo.example.com:443:VIP --cacert CERT_FILE -v
    

    En este paso, se requiere el archivo PEM del certificado que se usa para proteger el MultiClusterIngress. Un resultado correcto será similar al siguiente:

    ...
    * SSL connection using TLSv1.2 / ECDHE-RSA-CHACHA20-POLY1305
    * ALPN, server accepted to use h2
    * Server certificate:
    *  subject: O=example; CN=foo.example.com
    *  start date: Sep  1 10:32:03 2021 GMT
    *  expire date: Aug 27 10:32:03 2022 GMT
    *  common name: foo.example.com (matched)
    *  issuer: O=example; CN=foo.example.com
    *  SSL certificate verify ok.
    * Using HTTP2, server supports multi-use
    * Connection state changed (HTTP/2 confirmed)
    * Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0
    * Using Stream ID: 1 (easy handle 0x7fa10f00e400)
    > GET / HTTP/2
    > Host: foo.example.com
    > User-Agent: curl/7.64.1
    > Accept: */*
    >
    * Connection state changed (MAX_CONCURRENT_STREAMS == 100)!
    < HTTP/2 200
    < content-type: application/json
    < content-length: 308
    < access-control-allow-origin: *
    < server: Werkzeug/1.0.1 Python/3.8.6
    < date: Wed, 01 Sep 2021 11:39:06 GMT
    < via: 1.1 google
    < alt-svc: clear
    <
    {"cluster_name":"gke-us","host_header":"foo.example.com","metadata":"foo","node_name":"gke-gke-us-default-pool-22cb07b1-r5r0.c.mark-church-project.internal","pod_name":"foo-75ccd9c96d-dkg8t","pod_name_emoji":"👞","project_id":"mark-church-project","timestamp":"2021-09-01T11:39:06","zone":"us-central1-b"}
    * Connection #0 to host foo.example.com left intact
    * Closing connection 0
    

    El código de respuesta es 200 y se usa TLSv1.2, lo que indica que todo funciona correctamente.

    A continuación, puedes verificar que la política de SSL aplique la versión correcta de TLS si intentas conectarte con TLS 1.1. Tu política de SSL debe estar configurada para una versión mínima de 1.2 a fin de que este paso funcione.

  11. Envía la misma solicitud del paso anterior, pero aplica una versión de TLS 1.1.

    curl https://foo.example.com --resolve foo.example.com:443:VIP -v \
      --cacert CERT_FILE \
      --tls-max 1.1
    

    Un resultado correcto será similar al siguiente:

    * Added foo.example.com:443:34.149.29.76 to DNS cache
    * Hostname foo.example.com was found in DNS cache
    *   Trying 34.149.29.76...
    * TCP_NODELAY set
    * Connected to foo.example.com (34.149.29.76) port 443 (#0)
    * ALPN, offering h2
    * ALPN, offering http/1.1
    * successfully set certificate verify locations:
    *   CAfile: cert.pem
      CApath: none
    * TLSv1.1 (OUT), TLS handshake, Client hello (1):
    * TLSv1.1 (IN), TLS alert, protocol version (582):
    * error:1400442E:SSL routines:CONNECT_CR_SRVR_HELLO:tlsv1 alert protocol version
    * Closing connection 0
    curl: (35) error:1400442E:SSL routines:CONNECT_CR_SRVR_HELLO:tlsv1 alert protocol version
    

    Si no se completa el protocolo de enlace TLS, se indica que la política de SSL bloqueó correctamente TLS 1.1.

Crea una IP estática

  1. Asigna una IP estática:

    gcloud compute addresses create ADDRESS_NAME --global
    

    Reemplaza ADDRESS_NAME por el nombre de la IP estática que se asignará.

    El resultado contiene la URL completa de la dirección que creaste, similar a la siguiente:

    Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses/ADDRESS_NAME].
    
  2. Visualiza la dirección IP que acabas de crear:

    gcloud compute addresses list
    

    El resultado es similar a este:

    NAME          ADDRESS/RANGE  TYPE      STATUS
    ADDRESS_NAME  STATIC_IP_ADDRESS  EXTERNAL  RESERVED
    

    En esta salida, se incluye lo siguiente:

    • El ADDRESS_NAME que definiste.
    • El STATIC_IP_ADDRESS asignado.
  3. Actualiza el archivo mci.yaml con la IP estática:

    apiVersion: networking.gke.io/v1
    kind: MultiClusterIngress
    metadata:
      name: zone-ingress
      namespace: zoneprinter
    annotations:
      networking.gke.io/static-ip: STATIC_IP_ADDRESS
    spec:
      template:
        spec:
          backend:
            serviceName: zone-mcs
            servicePort: 8080
    

    Reemplaza STATIC_IP_ADDRESS por uno de los siguientes:

    • La dirección IP asignada, similar a: 34.102.201.47
    • La URL completa de la dirección que creaste, similar a "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses/ADDRESS_NAME"

    STATIC_IP_ADDRESS no es el nombre del recurso (ADDRESS_NAME).

  4. Vuelve a implementar el recurso MultiClusterIngress:

    kubectl apply -f mci.yaml
    

    El resultado es similar a este:

    multiclusteringress.networking.gke.io/zone-ingress configured
    
  5. Sigue los pasos en Valida un estado de implementación exitoso para verificar que la implementación se entregue en STATIC_IP_ADDRESS.

Certificados ya compartidos

Los certificados compartidos previamente son certificados subidos a Google Cloud que el balanceador de cargas puede usar para la finalización de TLS en lugar de los certificados almacenados en secretos de Kubernetes. Estos certificados se suben fuera de banda de GKE a Google Cloud y se hace referencia a ellos mediante un objeto Ingress de varios clústeres. También se admiten varios certificados, ya sea mediante certificados compartidos previamente o secretos de Kubernetes.

Para usar los certificados en Ingress de varios clústeres, se requiere la anotación networking.gke.io/pre-shared-certs y los nombres de los certificados. Cuando se especifican varios certificados para un objeto Ingress de varios clústeres determinado, rige un orden predeterminado sobre qué certificado se presenta al cliente.

Puedes generar una lista de los certificados SSL disponibles si ejecutas lo siguiente:

gcloud compute ssl-certificates list

En el siguiente ejemplo, se describe el tráfico del cliente a uno de los hosts especificados que coincide con el nombre común de los certificados compartidos previamente, por lo que se presentará el certificado respectivo que coincida con el nombre de dominio.

kind: MultiClusterIngress
metadata:
  name: shopping-service
  namespace: prod
  annotations:
    networking.gke.io/pre-shared-certs: "domain1-cert, domain2-cert"
spec:
  template:
    spec:
      rules:
      - host: my-domain1.gcp.com
        http:
          paths:
          - backend:
              serviceName: domain1-svc
              servicePort: 443
      - host: my-domain2.gcp.com
        http:
          paths:
          - backend:
              serviceName: domain2-svc
              servicePort: 443

Certificados administrados por Google.

Los certificados administrados por Google son compatibles con Ingress de varios clústeres a través de la anotación networking.gke.io/pre-shared-certs. Ingress de varios clústeres admite la conexión de certificados administrados por Google a un recurso MultiClusterIngress. Sin embargo, a diferencia de Ingress de un solo clúster, la generación declarativa de un recurso ManagedCertificate de Kubernetes no es compatible con Ingress de varios clústeres. La creación original del certificado administrado por Google debe realizarse directamente a través de la API de compute ssl-certificates create para poder adjuntarla a un MultiClusterIngress. Para ello, sigue estos pasos:

  1. Crea un certificado administrado por Google como en el paso 1 aquí. No pases al paso 2, ya que Ingress de clústeres múltiples adjuntará este certificado.

    gcloud compute ssl-certificates create my-google-managed-cert \
        --domains=my-domain.gcp.com \
        --global
    
  2. Haz referencia al nombre del certificado en tu MultiClusterIngress con la anotación networking.gke.io/pre-shared-certs.

    kind: MultiClusterIngress
    metadata:
    name: shopping-service
    namespace: prod
    annotations:
      networking.gke.io/pre-shared-certs: "my-google-managed-cert"
    spec:
    template:
      spec:
        rules:
        - host: my-domain.gcp.com
          http:
            paths:
            - backend:
                serviceName: my-domain-svc
                servicePort: 8080
    

El manifiesto anterior adjunta el certificado a tu MultiClusterIngress a fin de que pueda finalizar el tráfico para tus clústeres de GKE de backend. Google Cloud renovará automáticamente tu certificado antes de que se venza. Las renovaciones se realizan con transparencia y no requieren ninguna actualización de Ingress de varios clústeres.

Protocolos de las aplicaciones

Para la conexión del proxy del balanceador de cargas con tu aplicación, se usa HTTP de forma predeterminada. Con la anotación networking.gke.io/app-protocols, puedes configurar el balanceador de cargas para que use HTTPS o HTTP/2 cuando reenvíe solicitudes a tu aplicación. En el campo annotation del siguiente ejemplo, http2 se refiere al nombre del puerto MultiClusterService y HTTP2 se refiere al protocolo que usa el balanceador de cargas.

kind: MultiClusterService
metadata:
  name: shopping-service
  namespace: prod
  annotations:
    networking.gke.io/app-protocols: '{"http2":"HTTP2"}'
spec:
  template:
    spec:
      ports:
      - port: 443
        name: http2

BackendConfig

Consulta la sección anterior sobre cómo configurar la anotación.

Problemas conocidos, límites de productos y orientación

Las siguientes son limitaciones o avisos importantes sobre el comportamiento de Ingress de varios clústeres que determinan un uso seguro y aceptable. Comunícate con el equipo de cuentas o escribe a gke-mci-feedback@google.com si tienes alguna pregunta.

  • Los recursos del balanceador de cargas de Compute Engine se crean con un nombre que contiene un prefijo mci-[6 char hash]. Todos los recursos administrados de Ingress de varios clústeres de un proyecto usan el mismo prefijo. Este prefijo se usa para administrar y recopilar recursos de Compute Engine que Ingress de varios clústeres implementa. Debido a que este prefijo contiene un hash generado, es poco probable que un proyecto contenga recursos de Compute Engine fuera del dominio de Ingress de varios clústeres con este mismo prefijo. Sin embargo, los balanceadores de cargas de Compute Engine del mismo proyecto que Ingress de varios clústeres administra no deben usar este prefijo; de lo contrario, se borrarán.

  • Ingress de varios clústeres solo admite clústeres dentro del mismo proyecto. Solo se puede implementar una instancia de Ingress de varios clústeres por proyecto, aunque los permisos de los clústeres se pueden controlar con la selección de clústeres. Esto permite que los recursos MultiClusterService se implementen solo en subconjuntos de clústeres específicos dentro de un proyecto.

  • Ingress de varios clústeres y las flotas tienen una cuota preconfigurada de un máximo de 15 clústeres por proyecto. Esta cuota se puede aumentar si es necesario. Comunícate con tu equipo de cuentas con el fin de solicitar un límite de clúster por proyecto más alto si tienes requisitos para registrar más clústeres.

  • Ingress de varios clústeres tiene una cuota preconfigurada de 50 recursos de MultiClusterIngress y 100 recursos de MultiClusterService por proyecto. Esto permite que se creen hasta 50 recursos MCI y 100 MCS en un clúster de configuración para cualquier cantidad de clústeres de backend hasta el máximo de clúster por proyecto. Esta cuota se puede aumentar si es necesario. Comunícate con tu equipo de cuentas para solicitar cuotas de MCI y MCS más altas si tienes requisitos de mayor escalamiento.

  • La configuración de HTTPS requiere una dirección IP estática asignada previamente. En este momento, HTTPS no es compatible con direcciones IP efímeras.

¿Qué sigue?