GSP021

Descripción general

Kubernetes es un proyecto de código abierto (disponible en kubernetes.io) que se puede ejecutar en distintos entornos, desde laptops hasta clústeres multinodos con alta disponibilidad, desde nubes públicas hasta implementaciones locales y desde máquinas virtuales hasta equipos físicos.

En este lab, el uso de un entorno administrado como Kubernetes Engine te permite concentrarte en experimentar con Kubernetes, en vez de configurar la infraestructura subyacente. Kubernetes Engine es un entorno administrado para implementar aplicaciones alojadas en contenedores. Ofrece las innovaciones más recientes en materia de productividad para desarrolladores, eficiencia de recursos, automatización de operaciones y flexibilidad de código abierto, lo que permite acelerar el tiempo de salida al mercado.

Nota: App se aloja en GitHub y proporciona una aplicación de ejemplo de 12 factores. Durante este lab, trabajarás con las siguientes imágenes de Docker:

kelseyhightower/monolith: La aplicación monolítica incluye los Services auth y hello.

kelseyhightower/auth: es el microservicio de auth. Genera tokens JWT para los usuarios autenticados.

kelseyhightower/hello: es el microservicio de hello. Saluda a los usuarios autenticados.

nginx: Es el frontend para los Services auth y hello.

Objetivos

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 los objetos Deployment y Service de Kubernetes para dividir una aplicación en microservicios

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)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. 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 Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   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 ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia Cuenta de Google podría generar cargos adicionales.

7. Haga clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para ver un menú con una lista de productos y servicios de Google Cloud, haz clic en el menú de navegación que se encuentra en la parte superior izquierda.

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.

1. 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:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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.

2. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

3. Haz clic en Autorizar.

4. Ahora, el resultado debería verse de la siguiente manera:

Resultado:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: Para obtener toda la documentación de gcloud, consulta la guía con la descripción general de gcloud CLI en Google Cloud.

Google Kubernetes Engine

1. En el entorno de Cloud Shell, escribe el siguiente comando para configurar la zona:

gcloud config set compute/zone {{{project_0.default_zone|Zone}}}

2. Inicia un clúster para usarlo en este lab con el comando siguiente:

gcloud container clusters create io --zone {{{project_0.default_zone|Zone}}} Tras la creación, se te autentica automáticamente en tu clúster. Si pierdes conexión con Cloud Shell por cualquier motivo, ejecuta el comando gcloud container clusters get-credentials io para volver a autenticarte. Nota: Llevará un tiempo crear un clúster, ya que Kubernetes Engine aprovisiona unas pocas máquinas virtuales en segundo plano para que practiques con ellas.

Tarea 1: Obtén el código de muestra

1. Copia el código fuente desde la línea de comandos de Cloud Shell:

gsutil cp -r gs://spls/gsp021/* .

2. Cambia al directorio necesario para este lab con este comando:

cd orchestrate-with-kubernetes/kubernetes

3. Crea una lista de los archivos con los que trabajarás a través del siguiente comando:

ls

La muestra tiene el siguiente diseño:

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Ya puedes usar el código para probar Kubernetes.

Tarea 2: Demostración rápida de Kubernetes

La forma más fácil de comenzar a usar Kubernetes es utilizar el comando kubectl create.

1. Úsalo para iniciar una sola instancia del contenedor nginx:

kubectl create deployment nginx --image=nginx:1.10.0

Kubernetes ya creó un objeto Deployment (hablaremos sobre ellos más adelante). Por el momento, todo lo que necesitas saber es que los Deployments mantienen los Pods en funcionamiento, incluso cuando fallan los nodos en los que se ejecutan.

En Kubernetes, todos los contenedores se ejecutan en un Pod.

2. Usa el comando kubectl get pods para ver el contenedor nginx en ejecución:

kubectl get pods

3. Una vez que el contenedor nginx alcance el estado Running, podrás exponerlo por fuera de Kubernetes con el comando kubectl expose:

kubectl expose deployment nginx --port 80 --type LoadBalancer

¿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 Service. En este caso, esto correspondería al pod de nginx.

4. Crea una lista de nuestros Services con el comando kubectl get services:

kubectl get services Nota: Pueden pasar unos segundos hasta que el campo ExternalIP se complete para el Service. Esto es normal; solo vuelve a ejecutar el comando kubectl get services cada algunos segundos hasta que se complete el campo.

5. Para acceder al contenedor Nginx de forma remota, agrega la IP externa a este comando:

curl http://<External IP>:80

Listo. Kubernetes admite un flujo de trabajo inmediato y fácil de usar con 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.

Crear un clúster de Kubernetes y, también, iniciar el contendor Nginx

