GSP005

Descripción general

El objetivo de este lab práctico es que conviertas el código que desarrollaste en una aplicación replicada alojada en contenedores que se ejecute en Kubernetes Engine. Para este lab, el código será una simple aplicación node.js Hello World.

A continuación, encontrarás un diagrama de las diversas piezas en juego en este lab para ayudarte a comprender de qué manera encajan entre sí. Úsalo como referencia a medida que avanzas en el lab. Todo tendría que cobrar sentido cuando llegues al final (pero puedes ignorarlo por el momento).

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.

A los fines de este lab, utilizar un entorno administrado como Kubernetes Engine (una versión de Kubernetes alojada en Google que se ejecuta en Compute Engine) te permite concentrarte en experimentar con Kubernetes, en vez de configurar la infraestructura subyacente.

Qué aprenderás

• Crear un servidor Node.js
• Crear una imagen de contenedor de Docker
• Crear un clúster de contenedor
• Crear un Pod de Kubernetes
• Escalar verticalmente tus servicios

Requisitos previos

• Se recomienda tener experiencia con editores de texto estándares de Linux, como vim, emacs o nano.

Se incentiva a los estudiantes a que ellos mismos escriban los comandos, ya que eso los ayuda a aprender los conceptos básicos. Muchos labs incluyen un bloque de código que contiene los comandos necesarios. Durante el lab, puedes copiar y pegar fácilmente los comandos del bloque de código en los lugares apropiados.

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, 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 del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos 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: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

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

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes 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: Ordena 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 Cloud para este lab podría generar cargos adicionales.

