In diesem Artikel werden verschiedene Möglichkeiten zum Bereitstellen von Jenkins auf Ihrem Server behandelt. Verwenden Sie unseren aktuellen Leitfaden für die manuelle Installation oder den Start von Jenkins in Docker-Containern. Als Bonus zeigen wir Ihnen, wie Sie Jenkins mit CloudFormation bereitstellen. Stellen Sie Jenkins mithilfe unserer Anleitung in 5 Minuten auf Ihrem Server bereit.
Was ist Jenkins
Jenkins ist der beliebteste kostenlose Automatisierungsserver. Mit Jenkins können Sie nahezu alle Prozesse in Ihrem Unternehmen automatisieren. Aber der traditionelle Markt für Jenkins ist die Automatisierung der Softwareentwicklungsprozesse.
Vorteile von Jenkins:
- In Java geschrieben, daher auf allen Plattformen lauffähig
- Hat viele Plugins, die Ihnen helfen können, fast jedes Problem zu lösen, das Sie sich vorstellen können.
- Hilft Entwicklern, Codeänderungen zu integrieren und immer einen stabilen Softwareaufbau zu produzieren
Jenkins manuell installieren
Der Installationsprozess ist einfach und unkompliziert. Es besteht aus mehreren einfachen Schritten:
- Java-Installation.
- Hinzufügen offizieller Jenkins-Repositories zu Ihrem Paketmanager.
- Paketinstallation.
- Firewall-Konfiguration.
- Erste Jenkins-Konfiguration.
Machen wir sie nacheinander.
Java-Installation
Um Jenkins ausführen zu können, müssen Sie zuerst Java installieren.
Aktualisieren Sie zuerst den apt-Paketindex mit:
$ sudo apt updateInstallieren Sie als Nächstes das standardmäßige Java OpenJDK-Paket mit diesem:
$ sudo apt install openjdk-8-jreÜberprüfen Sie die Installation mit diesem Befehl:
$ java -version
Hier die Ausgabe nach erfolgreicher Installation:
Wichtig :Sie sollten sehen, dass Java Version 1.8 hat.
Zum Zeitpunkt der Erstellung dieses Artikels verwendet Jenkins die Java 8-Version. Wenn Sie eine andere Version sehen, wechseln Sie zur richtigen:
$ sudo update-alternatives --config javaJenkins-Repository hinzufügen
Standardmäßig ist Jenkins nicht in den Ubuntu-Repositories enthalten und Sie müssen es hinzufügen.
Zuerst müssen wir den Repository-Schlüssel importieren:
$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -Der nächste Schritt besteht darin, die Repository-Adresse an die Repository-Liste des Servers anzuhängen:
$ sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
/etc/apt/sources.list.d/jenkins.list'Sobald dies erledigt ist, müssen wir die Informationen über die Software aktualisieren, die wir aus dem neuen Repository verwenden können:
$ sudo apt-get update
Installation des Jenkins-Pakets
Da wir das Repository auf dem neuesten Stand haben, führen wir den folgenden Befehl aus:
$ sudo apt-get -y install jenkinsWenn Sie diesen Befehl ausführen, werden Sie aufgefordert, den Download und die Installation zu bestätigen.
Standardmäßig startet Jenkins nach dem Installationsvorgang. Wenn nicht, verwenden Sie den folgenden Befehl, um dies manuell zu tun:
$ sudo systemctl start jenkinsLassen Sie den Status des Jenkins-Dienstes überprüfen:
$ sudo systemctl status jenkins
Bei erfolgreicher Ausführung des obigen Befehls sollten Sie eine solche Ausgabe erhalten:
Firewall-Konfiguration
Standardmäßig wird Jenkins auf Port 8080 ausgeführt , also öffnen wir es, damit Jenkins kommunizieren kann.
Führen Sie den folgenden Befehl aus, wenn Sie die standardmäßige UFW-Firewall verwenden:
$ sudo ufw allow 8080Verwenden Sie den folgenden Befehl, um zu überprüfen, ob der Datenverkehr jetzt zulässig ist:
$ sudo ufw status
Die Ausgabe des obigen Befehls sollte wie folgt aussehen:
Wenn ufw inaktiv ist und Sie es aktivieren möchten, sind hier die Befehle:
$ sudo systemctl enable ufw
$ sudo systemctl start ufw
$ sudo ufw enableJetzt können Sie unter http://localhost:8080 auf Jenkins zugreifen .
Das Initialpasswort ist hier verfügbar:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordJenkins im Docker-Container starten
Um Jenkins in einem Docker-Container zu starten, muss Docker installiert sein. Der vollständige Installationsvorgang wird in der offiziellen Docker-Dokumentation beschrieben, daher stellen wir hier die erforderlichen Befehle bereit:
$ 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.ioSobald Docker erfolgreich installiert ist, können Sie den Docker-Container ausführen.
Jenkins-Docker-Image ziehen
Ziehen Sie die Jenkins mit dem folgenden Befehl aus dem öffentlichen Repository:
$ sudo docker pull jenkins/jenkins
Führen Sie den folgenden Befehl aus, um den Jenkins-Docker-Container zu starten:
$ sudo docker run -p 8080:8080 -d --name=jenkins-master jenkins/jenkinsWenn Sie die folgende Fehlermeldung erhalten:
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 canceledDas bedeutet, dass Sie versuchen, Jenkins im Docker-Container auf demselben Port zu starten, den das systemweite Jenkins verwendet.
Starten Sie es einfach auf Port 8082 :
$ sudo docker rm jenkins-master
$ sudo docker run -p 8082:8080 -d --name=jenkins-master jenkins/jenkins
Dieser Befehl führt zum Öffnen des Jenkins-Docker-Containers auf Port 8082 :
Erste Jenkins-Konfiguration
Um Jenkins zu konfigurieren, öffnen Sie einen Browser und navigieren Sie zu der tatsächlichen IP-Adresse oder dem Domänennamen, auf dem Sie Jenkins ausführen:http://ip_address_or_domain:8080 .
Jenkins-Passwort
Sie sehen die Seite mit dem Speicherort des anfänglichen Jenkins-Passworts:
Hier ist es:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPasswordJenkins-Plugins
Auf dem nächsten Bildschirm müssen Sie Plugins für die Erstinstallation auswählen. Wenn Sie noch nicht wissen, welche Plugins Sie einrichten sollen, verwenden Sie die „Vorgeschlagene Plugins installieren“. " Möglichkeit. 
Jenkins-Admin-Benutzer
Sobald die Installation abgeschlossen ist, werden Sie aufgefordert, den ersten Jenkins-Administratorbenutzer zu erstellen. 
Nachdem Sie die Benutzerdaten erfolgreich eingegeben haben, werden Sie zur Seite mit der Instanzkonfiguration weitergeleitet, um die URL für die Jenkins-Instanz zu bestätigen.
Um auf das Haupt-Dashboard von Jenkins zuzugreifen, klicken Sie auf „Start using Jenkins“. " Taste. Diese Aktion bringt Sie zur Hauptschnittstelle von Jenkins:
Installieren Sie Jenkins mit CloudFormation
Im Artikel „CloudFormation Tutorial – How To Automate EC2 Instance In 5 Mins“ wurde beschrieben, wie Sie CloudFormation und Cloud-Init-Metadaten verwenden, um die Softwareinstallation in EC2-Instances zu automatisieren.
Hier stellen wir eine Vorlage bereit, die den Jenkins-Server hinter dem Nginx-Proxyserver bereitstellt.
Achtung :Die folgende CloudFormation-Vorlage erstellt einen Jenkins-Server in einem öffentlichen VPC-Subnetz, der uneingeschränkten Zugriff auf Ihr AWS-Konto hat. Wenn Sie den Jenkins-Zugriff einschränken möchten, ändern Sie bitte die JenkinsPolicy oder das Remote-Instance-Profil vom Jenkins-Server.
Hier ist die CloudFormation-Vorlage (GitHub-Quellen):
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
Diese CloudFormation-Vorlage dient zum Bereitstellen von Jenkins hinter dem Nginx-Proxy in Ihrer AWS-Infrastruktur.
Diese Vorlage hat die folgenden Funktionen:
- Sie bewegen sich, um das anfängliche Jenkins-Passwort zu erhalten: curl http://ec2-host/password.txt .
- Sie können LetsEncrypt verwenden, um SSL-Zertifikate zu erstellen:
sudo certbot --nginx -d jenkins.example.com.
Zusammenfassung
In diesem Artikel haben wir verschiedene Möglichkeiten zur Bereitstellung von Jenkins auf Ihrem Server behandelt. Jetzt sind Sie bereit für die manuelle Installation von Jenkins, das Starten von Jenkins im Docker-Container oder das Bereitstellen von Jenkins mithilfe der CloudFormation-Vorlage.
Bitte teilen Sie uns im Kommentarbereich unten mit, wenn Sie Fragen haben. Außerdem empfehlen wir Ihnen, andere Linux-bezogene Artikel in unserem Blog zu lesen.
Wir hoffen, dass Sie diesen Artikel nützlich finden! Wenn ja, helfen Sie uns bitte, es in der Welt zu verbreiten!