Tema 2.2 - Práctica Jenkins

Consideraciones para el ejercicio práctico

• Los archivos a descargar pesan al rededor de 6 GB.
• El entregable será un documento de word que contendrá los siguientes pantallazos:

    a) Imagen de la consola cuando se ejecuta el comado "ipconfig" de las máquinas de Jenkins-sonar y Tomcat.

    b) imagen de la consola cuando se prueba la conectividad entre ambas máquinas 

    c) Imagen de jenkins después de instalado y logueado como admin

    d) Imagen donde se vea que Tomcat quedó correctamente configurado

    e) Imagen con los jobs de jenkins ejecutados correctamente (en color azul). se debe apreciar la fecha y hora del sistema.

Descripción y paso a paso

En esta práctica utilizaremos la herramienta Jenkins para evaluar un código integrándolo con SonarQube y posteriormente desplegar ese código en un servidor web. La práctica se realizará en dos máquinas virtuales que tienen el Sistema Operativo CentOS (distribución de Linux) y adicionalmente necesitaremos 2 archivos, los cuales para obtenerlos damos clic en los siguientes enlace:

Jenkins Sonar

Tomcast Haproxy

Se deben descargar los archivos  que se indican en la imagen y guardarlos en una carpeta la cual llamaremos Imágenes Máquina Virtual y en ella colocamos los archivos que descargamos.

Ahora procedemos a descomprimir esos archivos. Estos archivos son imágenes virtuales, en la imagen del archivo jenkins-sonar es donde vamos a configurar nuestro Jenkins y SonarQube, mientras que en la otra imagen tomcat-haproxy configuraremos nuestro servidor web.

Nota: Para montar las imágenes virtuales, necesitamos un software de virtualización y para ello utilizaremos VirtualBox que lo podemos descargar dándole clic al siguiente enlace https://www.virtualbox.org/wiki/Downloads

Una vez instalado VirtualBox, vamos a montar primero la imagen de jenkins-sonar. Abrimos el software de virtualización y le damos clic en el botón “Nueva”.

Nos aparecerá un cuadro de diálogo donde en el nombre colocaremos “Jenkins-Sonar” (sin comillas), en el tipo seleccionamos “Linux”, en la versión escogemos “Red Hat (64-bit)” y por último damos clic en el botón “Next”.

Seleccionamos un tamaño de memoria RAM mínimo de 2048 Megabytes y le damos clic en “Next”.

En el nuevo cuadro de diálogo seleccionamos la opción “Usar un archivo de disco duro virtual existente” y le damos clic en la figura de carpeta.

En esta nueva ventana que nos aparece, le damos clic en el botón “Agregar”.

Luego buscamos la imagen virtual que está en la carpeta jenkins-sonar y por último le damos clic en el botón “Seleccionar”.

Ya que escogimos la imagen virtual, finalizamos el proceso dando clic en el botón “Crear”.

Vemos que en el administrador de VirtualBox está montada nuestra imagen virtual en la cual configuraremos Jenkins y SonarQube.

Hacemos el mismo procedimiento para montar la imagen virtual que se encuentra en la carpeta tomcat-haproxy.

En el administrador de VirtualBox le damos clic en el botón “Nueva”, nombramos a la máquina virtual “Tomcat” (sin comillas), elegimos las mismas opciones que escogimos para la máquina de Jenkins-Sonar y le damos clic en “Next”.

Dejamos la misma memoria RAM que nos asigna por defecto (1024 MB) y le damos clic en “Next”.

A continuación, volvemos a escoger la opción “Usar un archivo de disco duro virtual existente”, le damos clic al ícono de la carpeta y luego agregamos la imagen virtual que tenemos en la carpeta tomcat-haproxy.

Ahora que seleccionamos la imagen, solo nos falta en darle clic en “Crear”. Al hacer esto podemos observar que en VirtualBox nos aparece dos máquinas virtuales con los nombres Jenkins-Sonar y Tomcat.