7. Haz 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 acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

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.

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API 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 {{{project_0.project_id | "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.

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

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

Tarea 1: Crea tu aplicación de Node.js

1. Con Cloud Shell, escribe un servidor Node.js simple para implementarlo en Kubernetes Engine:

vi server.js

2. Inicia el editor:

i

3. Agrega este contenido al archivo:

var http = require('http'); var handleRequest = function(request, response) { response.writeHead(200); response.end("Hello World!"); } var www = http.createServer(handleRequest); www.listen(8080); Nota: Aquí se usa vi, pero nano y emacs también están disponibles en Cloud Shell. También puedes usar la función de editor web de Cloud Shell, como se describe en la guía Cómo funciona Cloud Shell.

4. Para guardar el archivo server.js, presiona Esc y, luego, escribe lo siguiente:

:wq

5. Ya que Cloud Shell tiene instalado el ejecutable node, ejecuta este comando para iniciar el servidor del nodo (el comando no muestra ningún resultado):

node server.js

6. Utiliza la función Vista previa en la Web incorporada de Cloud Shell para abrir una nueva pestaña del navegador y enviar una solicitud a través de un proxy a la instancia que acabas de iniciar en el puerto 8080.

Se abrirá una pestaña nueva del navegador en la que se mostrarán los resultados:

7. Antes de continuar, vuelve a Cloud Shell y presiona Ctrl+C para detener la ejecución del servidor del nodo.

A continuación, empaquetarás esta aplicación en un contenedor de Docker.

Tarea 2: Crea una imagen de contenedor de Docker

1. Ahora, genera un Dockerfile que describa la imagen que quieres crear. Las imágenes de contenedor de Docker pueden extenderse desde otras imágenes existentes, por lo que, para esta imagen, haremos una extensión desde una imagen de nodo existente:

vi Dockerfile

2. Inicia el editor:

i

3. Agrega este contenido:

FROM node:6.9.2 EXPOSE 8080 COPY server.js . CMD ["node", "server.js"]

La “receta” para la imagen de Docker hará lo siguiente:

• Comenzará desde la imagen node que se encuentra en el concentrador de Docker.
• Expondrá el puerto 8080.
• Copiará el archivo server.js en la imagen.
• Iniciará el servidor del nodo como ya hicimos manualmente.

4. Para guardar este Dockerfile, presiona Esc y, luego, escribe lo siguiente:

:wq

5. Compila la imagen con lo siguiente:

docker build -t hello-node:v1 .

La descarga y extracción tardará un tiempo, pero puedes ver las barras de progreso a medida que se compila la imagen.

Cuando se complete, prueba la imagen de forma local. Para ello, ejecuta un contenedor de Docker como daemon en el puerto 8080 desde la imagen de contenedor que creaste recientemente.

6. Ejecuta el contenedor de Docker con este comando:

docker run -d -p 8080:8080 hello-node:v1

El resultado debería ser similar a este:

325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998

7. Para ver tus resultados, usa la función Vista previa en la Web de Cloud Shell. También puedes utilizar curl desde la ventana de Cloud Shell:

curl http://localhost:8080

Este es el resultado que deberías ver:

Hello World! Nota: Puedes encontrar la documentación completa del comando docker run en la referencia de docker run.

A continuación, detén el contenedor en ejecución.

1. Para encontrar el ID del contenedor de Docker, ejecuta lo siguiente:

docker ps

El resultado debería verse así:

CONTAINER ID IMAGE COMMAND 2c66d0efcbd4 hello-node:v1 "/bin/sh -c 'node

2. Para detener el contenedor, ejecuta el siguiente comando y reemplaza [CONTAINER ID] por el valor proporcionado en el paso anterior:

docker stop [CONTAINER ID]

El resultado de tu consola debería ser similar al siguiente (el ID de tu contenedor):

2c66d0efcbd4

Ahora que la imagen funciona como es debido, envíala a Google Artifact Registry, un repositorio privado para tus imágenes de Docker accesible desde tus proyectos de Google Cloud.

1. Primero, debes crear un repositorio en Artifact Registry. Llamémoslo my-docker-repo. Ejecuta el siguiente comando:

gcloud artifacts repositories create my-docker-repo \ --repository-format=docker \ --location={{{ project_0.default_region | YOUR_REGION }}} \ --project={{{ project_0.project_id | YOUR_PROJECT_ID }}}

2. Ejecuta el siguiente comando para configurar la autenticación de Docker.

gcloud auth configure-docker

Cuando se te pregunte, Do you want to continue (Y/N)?, ingresa Y.

3. Para etiquetar tu imagen con el nombre del repositorio, ejecuta este comando, pero reemplaza PROJECT_ID por tu ID del proyecto, que se encuentra en la consola o en la sección Detalles del lab:

docker tag hello-node:v1 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

4. Y envía la imagen del contenedor al repositorio ejecutando el siguiente comando:

docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

El envío inicial podría tardar unos minutos en completarse. Verás las barras de progreso a medida que se completa la operación.

The push refers to a repository [pkg.dev/qwiklabs-gcp-6h281a111f098/hello-node] ba6ca48af64e: Pushed 381c97ba7dc3: Pushed 604c78617f34: Pushed fa18e5ffd316: Pushed 0a5e2b2ddeaa: Pushed 53c779688d06: Pushed 60a0858edcd5: Pushed b6ca02dfe5e6: Pushed v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002

3. La imagen del contenedor aparecerá en la consola. Haz clic en el menú de navegación > Artifact Registry.

Ahora posees una imagen de Docker disponible para todo el proyecto, a la que Kubernetes puede acceder y que puede organizar.

Nota: Usamos la forma recomendada de trabajar con Artifact Registry, que es específica sobre qué región usar. Para obtener más información, consulta Envía y extrae de Artifact Registry.

Tarea 3: Crea tu clúster

Ahora tienes todo listo para crear tu clúster de Kubernetes Engine. Un clúster consiste en un servidor de API de la instancia principal de Kubernetes alojado por Google y en un conjunto de nodos trabajadores. Los nodos trabajadores son máquinas virtuales de Compute Engine.

1. Asegúrate de haber configurado tu proyecto con gcloud (reemplaza PROJECT_ID por el ID de tu proyecto, que se encuentra en la consola y en la sección Detalles del lab):

gcloud config set project PROJECT_ID

2. Crea un clúster con dos nodos e2-medium (tardará unos minutos en completarse):

gcloud container clusters create hello-world \ --num-nodes 2 \ --machine-type e2-medium \ --zone "{{{project_0.default_zone|ZONE}}}"

Puedes ignorar de forma segura las advertencias que aparecen cuando se compila el clúster.

El resultado de la consola debería ser similar al siguiente:

Creating cluster hello-world...done. Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/"{{{project_0.default_zone|ZONE}}}"/clusters/hello-world]. kubeconfig entry generated for hello-world. NAME ZONE MASTER_VERSION MASTER_IP MACHINE_TYPE STATUS hello-world "{{{project_0.default_zone|ZONE}}}" 1.5.7 146.148.46.124 e2-medium RUNNING

Como alternativa, puedes crear este clúster a través de la consola. Para ello, abre el menú de navegación y selecciona Kubernetes Engine > Clústeres de Kubernetes > Crear.

Nota: Se recomienda crear el clúster en la misma zona que el bucket de almacenamiento utilizado por Artifact Registry (consulta los pasos previos).

Si seleccionas el menú de navegación > Kubernetes Engine, verás que ahora tienes un clúster de Kubernetes completamente funcional con la tecnología de Kubernetes Engine:

Es hora de implementar tu propia aplicación alojada en contenedores en el clúster de Kubernetes. A partir de ahora, usa la línea de comandos kubectl (que ya está configurada en tu entorno de Cloud Shell).

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab.

Crea tu clúster.

Tarea 4: Crea tu Pod

Un pod de Kubernetes es un grupo de contenedores unidos para funciones administrativas y de herramientas de redes. Puede tener uno o muchos contenedores. Aquí, deberás usar un contenedor compilado con tu imagen de Node.js almacenada en tu Artifact Registry privado. Entregará contenido en el puerto 8080.

1. Crea un Pod con el comando kubectl run (reemplaza PROJECT_ID por el ID de tu proyecto, que se encuentra en la consola y en la sección Detalles de la conexión del lab):

kubectl create deployment hello-node \ --image={{{ project_0.default_region}}}-docker.pkg.dev/PROJECT_ID/my-docker-repo/hello-node:v1

Resultado:

deployment.apps/hello-node created

Como puedes ver, creaste un objeto Deployment. Las implementaciones son la forma recomendada para crear y escalar pods. Aquí, una nueva implementación administra una única réplica de pod que ejecuta la imagen hello-node:v1.

2. Ejecuta el siguiente comando para ver la implementación:

kubectl get deployments

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 1/1 1 1 1m36s

3. Para ver el Pod creado por la implementación, ejecuta lo siguiente:

kubectl get pods

Resultado:

NAME READY STATUS RESTARTS AGE hello-node-714049816-ztzrb 1/1 Running 0 6m

Ahora es un buen momento para revisar algunos comandos kubectl interesantes. Ninguna de estas opciones cambiará el estado del clúster. Para ver la documentación de referencia completa, consulta Herramienta de línea de comandos (kubectl):

kubectl cluster-info kubectl config view

Y para la solución de problemas:

kubectl get events kubectl logs <pod-name>

Ahora debes hacer que tu Pod sea accesible públicamente.

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab.

Crear tu Pod

Tarea 5: Permite el tráfico externo

Según la configuración predeterminada, el Pod únicamente es accesible a través de su IP interna dentro del clúster. Para hacer accesible el contenedor hello-node desde afuera de la red virtual de Kubernetes, tienes que exponer el Pod como un servicio de Kubernetes.

1. Desde Cloud Shell, puedes exponer el Pod al Internet público con el comando kubectl expose y la marca --type="LoadBalancer". Esta marca es necesaria para la creación de una IP accesible de forma externa:

kubectl expose deployment hello-node --type="LoadBalancer" --port=8080

Resultado:

service/hello-node exposed

La marca utilizada en este comando especifica que se usa el balanceador de cargas proporcionado por la infraestructura subyacente (en este caso, el balanceador de cargas de Compute Engine). Ten en cuenta que se expone directamente la implementación, no el Pod. Esto hará que el servicio resultante balancee la carga de tráfico en todos los Pods administrados por la implementación (en este caso, solo 1 Pod, pero luego podrás agregar más réplicas).

La instancia principal de Kubernetes crea el balanceador de cargas y las reglas de reenvío de Compute Engine relacionadas, los grupos de destino y las reglas de firewall para que el servicio se vuelva completamente accesible desde el exterior de Google Cloud.

2. Para obtener la dirección IP públicamente accesible del servicio, solicita que kubectl muestre todos los servicios del clúster:

kubectl get services

Este es el resultado que deberías ver:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-node 10.3.250.149 104.154.90.147 8080/TCP 1m kubernetes 10.3.240.1 < none > 443/TCP 5m

Se mencionan 2 direcciones IP para tu servicio hello-node, y ambas entregan contenido al puerto 8080. CLUSTER-IP corresponde a la IP interna que solo es visible dentro de tu red virtual de Cloud, mientras que EXTERNAL-IP corresponde a la IP externa de balanceo de cargas.

Nota: La EXTERNAL-IP podría tardar varios minutos en estar disponible y visible. Si falta la EXTERNAL-IP, espera unos minutos y vuelve a ejecutar el comando.

3. Ahora deberías poder acceder al servicio dirigiendo tu navegador a esta dirección: http://<EXTERNAL_IP>:8080.

En este punto, pasarse a los contenedores y a Kubernetes ya te brindó varios beneficios: no necesitas especificar en qué host ejecutar tu carga de trabajo y también te beneficias de la supervisión y el reinicio del servicio. Ahora, descubre qué más puedes obtener de tu nueva infraestructura de Kubernetes.

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab.

Crea un objeto Service de Kubernetes.

Tarea 6: Escala tu servicio verticalmente

Una de las características avanzadas que ofrece Kubernetes es la gran facilidad para escalar tu aplicación. Supongamos que, de repente, necesitas más capacidad. Puedes indicarle al controlador de replicación que administre una nueva cantidad de réplicas para tu Pod:

1. Establece la cantidad de réplicas para tu Pod:

kubectl scale deployment hello-node --replicas=4

Resultado:

deployment.extensions/hello-node scaled

2. Solicita una descripción de la implementación actualizada:

kubectl get deployment

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 16m

Vuelve a ejecutar el comando anterior hasta que veas que se crearon las 4 réplicas.

3. Enumera todos los Pods:

kubectl get pods

Este es el resultado que deberías ver:

NAME READY STATUS RESTARTS AGE hello-node-714049816-g4azy 1/1 Running 0 1m hello-node-714049816-rk0u6 1/1 Running 0 1m hello-node-714049816-sh812 1/1 Running 0 1m hello-node-714049816-ztzrb 1/1 Running 0 16m

Aquí se usa un enfoque declarativo. En vez de iniciar o detener nuevas instancias, debes declarar cuántas instancias deberían estar en ejecución constantemente. Los bucles de conciliación de Kubernetes garantizan que la realidad coincida con lo que solicitaste y, de ser necesario, ejecutan acciones.

Aquí tienes un diagrama que resume el estado de tu clúster de Kubernetes:

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab.

Escala tu servicio verticalmente.

Tarea 7: Implementa una actualización para tu servicio

En algún momento, la aplicación que implementaste en producción requerirá la corrección de errores o funciones adicionales. Kubernetes te ayuda a implementar una nueva versión en la producción sin afectar a tus usuarios.

1. Primero, abre server.js para modificar la aplicación:

vi server.js i

2. Luego, actualiza el mensaje de respuesta:

response.end("Hello Kubernetes World!");

3. Para guardar el archivo server.js, presiona Esc y, luego, escribe lo siguiente:

:wq

Ahora puedes compilar y publicar una nueva imagen de contenedor en el registro con una etiqueta incrementada (en este caso, v2):

4. Ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto de tu lab:

docker build -t hello-node:v2 . docker tag hello-node:v2 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 Nota: Crear y enviar esta imagen actualizada debería ser más rápido, ya que se aprovecha el almacenamiento en caché.

Kubernetes actualizará sin problemas tu controlador de replicación a la nueva versión de la aplicación. Para cambiar la etiqueta de la imagen de tu contenedor en ejecución, deberás editar hello-node deployment y cambiar la imagen de pkg.dev/PROJECT_ID/hello-node:v1 a pkg.dev/PROJECT_ID/hello-node:v2.

1. Para hacerlo, utiliza el comando kubectl edit:

kubectl edit deployment hello-node

Con esto se abre un editor de texto que muestra la configuración yaml completa de la implementación. No es necesario entender toda la configuración yaml por ahora, solo basta con comprender que cuando se actualiza el campo spec.template.spec.containers.image de la configuración, le indicas a la implementación que actualice los Pods con la nueva imagen.

2. Busca Spec > containers > image y cambia el número de versión de v1 a v2:

# Please edit the object below. Lines beginning with a '#' will be ignored, # and an empty file will abort the edit. If an error occurs while saving this file will be # reopened with the relevant failures. # apiVersion: extensions/v1beta1 kind: Deployment metadata: annotations: deployment.kubernetes.io/revision: "1" creationTimestamp: 2016-03-24T17:55:28Z generation: 3 labels: run: hello-node name: hello-node namespace: default resourceVersion: "151017" selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-node uid: 981fe302-f1e9-11e5-9a78-42010af00005 spec: replicas: 4 selector: matchLabels: run: hello-node strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 1 type: RollingUpdate template: metadata: creationTimestamp: null labels: run: hello-node spec: containers: - image: pkg.dev/PROJECT_ID/hello-node:v1 ## Update this line ## imagePullPolicy: IfNotPresent name: hello-node ports: - containerPort: 8080 protocol: TCP resources: {} terminationMessagePath: /dev/termination-log dnsPolicy: ClusterFirst restartPolicy: Always securityContext: {} terminationGracePeriodSeconds: 30

3. Luego de realizar el cambio, guarda y cierra el archivo. Para ello, presiona Esc y, luego, escribe lo siguiente:

:wq

Este es el resultado que deberías ver:

deployment.extensions/hello-node edited

4. Ejecuta lo siguiente para actualizar la implementación con la nueva imagen:

kubectl get deployments

Se crearán nuevos Pods con la nueva imagen, y los Pods anteriores se borrarán.

Este es el resultado que deberías ver (es posible que debas volver a ejecutar el comando anterior para ver lo siguiente):

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 1h

Mientras esto se aplica, los usuarios de tus servicios no deberían sufrir ninguna interrupción. Luego de un rato, comenzarán a acceder a la nueva versión de tu aplicación. Puedes encontrar más detalles sobre las actualizaciones progresivas en la documentación para realizar una actualización progresiva.

Esperamos que con estas funciones de implementación, escalamiento y actualización, una vez que hayas configurado tu clúster de Kubernetes Engine, estés de acuerdo en que Kubernetes te ayudará a enfocarte más en la aplicación que en la infraestructura.

¡Felicitaciones!

De esta manera, finaliza este lab práctico con Kubernetes. Solo vimos una mínima parte de esta tecnología. Por eso, te invitamos a explorar con tus propios Pods, controladores de replicación y servicios, y también consultar los sondeos de funcionamiento (verificaciones de estado) y considera usar directamente la API de Kubernetes.

Realiza tu próximo lab

Intenta administrar implementaciones con Kubernetes Engine o consulta las siguientes sugerencias:

• Cómo organizar la nube con Kubernetes
• Cómo configurar un clúster de Kubernetes privado

Próximos pasos y más información

• Luego de que hayas completado este lab, revisa Minikube, que te ofrece una configuración sencilla de un clúster de Kubernetes de un solo nodo para desarrollo y pruebas: http://kubernetes.io/docs/getting-started-guides/minikube/.
• Kubernetes es un proyecto de código abierto (http://kubernetes.io/) alojado en GitHub. Tus comentarios y contribuciones son siempre bienvenidos.
• Puedes mantenerte al tanto de las novedades de Kubernetes en X y en el blog de la comunidad.

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: 8 de mayo de 2025

Prueba más reciente del lab: 8 de mayo de 2025

Copyright 2025 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.