GSP051

Descripción general

En este lab, aprenderás a configurar una canalización de entrega continua con Jenkins en Kubernetes Engine. Jenkins es el servidor de automatización preferido de los desarrolladores que suelen integrar código en un repositorio compartido. La solución que crearás en este lab es similar al siguiente diagrama:

En Cloud Architecture Center, consulta Jenkins en Kubernetes Engine para obtener más información sobre la ejecución de Jenkins en Kubernetes.

Aprendizajes esperados

En este lab, completarás las siguientes tareas para aprender a ejecutar Jenkins en Kubernetes:

• Aprovisionar una aplicación de Jenkins en un clúster de Kubernetes Engine
• Configurar la aplicación de Jenkins con el administrador de paquetes Helm
• Explorar las funciones de una aplicación de Jenkins
• Crear y ejercitar una canalización de Jenkins

Requisitos previos

Este es un lab de nivel avanzado. Antes de hacerlo, debes conocer al menos los conceptos básicos de la programación en shells, así como Kubernetes y Jenkins. Aquí encontrarás algunos labs para ponerte al día:

• Introducción a Docker
• Hello Node Kubernetes
• Cómo administrar implementaciones con Kubernetes Engine
• Cómo configurar Jenkins en Kubernetes Engine

Cuando tengas todo listo, desplázate hacia abajo para obtener más información sobre Kubernetes, Jenkins y la entrega continua.

¿Qué es Kubernetes Engine?

Kubernetes Engine es la versión alojada de Google Cloud de Kubernetes, un potente sistema de organización y administración de clústeres para contenedores. Kubernetes es un proyecto de código abierto que se puede ejecutar en muchos entornos distintos, desde laptops hasta clústeres multinodos de alta disponibilidad, y desde máquinas virtuales hasta equipos físicos. Como se mencionó anteriormente, las apps de Kubernetes se compilan en contenedores. Estas aplicaciones son livianas y se empaquetan con todas las dependencias y bibliotecas necesarias para ejecutarlas. Esta estructura subyacente hace que las aplicaciones de Kubernetes tengan una alta disponibilidad y sean seguras y rápidas de implementar; un marco de trabajo ideal para los desarrolladores en la nube.

¿Qué es Jenkins?

Jenkins es un servidor de automatización de código abierto que permite organizar de manera flexible canalizaciones de compilación, prueba e implementación. Con Jenkins, los desarrolladores pueden iterar con rapidez en proyectos sin preocuparse por los problemas de sobrecarga que pueden derivar de la entrega continua.

¿Qué es la entrega continua o implementación continua?

Cuando necesitas configurar una canalización de entrega continua (CD), la implementación de Jenkins en Kubernetes Engine proporciona grandes beneficios en comparación con una implementación estándar basada en VM.

Cuando en tu proceso de compilación haces uso de contenedores, un host virtual puede ejecutar trabajos en varios sistemas operativos. Kubernetes Engine proporciona ejecutores de compilación efímera que solo se utilizan cuando las compilaciones se ejecutan activamente, lo que deja recursos para otras tareas de clúster, como los trabajos de procesamiento por lotes. Otro beneficio de los ejecutores de compilación efímera es la velocidad: se inician en cuestión de segundos.

Kubernetes Engine también viene equipado con el balanceador de cargas global de Google, que puedes usar para automatizar el enrutamiento del tráfico web a tus instancias. El balanceador de cargas maneja la terminación SSL y usa una dirección IP global que está configurada con la red troncal de Google. Junto con tu frontend web, este balanceador de cargas siempre pondrá a los usuarios en la ruta de acceso más rápida posible a una instancia de aplicación.

