Tutorial: Implementación desde GitHub en Azure Kubernetes Service con Jenkins

Artículo
08/07/2024

Importante

Muchos servicios de Azure tienen complementos de Jenkins. Algunos de estos complementos dejarán de ser compatibles a partir del 29 de febrero de 2024. La CLI de Azure es la forma recomendada actualmente de integrar Jenkins con los servicios de Azure. Para obtener más información, consulte el artículo Complementos de Jenkins para Azure.

En este tutorial se implementa una aplicación de ejemplo de GitHub en un clúster de Azure Kubernetes Service (AKS) mediante la integración (CI) e implementación continuas (CD) en Jenkins.

En este tutorial va a completar estas tareas:

Implementar una aplicación de votación de Azure de ejemplo en un clúster de AKS.
Crear un proyecto de Jenkins básico.
Configurar credenciales para que Jenkins interactúe con ACR.
Crear un trabajo de compilación de Jenkins y webhook de GitHub para las compilaciones automatizadas.
Probar la canalización de CI/CD para actualizar una aplicación en AKS en función de las confirmaciones de código de GitHub.

Requisitos previos

Para completar este tutorial, necesita estos elementos:

Conocimientos básicos de Kubernetes, Git, CI/CD e imágenes de contenedor
Un clúster de AKS y kubectl configurado con las credenciales del clúster de AKS.
Un registro de Azure Container Registry (ACR), el nombre del servidor de inicio de sesión de ACR y el clúster de AKS configurados para autenticarse con el registro de ACR.
Un controlador de Jenkins implementado en una máquina virtual de Azure.
CLI de Azure versión 2.0.46 o posterior instalada y configurada. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.
Docker instalado en el sistema de desarrollo
Una cuenta de GitHub, un token de acceso personal a GitHub y el cliente Git instalado en el sistema de desarrollo
Si al implementar Jenkins proporciona su propia instancia de Jenkins en lugar de utilizar un script como el de este ejemplo, su instancia de Jenkins necesitará kubectl y que Docker esté instalado y configurado.

Preparación de la aplicación

En este artículo, se usa una aplicación de votación de Azure de ejemplo que contiene una interfaz web y Redis para el almacenamiento temporal de los datos.

Antes de integrar Jenkins y AKS para las implementaciones automatizadas, primero prepare e implemente manualmente la aplicación de votación de Azure en el clúster de AKS. Esta implementación manual permite ver la aplicación en acción.

Nota:

La aplicación de ejemplo de voto de Azure usa un pod de Linux que está programado para ejecutarse en un nodo de Linux. El flujo que se describe en este artículo también funciona para un pod de Windows Server que se ha programado en un nodo de Windows Server.

Bifurque el siguiente repositorio de GitHub para la aplicación de ejemplo - https://github.com/Azure-Samples/azure-voting-app-redis. Para bifurcar el repositorio en su propia cuenta de GitHub, seleccione el botón Fork (Bifurcar) de la esquina superior derecha.

Clone la bifurcación para el sistema de desarrollo. Asegúrese de que usa la URL de la bifurcación al clonar este repositorio:

git clone https://github.com/<your-github-account>/azure-voting-app-redis.git

Cambie al directorio de la bifurcación clonada:

cd azure-voting-app-redis

Para crear las imágenes de contenedor necesarias para la aplicación de ejemplo, use el archivo docker-compose.yaml con docker-compose:

docker-compose up -d

Se extraen las imágenes bases necesarias y los contenedores de aplicación creados. Luego puede usar el comando docker images para ver la imagen creada. Se han descargado o creado tres imágenes. La imagen azure-vote-front contiene la aplicación y usa la imagen nginx-flask como base. La imagen redis se usa para iniciar una instancia de Redis:

$ docker images

REPOSITORY                   TAG        IMAGE ID            CREATED             SIZE
azure-vote-front             latest     9cc914e25834        40 seconds ago      694MB
redis                        latest     a1b99da73d05        7 days ago          106MB
tiangolo/uwsgi-nginx-flask   flask      788ca94b2313        9 months ago        694MB

Inicie sesión en su instancia de Azure Container Registry.

az acr login -n <acrLoginServer>

Reemplace <acrLoginServer> por el servidor de inicio de sesión de ACR.

