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 compilarás en este lab será similar al diagrama siguiente:

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

Qué aprenderás

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

• Aprovisionar una aplicación de Jenkins en un clúster de Kubernetes Engine
• Configurar tu 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 estés 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 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 son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

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

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

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

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

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón Abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

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

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

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

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

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

4. Haz clic en Siguiente.

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

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

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

6. Haz clic en Siguiente.

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

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

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

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

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

Activa Cloud Shell

Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. El resultado contiene una línea que declara el PROJECT_ID para esta sesión:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

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

gcloud auth list

3. Haz clic en Autorizar.

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

Resultado:

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

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

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

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

Tarea 1. Descarga el código fuente

1. Primero, abre una nueva sesión de Cloud Shell y ejecuta el comando siguiente 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 comando siguiente:

cd continuous-deployment-on-kubernetes

Tarea 2. Aprovisiona Jenkins

Crea un clúster de Kubernetes

1. Ahora, ejecuta el comando siguiente 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 sirven para que Jenkins acceda a Cloud Source Repositories y a Google Container Registry.

Prueba la tarea completada

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

Crea un clúster de Kubernetes (zona: )

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

gcloud container clusters list

3. Ahora, obtén las credenciales para el clúster:

gcloud container clusters get-credentials jenkins-cd

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

kubectl cluster-info

Tarea 3: Configura Helm

En este lab, usarás Helm para instalar Jenkins desde el repositorio de gráficos. Helm es un administrador de paquetes que facilita la configuración y la implementación de aplicaciones de Kubernetes. Una vez que instales Jenkins, podrás configurar tu canalización de CI/CD.

1. Agrega el repositorio de gráfico estable de Helm:

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

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

helm repo update

Tarea 4: Configura e instala Jenkins

Cuando instales Jenkins, puedes usar un archivo values como plantilla con el objetivo de proporcionar los valores necesarios para la configuración.

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

Esto permitirá 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

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

Prueba la tarea completada

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.

Configura e instala Jenkins

2. Una vez que se complete ese 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 resultado siguiente:

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

4. Ejecuta el comando siguiente 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 el complemento de Kubernetes para que los nodos compiladores se inicien automáticamente según sea necesario cuando la instancia principal de Jenkins los solicite. Cuando finalices el trabajo, los nodos 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. Esto expondrá 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 un ClusterIP, por lo que no se puede acceder desde fuera del clúster.

Tarea 5. Conéctate a Jenkins

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

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, haz clic en el botón Vista previa en la Web en Cloud Shell. Luego, haz clic en 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 automáticas de CI/CD en las secciones siguientes.

Tarea 6. Conoce la aplicación

Implementarás la misma aplicación de ejemplo, gceme, en la 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 a un microservicio a través de la admisión de dos modos de funcionamiento.

• 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

Deberás implementar la aplicación en dos entornos diferentes:

• Producción: el sitio real al que acceden tus usuarios.
• Versión Canary: 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 sea lanzado a todos tus usuarios.

1. En Google Cloud Shell, navega al directorio de la aplicación de ejemplo con el comando siguiente:

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

Prueba la tarea completada

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

Crea 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 comando siguiente 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 la versión 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 comando siguiente:

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 comando siguiente para comprobar el resultado de la versión del servicio (debe decir “1.0.0”):

curl http://$FRONTEND_SERVICE_IP/version

Implementaste con éxito 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 una canalización de Jenkins

Cómo crear 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 Cloud Source Repositories con el comando siguiente:

gcloud source repos create default

Puedes omitir la advertencia; no se te cobrará por este repositorio.

Prueba la tarea completada

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

Crear un repositorio git init

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

git config credential.helper gcloud.sh

3. Ejecuta el comando siguiente:

git remote add origin https://source.developers.google.com/p/$DEVSHELL_PROJECT_ID/r/default

4. Establece el nombre de usuario y la dirección de correo electrónico para las confirmaciones de Git. Reemplaza [EMAIL_ADDRESS] por tu dirección de correo electrónico de Git y [USERNAME] por tu nombre de usuario de Git:

git config --global user.email "[EMAIL_ADDRESS]" git config --global user.name "[USERNAME]"

5. Agrega, confirma y envía los archivos con el comando siguiente:

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

Agrega tus credenciales de la cuenta de servicio

Configura tus credenciales para permitir que Jenkins acceda al repositorio de código. Jenkins usará las credenciales de la cuenta de servicio de tu clúster para descargar el código del repositorio de Cloud Source Repositories.

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. Elige Google Service Account from metadata en el menú desplegable Kind y haz clic en Create.

Se agregaron las credenciales globales. El nombre de la credencial es el ID del proyecto que figura en la sección CONNECTION DETAILS del lab.

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. Haz clic en Kubernetes Cloud Details.
7. En el campo Jenkins URL, escribe el valor siguiente: http://cd-jenkins:8080.
8. En el campo Jenkins tunnel, agrega el valor siguiente: cd-jenkins-agent:50000.
9. 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 del repositorio sample-app en Cloud Source Repositories, en el campo Project Repository. Reemplaza [PROJECT_ID] por el ID de tu proyecto:

https://source.developers.google.com/p/[PROJECT_ID]/r/default

5. En el menú desplegable Credentials, elige el nombre de las credenciales que creaste cuando agregaste tu cuenta de servicio en los pasos anteriores.

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

7. La configuración del trabajo debería verse de la manera siguiente:

8. No modifiques el valor predeterminado del resto de las opciones 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.

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

• Crea una rama de desarrollo y envíala al servidor Git con el comando siguiente:

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

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

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, ejecuta lo siguiente:

:wq

5. Abre main.go con el comando siguiente:

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 valores siguientes:

const version string = "2.0.0"

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

:wq

Tarea 10. Inicia la implementación

1. Confirma y envía los cambios con el comando siguiente:

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

Esto iniciará 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 demorar 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 observa los mensajes kubectl --namespace=new-feature apply... para empezar. La rama new-feature se implementará ahora 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 el ejecutor de compilación, 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 comando siguiente:

kubectl proxy &

5. Si se atasca, presiona Ctrl + C para salir. Verifica que se pueda acceder a tu aplicación; para ello, envía una solicitud a localhost y deja 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 resultado siguiente:

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.

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 de la versión canary.

1. Crea una rama de la versión canary y envíala al servidor Git con el comando siguiente:

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 muestren 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, vuelve a ejecutar los comandos anteriores. 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 para producción.

Tarea 12: Realiza la implementación para 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 la versión canary y envíala al servidor Git con el comando siguiente:

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.

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

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

Finaliza tu Quest

Este lab de autoaprendizaje forma parte de las Quests Kubernetes in the Google Cloud, Cloud Architecture y DevOps Essentials. Una Quest es una serie de labs relacionados que forman una ruta de aprendizaje. Si completas esta Quest, obtendrás una insignia como reconocimiento por tu logro. Puedes hacer públicas tus insignias y agregar vínculos a ellas en tu currículum en línea o en tus cuentas de redes sociales. Inscríbete en cualquier Quest que contenga este lab y obtén un crédito inmediato de finalización. Consulta el catálogo de Google Cloud Skills Boost para ver todas las Quests disponibles.

Completa el próximo lab

Continúa tu Quest con Hello Node Kubernetes o revisa estos labs de Google Cloud Skills Boost:

• Cómo organizar la nube con Kubernetes
• Cómo administrar implementaciones con Kubernetes Engine

Próximos pasos/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.

Actualización más reciente del manual: 20 de septiembre de 2023

Prueba más reciente del lab: 20 de septiembre de 2023

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.