Comment installer Jenkins sur Kubernetes

Présentation

Jenkins est une intégration continue outil qui automatise une grande partie du processus de développement logiciel. Plusieurs équipes de développement travaillant sur plusieurs projets dans un environnement de microservices complexe peuvent mettre à rude épreuve des ressources limitées. Jenkins vous aide à livrer un produit final impeccable dans les délais.

Un cluster Kubernetes ajoute une nouvelle couche d'automatisation à Jenkins. Kubernetes garantit que les ressources sont utilisées efficacement et que vos serveurs et votre infrastructure sous-jacente ne sont pas surchargés.

Ce tutoriel vous montrera comment installer Jenkins sur un cluster Kubernetes.

Prérequis

• Accès à une ligne de commande/terminal
• Cluster Kubernetes
• Un outil de ligne de commande kubectl entièrement configuré sur votre machine locale

Installer Jenkins sur le cluster Kubernetes

La capacité de Kubernetes à orchestrer le déploiement de conteneurs garantit que Jenkins dispose toujours de la bonne quantité de ressources disponibles. L'exemple ci-dessous vous montre comment utiliser un ensemble de fichiers YAML pour installer Jenkins sur un cluster Kubernetes . Les fichiers YAML sont facilement suivis, modifiés et peuvent être réutilisés indéfiniment.

Créer un espace de noms pour le déploiement Jenkins

Un espace de noms distinct fournit une couche supplémentaire d'isolation et un meilleur contrôle sur l'environnement d'intégration continue. Créez un espace de noms pour le déploiement Jenkins en saisissant la commande suivante dans votre terminal :

kubectl create namespace jenkins

Le nom de l'espace de noms doit être une étiquette compatible DNS. Cet exemple utilise le nom jenkins .

Utilisez la commande suivante pour répertorier les espaces de noms existants :

kubectl get namespaces

La sortie confirme que le jenkins l'espace de noms a été créé avec succès.

Créer un compte de service

Les comptes de service fournissent des identités utilisées pour contrôler les processus de pod. Utilisez un éditeur de texte pour créer un fichier YAML dans lequel vous stockerez les déclarations de compte de service :

nano sa-jenkins.yaml

Le fichier définit le rôle de cluster avec des autorisations administratives. Il crée également un nouveau compte de service nommé admin et le lie au rôle de cluster précédemment défini.

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

Enregistrez le fichier et quittez. Appliquez la configuration avec kubectl apply .

kubectl apply -f sa-jenkins.yaml

Créer un volume persistant Jenkins et une revendication de volume persistant

Le rôle d'un volume persistant est de stocker les données Jenkins de base et de les conserver au-delà de la durée de vie d'un pod. Créez un fichier YAML qui définira les composants liés au stockage du déploiement :

nano volume-jenkins.yaml

Dans la première section, le fichier déclare le local-storage classe de stockage. La deuxième section définit le jenkins-pv volume persistant, tandis que le troisième crée une revendication de volume persistant jenkins-pvc qui sera lié au jenkins-pv le 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

Enregistrez le fichier et quittez. Ensuite, appliquez le fichier.

kubectl apply -f volume-jenkins.yaml

Créer et appliquer le fichier de déploiement Jenkins

Créez un fichier YAML pour stocker les informations de déploiement de Jenkins.

nano deploy-jenkins.yaml

Le fichier de déploiement dans cet exemple utilise le jenkins/jenkins:lts Image Docker et crée 1 réplica qui va être exposé sur le 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

Les volumeMounts La section du fichier monte le volume persistant créé à l'étape précédente. Le livenessProbe et readinessProbe Les sections déclarent des sondes qui redémarrent les pods défaillants et détectent quand les pods sont prêts.

Quittez le fichier et enregistrez les modifications. Utilisez le fichier nouvellement créé pour déployer Jenkins :

kubectl apply -f deploy-jenkins.yaml

Créer et appliquer le fichier de service Jenkins

Un service Kubernetes est une abstraction qui expose Jenkins au réseau plus large. Cela nous permet de maintenir une connexion persistante au pod, quels que soient les changements qui ont lieu au sein du cluster.

Créez un fichier YAML dans lequel vous définirez le service :

nano service-jenkins.yaml

Ajoutez le contenu suivant :

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

Enregistrez le fichier et quittez. Créez maintenant le service en tapant :

kubectl apply -f jenkins-service.yaml

Vous pouvez maintenant accéder au tableau de bord Jenkins.

Accéder au tableau de bord Jenkins

Avant de démarrer Jenkins, vérifiez si tous les composants que vous avez déployés fonctionnent comme prévu. Utilisez le kubectl get all commande et spécifiez l'espace de noms correct :

kubect get all -n jenkins

L'exemple montre un déploiement fonctionnant correctement :

• Le pod est marqué comme READY et Running .
• L'adresse IP et les ports du cluster du service ont été correctement alloués.
• Le déploiement est marqué comme READY et AVAILABLE .
• Le nombre de répliques souhaité (1) a été atteint.

Accédez à votre navigateur et accédez au nœud en utilisant son adresse IP et le port que vous avez défini dans le fichier de service. Si vous ne connaissez pas l'adresse IP de votre nœud, recherchez-la dans la sortie de la commande suivante :

kubectl get nodes -o yaml

L'adresse IP du nœud se trouve dans le status section de la sortie.

En utilisant les informations de l'exemple, l'adresse du tableau de bord Jenkins est :

http://192.168.49.2:44000

Pour accéder à Jenkins, vous devez d'abord entrer vos informations d'identification. Le nom d'utilisateur par défaut pour les nouvelles installations est admin .

Pour obtenir le mot de passe :

1. Recherchez le nom du pod dans la sortie de kubectl get all commande ci-dessus.

2. Une fois que vous avez localisé le nom du pod, utilisez-le pour accéder aux journaux du pod.

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

3. Recherchez le mot de passe à la fin du journal, sous la forme d'une longue chaîne alphanumérique.

Vous avez installé avec succès Jenkins sur votre cluster Kubernetes et pouvez l'utiliser pour créer de nouveaux pipelines de développement efficaces.