Ahora que aprendiste un poco sobre Kubernetes y Jenkins, y sobre cómo interactúan en una canalización de CD, es hora de crear una.

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 derecha, se encuentra el panel Configuración del lab y acceso, que tiene los siguientes elementos:

   • El botón Abrir la consola de Google Cloud
   • Las credenciales temporales (nombre de usuario y contraseña) que debes usar para este lab
   • Otra información para completar el lab (si es necesaria)

   Ten en cuenta que el cronómetro del lab se encuentra cerca de la parte superior de la página y muestra el tiempo restante.

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 los 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 Usa 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 Configuración del lab y acceso.

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 Configuración del lab y acceso.

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 ni autenticación de dos factores, ya que esta cuenta es 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: Descarga el código fuente

En esta tarea, descargarás el código fuente de este lab.

1. Primero, abre una nueva sesión de Cloud Shell y ejecuta el siguiente comando para configurar tu zona :

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

2. Luego, copia el código de muestra del lab:

gcloud storage cp gs://spls/gsp051/continuous-deployment-on-kubernetes.zip . unzip continuous-deployment-on-kubernetes.zip

3. Ahora, cambia al directorio correcto con el siguiente comando:

cd continuous-deployment-on-kubernetes

Tarea 2: Aprovisiona Jenkins

Crea un clúster de Kubernetes y habilita a Jenkins para que acceda a los servicios de Google Cloud y a Google Artifact Registry.

Crea un clúster de Kubernetes

1. Ahora, ejecuta el siguiente comando para aprovisionar un clúster de Kubernetes:

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Este paso puede tardar varios minutos en completarse. Los permisos adicionales permiten que Jenkins acceda a los servicios de Google Cloud y a Google Artifact Registry.

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si creaste correctamente un clúster de Kubernetes, verás una puntuación de evaluación.

Crear un clúster de Kubernetes en la zona

2. Antes de continuar, confirma que el clúster se esté ejecutando con el siguiente comando:

gcloud container clusters list

Obtén las credenciales del clúster

1. Obtén las credenciales para tu clúster con el siguiente comando:

gcloud container clusters get-credentials jenkins-cd

2. Kubernetes Engine usa estas credenciales para acceder al clúster recién aprovisionado. Confirma que puedes conectarte a él con el siguiente comando:

kubectl cluster-info

Tarea 3: Configura Helm

Helm es un administrador de paquetes que facilita configurar e implementar aplicaciones de Kubernetes. Una vez que instales Jenkins, podrás configurar tu canalización de CI/CD.

En esta tarea, usarás Helm para instalar Jenkins desde el repositorio de Charts.

1. Agrega el repo de chart estable de Helm:

helm repo add jenkins https://charts.jenkins.io

2. Asegúrate de que el repo esté actualizado con el siguiente comando:

helm repo update

Tarea 4: Instala y configura Jenkins

Cuando instales Jenkins, puedes proporcionar los valores necesarios para la configuración usando un archivo values como plantilla.

Usarás un archivo values personalizado para configurar automáticamente Kubernetes Cloud y agregar los siguientes complementos necesarios:

• Kubernetes:latest
• Workflow-multibranch:latest
• Git:latest
• Configuration-as-code:latest
• Google-oauth-plugin:latest
• Google-source-plugin:latest
• Google-storage-plugin:latest

Este paso permite que Jenkins se conecte al clúster y al proyecto de Google Cloud.

1. Usa la CLI de Helm para implementar el chart con tus parámetros de configuración:

helm install cd jenkins/jenkins -f jenkins/values.yaml --wait

La ejecución de este comando puede tardar algunos minutos en completarse.

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si configuraste con éxito un gráfico de Jenkins, verás una puntuación de evaluación.

Configurar e instalar Jenkins

2. Una vez que se complete el comando, asegúrate de que el Pod de Jenkins pase al estado Running y que el contenedor tenga el estado READY:

kubectl get pods

Resultado de ejemplo:

NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 2/2 Running 0 1m

3. Configura la cuenta de servicio de Jenkins para realizar la implementación en el clúster.

kubectl create clusterrolebinding jenkins-deploy --clusterrole=cluster-admin --serviceaccount=default:cd-jenkins

