Artikel ini membahas berbagai cara menerapkan Jenkins di server Anda. Gunakan panduan terbaru kami untuk instalasi manual atau meluncurkan Jenkins di wadah Docker. Sebagai bonus, kami akan menunjukkan cara menerapkan Jenkins menggunakan CloudFormation. Terapkan Jenkins di server Anda dalam 5 menit menggunakan panduan kami.
Apa itu Jenkins
Jenkins adalah server otomatisasi gratis paling populer. Anda dapat menggunakan Jenkins untuk mengotomatisasi hampir semua proses di perusahaan Anda. Namun pasar tradisional untuk Jenkins adalah otomatisasi proses pengembangan perangkat lunak.
Manfaat Jenkins:
- Ditulis dalam Java, sehingga Anda dapat menjalankannya di semua platform
- Memiliki banyak plugin, yang dapat membantu Anda memecahkan hampir semua masalah yang dapat Anda bayangkan.
- Membantu pengembang untuk mengintegrasikan perubahan kode dan selalu menghasilkan pembuatan perangkat lunak yang stabil
Instal Jenkins Secara Manual
Proses instalasi sederhana dan mudah. Ini terdiri dari beberapa langkah mudah:
- Instalasi Java.
- Menambahkan repositori resmi Jenkins ke pengelola paket Anda.
- Penginstalan paket.
- Konfigurasi firewall.
- Konfigurasi Jenkins awal.
Mari kita lakukan satu per satu.
Instalasi Java
Untuk dapat menjalankan Jenkins, Anda harus menginstal Java terlebih dahulu.
Pertama, perbarui indeks paket apt menggunakan ini:
$ sudo apt updateSelanjutnya, instal paket Java OpenJDK default menggunakan ini:
$ sudo apt install openjdk-8-jreVerifikasi instalasi menggunakan perintah ini:
$ java -version
Berikut output setelah instalasi berhasil:
Penting :Anda akan melihat bahwa Java memiliki versi 1.8.
Pada saat penulisan artikel ini, Jenkins menggunakan versi Java 8. Jika Anda melihat versi lain, alihkan ke versi yang benar:
$ sudo update-alternatives --config javaTambahkan repositori Jenkins
Secara default, Jenkins tidak disertakan dalam repositori Ubuntu, dan Anda perlu menambahkannya.
Pertama, kita perlu mengimpor kunci repositori:
$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -Langkah selanjutnya adalah menambahkan alamat repositori ke daftar repositori server:
$ sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
/etc/apt/sources.list.d/jenkins.list'Setelah selesai, kita perlu memperbarui informasi tentang perangkat lunak, yang dapat kita gunakan dari repositori baru:
$ sudo apt-get update
Instalasi Paket Jenkins
Karena kita memiliki repositori yang terbaru, mari kita jalankan perintah berikut:
$ sudo apt-get -y install jenkinsMenjalankan perintah ini akan meminta Anda untuk mengonfirmasi unduhan dan pemasangan.
Secara default, Jenkins dimulai setelah proses instalasi. Jika tidak, gunakan perintah berikut untuk melakukannya secara manual:
$ sudo systemctl start jenkinsMari periksa apakah status layanan Jenkins:
$ sudo systemctl status jenkins
Pada eksekusi yang berhasil dari perintah di atas, Anda akan mendapatkan output seperti itu:
Konfigurasi Firewall
Secara default, Jenkins berjalan pada port 8080 , jadi mari kita buka untuk mengizinkan Jenkins berkomunikasi.
Jalankan perintah berikut jika Anda menjalankan firewall UFW default:
$ sudo ufw allow 8080Gunakan perintah berikut untuk memeriksa bahwa lalu lintas sekarang diizinkan:
$ sudo ufw status
Output dari perintah di atas akan terlihat seperti ini:
Jika ufw tidak aktif dan Anda ingin mengaktifkannya, berikut adalah perintahnya:
$ sudo systemctl enable ufw
$ sudo systemctl start ufw
$ sudo ufw enableSekarang, Anda dapat mengakses Jenkins di http://localhost:8080 .
Kata sandi awal tersedia di sini:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordLuncurkan Jenkins Di Wadah Docker
Untuk meluncurkan Jenkins dalam wadah Docker, Anda harus menginstal Docker. Proses penginstalan lengkap dijelaskan dalam dokumentasi resmi Docker, jadi kami akan memberikan perintah yang diperlukan di sini:
$ 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.ioSetelah Docker berhasil diinstal, Anda dapat menjalankan container Docker.
Tarik Gambar Jenkins Docker
Tarik Jenkins dari repo publik menggunakan perintah berikut:
$ sudo docker pull jenkins/jenkins
Untuk meluncurkan wadah Jenkins Docker, jalankan perintah berikut:
$ sudo docker run -p 8080:8080 -d --name=jenkins-master jenkins/jenkinsJika Anda mendapatkan pesan kesalahan berikut:
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 canceledItu berarti Anda mencoba meluncurkan Jenkins di container Docker di port yang sama dengan yang digunakan Jenkins di seluruh sistem.
Cukup luncurkan di port 8082 :
$ sudo docker rm jenkins-master
$ sudo docker run -p 8082:8080 -d --name=jenkins-master jenkins/jenkins
Perintah ini menghasilkan pembukaan wadah buruh pelabuhan Jenkins pada port 8082 :
Konfigurasi Jenkins Awal
Untuk mengonfigurasi Jenkins, buka browser dan navigasikan ke alamat IP atau nama domain sebenarnya yang Anda jalankan Jenkins:http://ip_address_or_domain:8080 .
Kata Sandi Jenkins
Anda akan melihat halaman yang menunjukkan lokasi kata sandi Jenkins awal:
Ini dia:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordPlugin Jenkins
Pada layar berikutnya, Anda akan diminta untuk memilih plugin untuk instalasi awal. Jika Anda belum tahu plugin mana yang harus disiapkan, gunakan "Instal plugin yang disarankan " pilihan. 
Pengguna Admin Jenkins
Setelah instalasi selesai, Anda akan diminta untuk membuat pengguna admin Jenkins pertama. 
Setelah berhasil memasukkan detail pengguna, Anda akan diarahkan ke halaman konfigurasi instance untuk mengonfirmasi URL untuk instance Jenkins.
Untuk mengakses dasbor utama Jenkins, klik tombol “Mulai menggunakan Jenkins " tombol. Tindakan ini akan membawa Anda ke antarmuka Jenkins utama:
Instal Jenkins menggunakan CloudFormation
Artikel “Tutorial CloudFormation – Cara Mengotomatiskan Instans EC2 Dalam 5 Menit” menjelaskan cara menggunakan CloudFormation dan metadata cloud-init untuk mengotomatiskan penginstalan perangkat lunak dalam instans EC2.
Di sini kami akan menyediakan template, yang akan menerapkan server Jenkins di belakang server proxy Nginx.
Perhatian :template CloudFormation berikut akan membuat server Jenkins di subnet VPC publik, yang memiliki akses tak terbatas ke Akun AWS Anda. Jika Anda ingin membatasi akses Jenkins, harap ubah JenkinsPolicy atau profil instance jarak jauh dari server Jenkins.
Berikut template CloudFormation (sumber 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
Template CloudFormation ini untuk menerapkan Jenkins di belakang proxy Nginx di infrastruktur AWS Anda.
Template ini memiliki beberapa fitur berikut:
- Anda menggulung untuk mendapatkan sandi awal Jenkins: curl http://ec2-host/password.txt .
- Anda dapat menggunakan LetsEncrypt untuk membuat sertifikat SSL:
sudo certbot --nginx -d jenkins.example.com.
Ringkasan
Dalam artikel ini, kami membahas berbagai cara menerapkan Jenkins di server Anda. Sekarang Anda siap untuk penginstalan manual Jenkins, meluncurkan Jenkins di wadah Docker, atau menerapkan Jenkins menggunakan template CloudFormation.
Tolong beri tahu kami di bagian komentar di bawah jika Anda memiliki pertanyaan. Selain itu, kami menyarankan Anda untuk memeriksa artikel terkait Linux lainnya di blog kami.
Kami harap Anda menemukan artikel ini bermanfaat! Jika ya, tolong bantu kami untuk menyebarkannya ke seluruh dunia!