Descripción general

En este lab, crearás dos implementaciones de Pods y trabajarás con tres tipos diferentes de servicios, incluido el recurso de Ingress. Además, explorarás cómo los servicios de Kubernetes en GKE están asociados con los balanceadores de cargas de red de Google Cloud.

Objetivos

En este lab, aprenderás a realizar las siguientes tareas:

• Observar el DNS de Kubernetes en acción
• Definir varios tipos de servicios (ClusterIP, NodePort, LoadBalancer) en manifiestos junto con selectores de etiquetas para establecer una conexión con implementaciones y Pods etiquetados existentes, implementarlos en un clúster y probar la conectividad
• Implementar un recurso de Ingress que conecte a los clientes con dos servicios diferentes según la ruta de URL que se ingrese
• Verificar la creación de un balanceador de cargas de red de Google Cloud para los servicios type=LoadBalancer

Configuración del lab

Accede a Qwiklabs

En cada lab, recibirá un proyecto de Google Cloud y un conjunto de recursos nuevos por tiempo limitado y sin costo adicional.

1. Accede a Qwiklabs desde una ventana de incógnito.

2. Ten en cuenta el tiempo de acceso del lab (por ejemplo, 1:15:00) y asegúrate de finalizarlo en el plazo asignado.
   No existe una función de pausa. Si lo necesita, puede reiniciar el lab, pero deberá hacerlo desde el comienzo.

3. Cuando esté listo, haga clic en Comenzar lab.

4. Anote las credenciales del lab (el nombre de usuario y la contraseña). Las usarás para acceder a la consola de Google Cloud.

5. Haga clic en Abrir Google Console.

6. Haga clic en Usar otra cuenta, copie las credenciales para este lab y péguelas en el mensaje emergente que aparece.
   Si usa otras credenciales, se generarán errores o incurrirá en cargos.

7. Acepta las condiciones y omite la página de recursos de recuperación.

Después de realizar los pasos iniciales de acceso, aparecerá el panel del proyecto.

Abre Cloud Shell

Realizarás la mayor parte del trabajo para este lab en Cloud Shell.

1. En la barra de título de la consola de Google Cloud, haz clic en Activar Cloud Shell ().
2. Haz clic en Continuar.

Después de un momento de aprovisionamiento, se mostrará el prompt de Cloud Shell.

Tarea 1. Conéctate al clúster de GKE del lab y prueba el DNS

En esta tarea, te conectarás al clúster de GKE del lab y crearás un manifiesto de implementación para un conjunto de Pods dentro del clúster, que luego usarás a fin de probar la resolución de DNS del Pod y los nombres de servicio.

Conéctate al clúster de GKE del lab

1. En Cloud Shell, escribe el siguiente comando para crear variables de entorno para el nombre del clúster y la zona de Google Cloud que se usarán en la creación del clúster de este lab:

export my_zone={{{project_0.default_zone | ZONE}}} export my_cluster=standard-cluster-1

2. Configura el completado de línea de comando para la herramienta de línea de comandos de kubectl:

source <(kubectl completion bash)

3. Configura el acceso al clúster para kubectl:

gcloud container clusters get-credentials $my_cluster --zone $my_zone

Tarea 2: Crea Pods y servicios para probar la resolución de DNS

Crearás un servicio llamado dns-demo con dos Pods de aplicación de muestra llamados dns-demo-1 y dns-demo-2.

Clona el repositorio del archivo de origen y, luego, implementa los Pods de la aplicación de muestra

Los Pods que usarás para probar la conectividad de red mediante servicios de Kubernetes se implementan con el archivo de manifiesto dns-demo.yaml, que se te proporcionó en el repositorio de origen. Usarás estos Pods más adelante para probar la conectividad a través de distintos servicios desde sistemas que están dentro del clúster de Kubernetes.

También probarás la conectividad desde direcciones externas mediante Cloud Shell. Puedes usar Cloud Shell para esto porque está en una red completamente independiente de las redes del clúster de Kubernetes.

