Precondiciones:

1. Crear una Cuenta gratuita en Azure Devops con tu cuenta de correo de Choucair
https://dev.azure.com/

2. Una vez finalizado el proceso de crear la cuenta, procedemos a crear un nuevo Proyecto
en Azure Devops y cargar el código del siguiente enlace:
Nota: Puedes también cargar un código que tengas de ejemplo.

https://drive.google.com/open?id=1robn4F1R3UeA4NHA0-As__NLS5FIPEY_

3. Se debe crear un repositorio que en nuestro caso lo llamaremos “ProyectTest”.

A continuación, explicaremos como crear un repositorio en azure DevOps.

 Después de crear el proyecto, este se debería visualizar de la siguiente manera:

Para crear el repositorio, en el menú izquierdo nos posicionamos sobre “Repos>Files”.

Luego de haber dado clic debemos ver la siguiente pantalla.

Ahora continuaremos con la configuración del README y el archivo gitignore los cuales se pueden
visualizar al final de la página, para ello habilitaremos el check de “Add a README”, daremos clic
en botón “Add a .gitignore” y en el input buscaremos para palabra “Java” y por ultimo damos clic
al botón “Initialize”.
Lugo de haber realizado el paso anterior, debemos visualizar lo siguiente:

A partir de este momento vamos a hacer un paréntesis, debido a que vamos a cargar el proyecto a
él repositorio de Azure a través de git.

Nota: El proyecto a cargar esta realizado en el patrón Screenplay y realiza una traducción de una
palabra en el traductor de Google.
Una vez descargado el proyecto de la URL entrega en la parte inicial del presente Laboratorio, lo
descomprimimos en el lugar que deseemos.

Después vamos a ingresar a la carpeta donde se encuentra el mismo y vamos a dar clic derecho y
abriremos la consola de Git Bash.

Desde esta, y a través de los comandos de git nos podremos subir nuestro proyecto al repositorio
de Azure DevOps.
El primer comando que utilizaremos será:

- “git init”. Con este comando se crea un nuevo subdirectorio llamado “. git” que contiene
todos los archivos necesarios del repositorio es decir un esqueleto de un repositorio Git.

Seguidamente utilizaremos el comando:

- “git remote add origin <<url repositorio remoto>>” que será el encargado de
conectarnos con el repositorio remoto de azure, para esto vamos a volver al azure a
buscar el link para conectarnos al repositorio.

Vamos a dar clic al botón “Clone” , donde nos veremos la url que necesitamos, seguidamente
damos clic en el botón “Generate Git credentials” y por ultimo copiamos la Url y volvemos a la
consola de git.

Continuamos con el comando:

- “git pull origin <<rama>>”, con este comando vamos a bajar los dos archivos que tenemos
en el repositorio el README y el. gitignore.
Una vez ejecutado este comando, nos solicitara credenciales las cuales fueron generadas cuando
dimos clic al botón “Generate Git credentials” en Azure. Ingresamos el usuario y contraseña y
damos clic en el botón aceptar.

Una vez ingresadas las credenciales, procedemos a verificar que en nuestro proyecto local se
hayan descargado los dos archivos que estaban en el repositorio (README.md y .gitignore).
Ahora procedemos a modificar el archivo “.gitignore” de nuestro proyecto local, lo vamos a abrir
en un editor de texto y vamos a adicionar las siguientes líneas al final del mismo. Guardamos los
cambios y cerramos el archivo.

.gradle
build/
# Ignore Gradle GUI config
gradle-app.setting
# Avoid ignoring Gradle wrapper jar file (.jar files are usually
ignored)
!gradle-wrapper.jar
# Cache of project
.gradletasknamecache

Nuevamente volvemos a la consola de git para subir nuestro proyecto automatizado con los
últimos cambios realizados, para esto utilizaremos el comando:

- “git add -A” para preparar los archivos que vamos a subir.

Luego usamos el comando:

- “git commit -m "Observacion" con el preparamos todo y asignamos la observación de los

cambios que hemos realizado.

Y por último utilizamos el comando:

- “git push origin master” para subir los archivos al repositorio de Azure DevOps.
Una vez terminado el proceso, nos dirigimos al repositorio de Azure y al dar refresh a nuestra
pantalla debemos visualizar todos los archivos ya cargados de nuestro proyecto.

Ahora si estamos listos para crear los PipeLine (CI, CD, RM).
Creación PipeLine CI
1. Acceder a Azure Devops: https://dev.azure.com/
2. Dar clic en la opción Pipelines

3. Clic en “New Pipeline”

4. Como no tenemos ningún Template para nuestro Pipeline, procedemos a dar clic en el link
de la parte inferior izquierda “Use the classic editor”.
5. Seleccionamos nuestro Project, Repositorio y rama Master y clic en el botón Continuar

6. Seleccionamos para continuar con “Empty Job”

7. Le damos un nombre nemotécnico a nuestro Pipeline CI: <<Nombre_Proyecto>>_CI

8. Se debe limpiar los directorios cada que se compile la aplicación, para evitar fallas en el
repositorio. Para esto en Get “Sources” se debe poner la opción “Clean” en true y “Clean
Options” en All builds directories

9. Posteriormente, agregamos la Tarea de SONAR para nuestro “Agent Job” llamada

“Prepare analsys on SonarQube” dando clic en el “+”

10. Agregamos nuestro SonarQube Server Endpoint dando clic en “+ New”