Ya que tenemos las dos máquinas virtuales montadas, las debemos configurar. La máquina Jenkins-Sonar le asignaremos 2 procesadores, habilitaremos la opción para usar el ratón y le colocaremos un adaptador de red tipo puente (bridge).

Para lograr esta configuración, seleccionamos la máquina virtual Jenkins-Sonar y luego, damos clic en el botón “Configuración”.

Nos aparecerá una ventana de configuración, seleccionamos la opción “Sistema” que se encuentra en la parte izquierda de la pantalla; luego seleccionamos la pestaña “Placa base” y en “Dispositivo apuntador” buscamos la opción “Tableta USB” para poder usar el ratón (mouse) en la máquina virtual.

En la misma configuración del sistema, le damos clic en la pestaña “Procesador” y en “Procesador(es)” lo cambiamos por 2 CPU.

Luego seleccionamos la opción “Red” que está en la parte izquierda de la pantalla de configuración, escogemos la pestaña “Adaptador 1” buscamos la opción “Conectado a” y ponemos elegimos “Adaptador puente”, por último, en “Nombre” podemos escoger cualquiera de las dos, pero para esta práctica vamos a seleccionar “Intel(R) Centrino(R) Advanced-N 6205”.

Ahora le damos en “Aceptar” para que se guarden todos los cambios que le hicimos a la máquina virtual Jenkins-Sonar.

Para la máquina virtual Tomcat hacemos la misma configuración que se realizó anteriormente, exceptuando el procesador que en vez de 2 pondremos 1 procesador.

Como ya tenemos nuestras máquinas virtuales configuradas, es momento de realizar nuestra práctica.

Abrimos nuestras dos máquinas virtuales y vemos que tenemos 2 usuarios (osboxes y sonar) en la máquina Jenkins-Sonar y un usuario (osboxes) en la máquina Tomcat para iniciar sesión. El usuario y contraseña que vamos a utilizar para ambas máquinas son los siguientes:

• Usuario: osboxes.org
• Contraseña: osboxes.org

Para tener en cuenta: Cuando usted inicie cualquiera de las dos máquinas virtuales se dará cuenta que la pantalla no se ajusta automáticamente a la pantalla de invitado de VirtualBox, si desea arreglar esto (no es obligatorio) puede ingresar al siguiente enlace https://www.youtube.com/watch?v=XyEnoLWUrKE (Instalar Guest Additions) y seguir los pasos que muestra el vídeo. Si por alguna razón en la máquina virtual Tomcat o Jenkins-Sonar presentan problemas debido a que hay otra aplicación sosteniendo el “bloqueo yum”, entre a este enlace Arreglar Comando YUM para solucionarlo y ya luego realice los pasos para instalar los Guest Additions.

Tampoco es obligatorio, pero se recomienda cambiar el idioma de las máquinas virtuales a español para que sea más fácil digitar los comandos que se van a ejecutar más adelante.

Cuando ingresemos, abrimos la Terminal en ambas máquinas y en ella escribimos el comando ifconfig para conocer nuestras IP’s y poder verificar si configuró bien la red de tipo puente.

Nota: Las IP’s que se mostrarán en las siguientes imágenes puede que no sean las mismas que a usted le aparezcan, debido a que estas IP’s son asignadas aleatoriamente mediante el protocolo DHCP.

Ahora nos posicionamos en la máquina virtual de Jenkins-Sonar y escribimos ping <IP-MÁQUINA-VIRTUAL-TOMCAT> para probar la conectividad entre ambas máquinas. Si todo salió bien debemos ver algo similar.

Como podemos observar, los paquetes que estamos enviando llegan correctamente a la máquina virtual de Tomcat. Para cancelar el envío de paquetes presionamos las teclas Ctrl+C.

De aquí en adelante, todos los cambios e instrucciones se harán en la máquina virtual Jenkins-Sonar.

En la Terminal escribimos su, luego nos pedirá la contraseña la cual es osboxes.org, y con esto tendremos los privilegios del usuario administrador root.