Deberías recibir el siguiente resultado:

clusterrolebinding.rbac.authorization.k8s.io/jenkins-deploy created

4. Ejecuta el siguiente comando para configurar la redirección de puertos a la IU de Jenkins desde Cloud Shell:

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

5. Ahora, verifica que el servicio de Jenkins se haya creado de forma correcta con el comando siguiente:

kubectl get svc

Resultado de ejemplo:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins 10.35.249.67 8080/TCP 3h cd-jenkins-agent 10.35.248.1 50000/TCP 3h kubernetes 10.35.240.1 443/TCP 9h

Estás usando Kubernetes Plugin para que los nodos compiladores se inicien automáticamente según sea necesario cuando la instancia principal de Jenkins los solicite. Cuando finalicen el trabajo, los nodos compiladores se apagarán automáticamente y sus recursos se agregarán de nuevo al grupo de recursos del clúster.

Ten en cuenta que este servicio expone los puertos 8080 y 50000 para cualquier Pod que coincida con el selector. Esta medida expone la IU web de Jenkins y los puertos de registro del compilador y agente dentro del clúster de Kubernetes. Además, el servicio jenkins-ui se expone a través de una ClusterIP, por lo que no se puede acceder desde fuera del clúster.

Tarea 5: Conéctate a Jenkins

Recupera la contraseña de administrador y accede a la interfaz de Jenkins.

1. El chart de Jenkins creará automáticamente una contraseña de administrador para ti. Para recuperarla, ejecuta el siguiente comando:

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

2. Para acceder a la interfaz de usuario de Jenkins, en la barra de acciones de Cloud Shell, haz clic en Vista previa en la Web () Vista previa en el puerto 8080:

3. Si se te solicita, accede con el nombre de usuario admin y tu contraseña generada de forma automática.

Jenkins ya está configurado en tu clúster de Kubernetes y generará las canalizaciones de CI/CD automatizadas en las secciones siguientes.

Tarea 6: Conoce la aplicación

En esta tarea, implementarás la aplicación de ejemplo, gceme, en tu canalización de implementación continua. La aplicación está escrita en el lenguaje Go y se encuentra en el directorio sample-app del repo. Cuando ejecutas el objeto binario de gceme en una instancia de Compute Engine, la app muestra los metadatos de la instancia en una tarjeta de información.

La aplicación imita un microservicio admitiendo dos modos de operación:

• En el modo backend, gceme está a la escucha del puerto 8080 y devuelve los metadatos de la instancia de Compute Engine en formato JSON.
• En el modo frontend, gceme consulta el servicio de backend de gceme y renderiza el JSON resultante en la interfaz de usuario.

Tarea 7: Implementa la aplicación

Implementa la aplicación en dos entornos diferentes:

• Producción: Es el sitio real al que acceden tus usuarios.
• Versión Canary: Es un sitio de menor capacidad que recibe solo un porcentaje de tu tráfico de usuarios. Usa este entorno para validar tu software con tráfico en vivo antes de que lo lances a todos tus usuarios.

1. En Google Cloud Shell, ve al directorio de la aplicación de ejemplo:

cd sample-app

2. Crea el espacio de nombres de Kubernetes para aislar lógicamente el Deployment:

kubectl create ns production

3. Crea las implementaciones de producción y de versiones canary, así como los servicios, con los comandos de kubectl apply:

kubectl apply -f k8s/production -n production kubectl apply -f k8s/canary -n production kubectl apply -f k8s/services -n production

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si creaste implementaciones con éxito, verás una puntuación de evaluación.

Crear las implementaciones de producción y de versiones canary

De forma predeterminada, solo se implementa una réplica del frontend. Usa el comando kubectl scale para asegurarte de que haya, al menos, 4 réplicas ejecutándose en todo momento.

4. Ejecuta el siguiente comando para escalar verticalmente los frontends del entorno de producción:

kubectl scale deployment gceme-frontend-production -n production --replicas 4

5. Ahora confirma que tienes 5 Pods ejecutándose para el frontend: 4 para el tráfico de producción y 1 para los lanzamientos Canary (los cambios en el lanzamiento Canary solo afectarán a 1 de cada 5 usuarios [el 20%]):

kubectl get pods -n production -l app=gceme -l role=frontend

6. También confirma que tienes 2 Pods para el backend: 1 para producción y 1 para el lanzamiento Canary:

kubectl get pods -n production -l app=gceme -l role=backend

7. Recupera la IP externa para los servicios de producción con el siguiente comando:

kubectl get service gceme-frontend -n production Nota: Pueden transcurrir varios minutos antes de que veas la dirección IP externa del balanceador de cargas.

Resultado de ejemplo:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE gceme-frontend LoadBalancer 10.79.241.131 104.196.110.46 80/TCP 5h

Pega la IP externa en un navegador para ver la tarjeta de información que se muestra. Deberías ver una página similar a la siguiente:

8. Ahora, almacena la IP del balanceador de cargas del servicio de frontend en una variable de entorno para usarla más tarde:

export FRONTEND_SERVICE_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend)

9. Confirma que ambos servicios estén funcionando. Para ello, abre la dirección IP externa del frontend en el navegador.

10. Ejecuta el siguiente comando para comprobar el resultado de la versión del servicio (debe decir 1.0.0):

curl http://$FRONTEND_SERVICE_IP/version

Implementaste correctamente la aplicación de ejemplo. A continuación, configurarás una canalización para implementar los cambios de manera continua y confiable.

Tarea 8: Crea la canalización de Jenkins

En esta tarea, configurarás un repositorio de Git en tu servidor de Git dedicado y crearás la canalización de Jenkins:

• Enviarás el código fuente de la aplicación de ejemplo al servidor de Git.
• Agregarás las credenciales de tu cuenta de servicio a Jenkins.
• Configurarás Jenkins Cloud para Kubernetes.
• Crearás el trabajo de canalización de múltiples ramas de Jenkins.

Envía el código fuente de la app de ejemplo al servidor de Git

1. En Cloud Shell, recupera la dirección IP externa de tu servidor de Git:

export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{project_0.default_zone}}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP: ${GIT_SERVER_IP}"

2. Inicializa el directorio sample-app como un repositorio de Git:

cd ~/continuous-deployment-on-kubernetes/sample-app git init git config --global user.email "student@qwiklabs.net" git config --global user.name "Student" git branch -m master

3. Agrega el repositorio remoto que apunta a tu servidor de Git alojado localmente:

git remote add origin http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/sample-app.git

4. Agrega, confirma y envía los archivos a la rama master:

git add . git commit -m "Initial commit" git push -u origin master

Agrega las credenciales de cuenta de servicio

Configura tus credenciales para permitir que Jenkins acceda al clúster e implemente recursos.

1. En la interfaz de usuario de Jenkins, haz clic en Manage Jenkins en el panel izquierdo y, luego, en Credentials (en Security).

2. En Stores scoped to Jenkins, haz clic en System.

3. Haz clic en Global credentials (unrestricted).

4. Haz clic en Add Credentials.

5. En Kind, selecciona Google Service Account from metadata y haz clic en Next.

6. En el campo ID, ingresa tu ID del proyecto () y haz clic en Create.

Nota: Tu ID del proyecto se encuentra en el panel DETALLES DE LA CONEXIÓN del lab.

Se agregaron las credenciales globales.

Configura Jenkins Cloud para Kubernetes

1. En la interfaz de usuario de Jenkins, selecciona Manage Jenkins > Clouds (o System > Clouds).
2. Haz clic en New cloud.
3. En Cloud name, escribe kubernetes, selecciona Kubernetes para Type y haz clic en Create.
4. En el campo Jenkins URL, escribe el siguiente valor: http://cd-jenkins:8080.
5. En el campo Jenkins tunnel, agrega el siguiente valor: cd-jenkins-agent:50000.
6. Haz clic en Save.