Use el comando docker tag para etiquetar la imagen con el nombre del servidor de inicio de sesión de ACR y un número de versión v1. Utilice el nombre de <acrLoginServer> obtenido en el paso anterior:

docker tag azure-vote-front <acrLoginServer>/azure-vote-front:v1

Por último, inserte la imagen azure-vote-front en el registro de Azure Container Registry. De nuevo, reemplace <acrLoginServer> con el nombre del servidor de inicio de sesión de su propio registro de ACR, como myacrregistry.azurecr.io:

docker push <acrLoginServer>/azure-vote-front:v1

Implementar la aplicación de ejemplo en AKS

Para implementar la aplicación de ejemplo en el clúster de AKS, puede usar el archivo de manifiesto de Kubernetes en la raíz del repositorio de votación de Azure. Abra el archivo de manifiesto azure-vote-all-in-one-redis.yaml con un editor de texto, como vi: Reemplace microsoft por el nombre del servidor de inicio de sesión de ACR. Este valor se encuentra en la línea 60 del archivo de manifiesto:

containers:
- name: azure-vote-front
  image: azuredocs/azure-vote-front

Después, use el comando kubectl apply para ejecutar la aplicación en el clúster de AKS:

kubectl apply -f azure-vote-all-in-one-redis.yaml

Se crea un servicio de equilibrador de carga de Kubernetes que expone la aplicación en Internet. El proceso puede tardar unos minutos. Para supervisar el progreso de la implementación del equilibrador de carga, use el comando kubectl get service con el argumento --watch.

$ kubectl get service azure-vote-front --watch

Una vez que la dirección EXTERNAL-IP haya cambiado de pendiente a una dirección IP, use Control + C para detener el proceso de inspección de kubectl.

NAME               TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE

Para ver la aplicación en acción, abra un explorador web en la dirección IP externa del servicio. Se muestra la aplicación de votación de Azure, como en este ejemplo:

Aplicación de votación de ejemplo de Azure en AKS

Configuración del controlador de Jenkins

Aplique los siguientes cambios para habilitar las implementaciones de AKS desde el controlador de Jenkins:

Abra el puerto 80 de entrada.

az vm open-port \
--resource-group <Resource_Group_name> \
--name <Jenkins_Controller_VM>  \
--port 80 --priority 1020

Reemplace <Resource_Group_name> y <Jenkins_Controller_VM> por los valores adecuados.

SSH en el controlador de Jenkins

ssh azureuser@<PublicIPAddress>

Reemplace <PublicIPAddress> por la dirección IP del controlador de Jenkins.

Instalación de AzCLI e inicio de sesión en la interfaz

curl -L https://aka.ms/InstallAzureCli | bash

az login

Nota:

Para instalar AzCLI de forma manual, siga estas instrucciones.

Instalación de Docker

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common -y;
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -;
sudo apt-key fingerprint 0EBFCD88;
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable";
sudo apt-get update;
sudo apt-get install docker-ce -y;

Instalación de Kubectl y conexión a AKS

sudo az aks install-cli
sudo az aks get-credentials --resource-group <Resource_Group> --name <AKS_Name>

Reemplace <Resource_Group> y <AKS_Name> por los valores adecuados.

Configurar el acceso

sudo usermod -aG docker jenkins;
sudo usermod -aG docker azureuser;
sudo touch /var/lib/jenkins/jenkins.install.InstallUtil.lastExecVersion;
sudo service jenkins restart;
sudo cp ~/.kube/config /var/lib/jenkins/.kube/
sudo chmod 777 /var/lib/jenkins/
sudo chmod 777 /var/lib/jenkins/config

Crear una variable de entorno de Jenkins

Una variable de entorno de Jenkins se usa para contener el nombre del servidor de inicio de sesión de ACR. Se hace referencia a esta variable durante el trabajo de compilación de Jenkins. Para crear esta variable de entorno, siga estos pasos:

En el lado izquierdo del portal de Jenkins, seleccione Manage Jenkins (Administrar Jenkins)>Configure System (Configurar sistema).
En Propiedades globales, seleccione Variables de entorno. Agregue una variable con el nombre ACR_LOGINSERVER y el valor del servidor de inicio de sesión de ACR.
Cuando haya terminado, seleccione Save (Guardar) en la parte inferior de la página.

Crear una credencial de Jenkins para ACR

