Cara Menginstal Jenkins di Kubernetes

Pendahuluan

Jenkins adalah integrasi berkelanjutan alat yang mengotomatiskan sebagian besar proses pengembangan perangkat lunak. Beberapa tim pengembangan yang mengerjakan banyak proyek di lingkungan layanan mikro yang kompleks dapat membebani sumber daya yang terbatas. Jenkins membantu Anda memberikan produk akhir yang sempurna sesuai jadwal.

Cluster Kubernetes menambahkan lapisan otomatisasi baru ke Jenkins. Kubernetes memastikan bahwa sumber daya digunakan secara efektif dan server Anda serta infrastruktur yang mendasarinya tidak kelebihan beban.

Tutorial ini akan menunjukkan cara menginstal Jenkins di cluster Kubernetes.

Prasyarat

• Akses ke baris perintah/terminal
• Kluster Kubernetes
• Alat baris perintah kubectl yang terkonfigurasi penuh di mesin lokal Anda

Menginstal Jenkins di Cluster Kubernetes

Kemampuan Kubernetes untuk mengatur penyebaran kontainer memastikan bahwa Jenkins selalu memiliki jumlah sumber daya yang tepat. Contoh di bawah ini menunjukkan cara menggunakan sekumpulan file YAML untuk menginstal Jenkins di cluster Kubernetes . File YAML mudah dilacak, diedit, dan dapat digunakan kembali tanpa batas waktu.

Buat Namespace untuk Penerapan Jenkins

Namespace yang berbeda memberikan lapisan isolasi tambahan dan kontrol lebih besar atas lingkungan integrasi berkelanjutan. Buat namespace untuk penerapan Jenkins dengan mengetikkan perintah berikut di terminal Anda:

kubectl create namespace jenkins

Nama namespace harus berupa label yang kompatibel dengan DNS. Contoh ini menggunakan nama jenkins .

Gunakan perintah berikut untuk membuat daftar namespace yang ada:

kubectl get namespaces

Outputnya mengkonfirmasi bahwa jenkins namespace berhasil dibuat.

Buat Akun Layanan

Akun layanan memberikan identitas yang digunakan untuk mengontrol proses pod. Gunakan editor teks untuk membuat file YAML tempat Anda akan menyimpan deklarasi akun layanan:

nano sa-jenkins.yaml

File mendefinisikan peran cluster dengan izin administratif. Itu juga membuat akun layanan baru bernama admin dan mengikatnya dengan peran cluster yang ditentukan sebelumnya.

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

Simpan file dan keluar. Terapkan konfigurasi dengan kubectl apply .

kubectl apply -f sa-jenkins.yaml

Buat Volume Persistent Jenkins dan Klaim Volume Persisten

Peran dari volume persisten adalah untuk menyimpan data dasar Jenkins dan menyimpannya di luar masa pakai pod. Buat file YAML yang akan menentukan komponen penerapan terkait penyimpanan:

nano volume-jenkins.yaml

Di bagian pertama, file mendeklarasikan local-storage kelas penyimpanan. Bagian kedua mendefinisikan jenkins-pv volume persisten, sedangkan yang ketiga membuat klaim volume persisten jenkins-pvc yang akan diikat ke 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

Simpan file dan keluar. Selanjutnya, terapkan file tersebut.

kubectl apply -f volume-jenkins.yaml

Membuat dan Menerapkan File Penerapan Jenkins

Buat file YAML untuk menyimpan informasi penerapan Jenkins.

nano deploy-jenkins.yaml

File penerapan dalam contoh ini menggunakan jenkins/jenkins:lts Gambar buruh pelabuhan dan buat 1 replika yang akan diekspos pada port 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

volumeMounts bagian file memasang volume persisten yang dibuat pada langkah sebelumnya. livenessProbe dan readinessProbe bagian mendeklarasikan probe yang memulai ulang pod yang gagal dan mendeteksi saat pod sudah siap.

Keluar dari file dan simpan perubahan. Gunakan file yang baru dibuat untuk menerapkan Jenkins:

kubectl apply -f deploy-jenkins.yaml

Buat dan Terapkan File Layanan Jenkins

Layanan Kubernetes adalah abstraksi yang memaparkan Jenkins ke jaringan yang lebih luas. Ini memungkinkan kita untuk mempertahankan koneksi yang persisten ke pod terlepas dari perubahan yang terjadi di dalam cluster.

Buat file YAML di mana Anda akan menentukan layanan:

nano service-jenkins.yaml

Tambahkan konten berikut:

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

Simpan file dan keluar. Sekarang buat layanan dengan mengetik:

kubectl apply -f jenkins-service.yaml

Sekarang Anda dapat mengakses dasbor Jenkins.

Mengakses Dasbor Jenkins

Sebelum Anda melanjutkan untuk memulai Jenkins, periksa apakah semua komponen yang Anda terapkan berfungsi sebagaimana mestinya. Gunakan kubectl get all perintah dan tentukan namespace yang benar:

kubect get all -n jenkins

Contoh menunjukkan penerapan yang berfungsi dengan baik:

• Pod ditandai sebagai READY dan Running .
• IP Cluster dan port layanan telah berhasil dialokasikan.
• Penerapan ditandai sebagai READY dan AVAILABLE .
• Jumlah replika (1) yang diinginkan telah tercapai.

Buka browser Anda dan akses node dengan menggunakan alamat IP dan port yang Anda tentukan dalam file layanan. Jika Anda tidak mengetahui alamat IP node Anda, temukan alamat tersebut di output dari perintah berikut:

kubectl get nodes -o yaml

Alamat IP node terletak di status bagian keluaran.

Menggunakan informasi dari contoh, alamat dasbor Jenkins adalah:

http://192.168.49.2:44000

Untuk mengakses Jenkins, awalnya Anda harus memasukkan kredensial Anda. Nama pengguna default untuk pemasangan baru adalah admin .

Untuk mendapatkan kata sandi:

1. Temukan nama pod di output kubectl get all perintah di atas.

2. Setelah Anda menemukan nama pod, gunakan untuk mengakses log pod.

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

3. Temukan kata sandi di akhir log, yang diformat sebagai string alfanumerik yang panjang.

Anda telah berhasil menginstal Jenkins di cluster Kubernetes Anda dan dapat menggunakannya untuk membuat pipeline pengembangan baru dan efisien.