Cómo configurar Jenkins en el contenedor Docker
Jenkins es una herramienta de código abierto para realizar una integración continua y una automatización de la construcción. Un desarrollador puede crear y probar software fácilmente mediante la integración continua a través de Jenkins en el ciclo de vida de un proyecto. Permite la entrega continua de software mediante la creación de canalizaciones y la integración con una gran cantidad de tecnologías de prueba e implementación. En este tutorial, configuraremos jenkins2 en ubuntu 16.04 junto con el proxy inverso NGINX dentro de una ventana acoplable.
Para configurar Jenkins en una ventana acoplable, puede hacerlo simplemente extrayendo la imagen de la imagen oficial de Jenkins Docker y luego ejecutarla usando el comando de la ventana acoplable para configurar el contenedor. Pero con este enfoque, no podrá configurar los volúmenes de datos, la configuración del puerto, el proxy inverso, etc., exactamente como le gustaría hacerlo. Por lo tanto, para entenderlo en detalle, lo configuraremos en un enfoque paso a paso / modular. Entonces, comenzaremos creando el usuario y el hogar de Jenkins.
Crear usuario y hogar de Jenkins
Esto es importante en el sentido de que, Jenkins usa una identificación de usuario / grupo de 1000 y si la misma identificación de usuario y de grupo se asigna a otro usuario, habrá un error al ejecutar el contenedor. Utilice el siguiente comando para averiguar si el ID de usuario 1000 está disponible o no. Otra opción es cambiar el uid / gid del usuario que lo posee dejando uid / gid 1000 libre. Cuando el docker-compose compile jenkins, creará uid / gid 1000 de Jenkins junto con la ubicación de inicio predeterminada que es / var / jenkins_home
# useradd -u 1000 -g 1000 jenkins
# awk -F: '//home/ {printf "%s:%sn",$1,$3}' /etc/passwd
Si el uid / gid (1000) ya está asignado a otro usuario, intercambie el uid / gid de ese usuario con jenkins usando el comando usermod / groupmod. También asegúrese de haber instalado docker y docker-compose en el sistema host. Encuentra su versión con los siguientes comandos.
# docker -v Docker version 1.12.1, build 23cf638 # docker-compose -v docker-compose version 1.9.0, build 2585387
Configuración de carpeta
Creemos la estructura de directorios para jenkins. Cree tres carpetas dentro de su directorio de proyecto de Docker para datos de jenkins, jenkins master y nginx.
- Cree un directorio raíz con el nombre DockerJenkins (directorio del proyecto Jenkins) y un solo archivo docker-compose.yml dentro de él.
- Cree tres directorios: jenkins-data, jenkins-master y nginx dentro del directorio del proyecto jenkins, que es DockerJenkins.
- Cree Dockerfile dentro de las tres carpetas anteriores.
- Cree cuatro directorios con el nombre conf.d, ssl, htpass y logs dentro del directorio nginx.
- Cree el archivo de configuración predeterminado de nginx default.conf dentro de nginx y jenkins.conf dentro de conf.d Los archivos de registro para NGINX estarán dentro del directorio de registros.
- Crearemos la clave / certificado para NGINX dentro del directorio ssl y el usuario básico http dentro del directorio htpass en etapas posteriores.
# cd ~ # mkdir DockerJenkins # cd DockerJenkins/ ~/DockerJenkins# mkdir jenkins-data ~/DockerJenkins# mkdir jenkins-master ~/DockerJenkins# mkdir nginx ~/DockerJenkins# touch docker-compose.yml ~/DockerJenkins# cd jenkins-data/ ~/DockerJenkins/jenkins-data# touch Dockerfile ~/DockerJenkins/jenkins-data# cd ../jenkins-master ~/DockerJenkins/jenkins-master# touch Dockerfile ~/DockerJenkins/jenkins-master# cd ../nginx/ ~/DockerJenkins/nginx# mkdir conf.d ~/DockerJenkins/nginx# mkdir ssl ~/DockerJenkins/nginx# mkdir logs ~/DockerJenkins/nginx# touch default.conf ~/DockerJenkins/nginx# cd conf.d/ ~/DockerJenkins/nginx/conf.d# touch jenkins.conf ~/DockerJenkins/nginx/conf.d# cd ../logs ~/DockerJenkins/nginx/logs# touch access.log ~/DockerJenkins/nginx/logs# touch error.log
La estructura de directorio actual de nuestro proyecto de ventana acoplable (DockerJenkins) se ve así:
DockerJenkins /
├── docker-compose.yml
├── datos-jenkins
│ └── Dockerfile
├── maestro de Jenkins
│ └── Dockerfile
└── nginx
├── conf.d
│ └── jenkins.conf
├── default.conf
├── Dockerfile
├── registros
│ ├── access.log
│ └── error.log
└── ssl
├── demohost.crt
└── demohost.key
Configurar / construir datos de Jenkins
Ahora que se ha creado la estructura de directorio para nuestro proyecto de ventana acoplable, comenzaremos creando un archivo de ventana acoplable para jenkins-data.
# cd ~/DockerJenkins/jenkins-data ~/DockerJenkins/jenkins-data# vi Dockerfile FROM ubuntu:16.04 RUN useradd -d "/var/jenkins_home" -u 1000 -m -s /bin/bash jenkins RUN mkdir -p /var/log/jenkins RUN chown -R jenkins:jenkins /var/log/jenkins VOLUME ["/var/log/jenkins", "/var/jenkins_home"] USER jenkins CMD ["echo", "Data container for Jenkins"]
El archivo de la ventana acoplable anterior agrega el usuario ‘jenkins’ con la identificación 1000 y su inicio predeterminado es / var / jenkins_home. También hemos declarado dos directorios de volúmenes, uno para el registro y otro para los datos de jenkins. La imagen montará volúmenes para el maestro de Jenkins de modo que incluso si elimina el maestro de Jenkins, no habrá pérdida de datos. El comando VOLUMEN [«/var/log/jenkins», «/var/jenkins_home»] en el archivo de la ventana acoplable anterior declara los puntos de montaje en el host de la ventana acoplable. Se puede acceder a cualquier cambio realizado en este directorio desde la máquina host incluso si ha salido del contenedor. Sin embargo, si ejecuta un contenedor nuevo con un nombre nuevo, la ubicación del host que se monta cambiará y los datos no serán visibles la próxima vez que inicie el contenedor desde la misma imagen. La solucion es simple. Agregaremos el comando volume_from en el docker-compose para adjuntar el nombre del contenedor de forma permanente. Esto se conoce comúnmente como almacenamiento de datos persistentes en contenedores.
jenkins-master: image: jenkins volumes_from: - jenkins-data ..................... .....................
A continuación, nos movemos para configurar el archivo docker para jenkins master, pero antes de eso, vamos a construir datos de jenkins.
~/DockerJenkins/jenkins-data# docker build .
Configurar / construir maestro de Jenkins
Una vez que la compilación de datos de Jenkins se completó correctamente, crearemos un archivo de ventana acoplable para el maestro de Jenkins que es fácil de entender y se explica por sí mismo.
# cd ~/DockerJenkins/jenkins-master ~/DockerJenkins/jenkins-master# vi Dockerfile FROM jenkins USER root RUN mkdir /var/log/jenkins RUN mkdir /var/cache/jenkins RUN chown -R jenkins:jenkins /var/log/jenkins RUN chown -R jenkins:jenkins /var/cache/jenkins USER jenkins ENV JAVA_OPTS="-Xmx8192m" ENV JENKINS_OPTS="--handlerCountStartup=100 --handlerCountMax=300 --logfile=/var/log/jenkins/jenkins.log --webroot=/var/cache/jenkins/war"
El archivo de ventana acoplable anterior extrae la imagen de jenkins y, como usuario root, crea un directorio de registro y caché y cambia la propiedad a jenkins para configurar los entornos.
Construye el maestro jenkins
~/DockerJenkins/jenkins-master# docker build .
Configurar / compilar NGINX
Primero, cree el archivo docker para NGINX
# cd ~/DockerJenkins/nginx ~/DockerJenkins/nginx# vi Dockerfile FROM nginx RUN rm /etc/nginx/conf.d/default.conf EXPOSE 80 EXPOSE 443
Jenkins se ejecuta en el puerto no 8080, por lo que para acceder a él detrás de un proxy instalaremos NGINX y lo configuraremos para acceder al servicio de Jenkins a través de SSL con HTTP Basic Auth. Instalemos el paquete apache2-utils, que contiene la utilidad htpasswd.
# sudo apt-get -y install apache2-utils # cd ~/DockerJenkins/nginx/ ~/DockerJenkins/nginx# mkdir htpass ~/DockerJenkins/nginx# cd htpass/ ~/DockerJenkins/nginx/htpass# htpasswd -c jenkins.password linoxide New password: Re-type new password: Adding password for user linoxide
A continuación, crearemos certificados y claves SSL para el sitio de jenkins.
# cd ~/DockerJenkins/nginx/ssl root@demohost:~/DockerJenkins/nginx/ssl# sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout demohost.key -out demohost.crt Generating a 2048 bit RSA private key ..........................+++ ..............+++ writing new private key to 'demohost.key' -----
Edite el archivo default.conf para NGINX que hemos creado durante la configuración de la carpeta.
# cd ~/DockerJenkins/nginx/
~/DockerJenkins/nginx# vi default.conf
daemon off;
user www-data;
pid /var/run/nginx.pid;
worker_processes 1;
events {
worker_connections 1024;
}
http {
# Basic Settings
sendfile on;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 33;
types_hash_max_size 2048;
server_tokens off;
server_names_hash_bucket_size 64;
include /etc/nginx/mime.types;
default_type application/octet-stream;
# Logging Settings
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
# Gzip Settings
gzip on;
gzip_vary on;
gzip_proxied any;
gzip_comp_level 3;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_types text/plain text/xml text/css application/x-javascript application/json;
gzip_disable "MSIE [1-6].(?!.*SV1)";
# Virtual Host Configs
include /etc/nginx/sites-enabled/*;
# Error Page Config
#error_page 403 404 500 502 /srv/Splash;
}
Edite jenkins.conf dentro del directorio conf.d
~/Dockerjenkins/nginx# vi conf.d/jenkins.conf
server {
listen 80;
listen 443 ssl http2;
server_name "demohost.com";
ssl_certificate /etc/nginx/ssl/demohost.crt;
ssl_certificate_key /etc/nginx/ssl/demohost.key;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-
AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:
ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-
GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-
AES128-SHAECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-
SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-
RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-
SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-
GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS';
ssl_prefer_server_ciphers on;
access_log on;
location / {
auth_basic "Restricted";
auth_basic_user_file /etc/nginx/htpass/jenkins.password;
proxy_pass http://jenkins-master:8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto http;
proxy_max_temp_file_size 0;
proxy_connect_timeout 150;
proxy_send_timeout 100;
proxy_read_timeout 100;
proxy_buffer_size 8k;
proxy_buffers 4 32k;
proxy_busy_buffers_size 64k;
proxy_temp_file_write_size 64k;
}
}
Construye el contenedor NGINX
# cd ~/DockerJenkins/nginx/ ~/DockerJenkins/nginx# docker build .
Crear / ejecutar docker-compose
Ahora que casi hemos completado la configuración / compilación de los datos de jenkins, jenkins y NGINX, editemos docker-compose.yml dentro del directorio del proyecto de docker que es DockerJenkins para que puedan ejecutarse en un entorno aislado.
~/DockerJenkins# vi docker-compose.yml
Ahora, para crear los contenedores, use docker-compose.
~/DockerJenkins# docker-compose up -d
-d flag indica al docker compose que se ejecute como demonio. Para verificar, enumere los contenedores.
# docker ps -a
Una última pieza del rompecabezas es cómo accederá al sitio de jenkins, en nuestro caso es demohost.com que está configurado en el directorio conf de NGINX (jenkins.conf). Para eso necesita encontrar la dirección IP del contenedor NGINX. Utilice el comando docker inspect para encontrarlo.
root@demohost:~/DockerJenkins# docker inspect <Container_Name_Or_ID_Of_NGINX> | grep IPAddress
Edite el archivo / etc / hosts del sistema host y agregue una entrada para demohost.com y reinicie la red
# vi /etc/hosts ....................................... 172.17.0.2 demohost.com ....................................... # service networking restart
Abra su navegador favorito y apúntelo a http: //
Ingrese la contraseña y luego personalice jenkins según sus requisitos.
Conclusión
En este tutorial, hemos discutido cómo configurar jenkins en una ventana acoplable y lo encontramos fácil y simple. A continuación, puede agregar más funciones, como realizar una copia de seguridad de jenkins en el entorno de la ventana acoplable o incluir / excluir más complementos mediante el archivo de la ventana acoplable, etc. Gracias por leer este artículo.