Durante el proceso de CI/CD, Jenkins genera nuevas imágenes de contenedor en función de las actualizaciones de aplicaciones y luego debe insertar esas imágenes en el registro de Azure Container Registry.

Para permitir que Jenkins inserte imágenes de contenedor actualizadas en ACR, debe especificar las credenciales de ACR.

Para la separación de roles y permisos, configure una entidad de servicio de Jenkins con permisos de colaborador en el registro de ACR.

Crear una entidad de servicio para Jenkins para que use ACR

Primero, cree una entidad de servicio mediante el comando az ad sp create-for-rbac:

az ad sp create-for-rbac

Esto genera una salida similar a la del siguiente ejemplo:

{
  "appId": "<app-ID>",
  "displayName": "azure-cli-2018-09-28-22-19-34",
  "name": "http://azure-cli-2018-09-28-22-19-34",
  "password": "<password>",
  "tenant": "<tenant-ID>"
}

Anote el valor de appId y password. Estos valores se usan en los siguientes pasos para configurar el recurso de credencial de Jenkins.

Obtenga el identificador de recurso del registro de Azure Container Registry mediante el comando az acr show y almacénelo como una variable.

ACR_ID=$(az acr show --resource-group <Resource_Group> --name <acrLoginServer> --query "id" --output tsv)

Reemplace <Resource_Group> y <acrLoginServer> por los valores adecuados.

Cree una asignación de roles para asignar los derechos de colaborador de la entidad de servicio al registro de ACR.

az role assignment create --assignee <appID> --role Contributor --scope $ACR_ID

Reemplace <appId> por el valor proporcionado en la salida del comando anterior usado para crear la entidad de servicio.

Crear un recurso de credencial en Jenkins para la entidad de servicio de ACR

Con la asignación de roles que se creó en Azure, almacene ahora las credenciales de ACR en un objeto de credenciales de Jenkins. A estas credenciales se hace referencia durante el trabajo de compilación de Jenkins.

De nuevo en el lado izquierdo del portal de Jenkins, seleccione Manage Jenkins > Manage Credentials > Jenkins Store > Global credentials (unrestricted) > Add Credentials (Administrar Jenkins > Administrar credenciales > Almacén de Jenkins > Credenciales globales [sin restricción] > Agregar credenciales).

Asegúrese de que el tipo de credencial es Username with password (Nombre de usuario con contraseña) y especifique lo siguiente:

Username (Nombre de usuario): appId de la entidad de servicio creada para la autenticación con el registro de Azure Container Registry.
Password (Contraseña): password de la entidad de servicio creada para la autenticación con el registro de Azure Container Registry.
ID (Id.): identificador de credencial como, por ejemplo, acr-credentials.

Cuando termine, el formulario de credenciales tendrá este aspecto:

Crear un objeto de credencial de Jenkins con información de la entidad de servicio

Haga clic en OK (Aceptar) y vuelva al portal de Jenkins.

Crear un proyecto de Jenkins

En la página principal del portal de Jenkins, seleccione Nuevo elemento en el lado izquierdo:

Escriba azure-vote como nombre de trabajo. Seleccione Freestyle project (Proyecto de estilo libre) y elija OK (Aceptar).
En la sección General, seleccione Proyecto de GitHub y escriba la dirección URL del repositorio que ha bifurcado; por ejemplo, https://github.com/<your-github-account>/azure-voting-app-redis
En la sección Administración de código fuente, seleccione Git y escriba la dirección URL de .git del repositorio bifurcado; por ejemplo, https://github.com/<your-github-account>/azure-voting-app-redis.git
En la sección Build Triggers (Compilar desencadenadores), seleccione GitHub hook trigger for GITScm polling (Desencadenador de enlace de GitHub para sondeo de GITScm).
En Build Environment (Entorno de compilación), seleccione Use secret texts or files (Usar textos secretos o archivos).
En Bindings (Enlaces), seleccione Add (Agregar)>Username and password (separated) (Nombre de usuario y contraseña [separados]).
- Escriba ACR_ID como Username Variable (Variable de nombre de usuario) y ACR_PASSWORD como Password Variable (Variable de contraseña).

Elija agregar un Build Step (Paso de compilación) de tipo Execute shell (Ejecutar shell) y use este texto. Este script genera una nueva imagen del contenedor y la inserta en el registro de ACR.