a. Clic en New

b. Diligenciamos los datos del Servicio de Conexión de Sonar y clic en “OK”

Name: sonartestch
Sever Url: http://sonarqube-labch.eastus.cloudapp.azure.com:9000
 Token: a032c89010d0d73b925c7d296eb75b8da13be112

11. Continuamos diligenciando los datos de nuestra tarea, seleccionando el Server Endpoint
que acabamos de generar y los demás campos.

Project Key and Name: $(Build.Repository.Name)

 Damos clic en la sección Advanced y en el campo “Additional Properties” ingresar lo
siguiente.

sonar.sources= $(Build.SourcesDirectory)/src/main/java
sonar.tests = $(Build.SourcesDirectory)/src/test/java
sonar.java.binaries=$(Build.SourcesDirectory)/build/classes

- Configuración de los “Triggers”

Esta configuración se debe habilitar para el Pipeline de CI donde se habilitará la
ejecución automática cuando se realicen “commits” en las distintas ramas.
1. develop
2. release
3. master

12. Nuevamente, agregamos otra Tarea para nuestro “Agent Job” llamada “Gradle” dando clic
en el “+”.
 a. Diligenciamos los siguientes datos en la tarea
Display name: gradlew clean build -x test
Task: clean build -x test

13. Para terminar, agregamos una nueva tarea para nuestro “Agent Job” llamada “Run Code
Analysis” dando clic en el “+” y dejamos tal como la carga nuestra herramienta.
14. Terminado de configurar nuestro Pipeline de CI, procedemos a guardar y correr el mismo
para verificar que no se presente ningún error.

Agregamos comentarios sobre la modificación realizada, grabamos y ejecutar.

Podemos ir observando la ejecución, dando clic en el job.
Creación PipeLine CD
1. Acceder a Azure Devops: https://dev.azure.com/
2. Dar clic en la opción Pipelines

3. Clic en “New Pipeline”

4. Como no tenemos ningún Template para nuestro Pipeline, procedemos a dar clic en el link
de la parte inferior izquierda “Use the classic editor”.
5. Seleccionamos nuestro Project, Repositorio y rama Master y clic en el botón Continuar

6. Seleccionamos para continuar con “Empty Job”

7. Le damos un nombre nemotécnico a nuestro Pipeline: <<Proyecto>>_CD

8. Se deben limpiar los directorios cada que se compile la aplicación, para evitar fallas en el
repositorio. Para esto en “Get Sources” se debe poner la opción “Clean” en true y “Clean
Options” en All builds directories

9. Ahora vamos a comenzar a agregar nuestras Tareas “task” a nuestro “Agent job”

La primera de ella es “gradle” la cual una vez agregada la configuramos.

 Display Name: gradlew clean build -x test
Tasks: clean build -x test

Para el campo Gradle wrapper, damos clic en el campo para seleccionar ubicación y
buscamos el archivo “gradlew”:

10. Agregar una nueva tarea llamada “Copy files”

 Y se configuran sus parámetros
Display Name: Copy files
Source folder: $(system.defaultworkingdirectory)
Contents:

**/*
!build
Target folder: $(build.artifactstagingdirectory)

11. Agregamos la última tarea llamada “Publish Artifac”:

Para esta configuramos los valores:

Display name: Publish Artifact
Path to publish: $(Build.ArtifactStagingDirectory)
Artifact name: ProjectTestArtifact
Una vez finalizado, procedemos a Salvar y ejecutar nuestro pipeline.
Creación Pipeline RM
1. Damos clic en la opción de menú: Releases

2. Creamos un nuevo “Release pipeline”

3. Seleccionamos “Empty Job”

4. Le damos nombre a nuestro Stage “E2E”

5. Damos clic en Job, task

6. Agregamos una nueva tarea “Task” a nuestro “Agent job”

Llamada “gradle”

7. Parametrizamos la tarea de la siguiente manera:

Display name: gradlew
Para el campo “Gradle wrapper” damos clic en el botón para seleccionar el archivo
“gradlew” y clic en el botón “OK”

8. Para el campo “Working directory”, de igual manera damos clic en el botón para
especificar ruta y seleccionamos el directorio raíz de nuestro repositorio de código y
clic en el botón “OK”.
9. En los campos:
Task: clean test --info aggregate
10. Para el campo “Test results files” damos clic para seleccionar inicialmente como
ubicación el proyecto principal:

Y a la ruta que queda agregada:

Le complementamos con el siguiente segmento: /target/site/serenity/SERENITY-

*.xml
 Quedando como ruta definitiva: $(System.DefaultWorkingDirectory)/_ProjectTest-
CD/ProjectTestArtifactory/target/site/serenity/SERENITY-*.xml

11. En el campo “Test run title” colocamos: “pruebas de aceptación” y finalizamos dando
clic en SAVE

12. Para ejecutar el pipeline de RM. Damos clic en el botón “Create Release”
Damos clic en el Stage “E2E” y luego clic en el botón “Crear”

Para continuar con la ejecución del Pipeline damos clic en el link

Luego colocamos el cursor sobre el Stage “E2E” y damos clic en “Deploy”

Nuevamente clic en el botón “Deploy”

Para hacer seguimiento damos clic en “Logs”

Y visualizamos el Log de la ejecución.

Aquí hemos terminado con la creación de los pipelines (CI,

CD, RM), practícalo tantas veces sea necesario.