So installieren Sie Jenkins auf Kubernetes

Einführung

Jenkins ist eine kontinuierliche Integration Tool, das einen großen Teil des Softwareentwicklungsprozesses automatisiert. Mehrere Entwicklungsteams, die an mehreren Projekten in einer komplexen Microservices-Umgebung arbeiten, können begrenzte Ressourcen belasten. Jenkins hilft Ihnen, termingerecht ein einwandfreies Endprodukt zu liefern.

Ein Kubernetes-Cluster fügt Jenkins eine neue Automatisierungsebene hinzu. Kubernetes stellt sicher, dass Ressourcen effektiv genutzt werden und Ihre Server und die zugrunde liegende Infrastruktur nicht überlastet werden.

Diese Anleitung zeigt Ihnen, wie Sie Jenkins auf einem Kubernetes-Cluster installieren.

Voraussetzungen

• Zugriff auf eine Befehlszeile/ein Terminal
• Kubernetes-Cluster
• Ein vollständig konfiguriertes kubectl-Befehlszeilentool auf Ihrem lokalen Computer

Installieren von Jenkins im Kubernetes-Cluster

Die Fähigkeit von Kubernetes, die Bereitstellung von Containern zu orchestrieren, stellt sicher, dass Jenkins immer die richtige Menge an Ressourcen zur Verfügung hat. Das folgende Beispiel zeigt Ihnen, wie Sie einen Satz von YAML-Dateien verwenden, um Jenkins in einem Kubernetes-Cluster zu installieren . Die YAML-Dateien lassen sich leicht nachverfolgen, bearbeiten und unbegrenzt wiederverwenden.

Erstellen Sie einen Namespace für die Jenkins-Bereitstellung

Ein eindeutiger Namespace bietet eine zusätzliche Isolationsebene und mehr Kontrolle über die Continuous-Integration-Umgebung. Erstellen Sie einen Namespace für die Jenkins-Bereitstellung, indem Sie den folgenden Befehl in Ihr Terminal eingeben:

kubectl create namespace jenkins

Der Name des Namespace sollte ein DNS-kompatibles Label sein. Dieses Beispiel verwendet den Namen jenkins .

Verwenden Sie den folgenden Befehl, um vorhandene Namespaces aufzulisten:

kubectl get namespaces

Die Ausgabe bestätigt, dass die jenkins Namespace wurde erfolgreich erstellt.

Erstellen Sie ein Dienstkonto

Dienstkonten stellen Identitäten bereit, die zum Steuern von Pod-Prozessen verwendet werden. Verwenden Sie einen Texteditor, um eine YAML-Datei zu erstellen, in der Sie die Deklarationen des Dienstkontos speichern:

nano sa-jenkins.yaml

Die Datei definiert die Clusterrolle mit administrativen Berechtigungen. Außerdem wird ein neues Dienstkonto mit dem Namen admin erstellt und bindet es an die zuvor definierte Cluster-Rolle.

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: admin
rules:
  - apiGroups: [""]
    resources: ["*"]
    verbs: ["*"]

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin
  namespace: jenkins

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: admin
subjects:
- kind: ServiceAccount
  name: admin
  namespace: jenkins

Speichern Sie die Datei und beenden Sie sie. Wenden Sie die Konfiguration mit kubectl apply an .

kubectl apply -f sa-jenkins.yaml

Persistentes Jenkins-Volume und Anspruch auf persistentes Volume erstellen

Die Rolle eines persistenten Volumes besteht darin, grundlegende Jenkins-Daten zu speichern und über die Lebensdauer eines Pods hinaus aufzubewahren. Erstellen Sie eine YAML-Datei, die speicherbezogene Komponenten der Bereitstellung definiert:

nano volume-jenkins.yaml

Im ersten Abschnitt deklariert die Datei den local-storage Speicherklasse. Der zweite Abschnitt definiert jenkins-pv persistentes Volume, während das dritte einen persistenten Volume-Claim jenkins-pvc erstellt das wird an jenkins-pv gebunden Volumen.

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: jenkins-pv
  labels:
    type: local
spec:
  storageClassName: local-storage
  claimRef:
    name: jenkins-pvc
    namespace: jenkins
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  local:
    path: /mnt
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - minikube

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins-pvc
  namespace: jenkins
spec:
  storageClassName: local-storage
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 3Gi

Speichern Sie die Datei und beenden Sie sie. Als nächstes wenden Sie die Datei an.

kubectl apply -f volume-jenkins.yaml

Jenkins-Bereitstellungsdatei erstellen und anwenden

Erstellen Sie eine YAML-Datei zum Speichern von Jenkins-Bereitstellungsinformationen.

nano deploy-jenkins.yaml

