Tento článek popisuje různé způsoby nasazení Jenkins na váš server. Použijte naši aktuální příručku pro ruční instalaci nebo spuštění Jenkins v kontejnerech Docker. Jako bonus si ukážeme, jak nasadit Jenkins pomocí CloudFormation. Nasaďte Jenkins na svůj server za 5 minut podle našich pokynů.
Co je Jenkins
Jenkins je nejoblíbenější bezplatný automatizační server. Jenkins můžete použít k automatizaci téměř všech procesů ve vaší společnosti. Ale tradičním trhem pro Jenkins je automatizace procesů vývoje softwaru.
Výhody Jenkinse:
- Napsáno v jazyce Java, takže jej můžete spustit na všech platformách
- Má spoustu pluginů, které vám mohou pomoci vyřešit téměř jakýkoli problém, který si dokážete představit.
- Pomáhá vývojářům integrovat změny kódu a vždy vytvářet stabilní sestavení softwaru
Nainstalovat Jenkins ručně
Proces instalace je jednoduchý a přímočarý. Skládá se z několika jednoduchých kroků:
- Instalace Java.
- Přidání oficiálních Jenkinsových repozitářů do vašeho správce balíčků.
- Instalace balíčku.
- Konfigurace brány firewall.
- Počáteční konfigurace Jenkins.
Pojďme je udělat jeden po druhém.
Instalace Java
Abyste mohli spustit Jenkins, musíte nejprve nainstalovat Javu.
Nejprve aktualizujte index balíčků apt pomocí tohoto:
$ sudo apt updateDále nainstalujte výchozí balíček Java OpenJDK pomocí tohoto:
$ sudo apt install openjdk-8-jreOvěřte instalaci pomocí tohoto příkazu:
$ java -version
Zde je výstup po úspěšné instalaci:
Důležité :měli byste vidět, že Java má verzi 1.8.
V době psaní tohoto článku Jenkins používá verzi Java 8. Pokud vidíte jinou verzi, přepněte na tu správnou:
$ sudo update-alternatives --config javaPřidat úložiště Jenkins
Ve výchozím nastavení není Jenkins zahrnut v repozitářích Ubuntu a musíte jej přidat.
Nejprve musíme importovat klíč úložiště:
$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -Dalším krokem je připojení adresy úložiště k seznamu úložišť serveru:
$ sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
/etc/apt/sources.list.d/jenkins.list'Jakmile to uděláme, musíme aktualizovat informace o softwaru, který můžeme použít z nového úložiště:
$ sudo apt-get update
Instalace balíčku Jenkins
Protože máme úložiště aktuální, spusťte následující příkaz:
$ sudo apt-get -y install jenkinsSpuštění tohoto příkazu vás vyzve k potvrzení stažení a instalace.
Ve výchozím nastavení se Jenkins spustí po procesu instalace. Pokud ne, použijte následující příkaz k ručnímu provedení:
$ sudo systemctl start jenkinsZkontrolujte, zda stav služby Jenkins:
$ sudo systemctl status jenkins
Po úspěšném provedení výše uvedeného příkazu byste měli získat takový výstup:
Konfigurace brány firewall
Ve výchozím nastavení běží Jenkins na portu 8080 , takže jej otevřeme, aby Jenkins mohl komunikovat.
Pokud používáte výchozí bránu firewall UFW, spusťte následující příkaz:
$ sudo ufw allow 8080Pomocí následujícího příkazu zkontrolujte, zda je provoz nyní povolen:
$ sudo ufw status
Výstup výše uvedeného příkazu by měl vypadat takto:
Pokud je ufw neaktivní a chcete jej povolit, zde jsou příkazy:
$ sudo systemctl enable ufw
$ sudo systemctl start ufw
$ sudo ufw enableNyní máte přístup k Jenkins na http://localhost:8080 .
Počáteční heslo je k dispozici zde:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordSpustit Jenkins v kontejneru Docker
Chcete-li spustit Jenkins v kontejneru Docker, musíte mít nainstalovaný Docker. Celý proces instalace je popsán v oficiální dokumentaci Dockeru, takže potřebné příkazy poskytneme zde:
$ 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.ioJakmile je Docker úspěšně nainstalován, můžete spustit kontejner Docker.
Vytáhnout obrázek Jenkins Docker
Vytáhněte Jenkins z veřejného úložiště pomocí následujícího příkazu:
$ sudo docker pull jenkins/jenkins
Chcete-li spustit kontejner Jenkins Docker, spusťte následující příkaz:
$ sudo docker run -p 8080:8080 -d --name=jenkins-master jenkins/jenkinsPokud se vám zobrazuje následující chybová zpráva:
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 canceledTo znamená, že se pokoušíte spustit Jenkins v kontejneru Docker na stejném portu, jaký používá Jenkins pro celý systém.
Stačí jej spustit na portu 8082 :
$ sudo docker rm jenkins-master
$ sudo docker run -p 8082:8080 -d --name=jenkins-master jenkins/jenkins
Tento příkaz má za následek otevření kontejneru Jenkins docker na portu 8082 :
Počáteční konfigurace Jenkins
Chcete-li nakonfigurovat Jenkins, otevřete prohlížeč a přejděte na skutečnou IP adresu nebo název domény, kterou provozujete Jenkins:http://ip_address_or_domain:8080 .
Jenkinsovo heslo
Zobrazí se stránka s umístěním počátečního hesla Jenkins:
Tady to je:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordJenkins pluginy
Na další obrazovce budete muset vybrat pluginy pro počáteční instalaci. Pokud ještě nevíte, které pluginy nastavit, použijte „Instalovat navrhované pluginy možnost “. 
Uživatel Jenkins Admin
Po dokončení instalace budete požádáni o vytvoření prvního uživatele Jenkins admin. 
Po úspěšném zadání údajů o uživateli budete přesměrováni na konfigurační stránku instance, kde potvrdíte adresu URL instance Jenkins.
Pro přístup k hlavnímu panelu Jenkins klikněte na „Začít používat Jenkins " knoflík. Tato akce vás přivede do hlavního rozhraní Jenkins:
Instalovat Jenkins pomocí CloudFormation
Článek „CloudFormation Tutorial – How To Automate EC2 Instance In 5 Mins“ popsal, jak používat CloudFormation a metadata cloud-init k automatizaci instalace softwaru v instancích EC2.
Zde poskytneme šablonu, která nasadí server Jenkins za proxy server Nginx.
Pozor :následující šablona CloudFormation vytvoří server Jenkins ve veřejné podsíti VPC, která má neomezený přístup k vašemu účtu AWS. Pokud chcete omezit přístup Jenkins, upravte prosím JenkinsPolicy nebo profil vzdálené instance ze serveru Jenkins.
Zde je šablona CloudFormation (zdroje 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
Tato šablona CloudFormation slouží k nasazení Jenkins za proxy Nginx ve vaší infrastruktuře AWS.
Tato šablona má následující vlastnosti:
- Stočením získáte Jenkins počáteční heslo: curl http://ec2-host/password.txt .
- K vytvoření certifikátů SSL můžete použít LetsEncrypt:
sudo certbot --nginx -d jenkins.example.com.
Přehled
V tomto článku jsme se zabývali různými způsoby nasazení Jenkins na váš server. Nyní jste připraveni na ruční instalaci Jenkins, spuštění Jenkins v kontejneru Docker nebo nasazení Jenkins pomocí šablony CloudFormation.
Pokud máte nějaké dotazy, dejte nám vědět v sekci komentářů níže. Kromě toho vám doporučujeme přečíst si další články týkající se Linuxu na našem blogu.
Doufáme, že vám tento článek bude užitečný! Pokud ano, pomozte nám to rozšířit do světa!