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 Ingress de Kubernetes, el controlador de entrada de GKE se activa y crea un balanceador de cargas HTTP(S) de Google Cloud Platform. Este controlador de entrada configura el balanceador de cargas y uno o más servicios de backend asociados a este.

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:

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, sigue estos pasos:

  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).

Antes de comenzar

Sigue estos pasos a fin de prepararte para esta tarea:

  • Asegúrate de haber habilitado la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de haber instalado 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

Crea una implementación

Antes de crear una 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 una BackendConfig. El manifiesto especifica lo siguiente:

  • 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. En la anotación beta.cloud.google.com/backend-config, se especifica lo siguiente.

  • 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 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 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 el resultado. 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 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.

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

Puede 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, establece 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 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"}}'
...

Realiza una limpieza

Luego 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

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

Enviar comentarios sobre...

Documentación de Kubernetes Engine