# Build new image and push to ACR.
WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
docker build -t $WEB_IMAGE_NAME ./azure-vote
docker login ${ACR_LOGINSERVER} -u ${ACR_ID} -p ${ACR_PASSWORD}
docker push $WEB_IMAGE_NAME

Agregue otro Build Step (Paso de compilación) de tipo Execute shell (Ejecutar shell) y use el texto siguiente. Este script actualiza la implementación de aplicación en AKS con la nueva imagen de contenedor de ACR.
```
# Update kubernetes deployment with new image.
WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
kubectl set image deployment/azure-vote-front azure-vote-front=$WEB_IMAGE_NAME
```
Cuando termine, haga clic en Save (Guardar).

Prueba de la compilación de Jenkins

Antes de automatizar el trabajo en función de las confirmaciones de GitHub, pruebe manualmente la compilación de Jenkins.

Con esta compilación se asegura de que el trabajo se ha configurado correctamente. Confirma que el archivo de autenticación Kubernetes adecuado está implementado y que funciona la autenticación en ACR.

En el menú de la izquierda del proyecto, seleccione Build Now (Compilar ahora).

Compilación de prueba de Jenkins

La primera compilación tarda más, ya que las capas de imagen de Docker se extraen hacia el servidor de Jenkins.

La compilación realiza las tareas siguientes:

Clona el repositorio de GitHub.
Compila una nueva imagen de contenedor.
Envía la imagen del contenedor al registro de ACR.
Actualiza la imagen usada por la implementación de AKS.

Dado que no se ha efectuado ningún cambio en el código de aplicación, la interfaz de usuario web no se modifica.

Una vez completado el trabajo de compilación, seleccione build #1 (compilación n.º 1) en el historial de compilaciones. Seleccione Salida de la consola y vea la salida del proceso de compilación. La última línea debe indicar una compilación correcta.

Crear un webhook de GitHub

Con una correcta compilación manual completa, integre GitHub en la compilación de Jenkins. Use un webhook para ejecutar el trabajo de compilación de Jenkins cada vez que se confirme el código en GitHub.

Para crear el webhook de GitHub, siga estos pasos:

Vaya al repositorio de GitHub bifurcado en un explorador web.
Seleccione Configuración y Webhooks en el lado izquierdo.
Seleccione Agregar Webhook. Para Dirección URL de carga, escriba http://<publicIp:8080>/github-webhook/, donde <publicIp> corresponde a la dirección IP del servidor de Jenkins. Asegúrese de incluir la barra diagonal (/) final. Deje los demás valores predeterminados para el tipo de contenido y para el desencadenador en eventos de inserción.
Seleccione Agregar Webhook.

Probar la canalización de CI/CD completa

Ya puede probar la canalización de CI/CD completa. Cuando se inserte una confirmación de código en GitHub, se producen estos pasos:

El webhook de GitHub notifica a Jenkins.
Jenkins inicia el trabajo de compilación y extrae la última confirmación de código de GitHub.
Se inicia una compilación de Docker con el código actualizado y se etiqueta la nueva imagen de contenedor con el número de compilación más reciente.
Esta nueva imagen de contenedor se inserta en Azure Container Registry.
La aplicación que se ejecuta en Azure Kubernetes Service se actualiza con la imagen más reciente procedente de Azure Container Registry.

En la máquina de desarrollo, abra la aplicación clonada con un editor de código. En el directorio /azure-vote/azure-vote, abra el archivo con el nombre config_file.cfg. Actualice los valores de votación en este archivo a algo distinto de gatos y perros, como se muestra en el ejemplo:

# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Blue'
VOTE2VALUE = 'Purple'
SHOWHOST = 'false'

Cuando haya actualizado los valores, guarde el archivo, confirme los cambios e insértelos en la bifurcación del repositorio de GitHub. El webhook de GitHub desencadena un nuevo trabajo de compilación en Jenkins. Supervise el proceso de compilación en el panel web de Jenkins. Tarda unos segundos en extraer el código más reciente, crear e insertar la imagen actualizada e implementar la aplicación actualizada en AKS.

Una vez completada la compilación, actualice el explorador web de la aplicación de votación de Azure de ejemplo. Los cambios que ha realizado se pueden apreciar, como en este ejemplo:

Aplicación de votación de Azure de ejemplo en AKS actualizada por el trabajo de compilación de Jenkins

Pasos siguientes

Jenkins en Azure

Compartir a través de