Grupos de extremos de red independientes

En esta página, se muestra cómo crear un servicio de Kubernetes respaldado por un grupo de extremos de red.

Descripción general

Google Cloud Platform tiene una variedad de componentes de balanceo de cargas que puedes combinar de diferentes maneras para balancear las cargas de tus aplicaciones. Los pasos que se describen en este tema combinan los siguientes componentes para proporcionar balanceo de cargas a un servicio de Kubernetes:

En el siguiente diagrama, se ilustran las conexiones entre los componentes:

Diagrama de los componentes de balanceo de cargas para un grupo de extremos de red

Esta es una descripción general de los pasos que realizarás en este tema:

  1. Crea una implementación que tenga tres pods. Cada pod tiene un contenedor que escucha en el puerto TCP 50000.

  2. Crea un servicio. Incluye la anotación cloud.google.com/neg en tu manifiesto de servicio. Esto hace que un controlador de GKE cree un grupo de extremos de red.

  3. Crea una verificación de estado.

  4. Crea un servicio de backend. Conecta el servicio de backend a tu verificación de estado y grupo de extremos de red.

  5. Crea un proxy TCP. Conecta el proxy TCP a tu servicio de backend.

  6. Crea una regla de reenvío. Conecta la regla de reenvío a tu proxy TCP.

  7. Prueba tu regla de reenvío.

Antes de comenzar

Debes tener un clúster que ejecute la versión 1.10 o posterior de Google Kubernetes Engine.

Tu clúster debe ser nativo de VPC. Si quieres obtener más información, consulta Cómo crear clústeres de VPC nativa con direcciones IP de alias.

Tu clúster debe tener habilitado el balanceo de cargas HTTP. Los clústeres de GKE tienen habilitado el balanceo de cargas HTTP de forma predeterminada. No debes inhabilitarlo.

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

Crea un grupo de extremos de red

Este es un manifiesto para una implementación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      purpose: demo
      topic: standalone-neg
  replicas: 3
  template:
    metadata:
      labels:
        purpose: demo
        topic: standalone-neg
    spec:
      containers:
      - name: hello
        image: debian
        command: ["/bin/bash"]
        args:
        - "-c"
        - "apt-get update && apt-get install -y netcat && while true; do echo Hello TCP | nc -l -p 50000; done"

La implementación tiene tres pods, cada uno de los cuales tiene un contenedor.

Los campos cmd y args en el manifiesto de implementación usan netcat (nc) para implementar un servidor TCP simple que escucha las conexiones en el puerto 50000.

Copia el manifiesto a un archivo con el nombre my-deployment.yaml y crea la implementación:

kubectl apply -f my-deployment.yaml

A continuación, se detalla un manifiesto para un servicio:

apiVersion: v1
kind: Service
metadata:
  name: my-service
  annotations:
    cloud.google.com/neg: '{"exposed_ports": {"80":{}}}'
spec:
  type: ClusterIP
  selector:
    purpose: demo
    topic: standalone-neg
  ports:
  - name: my-service-port
    protocol: TCP
    port: 80
    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 purpose: demo y topic: standalone-neg será un miembro del servicio.

  • El servicio tiene una estructura servicePort llamada my-service-port. La anotación cloud.googe.com/neg dice que my-service-port estará asociado con un grupo de extremos de red.

  • Cada pod miembro debe tener un contenedor que esté escuchando en el puerto TCP 50000.

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

kubectl apply -f my-service.yaml

Cuando creas el servicio, un controlador de GKE crea un grupo de extremos de red.

Espera un minuto para que se cree el grupo de extremos de red. Luego, puedes inspeccionarlo con gcloud o Google Cloud Platform Console.

gcloud

Obtén una lista de los grupos de extremos de red:

gcloud compute network-endpoint-groups list

El resultado muestra que tu grupo de extremos de red tiene tres extremos:

NAME                                          LOCATION       ENDPOINT_TYPE   SIZE
k8s1-70aa83a6-default-my-service-80-c9710a6f  us-central1-a  GCE_VM_IP_PORT  3

Visualiza los extremos:

gcloud compute network-endpoint-groups list-network-endpoints \
    [NETWORK_ENDPOINT_GROUP_NAME]

donde [NETWORK_ENDPOINT_GROUP_NAME] es el nombre de tu grupo de extremos de red.

El resultado muestra tres extremos. Cada extremo es un par (dirección IP de pod, puerto).

