Jenkins

Jenkins es un gestor para integración y despliegue continuo que hace posible conectar nuestros repositorios en Git y definir tareas para automatizar nuestro proceso de desarrollo de Software. La plataforma funciona bajo Java por lo que se requiere su instalación previamente.

Instalación de Jenkins en Linux Ubuntu

Comenzamos por instalar Git, Java y Maven si aún no los tenemos en nuestro sistema. Para el JDK (Java Developer Kit) podríamos usar la instalación del paquete del sistema ejecutando sudo apt install default-jdk en caso de tener una máquina pequeña o un contenedor, o bien, usar GraalVM con SDKMan ejecutando sdk install java 22.1.0.r11-grl en caso de contar con buen espacio en disco. Por tanto, para instalar software requerido ejecutamos los siguientes comandos:

bash

sudo apt update
sudo apt install -y git
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install java 22.1.0.r11-grl
sdk install maven

Puede considerarse usar sdk home java 22.1.0.r11-grl y hacer un ajuste semejante al siguiente: ln -s /home/ubuntu/.sdkman/candidates/java/22.1.0.r11-grl/bin/java /usr/bin/java (dónde ubuntu corresponde al usuario respectivo).

Basándonos en la guía Jenkins, para su instalación ejecutamos los siguientes comandos:

bash

wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt update
sudo apt install -y jenkins

Para macOS se puede usar brew ejecutando: brew install jenkins-lts + brew services start jenkins-lts

Instalación de Jenkins con Docker

Para usar la instalación oficial podemos usar los siguientes comandos:

bash

docker pull jenkins/jenkins:lts
docker run -d -p 8080:8080 -p 50000:50000 -v ~/jenkins:/var/jenkins_home --name jenkins jenkins/jenkins:lts
docker logs -f jenkins

Se podría haber usado docker run -d -e JENKINS_OPTS="--httpPort=8081" -p 8081:8081 -p 50000:50000 -v ~/jenkins:/var/jenkins_home --name jenkins jenkins/jenkins:lts si se deseaba cambiar el puerto por defecto.

En pocos segundos puedes ver Jenkins disponible desde el navegador consultando la dirección correspondiente, por defecto localhost:8080. Con el comando docker logs... es posible ver la clave para continuar el proceso de instalación.

Para acceder de modo interactivo se podría ejecutar:

bash

docker exec -u root -it jenkins bash

Algunos plugins que suelen ser de interés son:

Git
GitHub Branch Source
Pipeline: GitHub Groovy Libraries
Pipeline: Stage View
SSH Build Agents
Email Extension
NodeJS
Docker
Amazon ECR Plugin

Alternativa con Dockerfile - Jenkins - BlueOcean UI & More

Otra manera de usar Jenkins con Docker es preparando tu propio contenedor a partir de un archivo Dockerfile basado en la imágen jenkins/jenkins:lts-jdk17. Según la documentación oficial de BlueOcean, tal archivo tendría un contenido como el siguiente:

Dockerfile

FROM jenkins/jenkins:lts-jdk17
USER root
RUN apt-get update && apt-get install -y lsb-release
RUN curl -fsSLo /usr/share/keyrings/docker-archive-keyring.asc \
  https://download.docker.com/linux/debian/gpg
RUN echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/usr/share/keyrings/docker-archive-keyring.asc] \
  https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" > /etc/apt/sources.list.d/docker.list
RUN apt-get update && apt-get install -y docker-ce-cli
RUN apt-get install -y apt-transport-https ca-certificates curl sudo gnupg2 software-properties-common
RUN apt-get install -y nodejs
RUN apt-get install -y python3-pip
RUN apt install awscli -y
#RUN pip3 install --upgrade awscli
RUN adduser jenkins sudo && usermod -aG sudo jenkins
RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
USER jenkins
RUN jenkins-plugin-cli --plugins "blueocean:1.27.7 docker-workflow:572.v950f58993843"

Acá hemos agregado otros paquetes como nodejs, python3, awscli

Puedes tener este archivo en una carpeta específica o temporal, y desde la línea de comandos se ejecuta lo siguiente:

bash

docker network create jenkins

docker build -t jenkins-bo:lts .

docker run --detach \
  --name jenkins \
  --restart=on-failure \
  --network jenkins \
  --env DOCKER_HOST=tcp://docker:2376 \
  --env DOCKER_CERT_PATH=/certs/client \
  --env DOCKER_TLS_VERIFY=1 \
  --env JAVA_OPTS="-Dhudson.plugins.git.GitSCM.ALLOW_LOCAL_CHECKOUT=true" \
  --env JENKINS_OPTS="--httpPort=8081" \
  --publish 8081:8081 \
  --publish 50000:50000 \
  --volume ~/jenkins:/var/jenkins_home \
  --volume jenkins-docker-certs:/certs/client:ro \
  jenkins-bo:lts