Crea el trabajo de Jenkins

Navega a la interfaz de usuario de Jenkins y sigue estos pasos para configurar un trabajo de canalización de múltiples ramas:

1. Haz clic en Jenkins > New Item en el panel izquierdo.

2. Ingresa el nombre del elemento sample-app, selecciona la opción Multibranch Pipeline y haz clic en OK.

3. En la página siguiente, en la sección Branch Sources, selecciona Git en el menú desplegable Add source.

4. En el campo Project Repository, ingresa la URL de clonación de tu repositorio:

http://{{{project_0.startup_script.git_server_ip}}}:3000/giteaadmin/sample-app.git Nota: Si la variable no se completa, puedes ingresar http://[GIT_SERVER_IP]:3000/giteaadmin/sample-app.git reemplazando [GIT_SERVER_IP] por la IP de tu servidor Git.

5. En Credentials, déjalo configurado en - none -.

6. En la sección Scan Multibranch Pipeline Triggers, marca la casilla Periodically if not otherwise run y establece el valor de Interval en 1 minute.

7. Deja el resto de las opciones con sus valores predeterminados y haz clic en Save.

Después de completar estos pasos, se ejecuta un trabajo denominado Branch indexing. Este metatrabajo identifica las ramas de tu repositorio y garantiza que no se hayan producido cambios en las ramas existentes. Si haces clic en sample-app en la barra de navegación, debería verse el trabajo master.

Nota: Es posible que la primera ejecución del trabajo master falle hasta que realices algunos cambios de código en el paso siguiente.

Creaste con éxito una canalización de Jenkins. A continuación, crearás el entorno de desarrollo para la integración continua.

Tarea 9: Crea el entorno de desarrollo

Las ramas de desarrollo son un conjunto de entornos que los desarrolladores usan para probar los cambios en el código antes de enviarlos con el objetivo de integrarlos en el sitio real. Estos entornos son versiones reducidas de tu aplicación, pero deben implementarse utilizando los mismos mecanismos que el entorno activo.

Crea una rama de desarrollo

Para crear un entorno de desarrollo a partir de una rama de funciones, puedes enviar la rama al servidor Git y dejar que Jenkins implemente tu entorno.

Nota: Si ves errores en Cloud Shell, presiona Ctrl + C y, luego, ejecuta el siguiente comando.

• Crea una rama de desarrollo y envíala al servidor Git:

git checkout -b new-feature

Modifica la definición de la canalización

El archivo Jenkinsfile que define esa canalización se escribe con la sintaxis de Groovy para canalizaciones de Jenkins. Si utilizas el archivo Jenkinsfile, podrás expresar una canalización de compilación completa en un solo archivo que se encuentre junto a tu código fuente. Las canalizaciones admiten funciones potentes como la paralelización y requieren la aprobación manual del usuario.

Para que la canalización funcione como se espera, debes modificar el Jenkinsfile con el objetivo de configurar el ID de tu proyecto.

1. Abre el Jenkinsfile en el editor de terminal (por ejemplo, vi) y ejecuta el siguiente comando:

vi Jenkinsfile

2. Inicia el editor con el siguiente comando:

i

3. Agrega tu PROJECT_ID al valor REPLACE_WITH_YOUR_PROJECT_ID. PROJECT_ID es el ID de tu proyecto que figura en la sección DETALLES DE LA CONEXIÓN de este lab. También puedes ejecutar gcloud config get-value project para encontrarlo.

4. Cambia el valor de CLUSTER_ZONE a . Ejecuta gcloud config get compute/zone para obtener este valor.