Ahora escribimos en la Terminal systemctl status jenkins para verificar si el estado del servicio de Jenkins está activado. Si está en ejecución el servicio, nos debería mostrar lo siguiente.

Luego iniciamos el servicio de SonarQube en nuestra máquina virtual Jenkins-Sonar, para esto hacemos los siguientes pasos:

1. En la Terminal escribimos su sonar – para entrar como usuario sonar.
2. Después nos pedirá una contraseña y colocamos sonar.
3. Escribimos el comando para cambiar de directorio cd /opt/sonarqube-6.7.7/bin/linux-x86-64/
4. Luego, ponemos el comando export JRE_HOME=/usr/java/jdk1.8.0_211-amd64/
5. Ahora escribimos ./sonar.sh start para iniciar el servicio.
6. Ponemos ./sonar.sh status para saber el estado de SonarQube, el cual debería estar ejecutándose.
7. Por último, escribimos exit para salir del usuario sonar.

A continuación, abrimos el navegador y escribimos la URL http://localhost:8080 o http://<IP-MAQUINA-JENKINS-SONAR>:8080 para ingresar a Jenkins. En mi caso coloco la dirección http://19.168.99.59:8080, los datos para iniciar sesión son:

• Usuario: admin
• Contraseña: admin

Al ingresar a Jenkins habrá 3 tareas creadas, si desea, las puede eliminar.

Antes de crear las tareas para realizar la práctica, debemos saber que antes se tuvo que instalar el plugin de Maven, SonarQube, tenerlos instalados en nuestro ordenador junto a Java Development Kit (JDK) y haberlos configurado dentro de Jenkins. En la máquina virtual ya está configurado todo eso, por lo cual usted no debe preocuparse.

Lo que sí vamos a hacer es instalar un plugin, para esto en la pantalla de inicio de Jenkins, le damos clic en la opción Administrar Jenkins.

Buscamos en la nueva interfaz que nos apareció la opción Administrar Plugins y le damos clic.

En la nueva interfaz que nos apareció hacemos los siguientes pasos:

1. Damos clic en la pestaña Disponible, y se nos mostrará todos los plugin que puede tener Jenkins.
2. En la casilla filtrar escribimos deploy to container que es el plugin que necesitamos.
3. Seleccionamos la casilla.
4. Presionamos el botón Instalar sin reiniciar para iniciar la descargar de este plugin.

Con el plugin este instalado, nos devolvemos a la pantalla de inicio de Jenkins y creamos nuestro primer proyecto.

Para esto seguiremos los siguientes pasos:

1. Damos clic en “Nuevo Tarea”.

2. Colocamos en la casilla “Enter an item name” el nombre de la tarea que será devops-app-build.
3. Seleccionamos la opción “Crear un proyecto maven” y por último damos clic en el botón “OK”.
4. En la nueva interfaz que aparece, buscamos la sección “Configurar el origen del código fuente” y seleccionamos la opción Git.
5. Ahora se nos mostrará una casilla en la cual debemos colocar el enlace del repositorio del proyecto. En esta caja ponemos este link https://github.com/QV-University/app_angular_java8.git.

6. En la sección “Entorno de ejecución”, seleccionamos la casilla Delete workspace before build starts.
7. En la sección “Proyecto”, buscamos la casilla que tiene nombre “Fichero POM raíz” y escribimos en ella backend/pom.xml.