Ahora que terminaste de revisar esta breve demostración de Kubernetes, es momento 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. En general, si tienes varios contenedores que dependen en gran medida entre sí, debes empaquetarlos 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 mientras 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. Tómate un momento para explorar el archivo de configuración del Pod de la aplicación monolítica.

1. Ve al directorio siguiente:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Ejecuta lo siguiente:

cat pods/monolith.yaml

En el resultado, se muestra el archivo de configuración abierto:

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Observa lo siguiente:

• Que tu Pod consta de un contenedor (la aplicación monolítica)
• Que cuando se inicia el contenedor, se le pasan algunos argumentos
• Que estás abriendo el puerto 80 para el tráfico HTTP

3. Usa kubectl para crear el Pod de la aplicación monolítica:

kubectl create -f pods/monolith.yaml

4. Examina tus Pods. Usa el comando kubectl get pods para crear una lista de todos los Pods que se ejecutan en el espacio de nombres predeterminado:

kubectl get pods Nota: El Pod de la aplicación monolítica puede tardar unos segundos en empezar a ejecutarse. Se debe extraer la imagen del contenedor monolith desde Docker Hub antes de poder ejecutarlo.

5. Para obtener más información sobre el Pod de la aplicación monolítica, usa el comando kubectl describe cuando se ejecute el Pod:

kubectl describe pods monolith

Verás mucha información sobre el Pod de la aplicación monolítica, como la 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 requiere tu objeto Deployment.

Tarea 5: Interactúa con los Pods

De manera predeterminada, se asigna a los Pods 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 de la aplicación monolítica.

Nota: A partir de este punto del lab, deberás trabajar en varias pestañas de Cloud Shell para configurar la comunicación entre Pods. Todo comando que se ejecute en una segunda o tercera shell de comandos se indicará en las instrucciones del comando.

1. Abre una segunda terminal de Cloud Shell. Ahora tienes dos terminales, una para ejecutar el comando kubectl port-forward y otra para emitir comandos curl.

2. Para configurar la redirección de puertos, ejecuta el siguiente comando en la 2ª terminal:

kubectl port-forward monolith 10080:80

3. Ahora, usa el comando curl en la 1ª terminal para empezar a comunicarte con el Pod:

curl http://127.0.0.1:10080

¡Sí! Recibiste un simpático saludo de tu contenedor.

4. A continuación, usa el comando curl para ver qué sucede cuando accedes a un extremo seguro:

curl http://127.0.0.1:10080/secure

¡Vaya!

5. Intenta acceder para que la aplicación monolítica proporcione un token de autenticación:

curl -u user http://127.0.0.1:10080/login

6. En el mensaje de acceso, usa la contraseña supersecreta password para acceder.

El hecho de acceder hace que se imprima un token JWT.

7. Crea una variable de entorno para el token, ya que Cloud Shell no copia bien las cadenas largas.

TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')

8. Vuelve a escribir la contraseña supersecreta password cuando se te solicite para la contraseña de host.

9. Usa este comando para copiar y usar el token con el objetivo de acceder el extremo seguro con curl:

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

En este punto, deberías recibir una respuesta de nuestra aplicación que informa que todo funciona como corresponde de nuevo.

10. Usa el comando kubectl logs para ver los registros del Pod de la aplicación monolítica.

kubectl logs monolith

11. Abre una tercera terminal y usa la marca -f para obtener una transmisión de los registros en tiempo real:

kubectl logs -f monolith

12. Si usas curl en la 1ª terminal para interactuar con la aplicación monolítica, verás que se actualizan los registros ubicados en la 3ª terminal:

curl http://127.0.0.1:10080

13. Usa el comando kubectl exec para ejecutar una shell interactiva dentro del Pod de la aplicación monolítica, lo que puede ser útil para solucionar problemas en un contenedor:

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. Por ejemplo, una vez que tienes una shell en el contenedor monolith, puedes usar el comando ping para probar la conectividad externa:

ping -c 3 google.com

15. Asegúrate de salir cuando termines de usar esta shell interactiva.

exit

Como puedes ver, interactuar con los Pods es tan sencillo como usar el comando kubectl. Kubernetes proporciona todo lo necesario para empezar 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 disponibilidad y actividad 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. Los Services proporcionan extremos estables para los Pods.

Los Services usan etiquetas para determinar en qué Pods operan. Si los Pods tienen las etiquetas correctas, nuestros Services los seleccionan y exponen automáticamente.

El tipo de Service 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 Service 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 Service a los nodos que contiene.

A continuación, aprenderás lo siguiente:

• Cómo crear un Service
• 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.

1. Si cambiaste de directorio, asegúrate de volver al directorio ~/orchestrate-with-kubernetes/kubernetes:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Explora el archivo de configuración del Service de la aplicación monolítica con el siguiente comando:

cat pods/secure-monolith.yaml

3. Crea los Pods secure-monolith y sus datos de configuración con este comando:

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-monolith.yaml