Die Bereitstellungsdatei in diesem Beispiel verwendet die Datei jenkins/jenkins:lts Docker-Image und erstellt 1 Replikat das wird auf Port 8080 offen gelegt .

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
  namespace: jenkins
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins-server
  template:
    metadata:
      labels:
        app: jenkins-server
    spec:
      securityContext:
            fsGroup: 1000 
            runAsUser: 1000
      serviceAccountName: admin
      containers:
        - name: jenkins
          image: jenkins/jenkins:lts
          resources:
            limits:
              memory: "2Gi"
              cpu: "1000m"
            requests:
              memory: "500Mi"
              cpu: "500m"
          ports:
            - name: httpport
              containerPort: 8080
            - name: jnlpport
              containerPort: 50000
          livenessProbe:
            httpGet:
              path: "/login"
              port: 8080
            initialDelaySeconds: 90
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 5
          readinessProbe:
            httpGet:
              path: "/login"
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 3
          volumeMounts:
            - name: jenkins-data
              mountPath: /var/jenkins_home         
      volumes:
        - name: jenkins-data
          persistentVolumeClaim:
              claimName: jenkins-pvc

Die volumeMounts Abschnitt der Datei stellt das persistente Volume bereit, das im vorherigen Schritt erstellt wurde. Die livenessProbe und readinessProbe -Abschnitte deklarieren Probes, die fehlerhafte Pods neu starten und erkennen, wann Pods bereit sind.

Beenden Sie die Datei und speichern Sie die Änderungen. Verwenden Sie die neu erstellte Datei, um Jenkins bereitzustellen:

kubectl apply -f deploy-jenkins.yaml

Jenkins-Dienstdatei erstellen und anwenden

Ein Kubernetes-Dienst ist eine Abstraktion, die Jenkins dem breiteren Netzwerk aussetzt. Es ermöglicht uns, eine dauerhafte Verbindung zum Pod aufrechtzuerhalten, unabhängig von den Änderungen, die innerhalb des Clusters stattfinden.

Erstellen Sie eine YAML-Datei, in der Sie den Dienst definieren:

nano service-jenkins.yaml

Fügen Sie den folgenden Inhalt hinzu:

apiVersion: v1
kind: Service
metadata:
  name: jenkins-svc
  namespace: jenkins
  annotations:
      prometheus.io/scrape: 'true'
      prometheus.io/path:   /
      prometheus.io/port:   '8080'
spec:
  selector: 
    app: jenkins-server
  type: NodePort  
  ports:
    - port: 8080
      targetPort: 8080
      nodePort: 44000

Speichern Sie die Datei und beenden Sie sie. Erstellen Sie nun den Dienst, indem Sie Folgendes eingeben:

kubectl apply -f jenkins-service.yaml

Sie können jetzt auf das Jenkins-Dashboard zugreifen.

Zugriff auf das Jenkins-Dashboard

Bevor Sie mit dem Start von Jenkins fortfahren, überprüfen Sie, ob alle von Ihnen bereitgestellten Komponenten wie vorgesehen funktionieren. Verwenden Sie kubectl get all Befehl und geben Sie den korrekten Namespace an:

kubect get all -n jenkins

Das Beispiel zeigt eine ordnungsgemäß funktionierende Bereitstellung:

• Der Pod ist als READY markiert und Running .
• Die Cluster-IP und die Ports des Dienstes wurden erfolgreich zugewiesen.
• Die Bereitstellung ist als READY gekennzeichnet und AVAILABLE .
• Die gewünschte Anzahl an Replikaten (1) wurde erreicht.

Gehen Sie zu Ihrem Browser und greifen Sie auf den Knoten zu, indem Sie seine IP-Adresse und den Port verwenden, den Sie in der Servicedatei definiert haben. Wenn Sie die IP-Adresse Ihres Knotens nicht kennen, finden Sie sie in der Ausgabe des folgenden Befehls:

kubectl get nodes -o yaml

Die Knoten-IP-Adresse befindet sich im status Abschnitt der Ausgabe.

Unter Verwendung der Informationen aus dem Beispiel lautet die Adresse des Jenkins-Dashboards:

http://192.168.49.2:44000

Um auf Jenkins zuzugreifen, müssen Sie zunächst Ihre Anmeldeinformationen eingeben. Der Standardbenutzername für neue Installationen ist admin .

So erhalten Sie das Passwort:

1. Suchen Sie den Namen des Pods in der Ausgabe von kubectl get all Befehl oben.

2. Sobald Sie den Namen des Pods gefunden haben, verwenden Sie ihn, um auf die Protokolle des Pods zuzugreifen.

kubectl logs jenkins-56c9d59dc-pv8kc --namespace jenkins

3. Suchen Sie das Passwort am Ende des Protokolls, formatiert als lange alphanumerische Zeichenfolge.

Sie haben Jenkins erfolgreich auf Ihrem Kubernetes-Cluster installiert und können damit neue und effiziente Entwicklungspipelines erstellen.