apiVersion: v1 kind: Service metadata: name: dns-demo spec: selector: name: dns-demo clusterIP: None ports: - name: dns-demo port: 1234 targetPort: 1234 --- apiVersion: v1 kind: Pod metadata: name: dns-demo-1 labels: name: dns-demo spec: hostname: dns-demo-1 subdomain: dns-demo containers: - name: nginx image: nginx --- apiVersion: v1 kind: Pod metadata: name: dns-demo-2 labels: name: dns-demo spec: hostname: dns-demo-2 subdomain: dns-demo containers: - name: nginx image: nginx

1. En Cloud Shell, ingresa el siguiente comando para clonar el repositorio en el entorno de Cloud Shell del lab:

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crea un vínculo simbólico como un acceso directo al directorio de trabajo:

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Cambia al directorio que contenga los archivos de muestra de este lab:

cd ~/ak8s/GKE_Services/

4. Crea el servicio y los Pods:

kubectl apply -f dns-demo.yaml

5. Verifica que tus Pods se estén ejecutando:

kubectl get pods

El resultado debería verse como este ejemplo.

Resultado:

NAME READY STATUS RESTARTS AGE dns-demo-1 1/1 Running 0 8s dns-demo-2 1/1 Running 0 8s

Haz clic en Revisar mi progreso para verificar el objetivo. Crear Pods y servicios para probar la resolución de DNS

6. Para ingresar al clúster, abre una sesión interactiva para bash que se ejecuta desde dns-demo-1:

kubectl exec -it dns-demo-1 -- /bin/bash

Ahora que estás dentro de un contenedor del clúster, los próximos comandos se ejecutarán desde ese contexto, y usarás esto para probar la conectividad de red haciendo ping a distintos destinos en tareas posteriores. Sin embargo, en este contenedor no tienes ninguna herramienta para hacer ping, así que primero deberás instalar el comando ping.

7. Actualiza apt-get y, luego, instala una herramienta de ping:

apt-get update apt-get install -y iputils-ping

8. Haz ping a dns-demo-2:

ping dns-demo-2.dns-demo.default.svc.cluster.local

Este ping no debería tener errores y debería informar que el destino tiene la dirección IP que encontraste antes para el Pod dns-demo-2.

9. Presiona Ctrl + C para anular el comando ping.
10. Haz ping al FQDN del servicio dns-demo, en lugar de hacerlo a un Pod específico dentro del servicio:

ping dns-demo.default.svc.cluster.local

Este ping tampoco debería tener errores, pero mostrará una respuesta desde el FQDN de uno de los dos Pods demo-dns (demo-dns-1 o demo-dns-2).

11. Presiona Ctrl + C para anular el comando ping.

Cuando implementas aplicaciones, el código de la aplicación se ejecuta dentro de un contenedor del clúster y, por lo tanto, puede acceder a otros servicios usando los FQDN de esos servicios desde dentro de ese clúster. Este enfoque es más simple que usar direcciones IP o, incluso, nombres de Pods, porque es mucho más probable que estos cambien.

12. Deja la shell interactiva en dns-demo-1 en ejecución.

Tarea 3: Implementa una carga de trabajo de muestra y un servicio ClusterIP

En esta tarea, crearás un manifiesto de implementación para un conjunto de Pods dentro del clúster y, luego, los expondrás con un servicio ClusterIP.

Implementa una aplicación web de muestra en tu clúster de Kubernetes Engine

En esta tarea, implementarás una imagen del contenedor de la aplicación web de muestra que escucha en un servidor HTTP en el puerto 8080. Con este fin, usarás el siguiente manifiesto que se acaba de crear para ti en el archivo de manifiesto hello-v1.yaml.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v1 spec: replicas: 3 selector: matchLabels: run: hello-v1 template: metadata: labels: run: hello-v1 name: hello-v1 spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: hello-v1 ports: - containerPort: 8080 protocol: TCP

1. En la barra de menú de Cloud Shell, haz clic en el ícono del signo más () para iniciar una nueva sesión de Cloud Shell.

Aparecerá una segunda sesión en tu ventana de Cloud Shell. Para pasar de una sesión a otra, haz clic en la barra de menú.

2. En la segunda pestaña de Cloud Shell, cambia al directorio que contiene los archivos de muestra de este lab:

cd ~/ak8s/GKE_Services/

