Cet article couvre différentes manières de déployer Jenkins sur votre serveur. Utilisez notre guide à jour pour l'installation manuelle ou le lancement de Jenkins dans des conteneurs Docker. En prime, nous montrerons comment déployer Jenkins à l'aide de CloudFormation. Déployez Jenkins sur votre serveur en 5 minutes en suivant nos conseils.
Qu'est-ce que Jenkins
Jenkins est le serveur d'automatisation gratuit le plus populaire. Vous pouvez utiliser Jenkins pour automatiser presque tous les processus de votre entreprise. Mais le marché traditionnel de Jenkins est l'automatisation des processus de développement logiciel.
Avantages Jenkins :
- Écrit en Java, vous pouvez donc l'exécuter sur toutes les plates-formes
- Dispose de nombreux plugins, qui peuvent vous aider à résoudre presque tous les problèmes que vous pouvez imaginer.
- Aide les développeurs à intégrer les modifications de code et à toujours produire une version logicielle stable
Installer Jenkins manuellement
Le processus d'installation est simple et direct. Il se compose de plusieurs étapes simples :
- Installation Java.
- Ajout de référentiels Jenkins officiels à votre gestionnaire de packages.
- Installation du package.
- Configuration du pare-feu.
- Configuration initiale de Jenkins.
Faisons-les un par un.
Installation Java
Pour pouvoir exécuter Jenkins, vous devez d'abord installer Java.
Tout d'abord, mettez à jour l'index du package apt en utilisant ceci :
$ sudo apt updateEnsuite, installez le package Java OpenJDK par défaut en utilisant ceci :
$ sudo apt install openjdk-8-jreVérifiez l'installation à l'aide de cette commande :
$ java -version
Voici le résultat après une installation réussie :
Important :vous devriez voir que Java a la version 1.8.
Au moment de la rédaction de cet article, Jenkins utilise la version Java 8. Si vous voyez une autre version, passez à la bonne :
$ sudo update-alternatives --config javaAjouter un référentiel Jenkins
Par défaut, Jenkins n'est pas inclus dans les référentiels Ubuntu et vous devez l'ajouter.
Tout d'abord, nous devons importer la clé du référentiel :
$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -L'étape suivante consiste à ajouter l'adresse du référentiel à la liste des référentiels du serveur :
$ sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
/etc/apt/sources.list.d/jenkins.list'Une fois cela fait, nous devons mettre à jour les informations sur le logiciel, que nous pouvons utiliser à partir du nouveau référentiel :
$ sudo apt-get update
Installation du paquet Jenkins
Puisque nous avons le référentiel à jour, lançons la commande suivante :
$ sudo apt-get -y install jenkinsL'exécution de cette commande vous invitera à confirmer le téléchargement et l'installation.
Par défaut, Jenkins démarre après le processus d'installation. Sinon, utilisez la commande suivante pour le faire manuellement :
$ sudo systemctl start jenkinsVérifions si l'état du service Jenkins :
$ sudo systemctl status jenkins
Lors de l'exécution réussie de la commande ci-dessus, vous devriez obtenir une telle sortie :
Configuration du pare-feu
Par défaut, Jenkins s'exécute sur le port 8080 , alors ouvrons-le pour permettre à Jenkins de communiquer.
Exécutez la commande suivante si vous exécutez sur le pare-feu UFW par défaut :
$ sudo ufw allow 8080Utilisez la commande suivante pour vérifier que le trafic est désormais autorisé :
$ sudo ufw status
La sortie de la commande ci-dessus devrait ressembler à ceci :
Si ufw est inactif et que vous souhaitez l'activer, voici les commandes :
$ sudo systemctl enable ufw
$ sudo systemctl start ufw
$ sudo ufw enableVous pouvez désormais accéder à Jenkins sur http://localhost:8080 .
Le mot de passe initial est disponible ici :
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordLancer Jenkins dans le conteneur Docker
Pour lancer Jenkins dans un conteneur Docker, vous devez avoir installé Docker. Le processus d'installation complet est décrit dans la documentation officielle de Docker. Nous vous fournirons donc les commandes nécessaires ici :
$ 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.ioUne fois Docker installé avec succès, vous pouvez exécuter le conteneur Docker.
Extraire l'image Docker de Jenkins
Extrayez Jenkins du référentiel public à l'aide de la commande suivante :
$ sudo docker pull jenkins/jenkins
Pour lancer le conteneur Jenkins Docker, exécutez la commande suivante :
$ sudo docker run -p 8080:8080 -d --name=jenkins-master jenkins/jenkinsSi vous obtenez le message d'erreur suivant :
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 canceledCela signifie que vous essayez de lancer Jenkins dans le conteneur Docker sur le même port que celui utilisé par Jenkins à l'échelle du système.
Lancez-le simplement sur le port 8082 :
$ sudo docker rm jenkins-master
$ sudo docker run -p 8082:8080 -d --name=jenkins-master jenkins/jenkins
Cette commande entraîne l'ouverture du conteneur docker Jenkins sur le port 8082 :
Configuration initiale de Jenkins
Pour configurer Jenkins, ouvrez un navigateur et accédez à l'adresse IP ou au nom de domaine réel que vous utilisez Jenkins :http://ip_address_or_domain:8080 .
Mot de passe Jenkins
Vous verrez la page indiquant l'emplacement du mot de passe Jenkins initial :
Le voici :
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordPlugins Jenkins
À l'écran suivant, vous devrez choisir des plugins pour l'installation initiale. Si vous ne savez pas encore quels plugins configurer, utilisez l'option "Installer les plugins suggérés " option. 
Utilisateur administrateur Jenkins
Une fois l'installation terminée, il vous sera demandé de créer le premier utilisateur administrateur Jenkins. 
Après avoir entré avec succès les détails de l'utilisateur, vous serez dirigé vers la page de configuration de l'instance pour confirmer l'URL de l'instance Jenkins.
Pour accéder au tableau de bord principal de Jenkins, cliquez sur "Commencer à utiliser Jenkins " bouton. Cette action vous amènera à l'interface principale de Jenkins :
Installer Jenkins à l'aide de CloudFormation
L'article « Tutoriel CloudFormation - Comment automatiser une instance EC2 en 5 minutes » décrit comment utiliser CloudFormation et les métadonnées cloud-init pour automatiser l'installation de logiciels dans les instances EC2.
Ici, nous allons fournir un modèle, qui déploiera le serveur Jenkins derrière le serveur proxy Nginx.
Attention :le modèle CloudFormation suivant créera un serveur Jenkins dans un sous-réseau VPC public, qui dispose d'un accès illimité à votre compte AWS. Si vous souhaitez restreindre l'accès à Jenkins, veuillez modifier JenkinsPolicy ou le profil d'instance distante à partir du serveur Jenkins.
Voici le modèle CloudFormation (sources 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
Ce modèle CloudFormation consiste à déployer Jenkins derrière le proxy Nginx dans votre infrastructure AWS.
Ce modèle présente les fonctionnalités suivantes :
- Vous curl pour obtenir le mot de passe initial de Jenkins : curl http://ec2-host/password.txt .
- Vous pouvez utiliser LetsEncrypt pour créer des certificats SSL :
sudo certbot --nginx -d jenkins.example.com.
Résumé
Dans cet article, nous avons couvert différentes manières de déployer Jenkins sur votre serveur. Vous êtes maintenant prêt pour l'installation manuelle de Jenkins, le lancement de Jenkins dans le conteneur Docker ou le déploiement de Jenkins à l'aide du modèle CloudFormation.
S'il vous plaît, laissez-nous savoir dans la section commentaires ci-dessous si vous avez des questions. De plus, nous vous recommandons de consulter d'autres articles liés à Linux dans notre blog.
Nous espérons que vous trouverez cet article utile ! Si oui, s'il vous plaît, aidez-nous à le diffuser dans le monde !