Configura un servicio de backend mediante BackendConfig

beta

En esta página, se muestra cómo usar un objeto Ingress de Kubernetes para configurar ciertas propiedades de un servicio de backend de Google Cloud (o BackendConfig). BackendConfig es un recurso personalizado que contiene información de configuración para las características de Google Cloud.

Descripción general

En un clúster de GKE, cuando creas un objeto Ingress de Kubernetes, el controlador de entrada de GKE se "activa" y crea un balanceador de cargas HTTP(S) de Google Cloud. Este controlador de entrada configura el balanceador de cargas, y uno o más servicios de backend asociados a este.

La información de configuración para un servicio de backend se guarda en un recurso personalizado llamando BackendConfig.

Para configurar las propiedades de un servicio de backend:

  1. Crea un BackendConfig.
  2. Crea un servicio y asocia uno de sus puertos al BackendConfig.
  3. Crea un Ingress y asócialo al par (servicio, puerto).

Las propiedades exactas que puedes configurar dependen de si usas Ingress con balanceo de cargas interno o externo.

Propiedades configurables del balanceador de cargas HTTP(S) externo

A partir de la versión 1.11.3-gke.18 de GKE, puedes usar un Ingress para configurar estas propiedades de un servicio de backend:

A partir de la versión 1.15.3-gke.1 de GKE, puedes usar un Ingress para configurar estas propiedades de un servicio de backend:

Propiedades configurables del balanceador de cargas HTTP(S) interno

Puedes usar un BackendConfig para configurar un balanceador de cargas HTTP(S) interno a fin de usar dos características adicionales:

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

  • Usa gcloud init si deseas ver una explicación sobre cómo configurar parámetros predeterminados.
  • Usa gcloud config para establecer individualmente el ID, la zona y la región de tu proyecto.

Usa gcloud init.

  1. Ejecuta gcloud init y sigue las instrucciones:

    gcloud init

    Si usas SSH en un servidor remoto, utiliza la marca --console-only para evitar que el comando abra un navegador:

    gcloud init --console-only
  2. Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
  3. Crea una configuración nueva o selecciona una existente.
  4. Elige un proyecto de Google Cloud.
  5. Elige una zona predeterminada de Compute Engine.

Usa gcloud config

  • 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

Crea una implementación

Antes de crear un BackendConfig y un Servicio, debes crear una implementación. A continuación, se muestra un manifiesto de implementación:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-bsc-deployment
    spec:
      selector:
        matchLabels:
          purpose: bsc-config-demo
      replicas: 2
      template:
        metadata:
          labels:
            purpose: bsc-config-demo
        spec:
          containers:
          - name: hello-app-container
            image: gcr.io/google-samples/hello-app:1.0
    

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

    kubectl apply -f my-bsc-deployment.yaml
    

Crea una BackendConfig

Aquí hay un manifiesto para un BackendConfig. El manifiesto especifica:

  • Un tiempo de espera de 40 segundos
  • Una conexión que agota el tiempo de espera de 60 segundos
    apiVersion: cloud.google.com/v1beta1
    kind: BackendConfig
    metadata:
      name: my-bsc-backendconfig
    spec:
      timeoutSec: 40
      connectionDraining:
        drainingTimeoutSec: 60
    

Copia el manifiesto en un archivo denominado my-bsc-backendconfig.yaml y crea el BackendConfig:

    kubectl apply -f my-bsc-backendconfig.yaml
    

Crea un servicio

Aquí hay un manifiesto para un servicio:

    apiVersion: v1
    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    spec:
      type: NodePort
      selector:
        purpose: bsc-config-demo
      ports:
      - port: 80
        protocol: TCP
        targetPort: 8080
    

A los fines de este ejercicio, estos son los aspectos importantes que debes tener en cuenta sobre tu Servicio:

  • Cualquier pod que tenga la etiqueta purpose: bsc-config-demo es miembro del servicio.

  • El puerto TCP 80 del Servicio está asociado a un BackendConfig denominado my-bsc-backendconfig. Esto se especifica en la anotación beta.cloud.google.com/backend-config.

  • Una solicitud enviada al puerto 80 del Servicio se reenvía a uno de los pods miembros en el puerto 8080.

Guarda el manifiesto en un archivo denominado my-bsc-service.yaml y crea el servicio:

    kubectl apply -f my-bsc-service.yaml
    

Crea un Ingress