3. Para crear una implementación a partir del archivo hello-v1.yaml, ejecuta el siguiente comando:

kubectl create -f hello-v1.yaml

4. Para ver una lista de implementaciones, ejecuta el siguiente comando:

kubectl get deployments

El resultado debería verse como este ejemplo.

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 14s

Define los tipos de servicios en el manifiesto

En esta tarea, implementarás un objeto Service mediante un ClusterIP. Con este fin, usarás el manifiesto de muestra hello-svc.yaml que ya se creó para ti.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: ClusterIP selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080

1. Para implementar el servicio ClusterIP, ejecuta el siguiente comando:

kubectl apply -f ./hello-svc.yaml

Este manifiesto define un servicio ClusterIP y lo aplica a Pods que corresponden al selector. En este caso, el manifiesto se aplica a los Pods de hello-v1 que implementó. Este servicio se aplicará automáticamente a cualquier otra implementación con la etiqueta name: hello-v1.

2. Verifica que se haya creado el servicio y que se haya asignado una IP del clúster:

kubectl get service hello-svc

Tu dirección IP quizás sea distinta a la del resultado de ejemplo.

Resultado:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc ClusterIP 10.11.253.203 80/TCP 20s

No hay ninguna IP externa asignada para este servicio. Dado que las direcciones IP del clúster de Kubernetes no son accesibles externamente de manera predeterminada, crear este servicio no hace que tu aplicación sea accesible fuera del clúster.

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar una carga de trabajo de muestra y un servicio ClusterIP

Prueba tu aplicación

1. En Cloud Shell, intenta abrir una sesión HTTP para el nuevo servicio con el siguiente comando:

curl hello-svc.default.svc.cluster.local

La conexión debería fallar porque ese servicio no está expuesto fuera del clúster.

Resultado:

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Ahora probarás el servicio desde el interior del clúster con la shell interactiva que se ejecuta en el Pod dns-demo-1.

2. Regresa a la primera ventana de Cloud Shell, que actualmente redirecciona el stdin y el stdout del Pod dns-demo-1.
3. Instala curl para poder hacer llamadas a los servicios web desde la línea de comandos:

apt-get install -y curl

4. Usa el siguiente comando para probar la conexión HTTP entre los Pods:

curl hello-svc.default.svc.cluster.local

Esta conexión debería establecerse correctamente y proporcionar una respuesta similar a la del resultado a continuación. Tu nombre de host quizás sea distinto al del resultado de ejemplo.

Resultado:

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Esta conexión funciona porque el servicio ClusterIP se puede resolver con el DNS interno dentro del clúster de Kubernetes Engine.

Tarea 4: Convierte el servicio para usar NodePort

En esta tarea, convertirás tu servicio ClusterIP existente a un servicio NodePort y, luego, volverás a probar el acceso al servicio desde el interior y el exterior del clúster.

Ya se creó para ti una versión modificada del archivo hello-svc.yaml llamada hello-nodeport-svc.yaml, que cambia el tipo de servicio a NodePort.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: NodePort selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080 nodePort: 30100

1. Regresa a tu segunda ventana de Cloud Shell. Esta ventana NO está conectada al stdin ni al stdout del Pod dns-test.
2. Para implementar el manifiesto que cambia el tipo de servicio de hello-svc a NodePort, ejecuta el siguiente comando:

kubectl apply -f ./hello-nodeport-svc.yaml

Este manifiesto redefine hello-svc como un servicio NodePort y asigna el puerto de servicio 30100 en cada nodo del clúster para ese servicio.

3. Ingresa el siguiente comando para verificar que el tipo de servicio haya cambiado a NodePort:

kubectl get service hello-svc

Tu dirección IP quizás sea distinta a la del resultado de ejemplo.

Resultado:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc NodePort 10.11.253.203 80:30100/TCP 59m Nota: No hay ninguna IP externa asignada para este servicio.

Haz clic en Revisar mi progreso para verificar el objetivo. Convertir el servicio para usar NodePort

Prueba tu aplicación

1. En Cloud Shell, intenta abrir una sesión HTTP para el nuevo servicio con el siguiente comando:

curl hello-svc.default.svc.cluster.local

La conexión debería fallar porque ese servicio no está expuesto fuera del clúster.

