Come installare Jenkins su Kubernetes

Introduzione

Jenkins è un'integrazione continua strumento che automatizza gran parte del processo di sviluppo del software. Diversi team di sviluppo che lavorano su più progetti in un ambiente di microservizi complessi possono mettere a dura prova le risorse limitate. Jenkins ti aiuta a consegnare un prodotto finale impeccabile nei tempi previsti.

Un cluster Kubernetes aggiunge un nuovo livello di automazione a Jenkins. Kubernetes si assicura che le risorse vengano utilizzate in modo efficace e che i server e l'infrastruttura sottostante non siano sovraccaricati.

Questo tutorial ti mostrerà come installare Jenkins su un cluster Kubernetes.

Prerequisiti

• Accesso a una riga di comando/terminale
• Gruppo Kubernetes
• Uno strumento da riga di comando kubectl completamente configurato sul tuo computer locale

Installazione di Jenkins su Kubernetes Cluster

La capacità di Kubernetes di orchestrare la distribuzione dei container assicura che Jenkins abbia sempre la giusta quantità di risorse disponibili. L'esempio seguente mostra come utilizzare un set di file YAML per installare Jenkins su un cluster Kubernetes . I file YAML sono facilmente tracciabili, modificati e possono essere riutilizzati all'infinito.

Crea uno spazio dei nomi per la distribuzione Jenkins

Uno spazio dei nomi distinto fornisce un ulteriore livello di isolamento e un maggiore controllo sull'ambiente di integrazione continua. Crea uno spazio dei nomi per la distribuzione Jenkins digitando il seguente comando nel tuo terminale:

kubectl create namespace jenkins

Il nome dello spazio dei nomi dovrebbe essere un'etichetta compatibile con DNS. Questo esempio usa il nome jenkins .

Utilizzare il comando seguente per elencare gli spazi dei nomi esistenti:

kubectl get namespaces

L'output conferma che il jenkins lo spazio dei nomi è stato creato correttamente.

Crea un account di servizio

Gli account di servizio forniscono identità utilizzate per controllare i processi del pod. Usa un editor di testo per creare un file YAML in cui memorizzerai le dichiarazioni dell'account di servizio:

nano sa-jenkins.yaml

Il file definisce il ruolo del cluster con autorizzazioni amministrative. Crea anche un nuovo account di servizio denominato admin e lo associa al ruolo del cluster precedentemente definito.

---
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

Salva il file ed esci. Applica la configurazione con kubectl apply .

kubectl apply -f sa-jenkins.yaml

Crea volume persistente Jenkins e richiesta volume persistente

Il ruolo di un volume persistente è archiviare i dati Jenkins di base e conservarli oltre la durata di un pod. Crea un file YAML che definirà i componenti relativi allo storage della distribuzione:

nano volume-jenkins.yaml

Nella prima sezione, il file dichiara il local-storage classe di archiviazione. La seconda sezione definisce il jenkins-pv volume persistente, mentre il terzo crea un'attestazione di volume persistente jenkins-pvc che sarà legato al jenkins-pv volume.

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

Salva il file ed esci. Quindi, applica il file.

kubectl apply -f volume-jenkins.yaml

Crea e applica il file di distribuzione Jenkins

Crea un file YAML per archiviare le informazioni sulla distribuzione Jenkins.

nano deploy-jenkins.yaml

Il file di distribuzione in questo esempio utilizza jenkins/jenkins:lts Docker e crea 1 replica che sarà esposto sulla porta 8080 .

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

Il volumeMounts sezione del file monta il volume persistente creato nel passaggio precedente. Il livenessProbe e readinessProbe le sezioni dichiarano le sonde che riavviano i pod non riusciti e rilevano quando i pod sono pronti.

Esci dal file e salva le modifiche. Usa il file appena creato per distribuire Jenkins:

kubectl apply -f deploy-jenkins.yaml

Crea e applica il file di servizio Jenkins

Un servizio Kubernetes è un'astrazione che espone Jenkins alla rete più ampia. Ci consente di mantenere una connessione persistente al pod indipendentemente dalle modifiche in corso all'interno del cluster.

Crea un file YAML in cui definirai il servizio:

nano service-jenkins.yaml

Aggiungi il seguente contenuto:

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

Salva il file ed esci. Ora crea il servizio digitando:

kubectl apply -f jenkins-service.yaml

Ora puoi accedere alla dashboard di Jenkins.

Accedi al dashboard di Jenkins

Prima di avviare Jenkins, controlla se tutti i componenti che hai distribuito funzionano come previsto. Usa il kubectl get all comando e specificare lo spazio dei nomi corretto:

kubect get all -n jenkins

L'esempio mostra una distribuzione correttamente funzionante:

• Il pod è contrassegnato come READY e Running .
• L'IP del cluster e le porte del servizio sono state allocate correttamente.
• L'implementazione è contrassegnata come READY e AVAILABLE .
• Il numero di repliche desiderato (1) è stato raggiunto.

Vai al tuo browser e accedi al nodo utilizzando il suo indirizzo IP e la porta che hai definito nel file di servizio. Se non conosci l'indirizzo IP del tuo nodo, trovalo nell'output del seguente comando:

kubectl get nodes -o yaml

L'indirizzo IP del nodo si trova nello status sezione dell'output.

Utilizzando le informazioni dell'esempio, l'indirizzo della dashboard Jenkins è:

http://192.168.49.2:44000

Per accedere a Jenkins, devi inizialmente inserire le tue credenziali. Il nome utente predefinito per le nuove installazioni è admin .

Per ottenere la password:

1. Trova il nome del pod nell'output di kubectl get all comando sopra.

2. Una volta individuato il nome del pod, utilizzalo per accedere ai registri del pod.

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

3. Trova la password alla fine del registro, formattata come una lunga stringa alfanumerica.

Hai installato correttamente Jenkins sul tuo cluster Kubernetes e puoi usarlo per creare nuove ed efficienti pipeline di sviluppo.