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

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

En este tutorial va a completar estas tareas:

Prerrequisitos

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 configurado para autenticarse con el registro de ACR.

• Un controlador de Jenkins implementado en una máquina virtual de Azure.

• La 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 de GitHub y un cliente de Git instalado en el sistema de desarrollo

• Si proporciona su propia instancia de Jenkins en lugar de este método de script de ejemplo para implementar Jenkins, su instancia de Jenkins requiere Docker instalado y configurado y kubectl.

Preparación de la aplicación

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

Antes de integrar Jenkins y AKS para 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 le permite ver la aplicación en acción.

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 Bifurcar en la esquina superior derecha.

Clona el repositorio bifurcado en tu sistema de desarrollo. Asegúrese de usar la URL de tu bifurcación para clonar este repositorio:

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

Cambia al directorio de tu 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

Las imágenes base necesarias se extraen y se compilan los contenedores de aplicaciones. A continuación, puede usar el comando docker images para ver la imagen creada. Se han descargado o creado tres imágenes. La azure-vote-front imagen contiene la aplicación y usa la nginx-flask imagen como base. La redis imagen 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 el registro de contenedor de Azure.

az acr login -n <acrLoginServer>

Reemplace <acrLoginServer> por su servidor de inicio de sesión 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 de v1. Utilice su propio <acrLoginServer> nombre 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 ACR. De nuevo, reemplace por <acrLoginServer> 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

Implementación de 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 azure vote. Abra el archivo manifiesto azure-vote-all-in-one-redis.yaml con un editor como vi. Reemplace por microsoft 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

A continuación, use el comando kubectl apply para implementar 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 para exponer la aplicación a 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 --watch argumento .

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

Una vez que la dirección EXTERNAL-IP ha cambiado de pendiente a una dirección IP, use Control + C para detener el proceso de visualizació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 se muestra en el ejemplo siguiente:

Configuración del controlador 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 por <PublicIPAddress> la dirección IP del controlador de Jenkins.

Instalar e iniciar sesión en AzCLI

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

az login

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

Creación de una variable de entorno de Jenkins

Se usa una variable de entorno de Jenkins 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, complete los pasos siguientes:

• En el lado izquierdo del portal de Jenkins, seleccione Manage Jenkins Configure System ( Administrar Jenkins>Configure System).

• 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 Guardar en la parte inferior de la página.

Creación de una credencial de Jenkins para ACR

Durante el proceso de CI/CD, Jenkins compila nuevas imágenes de contenedor basadas en actualizaciones de aplicaciones y, a continuación, debe insertar esas imágenes en el registro de ACR.

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

Para separar roles y permisos, configure una entidad de servicio para Jenkins con permisos de colaborador en el registro de ACR.

Crear una entidad de servicio para que Jenkins use ACR

En primer lugar, crea 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 appId y la contraseña. Estos valores se usan en los pasos siguientes para configurar el recurso de credenciales en Jenkins.

Obtenga el identificador de recurso del registro de ACR 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 utilizado para crear la entidad de servicio.

Crear un recurso de credenciales en Jenkins para el principal de servicio de ACR.

Con la asignación de roles creada en Azure, ahora almacene las credenciales de ACR en un objeto de credencial de Jenkins. Se hace referencia a estas credenciales durante el trabajo de compilación de Jenkins.

En el lado izquierdo del portal de Jenkins, seleccione Manage Jenkins>Manage Credentials>Jenkins Store>Credenciales globales (sin restricciones)>Agregar credenciales

Asegúrese de que el tipo de credencial es Nombre de usuario con contraseña y escriba los siguientes elementos:

• Nombre de usuario - El appId de la entidad de servicio creada para la autenticación con tu registro de ACR.
• Contraseña - la contraseña de la entidad de servicio creada para la autenticación con el registro de ACR.
• ID - Identificador de credencial, como acr-credentials

Cuando haya finalizado, el formulario de credenciales será similar al ejemplo siguiente:

Seleccione Aceptar y vuelva al portal de Jenkins.

Creación de un proyecto de Jenkins

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

1. Escriba azure-vote como nombre del trabajo. Elija Freestyle project (Proyecto freestyle) y, a continuación, seleccione Aceptar.

2. En la sección General, seleccione proyecto de GitHub y escriba la dirección URL del repositorio bifurcado, como https://github.com/<your-github-account>/azure-voting-app-redis.

3. En la sección Administración de código fuente, seleccione Git, escriba la dirección URL del repositorio .git bifurcado, como https://github.com/<your-github-account>/azure-voting-app-redis.git.

4. En la sección Desencadenadores de compilación (Build Triggers), seleccione Desencadenador de enlace de GitHub para el sondeo de GitSCM.

5. En Entorno de compilación, seleccione Usar textos o archivos secretos.

6. En Enlaces, seleccione Agregar>nombre de usuario y contraseña (separados)

   • Escriba ACR_ID para la variable username y ACR_PASSWORD para la variable password.

     

7. Elija añadir un paso de compilación de tipo Execute shell y use el texto siguiente. Este script compila una nueva imagen de contenedor e 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
   

8. Agregue otro paso de compilación de tipo Ejecutar shell y use el texto siguiente. Este script actualiza la implementación de la 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
   

9. Una vez completado, haga clic en 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.

Esta compilación valida que el trabajo se ha configurado correctamente. Confirma que el archivo de autenticación de Kubernetes adecuado está en vigor y que la autenticación en ACR funciona.

En el menú izquierdo del proyecto, seleccione Compilar ahora.

La primera compilación toma más tiempo, ya que las capas de imagen de Docker se descargan al servidor Jenkins.

Las compilaciones realizan las siguientes tareas:

1. Clona el repositorio de GitHub
2. Compila una nueva imagen de contenedor
3. Envía la imagen de contenedor al repositorio ACR.
4. Actualiza la imagen usada por el despliegue de AKS.

Dado que no se han realizado cambios en el código de la aplicación, la interfaz de usuario web no cambia.

Una vez completado el trabajo de compilación, seleccione compilación n.º 1 en historial de compilación. Seleccione Salida de la consola y vea la salida del proceso de compilación. La línea final debe indicar una compilación exitosa.

Creación de un webhook de GitHub

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

Para crear el webhook de GitHub, complete los pasos siguientes:

1. Ve a tu repositorio de GitHub bifurcado en un navegador web.

2. Seleccione Configuración y, después, Webhooks en el lado izquierdo.

3. Seleccione Agregar webhook. En Url de carga, escriba http://<publicIp:8080>/github-webhook/, donde <publicIp> es la dirección IP del servidor Jenkins. Asegúrese de incluir el / final. Deje los demás valores predeterminados para el tipo de contenido y para activar eventos de empuje.

4. Seleccione Agregar Webhook.

   

Prueba de la canalización completa de CI/CD

Ahora puede probar toda la canalización de CI/CD. Al insertar una confirmación de código en GitHub, se realizan los pasos siguientes:

1. El webhook de GitHub notifica a Jenkins.
2. Jenkins inicia el trabajo de compilación y extrae la confirmación de código más reciente de GitHub.
3. Una compilación de Docker se inicia con el código actualizado y la nueva imagen de contenedor se etiqueta con el número de compilación más reciente.
4. Esta nueva imagen de contenedor se inserta en Azure Container Registry.
5. La aplicación que se ejecuta en Azure Kubernetes Service se actualiza con la imagen más reciente 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 denominado config_file.cfg. Actualice los valores de voto de este archivo a algo distinto de gatos y perros, como se muestra en el ejemplo siguiente:

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

Cuando se actualice, 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. En el panel web de Jenkins, supervise el proceso de compilación. 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. Se muestran los cambios, como se muestra en el ejemplo siguiente:

Pasos siguientes