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 quieras, 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 aplicaciones 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 ventajas 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 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: 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 la zona :

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

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

gsutil 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 al repositorio de GitHub y a Google Container 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 al repositorio de GitHub y a Google Container 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 paquetes estables 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 gráfico con tus parámetros de configuración:

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

Este comando puede tardar algunos minutos en terminar de ejecutarse.

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 siguiente comando:

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 gráfico 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 automáticamente.

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 aplicación muestra los metadatos de la instancia en una tarjeta de información.

La aplicación imita un microservicio al admitir dos modos de operación.

• En el modo backend, gceme está a la escucha del puerto 8080 y muestra 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.
• Lanzamiento 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 de manera lógica la implementación a través de este comando:

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 production y 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: Puede que la dirección IP externa del balanceador de cargas tarde varios minutos en aparecer.

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, crearás la canalización de Jenkins de la siguiente manera:

• Crearás un repositorio para alojar el código fuente.
• Agregarás credenciales para permitir que Jenkins acceda al repositorio de código.
• Configurarás Jenkins Cloud para Kubernetes.
• Autenticarás Jenkins con el repo privado de GitHub.
• Crearás el trabajo de Jenkins.

Crea un repositorio para alojar el código fuente de la app de ejemplo

1. Crea una copia de la app de ejemplo gceme y envíala a un repositorio de GitHub:

En Cloud Shell, ejecuta los siguientes comandos para configurar Git y GitHub:

curl -sS https://webi.sh/gh | sh gh auth login gh api user -q ".login" GITHUB_USERNAME=$(gh api user -q ".login") git config --global user.name "${GITHUB_USERNAME}" git config --global user.email "${USER_EMAIL}" echo ${GITHUB_USERNAME} echo ${USER_EMAIL}

• Presiona INTRO para aceptar las opciones predeterminadas.
• Lee las instrucciones en el resultado del comando para acceder a GitHub con un navegador web.

Cuando hayas accedido a tu cuenta correctamente, tu nombre de usuario de GitHub aparecerá en el resultado de Cloud Shell.

gh repo create default --private

Puedes pasar por alto la advertencia, ya que no se te facturará por este repositorio.

git init

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

git config credential.helper gcloud.sh

3. Ejecuta el siguiente comando:

git remote add origin https://github.com/${GITHUB_USERNAME}/default

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

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

Agrega las credenciales de tu cuenta de servicio

Configura tus credenciales para permitir que Jenkins acceda al repositorio de código. Jenkins usa las credenciales de la cuenta de servicio de tu clúster para descargar código del repositorio de GitHub.

1. En la interfaz de usuario de Jenkins, haz clic en Manage Jenkins en el menú de navegación de la izquierda y haz clic en Security > Credentials.

2. Haz clic en System.

3. Haz clic en Global credentials (unrestricted).

4. Haz clic en Add Credentials en la esquina superior derecha.

5. Selecciona la Google Service Account from metadata del menú desplegable Kind.

6. En el campo ID, ingresa el Project ID y haz clic en Create.

Nota: "Project ID" se encuentra en la sección "CONNECTION DETAILS" del lab.

Se agregaron las credenciales globales.

Configura Jenkins Cloud para Kubernetes

1. En la interfaz de usuario de Jenkins, elige Manage Jenkins > Nodes.
2. Haz clic en Clouds en el panel de navegación izquierdo.
3. Haz clic en New cloud.
4. Escribe cualquier nombre en Cloud name y elige Kubernetes para Type.
5. Haz clic en Create.
6. En el campo Jenkins URL, escribe el siguiente valor: http://cd-jenkins:8080.
7. En el campo Jenkins tunnel, agrega el siguiente valor: cd-jenkins-agent:50000.
8. Haz clic en Save.

Autentica Jenkins con un repo privado de GitHub con una clave SSH

Para autenticar Jenkins con un repositorio privado de GitHub a través de una clave SSH, sigue estos pasos:

a. Genera la clave SSH

