Laboratorio - Integración Contínua (III)

Tercer paso en la creación de nuestro laboratorio CI. Recuerdo los pasos:

1. Instalación de Ubuntu en VMWare Player en Windows 7
2. Instalación de Jenkins en Ubuntu
3. Instalación GitLab en Ubuntu
4. Instalación de Docker y Minikube en Ubuntu
5. Desarrollo de un microservicio en Eclipse Windows (1) y (2)
1. Angular 6 frontend
2. SpringBoot 2.x backend
3. Mongo Replicaset (3 replicas)
6. Despliegue CI en Minikube utilizando la infraestructura configurada
1. Pipeline - Jenkinsfile
2. GitLab webhook
3. Dockerfile
4. Deploy y Service yaml
5. Secret
6. Ingress

Vamos pues con el tercer paso, la instalación de GitLab en nuestro Ubuntu.

Instalación

Si accedemos a la página oficial de GitLab, ahí encontramos la forma de instalar el producto.

Como siempre, actualizamos paquetes

    sudo apt update

Instalamos dependencias 

    sudo apt install -y curl openssh-server ca-certificates

    En nuestro caso ya las tenemos instaladas por lo que no se instalará nada. No obstante lanzamos y comprobamos que efectivamente es así:

    ...

    ca-certificates ya está en su versión más reciente (20180409).

    openssh-server ya está en su versión más reciente (1:7.6p1-4).

    curl ya está en su versión más reciente (7.58.0-2ubuntu3.2).

    ...

Se nos dice de instalar postfix para la gestión de envío de emails. 

    sudo apt install -y postfix

    es algo que no necesitamos por lo que nos lo podemos saltar

Añadimos el repositorio GitLaba a nuestra lista de repositorios

    curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.deb.sh | sudo bash

    nos aparece el mensaje final "The repository is setup! You can now install packages."

A continuación instalamos el producto asignando una url propia (la que proponen por defecto es "http://gitlab.example.com"). No importa la que sea ya que será de uso interno. Luego veremos como será usada desde Jenkins. Lanzamos, por tanto:

    sudo EXTERNAL_URL="http://gitlab.blog.com:81" apt install gitlab-ee

    esperamos unos instantes ya que se descargan alrededor de 500 MB de archivos.

Si en algún momento necesitásemos cambiar algún atributo de la instalación y configuración establecida, por ejemplo el puerto, podríamos ir al fichero "/etc/gitlab/gitlab.rb", modificar lo que fuese (en el caso del puerto deberíamos modificar el atributo external_url, que en mi caso aparece como "external_url 'http://gitlab.blog.com:81'") y lanzar el comando
    sudo gitlab-ctl reconfigure

Acceso

Una vez acabada la instalación podremos acceder mediante la url proporcionada anteriormente. No obstante, antes deberemos introducirla en "/etc/hosts"

sudo vi /etc/hosts

    en la línea donde porn "127.0.0.1  localhost" añadimos la "EXTERNAL_URL" que hayamos configurado anteriormente. En nuestro caso queda así:

    127.0.0.1 localhost gitlab.blog.com

Grabamos y accedemos en nuestro firefox de ubuntu con "http://gitlab.blog.com:81". 

Nos pide introducir una contraseña nueva en el primer acceso. Se trata de la contraseña del user "root", el único ya creado por defecto.

Las proporcionamos y pulsamos sobre "Change your password". 

A continuación nos presenta una pantalla donde podemos acceder con "root/contraseña proporcionada" o bien creando un nuevo usuario. Lo recomendable es acceder a la pestaña "Register", y crear dicho nuevo usuario. Procedemos de esta forma, aportando los datos necesarios y pulsamos ahora sobre el botón "Register".

Ahora ya podemos acceder con el nuevo usuario.

Grupo/Proyecto

GitLab está configurado a dos niveles. El primer nivel es el de Grupo, el segundo el de Proyecto.

El grupo habitualmente es usado como contenedor de proyectos, es decir, lo habitual es tener un conjunto de proyectos agrupados en una unidad superior, la de grupo.

En nuestro caso, crearemos el grupo "Blog". Lo podemos dejar como "Private", ya que al final lo que estamos montando es sólo para nuestro laboratorio personal.

Pulsamos en "Save", lo cual nos lleva al interior del grupo creado, dándonos la posibilidad de crear un "New project", lo cual hacemos según la captura siguiente:

Pulsamos sobre "Create project" y ya tenemos nuestro primer repo GitLab para "jugar" con él. 

En la pantalla "Details" del proyecto creado nos aparecen una serie de comandos a usar para hacer un primer upload de código. 

De momento no vamos a subir código propiamente dicho, eso lo dejamos para otras entradas. En esta sólo haremos una prueba básica que nos permita ver la integración con Jenkins.

Prueba

En la anterior entrada probamos un job pipeline de Jenkins a partir de un script incorporado en el mismo job. En esta entrada veremos cómo hacer lo mismo, pero a partir de un Jenkinsfile que reside en nuestro proyecto GitLab.

cliente git windows