Resultado:

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Ahora probarás el servicio desde otro Pod.

2. Regresa a la primera ventana de Cloud Shell, que actualmente redirecciona el stdin y el stdout del Pod dns-test.
3. Usa el siguiente comando para probar la conexión HTTP entre los Pods:

curl hello-svc.default.svc.cluster.local

Esta conexión debería establecerse correctamente y proporcionar una respuesta similar a la del resultado a continuación. Tu nombre de host quizás sea distinto al del resultado de ejemplo.

Resultado:

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Esta conexión funciona porque el ClusterIP se puede resolver con el DNS interno dentro del clúster de GKE.

Tarea 5: Crea direcciones IP públicas estáticas usando Herramientas de redes de Google Cloud

Reserva direcciones IP estáticas de Herramientas de redes de Google Cloud

1. En el menú de navegación de la consola de Google Cloud, navega a Herramientas de redes > Red de VPC > Direcciones IP.

2. Haz clic en Reservar dirección IP externa estática.

3. En Nombre, ingresa regional-loadbalancer.

4. Explora las opciones, pero deja la configuración restante con sus valores predeterminados. Ten en cuenta que el tipo predeterminado es Regional.

Nota: La región predeterminada debe coincidir con aquella en la que implementaste el clúster de GKE. Si este no es el caso, cambia la región para que coincida con la que usaste para crear el clúster. Si aceptaste los valores predeterminados del lab, esa debería ser la región .

5. Haz clic en Reservar.

6. Anota la dirección IP externa llamada regional-loadbalancer. La usarás más adelante en el lab.

7. Haz clic en Reservar dirección IP externa estática.

8. En Nombre, ingresa global-ingress.

9. Cambia el tipo a Global.

10. Deja la configuración restante con sus valores predeterminados.

11. Haz clic en Reservar.

12. Anota la dirección IP externa llamada global-ingress. La usarás más adelante en el lab.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear direcciones IP públicas estáticas mediante Herramientas de redes de Google Cloud

Tarea 6: Implementa un nuevo conjunto de Pods y un servicio LoadBalancer

Ahora implementarás un nuevo conjunto de Pods que ejecutan una versión diferente de la aplicación para que puedas diferenciar fácilmente los dos servicios. Luego, expondrás los nuevos Pods como un servicio LoadBalancer y accederás al servicio desde el exterior del clúster.

Ya se creó para ti un segundo manifiesto de objeto Deployment llamado hello-v2.yaml, que crea una nueva implementación que ejecuta la versión 2 de la aplicación de muestra hello en el puerto 8080.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v2 spec: replicas: 3 selector: matchLabels: run: hello-v2 template: metadata: labels: run: hello-v2 name: hello-v2 spec: containers: - image: gcr.io/google-samples/hello-app:2.0 name: hello-v2 ports: - containerPort: 8080 protocol: TCP

1. Regresa a tu segunda ventana de Cloud Shell. Esta ventana NO está conectada al stdin ni al stdout del Pod dns-test.
2. Para implementar el manifiesto que crea la implementación hello-v2, ejecuta el siguiente comando:

kubectl create -f hello-v2.yaml

3. Para ver una lista de implementaciones, ejecuta el siguiente comando:

kubectl get deployments

El resultado debería verse como este ejemplo.

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 18m hello-v2 3/3 3 3 7s

Define los tipos de servicios en el manifiesto

En esta tarea, implementarás un objeto Service de tipo LoadBalancer. Para eso, usarás el manifiesto de muestra hello-lb-svc.yaml que ya se creó para ti.

Usarás el comando sed a fin de reemplazar la dirección del marcador de posición 10.10.10.10 en el archivo YAML del balanceador de cargas por la dirección estática que reservaste antes para el balanceador.

apiVersion: v1 kind: Service metadata: name: hello-lb-svc spec: type: LoadBalancer loadBalancerIP: 10.10.10.10 selector: name: hello-v2 ports: - protocol: TCP port: 80 targetPort: 8080

1. Asegúrate de estar todavía en la segunda ventana de Cloud Shell. Esta ventana NO está conectada al stdin ni al stdout del Pod dns-test.