1. Crea una nueva clave SSH de GitHub, en la que github-email sea tu dirección de correo electrónico de GitHub:

ssh-keygen -t rsa -b 4096 -N '' -f id_github -C [your-github-email]

2. Para descargar la clave privada (id_github) y la pública (id_github.pub) de tu máquina local, en la barra de acciones de Cloud Shell, haz clic en Más () y selecciona la carpeta continuous-deployment-on-kubernetes/sample-app.

b. Agrega la clave pública a GitHub

Después de generar la clave SSH, debes agregar la clave pública a GitHub para que Jenkins pueda acceder a tus repositorios.

1. Ve a tu cuenta de GitHub. Haz clic en tu perfil de GitHub y navega a Settings.

2. En el menú lateral, selecciona SSH and GPG keys.

3. Haz clic en New SSH key.

4. Ingresa el título SSH_KEY_LAB.

5. Pega el contenido de tu clave pública (id_github.pub) descargada de la ruta de acceso (~/continuous-deployment-on-kubernetes/sample-app/id_github.pub) en el campo Key. También puedes agregar un nombre descriptivo en el campo Title.

6. Haz clic en Add SSH key.

c. Configura Jenkins para que use la clave SSH

1. Ve a Jenkins y selecciona Manage Jenkins en el panel principal.

2. Selecciona la opción Credentials.

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

4. Haz clic en Global credentials (unrestricted).

5. Haz clic en Add Credentials.

6. En el menú desplegable Kind, selecciona SSH Username with private key.

7. En ID, ingresa _ssh_key.

8. En Username, escribe [tu nombre de usuario de GitHub].

9. Elige Enter directly para la clave privada y haz clic en Add. Pega el contenido del archivo id_github (descargado de ~/continuous-deployment-on-kubernetes/sample-app/id_github).

10. Haz clic en Create.

d. Agrega la clave SSH pública a hosts conocidos

En Cloud Shell, crea un archivo llamado known_hosts.github y agrega la clave SSH pública a este archivo.

ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github cat known_hosts.github Nota: Si ves algún error en Cloud Shell, presiona Ctrl + C y, luego, ejecuta el comando anterior.

e. Configura la clave del host conocido

1. Haz clic en Dashboard > Manage Jenkins en el panel izquierdo.

2. En Security, haz clic en Security.

3. En Git Host Key Verification Configuration, en Host Key Verification Strategy, selecciona Manually provided keys en el menú desplegable.

4. Pega el contenido del archivo known hosts.github en Approved Host Keys.

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

1. Haz clic en Dashboard > New Item en el panel del lado izquierdo.

2. Otorga al proyecto el nombre sample-app y, luego, elige 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. Pega la HTTPS clone URL de tu repo de sample-app en el campo Project Repository. Reemplaza ${GITHUB_USERNAME} por tu nombre de usuario de GitHub:

git@github.com:${GITHUB_USERNAME}/default.git

5. En las opciones del menú Credentials, selecciona el nombre github credentials.

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 parte superior izquierda, debería verse el trabajo master.

Nota: Es posible que la primera ejecución del trabajo de instancia principal 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 este comando:

i

3. Agrega tu PROJECT_ID al valor REPLACE_WITH_YOUR_PROJECT_ID. (Tu PROJECT_ID es el ID de tu proyecto que figura en la sección CONNECTION DETAILS 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 ello, 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:

vi html.go

2. Inicia el editor con este 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 este 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 extremo de frontend aún no se ha propagado. 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 lanzamiento 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 lanzamiento 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. Pega la IP externa en una pestaña nueva para que aparezca la tarjeta de información con el siguiente comando:

kubectl get service gceme-frontend -n production

Resultado de ejemplo:

Tarea 13: Pon a prueba tus conocimientos

A continuación, se presentan 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 importante de DevOps en Kubernetes Engine y configurarla para su uso en producción. Trabajaste con la herramienta de línea de comandos 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: 10 de junio de 2025

Prueba más reciente del lab: 10 de junio 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.