INSTANCE                                           IP_ADDRESS  PORT
gke-standard-cluster-3-default-pool-4cc71a15-qlpf  10.12.1.43  50000
gke-standard-cluster-3-default-pool-4cc71a15-qlpf  10.12.1.44  50000
gke-standard-cluster-3-default-pool-4cc71a15-w9nk  10.12.2.26  50000
````

Console

  1. Visita la lista Grupos de extremos de red en GCP Console.

    Visitar Grupos de extremos de red

    Aparecerá la lista de los grupos de extremos de red de tu proyecto.

  2. Haz clic en el nombre de tu extremo de red. Aparecerán los detalles de tu grupo de extremos de red, incluida la cantidad de extremos, subredes, direcciones IP y puertos.

Crea una regla de firewall

Más adelante en este ejercicio, crearás una verificación de estado y un proxy TCP.

Crea una regla de firewall para permitir el tráfico de TCP desde el proxy TCP y la verificación de estado:

gcloud compute firewall-rules create my-fwr --network default \
    --source-ranges 130.211.0.0/22,35.191.0.0/16 --allow tcp

Crea una verificación de estado y un servicio de backend

Crea una verificación de estado de la siguiente forma:

gcloud compute health-checks create tcp my-hc --use-serving-port --global

Crea un servicio de backend:

gcloud compute backend-services create my-bes --global \
    --protocol tcp --health-checks my-hc

Agrega tu grupo de extremos de red al servicio de backend.

gcloud compute backend-services add-backend my-bes --global \
   --network-endpoint-group [NETWORK_ENDPOINT_GROUP_NAME] \
   --network-endpoint-group-zone [NETWORK_ENDPOINT_GROUP_ZONE] \
   --balancing-mode CONNECTION --max-connections-per-endpoint 5

donde:

  • [NETWORK_ENDPOINT_GROUP_NAME] es el nombre de tu grupo de extremos de red.
  • [NETWORK_ENDPOINT_GROUP_ZONE] es la zona del grupo.

Describe tu servicio de backend:

gcloud compute backend-services describe my-bes --global

El resultado muestra que el servicio de backend está asociado con la verificación de estado y el grupo de extremos de red.

...
backends:
- balancingMode: CONNECTION
  capacityScaler: 1.0
  group: ... /networkEndpointGroups/k8s1-70aa83a6-default-my-service-80-c9710a6f
...
healthChecks:
- ... /healthChecks/my-hc
...
name: my-bes
...

Espera cinco minutos para que se configure tu servicio de backend.

Verifica el estado del servicio de backend:

gcloud compute backend-services get-health my-bes --global

El resultado muestra el estado de cada extremo:

...
status:
  healthStatus:
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-qlpf
    ipAddress: 10.12.1.43
    port: 50000
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-qlpf
    ipAddress: 10.12.1.44
    port: 50000
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-w9nk
    ipAddress: 10.12.2.26
    port: 50000

Crea un proxy TCP y una regla de reenvío

Crea un proxy TCP:

gcloud compute target-tcp-proxies create my-tp --backend-service my-bes

Crea una regla de reenvío:

gcloud compute forwarding-rules create my-for --global \
    --ip-protocol tcp --ports 25 --target-tcp-proxy my-tp

Visualiza la regla de reenvío:

gcloud compute forwarding-rules describe my-for --global

El resultado muestra la dirección IP externa de la regla de reenvío:

IPAddress: 203.0.113.1
IPProtocol: TCP
...
kind: compute#forwardingRule
loadBalancingScheme: EXTERNAL
name: my-for
...
portRange: 25 - 25

Espera diez minutos para que se configure la regla de reenvío.

Usa netcat para probar la regla de reenvío:

nc -v [EXTERNAL_IP_ADDRESS] 25

donde [EXTERNAL_IP_ADDRESS] es la dirección IP externa de la regla de reenvío.

El resultado muestra la respuesta de uno de tus contenedores:

Connection to 203.0.113.1 25 port [tcp/smtp] succeeded!
Hello TCP

Limpia

Después de completar las tareas que se detallan en esta página, ingresa estos comandos para quitar los recursos y evitar cargos no deseados a tu cuenta:

gcloud compute forwarding-rules delete my-for --global --quiet
gcloud compute target-tcp-proxies delete my-tp --quiet
gcloud compute backend-services delete my-bes --quiet --global
gcloud compute firewall-rules delete my-fwr --quiet
gcloud compute health-checks delete my-hc --quiet
kubectl delete service my-service
kubectl delete deployment my-deployment

¿Qué sigue?

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Documentación de Kubernetes Engine