Este artículo cubre varias formas de implementar Jenkins en su servidor. Utilice nuestra guía actualizada para la instalación manual o el lanzamiento de Jenkins en contenedores Docker. Como beneficio adicional, le mostraremos cómo implementar Jenkins usando CloudFormation. Implemente Jenkins en su servidor en 5 minutos siguiendo nuestra guía.
Que es Jenkins
Jenkins es el servidor de automatización gratuito más popular. Puede usar Jenkins para automatizar casi cualquier proceso en su empresa. Pero el mercado tradicional de Jenkins es la automatización de los procesos de desarrollo de software.
Beneficios de Jenkins:
- Escrito en Java, por lo que puede ejecutarlo en todas las plataformas
- Tiene muchos complementos, que pueden ayudarlo a resolver casi cualquier problema que pueda imaginar.
- Ayuda a los desarrolladores a integrar los cambios de código y producir siempre una compilación de software estable
Instalar Jenkins manualmente
El proceso de instalación es simple y directo. Consta de varios pasos sencillos:
- Instalación de Java.
- Agregar repositorios oficiales de Jenkins a su administrador de paquetes.
- Instalación del paquete.
- Configuración del cortafuegos.
- Configuración inicial de Jenkins.
Hagámoslos uno por uno.
Instalación de Java
Para poder ejecutar Jenkins, primero debe instalar Java.
Primero, actualice el índice del paquete apt usando esto:
$ sudo apt updateA continuación, instale el paquete Java OpenJDK predeterminado usando esto:
$ sudo apt install openjdk-8-jreVerifique la instalación usando este comando:
$ java -version
Aquí está el resultado después de una instalación exitosa:
Importante :debería ver que Java tiene la versión 1.8.
Al momento de escribir este artículo, Jenkins está usando la versión Java 8. Si ve otra versión, cambie a la correcta:
$ sudo update-alternatives --config javaAñadir repositorio de Jenkins
De manera predeterminada, Jenkins no está incluido en los repositorios de Ubuntu y debe agregarlo.
Primero, necesitamos importar la clave del repositorio:
$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -El siguiente paso es agregar la dirección del repositorio a la lista de repositorios del servidor:
$ sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
/etc/apt/sources.list.d/jenkins.list'Una vez hecho esto, necesitamos actualizar la información sobre el software, que podemos usar desde el nuevo repositorio:
$ sudo apt-get update
Instalación del paquete Jenkins
Ya que tenemos el repositorio actualizado, ejecutemos el siguiente comando:
$ sudo apt-get -y install jenkinsEjecutar este comando le pedirá que confirme la descarga y la instalación.
De forma predeterminada, Jenkins se inicia después del proceso de instalación. Si no, usa el siguiente comando para hacerlo manualmente:
$ sudo systemctl start jenkinsVamos a comprobar si el estado del servicio de Jenkins:
$ sudo systemctl status jenkins
En la ejecución exitosa del comando anterior, debería obtener tal resultado:
Configuración del cortafuegos
De forma predeterminada, Jenkins se ejecuta en el puerto 8080 , así que abrámoslo para permitir que Jenkins se comunique.
Ejecute el siguiente comando si está ejecutando el firewall UFW predeterminado:
$ sudo ufw allow 8080Utilice el siguiente comando para comprobar que ahora se permite el tráfico:
$ sudo ufw status
La salida del comando anterior debería verse así:
Si ufw está inactivo y desea habilitarlo, estos son los comandos:
$ sudo systemctl enable ufw
$ sudo systemctl start ufw
$ sudo ufw enableAhora puede acceder a Jenkins en http://localhost:8080 .
La contraseña inicial está disponible aquí:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordIniciar Jenkins en Docker Container
Para iniciar Jenkins en un contenedor Docker, debe tener Docker instalado. El proceso de instalación completo se describe en la documentación oficial de Docker, por lo que proporcionaremos los comandos necesarios aquí:
$ sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg-agent \
software-properties-common
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.ioUna vez que Docker se haya instalado correctamente, puede ejecutar el contenedor de Docker.
Extraer imagen acoplable de Jenkins
Extraiga Jenkins del repositorio público con el siguiente comando:
$ sudo docker pull jenkins/jenkins
Para iniciar el contenedor Jenkins Docker, ejecute el siguiente comando:
$ sudo docker run -p 8080:8080 -d --name=jenkins-master jenkins/jenkinsSi recibe el siguiente mensaje de error:
docker: Error response from daemon: driver failed programming external connectivity on endpoint jenkins-master
(627574f0c75a8e4598abf0acfc2700caf53775a9dc34073fdbfb69cd408a9a36):
Error starting userland proxy: listen tcp 0.0.0.0:8080: bind: address already in use.
ERRO[0000] error waiting for container: context canceledEso significa que está tratando de iniciar Jenkins en el contenedor Docker en el mismo puerto que está usando Jenkins en todo el sistema.
Solo ejecútalo en el puerto 8082 :
$ sudo docker rm jenkins-master
$ sudo docker run -p 8082:8080 -d --name=jenkins-master jenkins/jenkins
Este comando da como resultado la apertura del contenedor acoplable de Jenkins en el puerto 8082 :
Configuración inicial de Jenkins
Para configurar Jenkins, abra un navegador y navegue hasta la dirección IP real o el nombre de dominio en el que está ejecutando Jenkins:http://ip_address_or_domain:8080 .
Contraseña de Jenkins
Verá la página que muestra la ubicación de la contraseña inicial de Jenkins:
Aquí está:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordComplementos de Jenkins
En la siguiente pantalla, se le pedirá que elija complementos para la instalación inicial. Si aún no sabe qué complementos configurar, use la opción "Instalar complementos sugeridos " opción. 
Usuario administrador de Jenkins
Una vez que se complete la instalación, se le pedirá que cree el primer usuario administrador de Jenkins. 
Después de ingresar correctamente los detalles del usuario, se le dirigirá a la página de configuración de la instancia para confirmar la URL de la instancia de Jenkins.
Para acceder al panel principal de Jenkins, haga clic en "Empezar a usar Jenkins " botón. Esta acción lo llevará a la interfaz principal de Jenkins:
Instalar Jenkins usando CloudFormation
El artículo "Tutorial de CloudFormation:cómo automatizar la instancia EC2 en 5 minutos" describe cómo usar CloudFormation y los metadatos de inicio de nube para automatizar la instalación de software en instancias EC2.
Aquí proporcionaremos una plantilla, que implementará el servidor Jenkins detrás del servidor proxy Nginx.
Atención :la siguiente plantilla de CloudFormation creará un servidor Jenkins en una subred de VPC pública, que tiene acceso ilimitado a su cuenta de AWS. Si desea restringir el acceso de Jenkins, modifique JenkinsPolicy o el perfil de instancia remota desde el servidor de Jenkins.
Aquí está la plantilla de CloudFormation (fuentes de GitHub):
AWSTemplateFormatVersion: 2010-09-09
Description: >-
This CloudFormation stack will deploy Jenkins on Ubuntu 20.04
in us-east-1 region.
Parameters:
JenkinsInstanceType:
Description: EC2 instance type for Jenkins EC2 instance
Type: String
Default: t2.small
ConstraintDescription: must be a valid Jenkins EC2 instance type.
KeyName:
Description: >-
The EC2 Key Pair to allow SSH access to Jenkins EC2 instance
Type: 'AWS::EC2::KeyPair::KeyName'
ConstraintDescription: must be the name of an existing EC2 KeyPair.
VpcId:
Description: The VPC Id where the Jenkins EC2 instance will be launched.
Type: 'AWS::EC2::VPC::Id'
ConstraintDescription: must be the ID of an existing VPC.
YourIPRange:
Description: >-
CIDR block of the network from where you will connect to the Jenkins
server using HTTP, HTTPS and SSH
Type: String
MinLength: '9'
MaxLength: '18'
AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
Default: 0.0.0.0/0
ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
PublicSubnet1:
Description: >-
The public subnet where the Jenkins Jenkins EC2 instance will be launched.
Type: 'AWS::EC2::Subnet::Id'
ConstraintDescription: Must be a valid Public VPC Subnet.
JenkinsInstanceAMI:
Description: Ubuntu 20.04 EC2 instance AMI
Type: String
Default: ami-0885b1f6bd170450c
Resources:
JenkinsAddress:
Type: AWS::EC2::EIP
Properties:
Domain: vpc
JenkinsAddressAssociaation:
Type: AWS::EC2::EIPAssociation
Properties:
AllocationId: !GetAtt JenkinsAddress.AllocationId
NetworkInterfaceId: !Ref JenkinsInterface
JenkinsInterface:
Type: AWS::EC2::NetworkInterface
Properties:
SubnetId: !Ref PublicSubnet1
Description: Interface for controlling traffic such as Web
GroupSet:
- !Ref JenkinsSecurityGroup
SourceDestCheck: true
Tags:
-
Key: Network
Value: Web
JenkinsServer:
Type: 'AWS::EC2::Instance'
CreationPolicy:
ResourceSignal:
Timeout: PT15M
Metadata:
Comment: 'Install Jenkins, nginx and the Jenkins CodeDeploy plugin'
'AWS::CloudFormation::Init':
configSets:
install_all:
- install_base
- install_nginx
- install_jenkins_repo
- install_jenkins
- jenkins_post_install
install_base:
packages:
apt:
git: []
python3-pip: []
awscli: []
files:
/etc/cfn/cfn-hup.conf:
content:
!Sub |
[main]
stack=${AWS::StackName}
region=${AWS::Region}
mode: "000400"
owner: "root"
group: "root"
/etc/cfn/hooks.d/cfn-auto-reloader.conf:
content:
!Sub |
[cfn-auto-reloader-hook]
triggers=post.update
path=Resources.LaunchConfig.Metadata.AWS::CloudFormation::Init
action=/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource JenkinsServer --configsets install_all --region ${AWS::Region}
runas=root
mode: "000400"
owner: "root"
group: "root"
/lib/systemd/system/cfn-hup.service:
content:
!Sub |
[Unit]
Description=cfn-hup daemon
[Service]
Type=simple
ExecStart=/opt/aws/bin/cfn-hup
Restart=always
[Install]
WantedBy=multi-user.target
mode: "000400"
owner: "root"
group: "root"
commands:
01_enable_cfn_hup:
command: systemctl enable cfn-hup.service > /dev/null 2>&1
02_start_cfn_hup:
command: systemctl start cfn-hup.service > /dev/null 2>&1
install_nginx:
packages:
apt:
nginx: []
certbot: []
python3-certbot-nginx: []
files:
/etc/nginx/nginx.conf:
content:
!Sub |
user www-data;
worker_processes 1;
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
keepalive_timeout 65;
include /etc/nginx/conf.d/*.conf;
index index.html index.htm;
server {
listen 80;
server_name _;
location / {
proxy_pass http://127.0.0.1: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_connect_timeout 150;
proxy_send_timeout 100;
proxy_read_timeout 100;
proxy_buffers 4 32k;
client_max_body_size 8m;
client_body_buffer_size 128k;
}
location /password.txt {
alias /web/initalpass.html;
}
}
}
mode: '000644'
owner: root
group: root
services:
sysvinit:
nginx:
enabled: 'true'
ensureRunning: 'true'
files:
- /etc/nginx/nginx.conf
install_jenkins_repo:
commands:
01_download_repo_file:
command: echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list
02_import_repo_file:
command: wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | apt-key add - > /dev/null 2>&1
03_update_pkg_mngr:
command: apt-get update -y > /dev/null 2>&1
install_jenkins:
packages:
apt:
jenkins: []
services:
sysvinit:
jenkins:
enabled: 'true'
ensureRunning: 'true'
jenkins_post_install:
commands:
01_web_folder:
command: mkdir -p /web
02_import_repo_file:
command: while [ ! -f /var/lib/jenkins/secrets/initialAdminPassword ]; do sleep 10; done
03_copy_jenkins_password:
command: cp -Rf /var/lib/jenkins/secrets/initialAdminPassword /web/initalpass.html && chown www-data:www-data /web/initalpass.html
Properties:
KeyName: !Ref KeyName
ImageId: !Ref JenkinsInstanceAMI
NetworkInterfaces:
-
NetworkInterfaceId: !Ref JenkinsInterface
DeviceIndex: '0'
InstanceType: !Ref JenkinsInstanceType
IamInstanceProfile: !Ref JenkinsInstanceProfile
UserData:
Fn::Base64:
!Sub |
#!/bin/bash -xe
apt-get update -y
apt-get install -y python-setuptools openjdk-8-jre
mkdir -p /opt/aws/bin
wget https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.tar.gz
python2 -m easy_install --script-dir /opt/aws/bin aws-cfn-bootstrap-latest.tar.gz
echo "Executing config-sets"
/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} \
--resource JenkinsServer \
--configsets install_all \
--region ${AWS::Region}
/opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} \
--resource JenkinsServer \
--region ${AWS::Region}
Tags:
-
Key: Name
Value: Jenkins Server
JenkinsSecurityGroup:
Type: 'AWS::EC2::SecurityGroup'
Properties:
GroupDescription: Enable SSH and HTTP access from specific CIDR block
VpcId: !Ref VpcId
SecurityGroupIngress:
-
IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: !Ref YourIPRange
-
IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: !Ref YourIPRange
-
IpProtocol: tcp
FromPort: 443
ToPort: 443
CidrIp: !Ref YourIPRange
SecurityGroupEgress:
-
IpProtocol: tcp
FromPort: 0
ToPort: 65535
CidrIp: 0.0.0.0/0
JenkinsRole:
Type: 'AWS::IAM::Role'
Properties:
Path: /
AssumeRolePolicyDocument:
Statement:
-
Effect: Allow
Principal:
Service:
- ec2.amazonaws.com
Action:
- 'sts:AssumeRole'
JenkinsInstanceProfile:
Type: 'AWS::IAM::InstanceProfile'
Properties:
Path: /
Roles:
- !Ref JenkinsRole
JenkinsPolicy:
Type: 'AWS::IAM::Policy'
Properties:
PolicyName: JenkinsPolicy
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action:
- '*'
Resource: '*'
Roles:
- !Ref JenkinsRole
Outputs:
JenkinsServerDNSName:
Description: DNS Name of Jenkins Server
Value: !GetAtt
- JenkinsServer
- PublicDnsName
Esta plantilla de CloudFormation es para implementar Jenkins detrás del proxy Nginx en su infraestructura de AWS.
Esta plantilla tiene las siguientes características:
- Tienes que curl para obtener la contraseña inicial de Jenkins: curl http://ec2-host/contraseña.txt .
- Puede usar LetsEncrypt para crear certificados SSL:
sudo certbot --nginx -d jenkins.example.com.
Resumen
En este artículo, cubrimos varias formas de implementar Jenkins en su servidor. Ahora está listo para la instalación manual de Jenkins, el lanzamiento de Jenkins en el contenedor Docker o la implementación de Jenkins mediante la plantilla de CloudFormation.
Por favor, háganos saber en la sección de comentarios a continuación si tiene alguna pregunta. Además, le recomendamos que consulte otros artículos relacionados con Linux en nuestro blog.
¡Esperamos que encuentre útil este artículo! Si es así, ¡ayúdanos a difundirlo por todo el mundo!