docker logs -f jenkins

El último comando, docker logs, se usa para ver los rastros del contenedor, así puedes identificar la clave que se necesita en el proceso de instalación.

También puedes explorar el contenedor creado interactuando con el siguiente comando:

bash

docker exec -it jenkins bash

Conceptos de Jenkins

Jenkins permite un flujo de construcción de código y despliegue del software software mediante Pipelines (canalizadores o tuberías) usando "scripts" en lenguaje Groovy. Cada Pipeline (Canalizador) tiene Stages (Etapas) en dónde se define cada Stage, por ejemplo "Build-Test-Deploy". A su vez, un Stage (Etapa) tiene Steps (Pasos), es decir la tarea a realizar, por ejemplo un script, una sentencia desde la línea de comandos (sh) o una salida de consola (echo). Veamos un ejemplo para ilustrar esto mediante el siguiente "script"...

groovy

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Checking code...'
                echo 'Build code...'
            }
        }

        stage('Test') {
            steps {
                echo 'Run tests...'
                echo 'Check coverage...'
            }
        }

        stage('Deploy') {
            steps {
                echo 'Check image...'
                echo 'Check plan...'
                echo 'Apply service...'
            }
        }
    }
}

Puede observarse que en el pipeline se sigue la estructura stages -> stage -> steps y dentro de este último encontramos por ejemplo echo, bien podría ser sh para lanzar un comando del sistema.

Configurando credenciales para AWS

Una vez identifiques un usuario IAM en AWS y generes Id y Clave de acceso, se pueden configurar estos valores en Jenkins haciendo lo siguiente:

Dirigete a Panel de Control de Jenkins.
Selecciona la opción de Administrar Jenkins.
Luego, selecciona el enlace de Credentials.
A continuación se usa como Almacenamiento el del Sistema (System) dando clic en "global".
Allí se da clic en el botón de "Add Credentials"
En el formulario que aparecese suministra la información respectiva. Por ejemplo, en Kind se indica la opción AWS Credentials, en Scope Global, enID un nombre descriptivo, en Access Key ID el "Access Key ID" de IAM, y finalmente el Secret Access Key correspondiente.

Agregando Terraform

Aunque existe un plugin para Terraform podría estar desactualizado, por ello se puede instalar simplemente la herramienta. Por ejemplo para Linux se pueden ejecutar los siguientes comandos:

bash

sudo apt update
sudo apt install -y gnupg software-properties-common
curl https://apt.releases.hashicorp.com/gpg | gpg --dearmor > hashicorp.gpg
sudo install -o root -g root -m 644 hashicorp.gpg /etc/apt/trusted.gpg.d/
sudo apt-add-repository "deb [arch=$(dpkg --print-architecture)] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt install terraform

Debe recordarse que, si se usa en un contenedor Docker con Jenkins, debe ingresarse de modo interactivo, por ejemplo:

bash

docker exec -it jenkins bash

En el Pipeline respectivo se puede usar Terraform como se muestra en el trozo de código siguiente:

groovy

stage('Prepare IaC with Terraform') {
    steps {
        dir('cicddemo/iac') {
            sh '''
            terraform -version
            terraform init
            terraform validate
            terraform plan -out=tfplan
            '''
        }
    }
}

Dado que conviene indicar credenciales AWS, estas deben configurarse conforme se ha visto anteriormente y el código de ejemplo quedaría como siguiente:

groovy

stage('Prepare IaC with Terraform') {
    steps {
        dir('cicddemo/iac') {
            withCredentials([[
                $class: 'AmazonWebServicesCredentialsBinding',
                credentialsId: 'AWS_CREDENTIALS_TF',
                accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
            ]]) {
                sh '''
                terraform -version
                terraform init
                terraform validate
                terraform apply -auto-approve tfplan
                '''
            }
        }
    }
}

Jenkins ​

Instalación de Jenkins en Linux Ubuntu ​

Instalación de Jenkins con Docker ​

Alternativa con Dockerfile - Jenkins - BlueOcean UI & More ​

Conceptos de Jenkins ​

Configurando credenciales para AWS ​

Agregando Terraform ​

Jenkins

Instalación de Jenkins en Linux Ubuntu

Instalación de Jenkins con Docker

Alternativa con Dockerfile - Jenkins - BlueOcean UI & More

Conceptos de Jenkins

Configurando credenciales para AWS

Agregando Terraform