Para poder probar, y para todo lo que seguirá después en las siguientes entradas, necesitaremos tener instalado git en nuestro windows. Para ello vamos a la web de GIT y nos lo descargamos e instalamos (Git-2.18.0-64-bit.exe actualmente). Con la instalación de GIT se nos instala una consola "Git Bash" y un "Git GUI". Nosotros vamos a trabajar con la consola, Git Bash.

HEmos de hacer una configuración extra para dar visibilidad a nuestro GitLab desde nuestro windows, ya que ahora mismo no podemos acceder a la url configurada, en mi caso "http://gitlab.blog.com:81". Lo podemos probar haciendo un ping a gitlab.blog.com. Veremos que no hay respuesta.

Buscamos entonces el fichero "hosts" de nuestro windows. La ubicación habitual es "C:\Windows\System32\drivers\etc\hosts". Lo abrimos e introducimos la entrada 

    192.168.153.201 gitlab.blog.com

    Ojo, esos son mis datos, los tuyos puede ser otros (se trata de la ip fijada de nuestro ubuntu, y el EXTERNAL_URL del apartado de instalación anterior). Probamos ahora el "ping gitlab.blog.com" y veremos que ahora si hay respuesta.

Abrimos ahora la consola Git:

A continuación y dentro de la consola, crearemos un directorio de trabajo. Escribimos "cd c:". Verificamos que no exista una carpeta blog en la raís de nuestra "c:" con "ls blog". El resultado debería ser ".... no such file or directory". En ese caso lanzamos "mkdir blog && cd $_" lo cual nos crea dicha carpeta y nos sitúa en su interior.

A continuación revisamos la página por defecto que aparece en la opción "Details" del proyecto creado en GitLab. Nos fijamos en el apartado "Git global setup" y ejecutamos las dos instrucciones "globales" tal cual están.
    git config --global user.email ....
    git config --global user.name ....

Pasamos ahora al apartado "Create a new repository" y vamos lanzando las instrucciones que allí aparecen. Lo que estamos haciendo es creando un repo local (windows) a partir del repo creado en ubuntu. En mi caso los comandos a ejecutar desde la consola git bash de windows son

    git clone http://gitlab.blog.com/blog/holamundo-ci.git

    se nos pedirán credenciales de acceso. Proporcionamos user / password del usuario con el que hemos creado el repo en GitLab. Con ello se nos creará un nuevo directorio "C:\blog\holamundo-ci". Accedemos a él:

    cd holamundo-ci

Ahora cogemos el contenido del script del pipeline Hola Mundo de la anterior entrada y lo guardamos en un fichero con nombre Jenkinsfile (sin extensión), dentro del directorio anterior. Verificamos desde la consola git que el fichero está donde debe lanzando un "ls" desde dicho directorio. 

Ya estamos casi preparados, pero antes hay que configurar Jenkins y Gitlab antes de poder hacer el push de nuestro Jenkinsfile y que se dispare todo el circuito de CI. Paciencia.

Jenkins

Crearemos un nuevo job para integrarlo con GitLab. Será muy parecido al que creamos en la entrada de Jenkins.

Antes de nada hemos de hacer un par de pasos extra. 

• Hemos de instalar el cliente git en ubuntu

            para ello ejecutamos "sudo apt install git", que lo instalará en "/user/bin/git"
            A continuaciuón, en jenkins "Manage Jenkins" / "Global Tool Configuration" informamos nuestra "Git installation":

• Añadimos el repositorio GitLab creado en el apartado "Manage Jenkins" / "Configure System"

       

          Añadimos credenciales de acceso a GitLab pulsando sobre el botón "Add" y configuramos el usuario creado en GitLab anteriormente:

          Pulsamos en "Add", y finalmente en "Save"

  

pipeline
Creamos ahora el job de tipo pipeline. Para ello, accedemos a la pestaña o vista que creamos en la anterior entrada, y dentro de ella pulsamos sobre "New Item". Le damos por nombre "HolaMundo-CI" y seleccionamos el tipo "Pipeline". Finalmente pulsamos OK.

En la configuración del job informamos el check "Build when...." del apartado "Build Triggers", dejando el resto de elementos de este apartado con la configuración por defecto

Nos quedamos con la url que nos proporciona para "GitLab webhook", en mi caso "http://192.168.153.201:8787/project/HolaMundo-CI".

En el mismo apartado, un poco más abajo, pulsamos sobre el botón "Advanced", lo cual provoca la aparición de más campos de configuración. Vamos al que pone "Secret Token" y pulsamos sobre "Generate" (a la derecha del todo). Nos genera un token alfanumérico que hemos de conservar para la configuración posterior del webhook. En mi caso me ha generado "fdb8b384c348f50cbc762df1bc633b82".

A continuación vamos al apartado Pipeline. En Definition seleccionamos "Pipeline script from SCM". En SCM seleccionamos "Git". En "Repository URL" informamos la url del repo del poyecto que queremos enlazar, en mi caso "http://gitlab.blog.com:81/blog/holamundo-ci.git". Por último, en credenciales seleccionamos la configurada en el apartado anterior. El resto lo dejamos con los valores por defecto:

El atributo "Script Path" es la ruta relativa al proyecto del fichero Jenkinsfile Como que en nuestro caso dicho fichero está en la raíz del proyecto, se puede dejar tal como nos lo propone Jenkins. Si estuviese en una carpeta interna al proyecto deberíamos poner el path relativo a la raíz del proyecto.

Webhook

Creamos aquí el webhook que enviará un "aviso" a Jenkins para que éste venga a recoger el código del GitLab y proceda con la ejecución del pipeline.

Para que GitLab pueda configurarse para envíos a servidores locales (localhost, 192.168....) hemos de acceder con "root" al "Admin area" (icono de llave inglesa) / "Settings" y en el apartado "OutBound requests" marcar el check "Allow requests to the local network....". Pulsamos sobre "Save changes"

Salimos de root.

Ahora, accedemos con el user propietario del proyecto creado anteriormente, vamos a "Settings / Integrations". Ahí informamos la url del "Build when .... " del job pipeline descrito en el apartado anterior y el "secret token" también del paso anterior.

Así queda:

Pulsamos sobre "Add Webhook" y ya tenemos nuestra integración creada.

Git push
Ahora si, ya llega la prueba final.

Desde windows, directorio donde tenemos el Jenkinsfile ejecutamos en la consola Git los siguientes comandos:
    git add .
    git commit -m "subida incial"
    git push origin master

Con el primero añadimos todos los ficheros desde la carpeta actual, en nuestro caso sólo tenemos el Jenkinsfile. Con el segundo, pasamos dicho fichero al área de "preparado" o "staging", es decir, listo para su entrega o subida al repositorio remoto. Finalmente con el tercero hacemos la subida efectiva al repositorio remoto configurado, es decir, a nuestro GitLab.

Tras el push, vemos que la página por defecto del proyecto ha cambiado y ahora muestra nuestro fichero Jenkinsfile subido con el mensaje asociado al commit:

Y sorpresa, si vamos a Jenkins, vemos que efectivamente, se ha disparado el job configurado. Parece magia, pero no, hemos tenido que trabajara bastante hasta llegar hasta aquí:

Y el resultado de la ejecución:

Lo hemos lanzado dos veces, el primero desde el propio push y el segundo desde el mismo Webhook, el cual permite hacerlo de forma manual desde su misma configuración (botón desplegable "Test", opción "Push events"):

 A partir de ahora, cada vez que editemos el fichero y hagamos push se lanzará una nueva ejecución. Vamos a verlo. Añadamos al fichero Jenkinsfile de la anterior entrada el código de finalización (en azul) :

    pipeline {
        agent any
        tools {
            maven "mvn35"
            jdk "java8"
        }
 
        stages {
            ....
        }

        post {
            always {
echo "Fin Proceso"
            }
            success {
                echo "Fin success";
            }
            unstable {
                echo "Fin unstable";
            }
            failure {
                echo "Fin failure";
            }
        }
    }

Desde la consola git miramos que efectivamente, el fichero se ha modificado y está pendiente de subir
    git status

    nos mostrará una salida como la siguiente:

Para evitar que con cada push nos pida credenciales vamos a introducirlas en la url.
Vemos la configuración del repo remote:
    git remote -v

    nos devuelve
      origin  http://gitlab.blog.com/blog/holamundo-ci.git (fetch)
      origin  http://gitlab.blog.com/blog/holamundo-ci.git (push)

Cambiamos la url introduciendo las credenciales de GITLAB en dicha url:
    git remote set-url origin http://USER:PASSWORD@gitlab.blog.com/blog/holamundo-ci.git

Ahora ya procedemos como anteriormente
    git add .
    git commit -m "adición log resultado"
    git push origin master

Si finaliza bien nuestro lanzamiento deberá generarse un nuevo paso ("Post Actions"), lo cual podemos comprobar tras la ejecución:

El log de esta última etapa es justamente el que hemos introducido en el apartado "post" descrito más arriba:
    Print Message -- Fin Proceso -- (self time 126ms)
    Print Message -- Fin success -- (self time 70ms) 

Con esto queda validado el entorno CI. A partir de ahora, cada vez que necesitemos añadir un nuevo proyecto e integrarlo en nuestro CI deberemos:

1. Crear el código en nuestro eclipse windows
2. Crear un proyecto en GitLab Ubuntu
3. Crear un Pipeline en Jenkins Ubuntu con un Jenkinsfile
4. Asociar Pipeline Jenkins y Proyecto Gitlab 
1. Apuntando desde el Pipeline al GitLab como SCM
2. Creando un Webhook en GitLab apuntando al Proyecto Pipeline Jenkins

Veremos como esto nos facilita mucho las cosas a la hora de desplegar nuestras aplicaciones en un entorno Kubernetes / Minikube que montaremos en la siguiente entrada.



Más info
Para este tipo de instalaciones y configuraciones lo mejor es acceder a las páginas oficiales.

GitLab:
https://about.gitlab.com/
https://docs.gitlab.com/

Jenkins:

https://jenkins.io/
https://jenkins.io/doc/

https://jenkins.io/doc/book/pipeline/

Anterior

Siguiente