8. En la sección “Acciones para ejecutar después”, le damos clic en el botón “Añadir una acción”, se nos desplegará una serie de opciones y buscamos la opción “Guardar los archivos generados”.
9. Al darle clic en “Guardar los archivos generados” se nos abrirá una casilla que tiene como nombre “Ficheros para guardar” y en dicha casilla ponemos **/*.

10. Le damos clic en el botón “Apply” y luego al botón “Guardar”.

Si hemos hecho todos los pasos de manera correcta deberíamos ver en la pantalla de inicio de Jenkins la tarea que creamos.

Antes de continuar con la creación de tareas en Jenkins, creamos nuestro proyecto de SonarQube, para esto abrimos una nueva pestaña en el navegador web y escribimos la siguiente URL http://<IP-MÁQUINA-VIRTUAL-JENKINS-SONAR>:9000 y seguimos los siguientes pasos:

1. En la pantalla que nos aparece, buscamos la opción Log in y le damos clic en él

2. El usuario y contraseña para ingresar como Administrador a SonarQube es admin, cuando ingrese esos datos le damos clic en el botón “Log in”.

3. Ahora damos clic a la pestaña Administration. En esta interfaz hay un proyecto creado, si usted desea lo puede eliminar.

4. Luego, damos clic en la pestaña “Projects”. Se nos desplegará dos opciones, pero escogemos la que dice Managment.

5. Presionamos el botón Create project que se encuentra en la parte superior derecha de la ventana.

6. Completamos la información que nos piden con los siguientes datos:



    Name: angular
    Key: angular-key

Por último, presionamos el botón Create.

Observemos se nos creó el proyecto.

Lo siguiente es crear un nuevo proyecto en Jenkins para realizar las pruebas de código estático con SonarQube.

1. Clic en “Nuevo Tarea”.
2. Colocamos como nombre del proyecto devops-app-sonar.
3. Seleccionamos la opción “Crear un proyecto maven” y luego le damos clic al botón “OK”.
4. En la sección “Entorno de ejecución”, escogemos la opción Delete workspace before build starts.
5. En la sección “Pasos previos” le damos clic al botón “Añadir un paso previo”. Se nos despliega varios pasos, pero escogemos el que dice Copy artifacts from another project.
6. Vemos que nos aparecieron varias casillas, entonces buscamos casilla “Project name” y escribimos devops-app-build; luego buscamos la casilla “Artifacts to copy” y escribimos **/*.

7. En la sección “Proyecto”, buscamos la casilla “Fichero POM raíz” y escribimos los siguiente backend/pom.xml.
8. En la sección “Pasos posteriores”, le damos clic en el botón “Añadir un paso anterior” y agregamos la opción “Execute SonarQube Scanner”.
9. En la casilla de “JDK” seleccionamos la opción java 8.
10. En la casilla “Analysis properties” escribimos las siguientes propiedades:

    sonar.sources=backend/src
     sonar.java.binaries=backend/target/classes
     sonar.projectKey=angular-key
     sonar.projectVersion=1.0
     sonar.language=java
     sonar.sourceEncoding=UTF-8

11. Por último, le damos clic en “Apply” y luego en “Guardar”.

Creemos otro proyecto para el build del frontend.