Ahora que tienes un Pod seguro, es hora de exponer de forma externa el Pod secure-monolith. Para ello, crea un Service de Kubernetes.

4. Explora el archivo de configuración del Service de la aplicación monolítica con el siguiente comando:

cat services/monolith.yaml

(Resultado):

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Algunos aspectos que debes tener en cuenta:

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

5. Usa el comando kubectl create para crear el Service de la aplicación monolítica a partir del archivo de configuración del Service de la aplicación:

kubectl create -f services/monolith.yaml

(Resultado):

service/monolith created

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 Pods y el Service de la aplicación monolítica, verás una puntuación de evaluación.

Crear Pods y un Service para la aplicación monolítica

Estás usando un puerto para exponer el Service. Esto significa que es posible tener conflictos de puerto si otra aplicación intenta vincularse al puerto 31000 en uno de tus 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.

6. Usa el comando gcloud compute firewall-rules para permitir el tráfico hacia el Service de la aplicación monolítica en el puerto del nodo expuesto:

gcloud compute firewall-rules create allow-monolith-nodeport \ --allow=tcp:31000

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.

Permitir el tráfico hacia el Service de la aplicación monolítica en el puerto del nodo expuesto

Ahora que todo está configurado, deberías poder acceder al Service de secure-monolith desde fuera del clúster sin usar la redirección de puertos.

1. Primero, obtén una dirección IP externa para uno de los nodos.

gcloud compute instances list

2. A continuación, usa el comando curl para acceder al Service de secure-monolith:

curl -k https://<EXTERNAL_IP>:31000

¡Vaya! 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:

¿Por qué no puedes obtener una respuesta del Service de la aplicación monolítica?

¿Cuántos extremos tiene el Service de la aplicación monolítica?

¿Qué etiquetas debe tener un Pod para que el Service de la aplicación monolítica lo seleccione?

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 de la aplicación monolítica no posee extremos. Una forma de solucionar un problema como este es usar el comando kubectl get pods con una consulta de etiquetas.

1. Puedes ver que hay pocos Pods ejecutándose con la etiqueta monolith.

kubectl get pods -l "app=monolith"

2. Sin embargo, ¿qué sucede con “app=monolith” y “secure=enabled”?

kubectl get pods -l "app=monolith,secure=enabled"

Observa que esta consulta de etiquetas no genera resultados. Parece que debes agregarles la etiqueta “secure=enabled”.

3. Usa el comando kubectl label para agregar la etiqueta secure=enabled faltante al Pod secure-monolith. A continuación, puedes comprobar y revisar que se hayan actualizado las etiquetas.

kubectl label pods secure-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

4. Ahora que los Pods están bien etiquetados, observa la lista de extremos en el Service de la aplicación monolítica con este comando:

kubectl describe services monolith | grep Endpoints

Ya lograste obtener uno.

5. Para probarlo, vuelve a acceder a uno de los nodos.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

Listo. 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 de la aplicación monolítica, verás una puntuación de evaluación.

Agregar etiquetas a los Pods

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. También permite reiniciar los Pods si 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 monolítica en Services más pequeños a través de Deployments.

Tarea 10: Crea Deployments

Dividirás la aplicación monolítica en tres partes:

• auth: Genera tokens JWT para usuarios autenticados.
• hello: Saluda a los usuarios autenticados.
• frontend: Enruta el tráfico hacia los Services 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 la aplicación monolítica, solo que ahora podrás implementar y escalar cada parte de forma independiente.

1. Empieza por examinar el archivo de configuración del Deployment auth.

cat deployments/auth.yaml

(Resultado)

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

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 Réplicas.

2. De cualquier manera, crea tu objeto Deployment con el comando siguiente:

kubectl create -f deployments/auth.yaml

3. Es hora de crear un Service para tu Deployment auth. Usa el comando kubectl create para crear el Service auth:

kubectl create -f services/auth.yaml

4. Ahora, haz lo mismo para crear y exponer el Deployment hello:

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.yaml

5. Y haz lo mismo una vez más para crear y exponer el Deployment frontend.

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Nota: Hay un paso más que debes seguir para crear el frontened porque necesitas almacenar algunos datos de configuración con el contenedor.

6. Usa la IP externa del frontend y ejecuta el comando curl para interactuar con él:

kubectl get services frontend Nota: La dirección IP externa puede tardar un minuto en crearse. Ejecuta el comando anterior de nuevo si el estado de la columna EXTERNAL-IP es pending. curl -k https://<EXTERNAL-IP>

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.

Crear Deployments (Auth, Hello y Frontend)

¡Felicitaciones!

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

Próximos pasos y más información

• Sigue 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: 29 de abril de 2024

Prueba más reciente del lab: 29 de abril de 2024

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.