Configura un servicio de backend con Ingress

En esta página, se muestra cómo usar un objeto Kubernetes Ingress para configurar ciertas propiedades de un servicio de backend de Google Cloud Platform.

Descripción general

En un clúster de GKE, cuando creas un objeto Kubernetes Ingress, el controlador de entrada de GKE despierta y crea un balanceador de cargas HTTP de Google Cloud Platform. Este controlador de entrada configura el balanceador de cargas y también configura uno o más servicios de backend que están asociados con este.

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

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 con el BackendConfig.
  3. Crea una entrada y asóciala con el par (servicio, puerto).

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.

  • Familiarízate con el recurso personalizado BackendConfig.

Crea una implementación

Antes de crear una BackendConfig y un Servicio, debes crear una implementación. A continuación, se muestra un manifiesto para una 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 a 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 una BackendConfig. El manifiesto especifica:

  • Un tiempo de espera de 40 segundos
  • Una conexión que agota el tiempo de espera de 60 segundos
  • Un valor de tiempo de actividad de cookie de 50 segundos para afinidad con base en cookies
apiVersion: cloud.google.com/v1beta1
kind: BackendConfig
metadata:
  name: my-bsc-backendconfig
spec:
  timeoutSec: 40
  connectionDraining:
    drainingTimeoutSec: 60
  sessionAffinity:
    affinityType: "GENERATED_COOKIE"
    affinityCookieTtlSec: 50

Copia el manifiesto a un archivo llamado my-bsc-backendconfig.yaml y crea la 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 a tener en cuenta sobre tu servicio:

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

  • El puerto TCP 80 del servicio está asociado con una BackendConfig llamado my-bsc-backendconfig. La anotación beta.cloud.google.com/backend-config lo especifica.

  • 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 llamado my-bsc-service.yaml y crea el servicio:

kubectl apply -f my-bsc-service.yaml

Crea un Ingress

Aquí hay un manifiesto para 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 a un archivo llamado 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 HTTPS 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

Enumera los servicios de backend en tu proyecto de GCP.

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.

La salida muestra valores para las propiedades que configuraste:

affinityCookieTtlSec: 50
...
connectionDraining:
  drainingTimeoutSec: 60
...
sessionAffinity: GENERATED_COOKIE
...
timeoutSec: 40

Configura la afinidad de IP de cliente

En el ejercicio anterior, configuraste la afinidad basada en cookies. También puedes usar una BackendConfig para establecer la afinidad de IP de cliente.

La afinidad de IP de cliente es útil solo para servicios que tienen copia de seguridad mediante grupos de extremo de red.

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

sessionAffinity:
  affinityType: "CLIENT_IP"

Para la afinidad de IP de cliente, el campo affinityCookieTtlSec es irrelevante.

En tu 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"}}'
...

Limpieza

Después de completar los ejercicios en esta página, sigue estos pasos para quitar los recursos a fin de evitar incurrir en 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

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

Enviar comentarios sobre...