PROJECT = "REPLACE_WITH_YOUR_PROJECT_ID" APP_NAME = "gceme" FE_SVC_NAME = "${APP_NAME}-frontend" CLUSTER = "jenkins-cd" CLUSTER_ZONE = "{{{project_0.default_zone}}}" IMAGE_TAG = "gcr.io/${PROJECT}/${APP_NAME}:${env.BRANCH_NAME}.${env.BUILD_NUMBER}" JENKINS_CRED = "${PROJECT}"

5. Guarda el archivo Jenkinsfile. Para hacerlo, presiona Esc y, luego, ingresa lo siguiente (para usuarios de vi):

:wq

Modifica el sitio

Para demostrar el cambio de la aplicación, cambiarás las tarjetas de gceme de azul a naranja.

1. Abre html.go con el siguiente comando:

vi html.go

2. Inicia el editor con el siguiente comando:

i

3. Cambia las dos instancias de <div class="card blue"> por lo siguiente:

<div class="card orange">

4. Guarda el archivo html.go. Para ello, presiona Esc y, luego, ingresa lo siguiente:

:wq

5. Abre main.go con el siguiente comando:

vi main.go

6. Inicia el editor con el siguiente comando:

i

7. La versión se define en esta línea:

const version string = "1.0.0"

Actualízala a los siguientes valores:

const version string = "2.0.0"

8. Guarda el archivo main.go una vez más. Para ello, presiona Esc y, luego, ingresa lo siguiente:

:wq

Tarea 10: Comienza la implementación

En esta tarea, implementarás tu entorno de desarrollo.

1. Confirma y envía los cambios:

git add Jenkinsfile html.go main.go git commit -m "Version 2.0.0" git push origin new-feature

Estos comandos inician una compilación de tu entorno de desarrollo.

Después de enviar el cambio al repositorio de Git, navega a la interfaz de usuario de Jenkins, en la que podrás ver que empezó la compilación para la rama new-feature. Los cambios pueden tardar hasta un minuto en implementarse.

2. Una vez que se esté ejecutando la compilación, haz clic en la flecha hacia abajo junto a la compilación, en el menú de navegación de la izquierda, y selecciona Console output:

3. Realiza un seguimiento del resultado de la compilación durante unos minutos y espera a que comiencen a aparecer los mensajes kubectl --namespace=new-feature apply… La rama new-feature se implementó en tu clúster.

Nota: En una situación de desarrollo, no usarías un balanceador de cargas público. Para proteger tu aplicación, usa el proxy de kubectl. El proxy se autentica por sí solo con la API de Kubernetes y procesa las solicitudes de tu máquina local al servicio en el clúster sin exponer tu servicio a Internet.

Si no viste nada en Build Executor, no te preocupes. Solo accede a la página principal de Jenkins > sample app. Verifica que la canalización new-feature se haya creado.

4. Una vez que todo esto esté resuelto, inicia el proxy en segundo plano con el siguiente comando:

kubectl proxy &

5. Si se atasca, presiona Ctrl + C para salir. Verifica que se pueda acceder a tu aplicación enviando una solicitud a localhost y dejando que el proxy kubectl la reenvíe a tu servicio:

curl \ http://localhost:8001/api/v1/namespaces/new-feature/services/gceme-frontend:80/proxy/version

Debería responder con 2.0.0, que es la versión que ahora se está ejecutando.

Si recibes un error similar a este:

{ "kind": "Status", "apiVersion": "v1", "metadata": { }, "status": "Failure", "message": "no endpoints available for service \"gceme-frontend:80\"", "reason": "ServiceUnavailable", "code": 503

6. Significa que tu endpoint de frontend aún no se propagó. Espera un poco y vuelve a probar el comando curl. Continúa cuando obtengas el siguiente resultado:

2.0.0

Configuraste el entorno de desarrollo. A continuación, aplicarás lo que aprendiste en el módulo anterior implementando un lanzamiento Canary para probar una función nueva.

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si iniciaste correctamente la compilación de la rama new-feature, verás una puntuación de evaluación.

Realizar la compilación de la rama new-feature

Tarea 11: Implementa un lanzamiento Canary

Verificaste que tu app está ejecutando el código más reciente en el entorno de desarrollo, así que implementa el código en el entorno del lanzamiento Canary.

1. Crea una rama de versiones canary y envíala al servidor Git con el siguiente comando:

git checkout -b canary git push origin canary

2. En Jenkins, deberías ver que se inició la canalización canary. Una vez que se complete, podrás consultar la URL del servicio para asegurarte de que la versión nueva entregue parte del tráfico. Deberías ver alrededor de 1 a 5 solicitudes (sin ningún orden en particular) que devuelvan la versión 2.0.0:

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Si sigues viendo 1.0.0, intenta ejecutar los comandos anteriores nuevamente. Una vez que hayas comprobado que funciona lo anterior, finaliza el comando con Ctrl + C.

Listo. Implementaste un lanzamiento Canary. A continuación, implementarás la versión nueva en la producción.

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si implementaste correctamente el lanzamiento Canary, verás una puntuación de evaluación.

Implementar un lanzamiento Canary

Tarea 12: Implementa el lanzamiento en producción

Ahora que el lanzamiento Canary tuvo éxito y no hemos escuchado ninguna queja de los clientes, impleméntalo en el resto de tu flota de producción.

1. Crea una rama de versiones canary y envíala al servidor Git con el siguiente comando:

git checkout master git merge canary git push origin master

En Jenkins, deberías ver que se inició la canalización de la instancia principal.

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si iniciaste correctamente la canalización principal, verás una puntuación de evaluación.

Implementar el lanzamiento en producción

2. Una vez que se complete (lo cual puede tardar algunos minutos), puedes consultar la URL del servicio para asegurarte de que tu nueva versión (2.0.0) entregue todo el tráfico.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Una vez más, si ves instancias de 1.0.0, vuelve a ejecutar los comandos anteriores. Para detener este comando, presiona Ctrl + C.

Resultado de ejemplo:

gcpstaging9854_student@qwiklabs-gcp-df93aba9e6ea114a:~/continuous-deployment-on-kubernetes/sample-app$ while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 ^C

También puedes navegar al sitio en el que la aplicación gceme muestra las tarjetas de información. El color de la tarjeta cambió de azul a naranja.

4. Aquí presentamos de nuevo el comando para obtener la dirección IP externa. Usa el siguiente comando para pegar la IP externa en una pestaña nueva y que aparezca la tarjeta de información:

kubectl get service gceme-frontend -n production

Resultado de ejemplo:

Tarea 13: Pon a prueba tus conocimientos

Aquí tienes algunas preguntas de opción múltiple para reforzar tus conocimientos de los conceptos de este lab. Intenta responderlas lo mejor posible.

¡Listo!

¡Impresionante trabajo! Implementaste con éxito tu aplicación en producción.

¡Felicitaciones!

Así concluye este lab práctico sobre cómo implementar y trabajar con Jenkins en Kubernetes Engine para habilitar una canalización de entrega continua o implementación continua. Tuviste la oportunidad de implementar una herramienta DevOps importante en Kubernetes Engine y configurarla para su uso en producción. Trabajaste con la herramienta de línea de comandos de kubectl y los parámetros de configuración de implementación en archivos YAML, y aprendiste un poco acerca de cómo configurar las canalizaciones de Jenkins para un proceso de desarrollo o implementación. Con esta experiencia práctica, deberías sentirte capaz de emplear estas herramientas en tu propio taller de DevOps.

Próximos pasos y más información

• Lee más sobre la solución Jenkins en Kubernetes Engine.
• Aprende a usar Jenkins para habilitar la entrega continua en Kubernetes Engine.
• Lee más sobre las soluciones y guías de DevOps en la documentación de Google Cloud.
• Conéctate con la comunidad de Jenkins.

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: 20 de mayo de 2026

Prueba más reciente del lab: 26 de febrero de 2026

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