- Instalación de Ubuntu en VMWare Player en Windows 7
- Instalación de Jenkins en Ubuntu
- Instalación GitLab en Ubuntu
- Instalación de Docker y Minikube en Ubuntu
- Desarrollo de un microservicio en Eclipse Windows (1) y (2)
- Angular 6 frontend
- SpringBoot 2.x backend
- Mongo Replicaset (3 replicas)
- Despliegue CI en Minikube utilizando la infraestructura configurada
- Pipeline - Jenkinsfile
- GitLab webhook
- Dockerfile
- Deploy y Service yaml
- Secret
- Ingress
Vamos ahora con la instalación de Jenkins.
Instalación
Java 8
Como único pre-requisito hemos de tener instalado java 8 en nuestro sistema para poder instalar Jenkins. Según la documentación oficial, la versión recomendada es "OpenJDK JDK / JRE 8 - 64 bits".
En la página oficial de OpenJDK nos dicen como hacerlo:
En la página oficial de OpenJDK nos dicen como hacerlo:
sudo apt install openjdk-8-jdk
Tras aceptar la descarga e instalación validamos
java -version
nos devolverá algo parecido a
openjdk version "1.8.0_171"
OpenJDK Runtime Environment (build 1.8.0_171-8u171-b11-0ubuntu0.18.04.1-b11)
OpenJDK 64-Bit Server VM (build 25.171-b11, mixed mode)
Podemos ver la ruta del comando java con "which java", que nos devolverá "/usr/bin/java".
La ruta de instalación del jdk se obtiene con "update-alternatives --list java", lo cual nos devuelve
La ruta de instalación del jdk se obtiene con "update-alternatives --list java", lo cual nos devuelve
/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java
donde la ruta al directorio de instalación del jdk es "/usr/lib/jvm/java-8-openjdk-amd64/". Más adelante lo necesitaremos.
donde la ruta al directorio de instalación del jdk es "/usr/lib/jvm/java-8-openjdk-amd64/". Más adelante lo necesitaremos.
Maven
Instalamos también maven, en su última versión. Nos hará falta para compilar las aplicaciones que subamos a nuestro entorno CI.
sudo apt install maven
Validamos
mvn -version
que nos devuelve
Apache Maven 3.5.2
Maven home: /usr/share/maven
Java version: 1.8.0_171, vendor: Oracle Corporation
Java home: /usr/lib/jvm/java-8-openjdk-amd64/jre
Default locale: es_ES, platform encoding: UTF-8
OS name: "linux", version: "4.15.0-23-generic", arch: "amd64", family: "unix"
Jenkins
Comenzamos la instalación de Jenkins propiamente dicha. Como siempre, nos basamos en la página oficial del producto.
Lanzamos los siguientes comandos
Primero añadimos el repositorio jenkins a nuestra lista de repositorios
wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
Descargamos la lista de packages disponibles en el repo añadido
sudo apt update
Descargados 15,3 kB en 1s (13,0 kB/s)
Leyendo lista de paquetes... Hecho
Lanzamos la instalación
sudo apt install jenkins
Post-instalación
El directorio donde se ha instalado Jenkins es "/var/lib/jenkins"
Estos son los servicios principales que se instalan:
El daemon instalado se levantará en el arranque del ubuntu, por lo que no deberemos preocuparnos de arrancarlo de forma manual. El script de arranque de dicho daemon lo podemos ver en "/etc/init.d/jenkins".
Si necesitamos parar, arrancar, reiniciar o ver el estado de Jenkins hay dos vías
sudo service jenkins status/start/stop/restart
sudo systemctl status/start/stop/restart jenkins
Vemos también un proceso java asociado a Jenkins. Se trata del java 8 instalado en el el apartado de pre-requisitos. Vemos que el puerto por defecto es el 8080, el habitual de Tomcat. Esto es así porque la misma consola es una aplicación "war" que se despliega en un tomcat incorporado en la misma instalación de Jenkins.
En mi caso cambiaré el puerto ya que es posible que lo necesitemos libre para el despliegue de aplicaciones, etc... que vayamos haciendo en los pasos siguientes. Para ello edito el fichero "/etc/default/jenkins"
sudo vi /etc/default/jenkins
y modifico el parámetro "HTTP_PORT=8080" por "HTTP_PORT=8787"
Si en algún momento necesitase modificarlo de nuevo usaría este mismo procedimiento. No obstante, ojo que en la configuración CI necesitaremos configurar webhook's en GitLab que apunten a Jenkins, por lo que cualquier cambio de puerto obligará a actualizar todos los webhoolk's configurados.
Una vez cambiado reiniciamos Jenkins
sudo systemctl restart jenkins
Si revisamos el proceso tras el cambio veremos el cambio de puerto
ps -ef | grep jenkins | grep httpPort
...... --webroot=/var/cache/jenkins/war --httpPort=8787
Consola
Para acceder a la consola Jenkins ponemos la url "http://localhost:8787" en el navegador de nuestro ubuntu
En el primer acceso, nos aparece una pantalla en la que nos indica que el acceso está bloqueado y nos muestra dónde obtener el password inicial. Está en la ruta "/var/lib/jenkins/secrets/initialAdminPassword". Por tanto lanzamos "sudo cat /var/lib/jenkins/secrets/initialAdminPassword", lo cual nos muestra un literal alfanumérico parecido al que aparece en mi instalación: "db9815186c804b87aac809aa093ad223"
Lo introducimos en el campo de texto y pulsamos "Continue"
Nos aparece una pantalla de bienvenida proponiéndonos la instalación de una serie de plugins recomendados o bien de selección libre. De momento vamos a seguir las sugerencias iniciales e instalamos los plugins que Jenkins nos propone. Es posible que más adelante debamos añadir algún plugin más. En la zona de Administración podremos hacerlo sin ningún problema.
A continuación nos pide la creación de un usuario Admin para no usar el por defecto. Procedemos proporcionando los datos que nos pide. Tras finalizar accedemos a la consola habitual de Jenkins usando el nuevo usuario creado:
Configuraciones extra
Si accedemos al menu de Administración (Manage Jenkins), apartado de configuración del sistema (Configure System) veremos un warning en el apartado "Jenkins Location", donde aparece "http://localhost:8787/". Lo cambiamos por la ip fijada en la entrada anterior (la podemos obtener con "ifconfig"). Finalmente salvamos.
Accedemos ahora a la opción "Global Tool Configuration" del mismo menu "Manage Jenkins". Aquí configuraremos el jdk y maven, indicando las rutas de instalación
la de java8 recordad que se puede obtener con "update-alternatives --list java" y eliminando del path obtenido desde /jre en adelante.
la de maven la podemos obtener del comando "mvn -version"
En otras entradas deberemos acceder de nuevo y realizar alguna configuración más.
Plugin GitLab
Accedemos al apartado del "Plugin Manager" del "Manage Jenkins". En la pestaña de "Available" filtramos por "gitlab". Marcamos el check del plugin "GitLab" y pulsamos sobre "Download now and install after restart".
Ahora mismo no nos es necesario, pero lo será en las siguientes entradas.
Prueba
Vamos a crear un job de tipo pipeline a modo de ejemplo y validación de que nuestro entorno funciona.
Creamos primero una vista (conjunto de jobs) pulsando sobre "New View" en el menú de la izquierda. Ponedle el nombre que deseéis y seleccionar uno de los dos tipos de vistas que se presentan, en mi caso escojo la "List View". En el formulario que nos aparece a continuación lo dejamos sin modificar (salvo que queramos ponerle una descripción) y pulsamos el botón inferior de "OK".
A continuación, pulsamos sobre "New Item" del menú lateral izquierdo, asegurándonos de que en la barra de navegación aparezca la lista creada anteriormente. De esta forma, el job que creemos estará dentro de dicha lista.
Bien, en el item a crear, le damos un nombre, seleccionamos Pipeline (es el tipo de job que usaremos con todos los proyectos), y pulsamos OK (el check "Add to current view" ha de estar marcado).
Se nos presenta un formulario con multitud de opciones. De momento, para el ejemplo sólo vamos a introducir un código de ejemplo, que habitualmente lo tendremos en un fichero Jenkinsfile que acompañará a nuestros proyectos.
En el apartado Pipeline nos aseguramos que en el combo "Definition" aparece seleccionado "Pipeline script". En el textarea "Script" introducimos
pipeline {
agent any
tools {
maven "mvn35"
jdk "java8"
}
stages {
stage('maven') {
steps {
echo "Inicio maven"
sh 'mvn --version'
echo "Fin maven"
}
}
stage('java') {
steps {
echo "Inicio java"
sh 'java -version'
echo "Fin java"
}
}
}
}
Pulsamos sobre "Save".
El apartado de agent es obligatorio y le decimos donde va a ejecutar los comandos que vienen a continuación en los stages. En nuestro caso es en el propio sistema donde está instalado jenkins. Podríamos haber puesto (aún no ya que aún no hemos instalado Docker):
agent {
docker { image 'java:openjdk-8-jdk-alpine' }
}
a nivel del stage java y eso quería decir que el comando "java -version" se habría ejecutado en un contenedor levantado "al vuelo" a partir de la imagen "java:openjdk-8-jdk-alpine". Lo veremos más en detalle en esta serie de entradas o entradas posteriores sobre otros temas.
En el apartado de tools indicamos que vamos a usar maven y java, informando el nombre dado en la configuración descrita en los apartados respectivos vistos más arriba. Es decir, las variables informan la home de java y maven. A paritr de ahí, los comandos java y mvn se nutren de dichas "home's".
A continuación definimos dos pasos o stages, el de maven y el de java, lanzando únicamente el comando que verifica la versión usada en cada caso.
Idealmente tendremos algo como lo siguiente:
Accedemos al job y pulsamos sobre "Build Now", lo cual lanzará la ejecución del job. Tras finalizar veremos el resultado OK (todos los stages están en verde):
Podemos ver el log accediendo al desplegable del "#1" y seleccionando "Console Output" o bien, de forma resumida pulsando sobre cada stage, por ejemplo en el de java podemos ver la salida (los "echo's" y el "java -version")
De momento es suficiente. En la próxima entrada veremos cómo instalar y usar GitLab. Haremos una prueba más real de lo que será nuestro entorno CI integrando ambos elmentos, GitLab y Jenkins.
Más Info
Jenkins Pipeline: https://jenkins.io/doc/book/pipeline/
