Puntos de control
Create a Kubernetes cluster and launch Nginx container
/ 25
Create Monolith pods and service
/ 25
Allow traffic to the monolith service on the exposed nodeport
/ 5
Adding Labels to Pods
/ 20
Creating Deployments (Auth, Hello and Frontend)
/ 25
Organiza la nube con Kubernetes (Azure)
- GSP1121
- Descripción general
- Configuración y requisitos
- Tarea 1: Obtén el código de muestra
- Tarea 2: Haz una demostración rápida de Kubernetes
- Tarea 3: Pods
- Tarea 4: Crea Pods
- Tarea 5: Interactúa con los Pods
- Tarea 6: Services
- Tarea 7: Crea un Service
- Tarea 8: Agrega etiquetas a los Pods
- Tarea 9: Implementa aplicaciones con Kubernetes
- Tarea 10: Crea implementaciones
- ¡Felicitaciones!
GSP1121
Descripción general
Kubernetes es uno de los métodos que más usan los profesionales de la nube para implementar aplicaciones. Probablemente hayas usado una solución de Kubernetes administrada para implementar aplicaciones en tu organización. Estas son algunas de las preguntas clave que surgen cuando se usa Kubernetes para implementar y alojar aplicaciones:
- ¿Qué servicio de balanceo de cargas requiere la app?
- ¿Cómo se administrará la infraestructura subyacente?
En Azure, Azure Kubernetes Service (AKS) administra la infraestructura subyacente para Pods, nodos y redes, gestiona la capa de acceso entre componentes y proporciona los servicios de Kubernetes para respaldar el ciclo de vida de las aplicaciones.
Probablemente hayas implementado aplicaciones en Azure AKS a través de la línea de comandos con Azure CLI y kubectl. La solución administrada de Kubernetes de Google Cloud, Google Kubernetes Engine (GKE), ofrece las mismas funciones que AKS. Puedes utilizar los mismos comandos de la CLI y kubectl con GKE y AKS.
En este lab, aprenderás a hacer lo siguiente:
- Usar Kubernetes Engine para aprovisionar un clúster completo de Kubernetes
- Usar
kubectl
para implementar y administrar contenedores de Docker - Usar las implementaciones y los servicios de Kubernetes para dividir una aplicación en microservicios
Kubernetes se basa en aplicaciones. En esta parte del lab, usarás una aplicación de ejemplo llamada “app”.
Kubernetes es un proyecto de código abierto (disponible en kubernetes.io) que se puede ejecutar en distintos entornos, desde laptops hasta clústeres de múltiples nodos de alta disponibilidad, desde nubes públicas hasta implementaciones locales, desde máquinas virtuales hasta equipos físicos.
En este lab, usar un entorno administrado como Kubernetes Engine te permite concentrarte en experimentar con Kubernetes en vez de en configurar la infraestructura subyacente.
Configuración y requisitos
Antes de hacer clic en el botón Comenzar lab
Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.
Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.
Para completar este lab, necesitarás lo siguiente:
- Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)
- Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.
Cómo iniciar su lab y acceder a la consola de Google Cloud
-
Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab que tiene estos elementos:
- El botón Abrir la consola de Google
- Tiempo restante
- Las credenciales temporales que debe usar para el lab
- Otra información para completar el lab, si es necesaria
-
Haga clic en Abrir la consola de Google. El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.
Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.
Nota: Si ve el diálogo Elegir una cuenta, haga clic en Usar otra cuenta. -
Si es necesario, copie el nombre de usuario del panel Detalles del lab y péguelo en el cuadro de diálogo Acceder. Haga clic en Siguiente.
-
Copie la contraseña del panel Detalles del lab y péguela en el cuadro de diálogo de bienvenida. Haga clic en Siguiente.
Importante: Debe usar las credenciales del panel de la izquierda. No use sus credenciales de Google Cloud Skills Boost. Nota: Usar su propia Cuenta de Google podría generar cargos adicionales. -
Haga clic para avanzar por las páginas siguientes:
- Acepte los términos y condiciones.
- No agregue opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
- No se registre para obtener pruebas gratuitas.
Después de un momento, se abrirá la consola de Cloud en esta pestaña.
Activa Cloud Shell
Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.
- Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.
Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. El resultado contiene una línea que declara el PROJECT_ID para esta sesión:
gcloud
es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.
- Puedes solicitar el nombre de la cuenta activa con este comando (opcional):
-
Haz clic en Autorizar.
-
Ahora, el resultado debería verse de la siguiente manera:
Resultado:
- Puedes solicitar el ID del proyecto con este comando (opcional):
Resultado:
Resultado de ejemplo:
gcloud
, consulta la guía con la descripción general de gcloud CLI en Google Cloud.
Google Kubernetes Engine
- En Cloud Shell, escribe el siguiente comando para establecer la zona:
- Inicia un clúster para usarlo en este lab con el siguiente comando:
gcloud container clusters get-credentials io
para volver a autenticarte.
Tarea 1: Obtén el código de muestra
- En Cloud Shell, ingresa el siguiente comando para clonar el repositorio en el entorno de Cloud Shell del lab.
-
Crea un vínculo simbólico como un acceso directo al directorio de trabajo:
ln -s ~/training-data-analyst/courses/ak8s/CloudBridge ~/ak8s -
Cambia al directorio necesario para este lab con este comando:
cd ~/ak8s/ -
Solicita una lista de los archivos con los que trabajarás:
La muestra tiene el siguiente diseño:
Ya puedes usar el código para probar Kubernetes.
Tarea 2: Haz una demostración rápida de Kubernetes
La forma más fácil de comenzar a usar Kubernetes es utilizar el comando kubectl create
.
- Úsalo para iniciar una sola instancia del contenedor nginx:
Kubernetes ya creó una implementación; hablaremos sobre ellas más adelante. Por el momento, todo lo que necesitas saber es que las implementaciones mantienen a los Pods en funcionamiento, incluso cuando fallan los nodos en los que se ejecutan.
En Kubernetes, todos los contenedores se ejecutan en un Pod.
- Usa el comando
kubectl get pods
para ver el contenedor nginx en ejecución:
- Una vez que el contenedor nginx alcance el estado Running, podrás exponerlo por fuera de Kubernetes con el comando
kubectl expose
:
¿Qué acaba de suceder? En segundo plano, Kubernetes creó un balanceador de cargas externo vinculado a una dirección IP pública. Los clientes que accedan a esa dirección IP pública serán redirigidos a los Pods del servicio. En este caso, esto correspondería al Pod de nginx.
- Crea una lista de nuestros servicios con el comando
kubectl get services
:
ExternalIP
se complete para el servicio. Esto es normal; solo vuelve a ejecutar el comando kubectl get services
cada algunos segundos hasta que se complete el campo.
- Para acceder al contenedor nginx de forma remota, agrega la IP externa a este comando:
Listo. Kubernetes es compatible con un flujo de trabajo inmediato y fácil de usar mediante los comandos kubectl
run y expose.
Prueba la tarea completada
Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste un clúster de Kubernetes con éxito y también implementaste un contenedor Nginx, verás una puntuación de evaluación.
Ahora que terminaste de revisar esta breve demostración de Kubernetes, es hora de profundizar en cada uno de los componentes y las abstracciones.
Tarea 3: Pods
Los Pods son uno de los conceptos centrales de Kubernetes.
Representan y contienen una colección de uno o más contenedores. Por lo general, si tienes varios contenedores que dependen fuertemente entre sí, los empaquetas en un solo Pod.
En este ejemplo, tenemos un Pod con los contenedores monolith y nginx.
Los Pods también tienen volúmenes. Son discos de datos que funcionan en tanto los Pods estén activos, y los pueden usar los contenedores del Pod correspondiente. Los Pods proporcionan un espacio de nombres compartido para sus contenidos. Esto significa que los dos contenedores de nuestro Pod de ejemplo se pueden comunicar entre sí y, además, comparten los volúmenes adjuntos.
Los Pods también comparten un espacio de nombres de red, lo que significa que hay una dirección IP por Pod.
A continuación, profundizaremos en los Pods.
Tarea 4: Crea Pods
Los Pods se pueden crear con archivos de configuración de Pod. Dedica un momento a explorar el archivo de configuración del Pod monolith.
- Ve al siguiente directorio:
- Ejecuta lo siguiente:
El resultado muestra el archivo de configuración abierto:
Observa lo siguiente:
- Que tu Pod conste de un contenedor (monolith)
- Que cuando se inicie el contenedor, se le pasen algunos argumentos
- Que abras el puerto 80 para el tráfico HTTP
- Usa
kubectl
para crear el Pod monolith:
- Examina tus Pods. Usa el comando
kubectl get pods
para obtener una lista de todos los Pods que se ejecutan en el espacio de nombres predeterminado:
- Para obtener más información sobre el Pod monolith, usa el comando
kubectl describe
cuando se ejecute el Pod:
Verás mucha información sobre el Pod monolith, como su dirección IP y el registro de eventos. Esta información será de utilidad para solucionar problemas.
Con Kubernetes, es fácil crear Pods con solo describirlos en los archivos de configuración y también es fácil ver información sobre ellos mientras se ejecutan. En este momento, tienes la capacidad de crear todos los Pods que requiera tu implementación .
Tarea 5: Interactúa con los Pods
De forma predeterminada, los Pods reciben una dirección IP privada a la que no se puede acceder desde fuera del clúster. Usa el comando kubectl port-forward
para asignar un puerto local a un puerto dentro del Pod monolith.
-
Abre una segunda terminal de Cloud Shell. Ahora tienes dos terminales, una para ejecutar el comando
kubectl port-forward
y otra para emitir comandoscurl
. -
Para configurar la redirección de puertos, ejecuta el siguiente comando en la segunda terminal:
- Ahora, usa el comando
curl
en la primera terminal para empezar a comunicarte con el Pod:
¡Perfecto! Recibiste un amigable saludo de tu contenedor.
- A continuación, usa el comando
curl
para ver qué sucede cuando accedes a un extremo seguro:
¡Uy!
- Intenta acceder para que monolith te proporcione un token de auth:
- En la ventana de acceso, usa la contraseña supersecreta “password”.
El hecho de acceder hace que se genere un token JWT.
- Crea una variable de entorno para el token, ya que Cloud Shell no copia bien las cadenas largas.
-
Ingresa nuevamente la contraseña supersecreta “password” cuando se te solicite la contraseña del host.
-
Usa el siguiente comando para copiar el token y usarlo para acceder el extremo seguro con
curl
:
En este punto, deberías recibir una respuesta de nuestra aplicación para informarte que todo funciona como corresponde nuevamente.
- Usa el comando
kubectl logs
para ver los registros del Podmonolith
.
-
Abre una tercera terminal y usa la marca
-f
para obtener una transmisión de los registros en tiempo real:
- Si usas
curl
en la primera terminal para interactuar con monolith, verás que se actualizan los registros ubicados en la tercera terminal:
- Usa el comando
kubectl exec
para ejecutar una shell interactiva dentro del Pod monolith, lo que puede ser útil para solucionar problemas en un contenedor:
- Por ejemplo, una vez que tienes una shell en el contenedor monolith, puedes usar el comando
ping
para probar la conectividad externa:
- Asegúrate de salir cuando termines de usar esta shell interactiva.
Como puedes ver, interactuar con los Pods es tan sencillo como usar el comando kubectl
. Kubernetes proporciona todo lo que necesitas para comenzar a usar el servicio, ya sea que necesites obtener una shell de acceso o acceder a un contenedor de forma remota.
Tarea 6: Services
Los Pods no están diseñados para ser persistentes. Pueden detenerse o iniciarse por diversos motivos, como verificaciones de funcionamiento y preparación fallidas, lo que genera el siguiente problema:
¿Qué sucede si deseas comunicarte con un conjunto de Pods? Es posible que la dirección IP cambie cuando se reinicien.
Ahora es cuando los Services cobran importancia, ya que proporcionan extremos estables para los Pods.
Los Services usan etiquetas para determinar en qué Pods operan. Si los Pods tienen las etiquetas correctas, nuestros servicios los seleccionan y exponen automáticamente.
El tipo de servicio determina el nivel de acceso que proporciona a un conjunto de Pods. Estos son los tres tipos disponibles actualmente:
-
ClusterIP
(interno): Este tipo predeterminado significa que el servicio solo se puede ver dentro del clúster. -
NodePort
: Proporciona una IP accesible de forma externa a cada nodo del clúster. -
LoadBalancer
: Agrega un balanceador de cargas del proveedor de servicios en la nube que reenvía el tráfico del servicio a los nodos que contiene.
A continuación, aprenderás lo siguiente:
- Cómo crear un servicio
- Cómo usar los selectores de etiquetas para exponer de forma externa un conjunto limitado de Pods
Tarea 7: Crea un Service
Antes de poder crear Services, primero crea un Pod seguro que pueda manejar el tráfico HTTPS.
- Si cambiaste de directorio, asegúrate de volver al directorio
~/orchestrate-with-kubernetes/kubernetes
:
- Explora el archivo de configuración del Service de monolith con el siguiente comando:
- Crea los Pods secure-monolith y sus datos de configuración:
Ahora que tienes un Pod seguro, es hora de exponer de forma externa el Pod secure-monolith. Para ello, crea un Service de Kubernetes.
- Explora el archivo de configuración del Service de monolith con el siguiente comando:
(Resultado):
* Hay un selector que se usa para buscar y exponer automáticamente cualquier Pod con las etiquetas `app: monolith` y `secure: enabled`.
* Ahora debes exponer el puerto del nodo aquí, ya que es la forma en que reenviarás el tráfico externo del puerto 31000 a nginx (en el puerto 443).
- Usa el comando
kubectl create
para crear el Service monolith a partir del archivo de configuración correspondiente:
(Resultado):
Prueba la tarea completada
Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste correctamente los Pods y el Service monolith, verás una puntuación de evaluación.
Estás usando un puerto para exponer el servicio. Esto significa que es posible tener conflictos de puerto si otra aplicación intenta vincularse al puerto 31000 en uno de sus servidores.
Normalmente, Kubernetes se encarga de la asignación de puertos. En este lab, elegiste un puerto para configurar fácilmente las verificaciones de estado más adelante.
- Usa el comando
gcloud compute firewall-rules
para permitir el tráfico hacia el Service monolith en el puerto de nodo expuesto:
Prueba la tarea completada
Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste con éxito una regla de firewall que permite el tráfico de TCP en el puerto 31000, verás una puntuación de evaluación.
Ahora que todo está configurado, deberías poder acceder al Service secure-monolith desde fuera del clúster sin usar la redirección de puertos.
- Primero, obtén una dirección IP externa para uno de los nodos.
- A continuación, usa el comando
curl
para acceder al Service secure-monolith:
Se agotó el tiempo de espera. ¿Cuál es el problema?
Nota: Es momento de realizar una verificación de conocimientos rápida.
Usa estos comandos para responder las siguientes preguntas:kubectl get services monolith
kubectl describe services monolith
Preguntas:
Pista: La respuesta está relacionada con las etiquetas. Solucionarás el problema en la siguiente sección.
Tarea 8: Agrega etiquetas a los Pods
De momento, el Service monolith no cuenta con extremos. Una forma de solucionar un problema como este es usar el comando kubectl get pods
con una consulta sobre etiquetas.
- Puedes ver que hay pocos Pods ejecutándose con la etiqueta monolith.
- Sin embargo, ¿qué sucede con “app=monolith” y “secure=enabled”?
Observa que esta consulta sobre etiquetas no genera resultados. Parece que debes agregarles la etiqueta “secure=enabled”.
- Usa el comando
kubectl label
para agregar la etiqueta faltantesecure=enabled
al Pod secure-monolith. A continuación, puedes verificar y revisar que se hayan actualizado las etiquetas.
- Ahora que los Pods están bien etiquetados, observa la lista de extremos en el Service monolith con este comando:
Ya lograste obtener uno.
- Para probarlo, vuelve a acceder a uno de los nodos.
¡Excelente! Se estableció la conexión.
Prueba la tarea completada
Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si agregaste etiquetas con éxito a los Pods monolith, verás una puntuación de evaluación.
Tarea 9: Implementa aplicaciones con Kubernetes
El objetivo de este lab es prepararte para escalar y administrar los contenedores en producción. Ahora es cuando los Deployments cobran importancia. Los Deployments son una forma declarativa de garantizar que la cantidad de Pods en ejecución sea igual a la cantidad deseada de Pods que especifica el usuario.
La ventaja principal de los Deployments es abstraer los detalles de bajo nivel de la administración de los Pods. En segundo plano, los Deployments usan conjuntos de réplicas para administrar el inicio y la detención de los Pods. Un objeto Deployment permite actualizar o escalar los Pods si es necesario, así como reiniciar los Pods si estos se desconectan por algún motivo.
Observa un ejemplo breve:
Los Pods están sujetos al ciclo de vida del nodo en el que se crearon. En el ejemplo anterior, Node3 se desconectó, por lo que también se desconectó un Pod. En vez de crear un Pod nuevo de forma manual y buscar un nodo para él, el Deployment creó un Pod nuevo y lo inició en Node2.
Eso es muy práctico.
Es momento de aplicar todo lo que aprendiste sobre los Pods y Services para dividir la aplicación monolith en Services más pequeños a través de Deployments.
Tarea 10: Crea implementaciones
Dividirás la app monolith en tres partes:
- auth: Genera tokens JWT para usuarios autenticados.
- hello: Saluda a los usuarios autenticados.
- frontend: Enruta el tráfico hacia los servicios auth y hello.
Ya cuentas con lo necesario para crear Deployments, uno por Service. Luego de esto, definirás los Services internos para los Deployments auth y hello, además de un Service externo destinado al Deployment del frontend. Una vez que termines, podrás interactuar con los microservicios al igual que con monolith, solo que ahora podrás implementar y escalar cada parte de forma independiente.
- Empieza por examinar el archivo de configuración del Deployment auth.
(Resultado)
El Deployment creará 1 réplica, y estás usando la versión 2.0.0. del contenedor auth.
Cuando ejecutes el comando kubectl create
para crear el Deployment auth, se creará un Pod que se ajusta a los datos del manifiesto de Deployment. Esto significa que puedes escalar la cantidad de Pods con solo modificar la cantidad especificada en el campo “Replicas”.
- De cualquiera manera, crea tu objeto Deployment con el comando siguiente:
- Es hora de crear un Service para tu Deployment auth. Usa el comando
kubectl create
para crear el servicio auth:
- Ahora, haz lo mismo para crear y exponer el Deployment hello:
- Y haz lo mismo una vez más para crear y exponer el Deployment frontend.
- Usa la IP externa del frontend y ejecuta el comando curl para interactuar con él:
EXTERNAL-IP
es pending.Recibirás un saludo como respuesta.
Prueba la tarea completada
Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste con éxito los Deployments auth, hello y frontend, verás una puntuación de evaluación.
¡Felicitaciones!
Desarrollaste una aplicación de varios servicios con Kubernetes. Las habilidades que aprendiste te permitirán usar una colección de Deployments y Services para implementar aplicaciones complejas en Kubernetes.
Analicemos las similitudes y diferencias que observaste durante el lab entre las dos plataformas.
Similitudes:
- El proceso de configuración y de implementación de una aplicación en GKE es muy similar al de Azure AKS.
- Ambos servicios utilizan comandos kubectl y aceptan Dockerfiles.
- Al igual que AKS, GKE administra la infraestructura subyacente y proporciona Services de Kubernetes.
Diferencias:
- A medida que continúes explorando el funcionamiento de GKE, notarás algunas diferencias con respecto a AKS. En concreto, GKE ofrece Autopilot, que proporciona una configuración optimizada según las prácticas recomendadas de Google.
- En términos de red, AKS utiliza la red virtual de Azure y la interfaz de red de contenedores de Azure. La interfaz de red de contenedores de Azure ayuda a proporcionar direcciones IP de red virtual para cada Pod y los Pods pueden acceder directamente a otros servicios que están bajo los extremos del servicio de red virtual. En Google Cloud, el modelo de herramientas de redes de Kubernetes se basa en gran medida en las direcciones IP. Los objetos Service, los Pods, los contenedores y los nodos se comunican mediante direcciones IP y puertos.
Finaliza la Quest
Este lab de autoaprendizaje forma parte de Build Google Cloud Infrastructure for Azure Professionals. Una Quest es una serie de labs relacionados que forman una ruta de aprendizaje. Si completas esta Quest, obtendrás una insignia como reconocimiento por tu logro. Puedes hacer públicas tus insignias y agregar vínculos a ellas en tu currículum en línea o en tus cuentas de redes sociales. Inscríbete en cualquier Quest que contenga este lab y obtén un crédito inmediato de finalización. Consulta el catálogo de Google Cloud Skills Boost para ver todas las Quests disponibles.
Completa el próximo lab
Continúa tu Quest con el lab Cómo alojar una aplicación web en Google Cloud mediante Compute Engine.
Próximos pasos/Más información
- Puede seguir las novedades de Kubernetes en X y en el blog de la comunidad.
- Recuerda que Kubernetes es un proyecto de código abierto (http://kubernetes.io/) alojado en GitHub. Tus comentarios y contribuciones son siempre bienvenidos.
Capacitación y certificación de Google Cloud
Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.
Última actualización del manual: 30 de octubre de 2023
Prueba más reciente del lab: 30 de octubre de 2023
Copyright 2024 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.