2. Ingresa el siguiente comando en Cloud Shell para guardar en una variable de entorno la dirección IP estática regional que creaste antes:

   export STATIC_LB=$(gcloud compute addresses describe regional-loadbalancer --region {{{project_0.default_region | REGION}}} --format json | jq -r '.address')

3. Ingresa el siguiente comando en Cloud Shell para reemplazar la dirección del marcador de posición por la dirección IP estática regional:

sed -i "s/10\.10\.10\.10/$STATIC_LB/g" hello-lb-svc.yaml

4. Para verificar que se reemplazó correctamente la dirección IP externa, escribe el siguiente comando en Cloud Shell:

cat hello-lb-svc.yaml

El campo loadBalancerIP debería coincidir con la dirección que anotaste anteriormente para la dirección IP estática reservada regional-loadbalancer.

5. Para implementar tu manifiesto del servicio LoadBalancer, ejecuta el siguiente comando:

kubectl apply -f ./hello-lb-svc.yaml

Este manifiesto define un servicio LoadBalancer, que implementa un balanceador de cargas de red de Google Cloud para proporcionar acceso externo al servicio. Este servicio se aplica únicamente a los Pods con el selector name: hello-v2.

6. Verifica que se haya creado el servicio y que se haya asignado un puerto de nodo:

kubectl get services

Tu dirección IP quizás sea distinta a la del resultado de ejemplo.

Resultado:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dns-demo ClusterIP None 1234/TCP 1h hello-lb-svc LoadBalancer 10.11.253.48 35.184.45.240 80:30103/TCP 2m hello-svc NodePort 10.11.253.203 80:30100/TCP 1h kubernetes ClusterIP 10.11.240.1 443/TCP 2h

Observa que el nuevo servicio LoadBalancer muestra la dirección reservada regional-loadbalancer como su dirección IP externa. En entornos de GKE, el balanceador de cargas externo para el tipo de servicio LoadBalancer se implementa usando un balanceador de cargas de Google Cloud y tardará unos minutos en crearse. Esta dirección IP externa hace que el servicio sea accesible desde el exterior del clúster.

Confirma que se haya creado un balanceador de cargas regional de Google Cloud

1. En la consola de Google Cloud, navega a Herramientas de redes > Servicios de red > Balanceo de cargas.

Deberías ver un balanceador de cargas TCP con 1 backend del grupo de destino y 2 instancias.

2. Haz clic en el nombre para abrir la página de detalles.

En los detalles, se debería mostrar que se trata de un balanceador de cargas TCP regional que usa la dirección IP estática a la que asignaste el nombre regional-loadbalancer cuando la reservaste anteriormente.

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar un nuevo conjunto de Pods y un servicio LoadBalancer

Prueba tu aplicación

1. En Cloud Shell, intenta abrir una sesión HTTP para el nuevo servicio con el siguiente comando:

curl hello-lb-svc.default.svc.cluster.local

La conexión debería fallar porque ese nombre de servicio no está expuesto fuera del clúster.

Resultado:

curl: (6) Could not resolve host: hello-lb-svc.default.svc.cluster.local

Esto ocurre porque la dirección IP externa no está registrada con este nombre de host.

2. Vuelve a probar la conexión usando la dirección IP externa asociada con el servicio de balanceador de cargas regional. Escribe el siguiente comando y reemplaza [external_IP] por la dirección IP externa de tu servicio:

curl [external_IP]

Ejemplo:

curl 35.184.45.240

Esta vez, la conexión no fallará porque se puede alcanzar la dirección IP externa de LoadBalancer desde fuera de Google Cloud.

Nota: Puede tardar hasta 5 minutos en estar disponible.

Resultado:

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

3. Regresa a la primera ventana de Cloud Shell, que actualmente redirecciona el stdin y el stdout del Pod dns-demo-1.
4. Usa el siguiente comando para probar la conexión HTTP entre los Pods:

curl hello-lb-svc.default.svc.cluster.local

Esta conexión debería establecerse correctamente y proporcionar una respuesta similar a la del resultado a continuación. Tu nombre de host será distinto al del resultado de ejemplo.

Resultado:

root@dns-demo-1:/# curl hello-lb-svc.default.svc.cluster.local Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-78ggz root@dns-demo-1:/#

El nombre de DNS interno funciona dentro del Pod, y tú podrás ver que está accediendo a la misma versión v2 de la aplicación, como si estuviera en el exterior del clúster y usara la dirección IP externa.

5. Prueba nuevamente la conexión dentro del Pod con la dirección IP externa asociada con este servicio. Escribe el siguiente comando y reemplaza [external_IP] por la dirección IP externa de tu servicio:

curl [external_IP]

Ejemplo:

curl 35.184.45.240

Resultado:

root@dns-demo-1:/# curl 35.184.45.240 Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d root@dns-demo-1:/#

La IP externa también funciona desde el interior de los Pods que se ejecutan en el clúster y devuelve como resultado la misma versión v2 de las aplicaciones.

6. Escribe “exit” para salir de la sesión de redireccionamiento de la consola al Pod:

exit

Esto te llevará nuevamente al símbolo del sistema de Cloud Shell.

Tarea 7. Implementa un recurso de Ingress

En tu clúster, tienes dos servicios para la aplicación hello. Uno de ellos aloja la versión 1.0 mediante un servicio NodePort, mientras que el otro aloja la versión 2.0 mediante un servicio LoadBalancer. Ahora implementarás un recurso de Ingress que dirigirá el tráfico a ambos servicios en función de la URL que ingrese el usuario.

Crea un recurso de Ingress

Ingress es un recurso de Kubernetes que encapsula una colección de reglas y parámetros de configuración para enrutar el tráfico HTTP(S) externo a los servicios internos.

En GKE, Ingress se implementa con Cloud Load Balancing. Cuando creas un recurso de Ingress en tu clúster, GKE crea un balanceador de cargas HTTP(S) y lo configura para enrutar el tráfico a tu aplicación.

Para configurar un recurso de Ingress, se creó un manifiesto de muestra llamado hello-ingress.yaml.

apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: hello-ingress annotations: nginx.ingress.kubernetes.io/rewrite-target: / kubernetes.io/ingress.global-static-ip-name: "global-ingress" spec: rules: - http: paths: - path: /v1 pathType: ImplementationSpecific backend: service: name: hello-svc port: number: 80 - path: /v2 pathType: ImplementationSpecific backend: service: name: hello-lb-svc port: number: 80

Este archivo de configuración define un recurso de Ingress que se adjuntará a la dirección IP estática global-ingress que creaste en un paso anterior. Este recurso de Ingress creará un balanceador de cargas HTTP(S) global que dirige el tráfico a tus servicios web en función de la ruta de acceso ingresada.

La anotación kubernetes.io/ingress.global-static-ip-name permite especificar una dirección IP reservada con nombre que el recurso de Ingress usará cuando se cree el balanceador de cargas HTTP(S) global de Google Cloud para el recurso.

• Para implementar este recurso de Ingress, ejecuta el siguiente comando:

kubectl apply -f hello-ingress.yaml

Una vez que implementes este manifiesto, Kubernetes creará un recurso de Ingress en tu clúster. El controlador de Ingress que se ejecuta en el clúster es responsable de crear un balanceador de cargas HTTP(S) para enrutar todo el tráfico HTTP externo (en el puerto 80) al servicio web NodePort y al servicio LoadBalancer que expusiste.

Confirma que se creó un balanceador de cargas HTTP(S) global

1. En la consola de Google Cloud, navega a Herramientas de redes > Servicios de red > Balanceo de cargas. Ahora también deberías ver un balanceador de cargas HTTP(S).

2. Haz clic en el nombre para abrir la página de detalles. En los detalles, se debería mostrar que se trata de un balanceador de cargas HTTP(S) global que usa la dirección IP estática a la que asignó el nombre global-ingress cuando la reservaste anteriormente.

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar un recurso de Ingress

Prueba tu aplicación

1. Para obtener la dirección IP externa del balanceador de cargas que entrega tu aplicación, ejecuta el siguiente comando:

kubectl describe ingress hello-ingress

Resultado parcial:

Name: hello-ingress Namespace: default Address: 35.244.173.44 Default backend: default-http-backend:80 (10.8.2.5:8080) Rules: Host Path Backends ---- ---- -------- * /v1 hello-svc:80 () /v2 hello-lb-svc:80 () [...] ingress.kubernetes.io/backends:{"k8s-[...]"HEALTHY"[...]} [...] Events: Type Reason Age From Message ---- ------ --- ---- ------- Normal ADD 5m loadbalancer-controller default/hello-ingress Normal CREATE 5m loadbalancer-controller ip: 35.244.173.44 Nota: Debes esperar unos minutos para que el balanceador de cargas se active y las verificaciones de estado se realicen correctamente antes de que se muestre la dirección externa.

Repite el comando cada algunos minutos para verificar si el recurso de Ingress terminó de inicializarse. Cuando se haya creado e inicializado el balanceador de cargas HTTP(S) global de Google Cloud, el comando informará la dirección IP externa, la cual coincidirá con la dirección IP estática global global-ingress que reservó antes.

2. Usa la dirección IP externa asociada con el recurso de Ingress y escribe el siguiente comando, pero sustituye [external_IP] con la dirección IP externa del recurso de Ingress. Asegúrate de incluir /v1 en la ruta de URL:

curl http://[external_IP]/v1

Ejemplo:

curl http://35.201.92.69/v1

Resultado:

Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-4rmqw

La URL de la v1 está configurada en hello-ingress.yaml para apuntar al servicio NodePort de hello-svc que dirige el tráfico a los Pods de la v1 de la aplicación.

Nota: GKE puede tardar unos minutos en configurar reglas de reenvío hasta que el balanceador de cargas global utilizado para el recurso de Ingress esté listo y pueda entregar tu aplicación.

Mientras tanto, es posible que recibas errores, como HTTP 404 o HTTP 500, hasta que la configuración del balanceador de cargas se propague por todo el mundo.

3. Ahora prueba la ruta de URL de la v2 desde Cloud Shell. Usa la dirección IP externa asociada con el recurso de Ingress y escribe el siguiente comando, pero sustituye [external_IP] con la dirección IP externa del recurso de Ingress. Asegúrate de incluir /v2 en la ruta de URL:

curl http://[external_IP]/v2

La URL de la v2 está configurada en hello-ingress.yaml para apuntar al servicio LoadBalancer de hello-lb-svc que dirige el tráfico a los Pods de la v2 de la aplicación.

Ejemplo:

curl http://35.201.92.69/v2

Resultado:

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

Inspecciona los cambios en tus recursos de red en la consola de Google Cloud

1. En el menú de navegación de la consola de Google Cloud, haz clic en Herramientas de redes > Servicios de red > Balanceo de cargas.

Ahora se mostrarán dos balanceadores de cargas:

• Uno es el balanceador de cargas regional inicial para el servicio hello-lb-svc. Tiene un nombre de estilo ID único y está configurado para balancear las cargas del tráfico del puerto TCP 80 a los nodos del clúster.

• El segundo se creó para el objeto de Ingress y es un balanceador de cargas HTTP(S) completo que incluye reglas de host y de ruta de acceso que coinciden con la configuración de Ingress. Este incluirá hello-ingress en su nombre.

2. Haz clic en el balanceador de cargas que incluye hello-ingress en el nombre.

Mostrará información resumida sobre los protocolos, los puertos, las rutas de acceso y los servicios de backend del balanceador de cargas HTTP(S) global de Google Cloud creado para el recurso de Ingress.

Finalice su lab

Cuando haya completado el lab, haga clic en Finalizar lab. Google Cloud Skills Boost quitará los recursos que usó y limpiará la cuenta.

Tendrá la oportunidad de calificar su experiencia en el lab. Seleccione la cantidad de estrellas que corresponda, ingrese un comentario y haga clic en Enviar.

La cantidad de estrellas indica lo siguiente:

• 1 estrella = Muy insatisfecho
• 2 estrellas = Insatisfecho
• 3 estrellas = Neutral
• 4 estrellas = Satisfecho
• 5 estrellas = Muy satisfecho

Puede cerrar el cuadro de diálogo si no desea proporcionar comentarios.

Para enviar comentarios, sugerencias o correcciones, use la pestaña Asistencia.

Copyright 2020 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.