1. Clic en “Nuevo Tarea”.
2. Colocamos como nombre devops-app-frontend-build.
3. Seleccionamos la opción “Crear un proyecto de estilo libre” y le damos clic en el botón “OK”.
4. En la sección “Entorno de ejecución” marcamos la casilla Delete workspace before build starts.
5. En la sección “Ejecutar” le damos clic en el botón “Añadir un nuevo paso”. Se desplegarán varias opciones, pero escogemos la opción “Copy artifacts from another project”.
6. 6. Al dar clic en la opción anterior, se abrieron varias casillas, primero buscamos la casilla con nombre “Project name” y en ella escribimos devops-app-build y en la casilla “Artifacts to copy” ponemos **/*.

7. En la misma sección “Ejecutar, le damos clic en el botón “Añadir un nuevo paso” y localizamos la opción “Ejecutar linea de comandos (shell)”.
8. En la caja que aparece escribimos los siguientes comandos:

    cd ${WORKSPACE}/frontend/
     npm install
     ng build --prod


9. Ahora en la sección “Acciones para ejecutar después”, presionamos el botón “Añadir una acción” y buscamos la opción “Guardar los archivos generados”.
10. En la casilla “Ficheros para guardar” escribimos lo siguiente frontend/dist/**.
11. Por último, le damos al botón “Apply” y después al botón “Guardar” para que todos los cambios realizados queden guardados.

El paso siguiente es crear un nuevo proyecto para desplegar el backend.

1. Clic en “Nuevo Tarea”.
2. En la casilla “Enter an item name” colocamos devops-app-backend-deploy.
3. Seleccionamos la opción “Crear un proyecto de estilo libre” y luego, le damos clic en el botón “OK”.
4. En la sección “Entorno de ejecución”, marcamos la opción Delete workspace before build starts.
5. En la sección “Ejecutar”, presionamos el botón “Añadir un paso nuevo” y luego damos clic a la opción “Copy artifacts from another project”.
6. Como pudo observar, al darle clic en la opción anterior se abrieron varias casillas, buscamos la que dice “Project name” y escribimos devops-app-build.
7. En la misma sección “Ejecutar”, buscamos la casilla “Artifacts to copy” y escribimos en ella **/*.
8. Luego en la sección “Acciones para ejecutar después”, le damos clic al botón “Añadir una acción” y, por último, damos clic en la opción “Deploy war/ear to container”.
9. Con las nuevas casillas que salieron en la sección “Pasos para ejecutar después”, buscamos la casilla “WAR/EAR files” y escribimos backend/target/testWar.war
10. Ahora buscamos el botón “Add Container” y seleccionamos la opción “Tomcat 8.x Remote”.
11. Después en la casilla “Tomcat URL” escribimos http://<IP-MÁQUINA-VIRTUAL-TOMCAT>:8081. En mi caso sería http://192.168.99.67:8081, usted debe mirar cuál es la IP que le fue asignada a su máquina virtual Tomcat.

12. En la misma ventana donde encontramos la casilla “Tomcat URL”, buscamos el botón “Add”, lo presionamos y luego damos clic en la opción “Jenkins”.

13. Vemos que se abre una nueva ventana y en ella buscamos la casilla “Username”, en ella escribimos admin, luego, en la casilla “Password” colocamos password y, por último, le damos clic en el botón “Add” para guardar el usuario y contraseña configurados.

14. Ahora en la opción “Credentials” la desplegamos y escogemos la única opción que nos aparece que debería ser admin/******.

15. Por último, damos clic en “Apply” y posteriormente en el botón “Guardar”.

Creamos el último proyecto en Jenkins con la finalidad de desplegar el frontend.

1. Clic en “Nuevo Tarea”.
2. Colocamos como nombre del proyecto devops-app-frontend-deploy.
3. Seleccionamos la opción “Crear un proyecto de estilo libre” y le damos clic en el botón “OK”.
4. En la sección “Entorno de ejecución” marcamos la opción Delete workspace before build starts.
5. En la sección “Ejecutar”, damos clic en el botón “Añadir un nuevo paso”, buscamos la opción “Copy artifacts from another project” y le damos clic.
6. Observamos como se abrieron unas nuevas casillas, buscamos la casilla “Project name” y escribimos en ella devops-app-frontend-build. Ahora en la casilla “Artifacts to copy” escribimos **/*.

7. En la misma sección “Ejecutar”, añadimos un nuevo paso que es “Ejecutar linea de comandos (shell)” y en ella escribimos:

    rsync -avh ${WORKSPACE}/frontend/dist/zoom-records/ root@<IP-MÁQUINA-VIRTUAL-TOMCAT>:/var/www/html/




Nota: Recuerde que la <IP-MÁQUINA-VIRTUAL-TOMCAT> es la IP que le fue asignada a la máquina virtual de Tomcat.

8. Ahora le damos clic en el botón “Apply” y luego en el botón “Guardar”.

En la Terminal de nuestra máquina virtual Jenkins-Sonar ponemos vim /etc/passwd

Nota: Ingrese el comando anterior usando privilegios de usuario administrador “root” para poder modificar el archivo y poder guardarlo.