Este es el manifiesto de un Ingress:

    apiVersion: extensions/v1beta1
    kind: Ingress
    metadata:
      name: my-bsc-ingress
    spec:
      rules:
      - http:
          paths:
          - path: /*
            backend:
              serviceName: my-bsc-service
              servicePort: 80
    

En el manifiesto, puedes ver que las solicitudes entrantes se enrutan al puerto 80 del servicio denominado my-bsc-service.

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

    kubectl apply -f my-bsc-ingress.yaml
    

Espera unos minutos para que el controlador de Ingress configure un balanceador de cargas HTTP(S) y un servicio de backend asociado.

Observa el servicio de backend

Observa tu servicio:

    kubectl get service my-bsc-service
    

Toma nota del valor del puerto de nodo que se muestra en la salida. Por ejemplo, en la siguiente salida, el valor del puerto del nodo es 30936.

    NAME             TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
    my-bsc-service   NodePort   10.83.15.111   none          80:30936/TCP   2m
    

Genera una lista de los servicios de backend de tu proyecto de Cloud.

    gcloud compute backend-services list
    

En la salida, busca el nombre de tu servicio de backend. Es el nombre que contiene el puerto de nodo de tu Servicio. Por ejemplo, si tu puerto de nodo es 30936, el nombre de tu servicio de backend sería similar a este:

    NAME
    ...
    k8s-be-30936--078bc860bb6f7a2f
    ...
    

Describe tu servicio de backend:

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

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

El resultado muestra valores para las propiedades que configuraste:

    connectionDraining:
      drainingTimeoutSec: 60
    ...
    timeoutSec: 40
    

Configura la afinidad de IP de cliente

Puedes usar un BackendConfig para configurar la afinidad de IP de cliente.

Para hacer este ejercicio, necesitas un clúster nativo de la VPC. La afinidad de IP de cliente es útil solo para los servicios respaldados por grupos de extremos de red, que requieren un clúster nativo de la VPC.

Para configurar la afinidad de IP de cliente, establece affinityType en “CLIENT_IP” en tu manifiesto de BackendConfig.

    apiVersion: cloud.google.com/v1beta1
    kind: BackendConfig
    metadata:
      name: my-bsc-backendconfig
    spec:
      timeoutSec: 40
      connectionDraining:
        drainingTimeoutSec: 60
      sessionAffinity:
        affinityType: "CLIENT_IP"
    

En el manifiesto de Servicio, incluye la anotación cloud.google.com/neg: '{"ingress": true}':

    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        cloud.google.com/neg: '{"ingress": true}'
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    ...
    

Puedes usar un BackendConfig para configurar la afinidad de cookie generada.

Para hacer este ejercicio, necesitas un clúster nativo de la VPC. La afinidad de cookie generada es útil solo para los Servicios respaldados por grupos de extremos de red, que requieren un clúster nativo de la VPC.

Para establecer la afinidad de cookie generada, configura affinityType en “GENERATED_COOKIE” en tu manifiesto de BackendConfig. También puedes usar affinityCookieTtlSec a fin de establecer el período para la cookie.

    sessionAffinity:
      affinityType: "GENERATED_COOKIE"
      affinityCookieTtlSec: 50
    

En el manifiesto de servicio, incluye la anotación cloud.google.com/neg: '{"ingress": true}':

    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        cloud.google.com/neg: '{"ingress": true}'
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    ...
    

Configura encabezados de solicitud definidos por el usuario

Si utilizas Ingress para el balanceo de cargas externo, puedes usar una BackendConfig a fin de configurar los encabezados de las solicitudes definidas por el usuario.

Para habilitar los encabezados de solicitud definidos por el usuario, especifica una lista de encabezados en una propiedad customRequestHeaders del recurso BackendConfig. El balanceador de cargas agrega los encabezados a las solicitudes que reenvía a los backends.

    customRequestHeaders:
      headers:
      - "X-Client-Region:{client_region}"
      - "X-Client-City:{client_city}"
      - "X-Client-CityLatLong:{client_city_lat_long}"
    

En el manifiesto de Servicio, incluye la anotación cloud.google.com/neg: '{"ingress": true}':

    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    ...
    

Limpieza

Después de completar los ejercicios de esta página, sigue estos pasos para quitar los recursos y evitar cargos no deseados en tu cuenta:

Borra los objetos Kubernetes que creaste para este ejercicio:

    kubectl delete ingress my-bsc-ingress
    kubectl delete service my-bsc-service
    kubectl delete backendconfig my-bsc-backendconfig
    kubectl delete deployment my-bsc-deployment
    

Pasos siguientes