Luego en el archivo que nos apareció cambiamos jenkins:x:988:982:Jenkins Automation Server:/var/lib/jenkins:/bin/false por jenkins:x:988:982:Jenkins Automation Server:/var/lib/jenkins:/bin/bash y guardamos los cambios.

Para poder insertar texto, presionamos la tecla “i” y modificamos la línea mencionada anteriormente. Para guardar los cambios primero presionamos la tecla Esc, luego pulsamos la tecla : (dos puntos), por último, escribimos wq y damos ENTER.

Seguimos en la Terminal y nos loguemos como usuario Jenkins, usando el comando su jenkins -. Ahora ejecutamos los siguientes pasos:

1. Escribimos el comando ssh-keygen para generar una llave y posteriormente presionamos 3 veces la tecla ENTER.
2. Agregamos la llave que creamos a nuestro servidor Apache que está instalada en nuestra máquina virtual Tomcat para conectarse remotamente usando el siguiente comando ssh-copy-id root@<IP-MÁQUINA-VIRTUAL-TOMCAT>
3. Cuando esté en el proceso de copiar la llave nos preguntará si queremos con la conexión y escribimos yes
4. Después, nos pedirá la contraseña de nuestra máquina virtual Tomcat para ingresar a ella desde la máquina Jenkins-Sonar, la contraseña es osboxes.org

A continuación, todas las configuraciones que se muestren, se harán en la máquina virtual Tomcat.

Nos posicionamos en la máquina virtual Tomcat y abrimos la Terminal, una vez ella escribimos el comando su y luego nos pedirá la cual es osboxes.org

Una vez hecho esto, seguimos estos pasos:

1. En la Terminal ingresamos la siguiente línea de comando export JRE_HOME=/usr/java/jdk1.8.0_211-amd64/
2. Luego escribimos el comando vim /opt/tomcat1/conf/tomcat-users.xml para poder abrir el archivo “tomcat-users”.

3. Ahora agregamos las siguientes líneas para añadir dos roles y un usuario, el cual accederá a nuestro contenedor Tomcat.

    <role rolename="manager-gui"/>
     <role rolename="manager-script"/>
     <user username="admin" password="password" roles="manager-gui,manager-script"/>

4. En la Terminal ingresamos vim /opt/tomcat1/webapps/manager/META-INF/context.xml. Una vez en este archivo comentamos la línea:

    <Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" />

Nota: Los comentarios se hacen con los símbolos <!-- (para iniciar el comentario) y --> (para cerrar el comentario).

5. Escribimos en la Terminal cd /opt/tomcat1/bin/ y luego ./startup.sh para iniciar Tomcat.

6. Verificamos si nuestro Tomcat quedó configurado con los roles y usuario que añadimos anteriormente, entonces ingresamos a nuestro navegador y ponemos la URL http://localhost:8081 o http://<IP-MÁQUINA-VIRTUAL-TOMCAT>:8081.

7. Damos clic en el botón Server Status o en el Manager Status, después nos aparecerá un cuadro de diálogo en donde tenemos que ingresar estos datos:
• Usuario: admin
• Password: password

Si configuramos bien el archivo tomcat-users.xml, deberíamos poder ingresar. En este caso entramos al Server Status.

De nuevo en la Terminal obtenemos permisos de usuario root con su para poder eliminar un archivo usando el siguiente comando rm /etc/httpd/conf.d/welcome.conf. Luego nos preguntará si realmente queremos eliminar el archivo y escribimos s para confirmar.

A continuación, iniciamos el servicio de Apache usando el comando service httpd start.

Para verificar si inició correctamente Apache, vamos a nuestro navegador e ingresamos http://localhost o http://<IP-MÁQUINA-VIRTUAL-TOMCAT> y nos debería mostrar la siguiente imagen. En mi caso, la IP que se me asignó por el protocolo DHCP es 192.168.99.67, usted debe verificar cuál es su IP.

El paso siguiente es ubicarnos en el Escritorio desde la Terminal usando el comando cd /home/osboxes/Escritorio/, cuando estemos en esta ruta clonamos el proyecto que está en Github con el comando git clone https://github.com/QV-University/app_angular_java8.git

Estando en la ruta del Escritorio en la Terminal ejecutamos el comando mysql -u root -proot para entrar a MySQL.

Una vez que nos conectemos MySQL vamos a crear un base de datos que tendrá como nombre db_empleados, y para lograr esto escribimos los siguientes comandos:

    CREATE DATABASE db_empleados;
     ALTER DATABASE db_empleados DEFAULT CHARACTER SET utf8
     COLLATE utf8_unicode_ci;

Salimos de MySQL escribiendo exit.

Nos mantenemos en la misma ruta del Escritorio en donde se encuentra nuestro proyecto app_angular_java8 que descargamos de GitHub y colocamos el comando mysql -uroot -proot db_empleados < app_angular_java8/db_empleados_diplo.sql para copiar la información que tiene el archivo “db_empleados_diplo.sql” a la base de datos “db_empleados” que creamos anteriormente.

Después escribimos vim /etc/hosts/. Cuando estemos en el archivo añadimos la siguiente línea <IP-MÁQUINA-VIRTUAL> aplicacion.com

Tenga en cuenta que la IP encerrada en la imagen anterior es la que fue establecida por medio del protocolo DHCP, usted debe mirar la IP que se le ha sido asignada.

Con lo anterior, hemos modificado todo en la máquina virtual Tomcat, pero nos falta enlazar los proyectos de Jenkins que creamos en la máquina Jenkins-Sonar, por ende, volvemos a ejecutar esta máquina y abrimos Jenkins en el navegador.

Buscamos el proyecto devops-app-build y le damos clic. En la nueva interfaz que nos aparece, le damos clic en la opción “Configurar” que se encuentra en la parte izquierda de dicha pantalla.

Nos saldrá la interfaz de configuración del proyecto, en la cual nos dirigimos a la sección “Acciones para ejecutar después”, le damos clic al botón “Añadir una acción”, seleccionamos la opción “Ejecutar otros proyectos” y escribimos devops-app-sonar. Se debe eliminar la coma que coloca el buscador.

En el proyecto devops-app-sonar nos dirigimos a la configuración, buscamos la sección “Acciones para ejecutar después”, le damos clic al botón “Añadir una acción”, seleccionamos la opción “Ejecutar otros proyectos” y escribimos devops-app-frontend-build. Se debe eliminar la coma que coloca el buscador.

En el proyecto devops-app-frontend-build nos dirigimos a la configuración, buscamos la sección “Acciones para ejecutar después”, le damos clic al botón “Añadir una acción”, seleccionamos la opción “Ejecutar otros proyectos” y escribimos devops-app-backend-deploy. Se debe eliminar la coma que coloca el buscador.

En el proyecto devops-app-backend-deploy nos dirigimos a la configuración, buscamos la sección “Acciones para ejecutar después”, le damos clic al botón “Añadir una acción”, seleccionamos la opción “Ejecutar otros proyectos” y escribimos devops-app-frontend-deploy. Se debe eliminar la coma que coloca el buscador.

Después de haber hechos todas estas configuraciones, nos vamos al proyecto devops-app-build y le damos clic al botón “Construir ahora”.

Si regresamos a la pantalla de inicio de Jenkins podemos ver como el proceso inició.

Al finalizar la ejecución de todos los proyectos creados en Jenkins, los círculos deberían cambiar a color azul, significando que el proceso ha sido exitoso.

Entramos a nuestro servidor Apache que está en la máquina virtual Tomcat para observar que se nos desplego el proyecto app_angular_java8 que está en GitHub. Para entrar al servidor Apache abrimos nuestro navegador e ingresamos cualquiera de las siguientes URL:

• aplicacion.com
• http://<IP-MÁQUINA-VIRTUAL-TOMCAT>
• http://locahost

Por último, miramos SonarQube para saber si nuestro código al ser evaluado pasó o no y también para ver si tiene algún bug.