Jenkins sur Kubernetes Engine

Cette rubrique vous présente les bonnes pratiques d'utilisation de Jenkins avec Google Kubernetes Engine. Pour mettre en œuvre cette solution, consultez la page Configurer Jenkins sur Kubernetes Engine.

Jenkins est un serveur d'automatisation Open Source qui vous permet d'orchestrer de manière flexible vos pipelines de build, de test et de déploiement. Kubernetes Engine est une version hébergée de Kubernetes, un puissant gestionnaire de clusters et système d'orchestration pour les conteneurs.

Comparé à un déploiement standard basé sur des machines virtuelles (VM), le déploiement de Jenkins sur Kubernetes Engine offre des avantages considérables dans le cadre de la configuration d'un pipeline de diffusion continue.

  • Lorsque votre processus de build utilise des conteneurs, un même hôte virtuel peut exécuter des tâches sur plusieurs systèmes d'exploitation.

  • Kubernetes Engine fournit des exécuteurs de build éphémères, qui permettent à chaque build de s'exécuter dans un environnement propre identique aux builds précédents.

    • En tant que facteur éphémère des exécuteurs de build, le cluster Kubernetes Engine n'est utilisé que lorsque les builds sont en cours d'exécution, ce qui libère des ressources pour d'autres tâches du cluster telles que les tâches de traitement par lots.

    • Les exécuteurs de build se lancent en quelques secondes.

  • Kubernetes Engine s'appuie sur l'équilibreur de charge global de Google pour acheminer le trafic Web vers votre instance. L'équilibreur de charge gère la terminaison SSL et fournit une adresse IP globale qui dirige les utilisateurs vers votre frontal Web sur l'un des chemins les plus rapides depuis le point de présence le plus proche de vos utilisateurs, via le réseau backbone Google.

Pour une présentation détaillée de Jenkins sur Kubernetes Engine, visionnez la conférence Next 2018 sur YouTube.

Les rapports sur l'état du DevOps identifient les fonctionnalités qui améliorent les performances de livraison de logiciels. Cet article vous permettra d'effectuer les opérations suivantes :

Déployer le contrôleur Jenkins avec Helm

Utilisez Helm pour déployer Jenkins à partir du dépôt Charts. Helm est un gestionnaire de packages grâce auquel vous pouvez configurer et déployer des applications Kubernetes.

L'image suivante présente l'architecture de déploiement de Jenkins dans un cluster Kubernetes multinœuds.

Architecture de Jenkins et Kubernetes

Déployez le contrôleur Jenkins dans un espace de noms distinct dans le cluster Kubernetes. Les espaces de noms permettent de créer des quotas pour le déploiement de Jenkins et de séparer Jenkins des autres déploiements au sein du cluster de manière logique.

Créer des services Jenkins

Jenkins fournit deux services auxquels le cluster doit avoir accès. Déployez ces services séparément afin qu'ils puissent être gérés et nommés individuellement.

  • Un service NodePort externe sur le port 8080 qui permet aux pods et aux utilisateurs externes d'accéder à l'interface utilisateur Jenkins. Ce type de service peut être équilibré par un équilibreur de charge HTTP.

  • Un service ClusterIP interne et privé sur le port 50 000 que les exécuteurs Jenkins utilisent pour communiquer avec le contrôleur Jenkins depuis l'intérieur du cluster.

Les sections suivantes présentent des exemples de définitions de service. (Le contrôleur est nommé master dans les définitions).

---
  kind: Service
  apiVersion: v1
  metadata:
    name: jenkins-ui
    namespace: jenkins
  spec:
    type: NodePort
    selector:
      app: master
    ports:
      - protocol: TCP
        port: 8080
        targetPort: 8080
        name: ui
---
  kind: Service
  apiVersion: v1
  metadata:
    name: jenkins-discovery
    namespace: jenkins
  spec:
    selector:
      app: master
    ports:
      - protocol: TCP
        port: 50000
        targetPort: 50000
        name: slaves

Créer le déploiement Jenkins

Déployez le contrôleur Jenkins en tant que déploiement avec un nombre d'instances dupliquées égal à 1. Cela permet de s'assurer qu'un seul contrôleur Jenkins est en cours d'exécution dans le cluster à tout moment. Si le pod du contrôleur Jenkins meurt ou si le nœud sur lequel il est exécuté est arrêté, Kubernetes redémarre le pod ailleurs dans le cluster.

Il est important de définir les requêtes et limites dans le cadre du déploiement Helm, afin de garantir au conteneur une certaine quantité de ressources de processeur et de mémoire au sein du cluster avant la planification. Sinon, votre contrôleur pourrait tomber en panne en raison d'un manque de ressources de processeur ou de mémoire.

Le volume d'accueil Jenkins stocke les fichiers de configuration XML et les fichiers JAR de plug-in qui constituent votre configuration. Ces données sont stockées sur un disque persistant géré par le cluster GKE et persisteront lors des redémarrages de Jenkins. Pour modifier la taille du disque persistant, modifiez la valeur Persistence.Size lors de l'installation de Jenkins avec Helm.

Connexion à Jenkins

Une fois le pod Jenkins créé, vous pouvez créer un point de terminaison d'équilibreur de charge pour vous y connecter en dehors de Cloud Platform. Tenez compte des bonnes pratiques suivantes.

  • Utilisez une ressource d'entrée Kubernetes pour obtenir un équilibreur de charge L7 facile à configurer avec une terminaison SSL.

  • Fournissez des certificats SSL à l'équilibreur de charge à l'aide de codes secrets Kubernetes. Utilisez les valeurs tls.cert et tls.key, puis référencez-les dans la configuration de votre ressource d'entrée.

Configurer Jenkins

Sécuriser Jenkins

Il est important de sécuriser immédiatement Jenkins lorsque vous vous y connectez pour la première fois. Vous pouvez suivre le tutoriel de configuration de la sécurité standard Jenkins pour bénéficier d'une procédure simple qui exploite une base de données utilisateur interne. Cette configuration ne nécessite aucune infrastructure supplémentaire et permet de bloquer les utilisateurs anonymes.

Installer des plug-ins

Vous pouvez installer les plug-ins suivants afin d'améliorer les interactions entre Jenkins et Kubernetes Engine.

  • Le plug-in Kubernetes permet d'utiliser des comptes de service Kubernetes pour l'authentification, et de créer des configurations d'exécuteur avec libellé avec différentes images de base. Le plug-in crée un pod lorsqu'un exécuteur est requis et le détruit lorsqu'une tâche se termine.

  • Le plug-in Google Authenticated Source vous permet d'utiliser les identifiants de votre compte de service lorsque vous accédez à des services Cloud Platform tels que Cloud Source Repositories.

Pour ajouter des plug-ins supplémentaires à l'aide du graphique Helm, modifiez la liste des plug-ins du fichier de valeurs que vous transmettez aux commandes Helm install ou upgrade.

Personnaliser l'image Docker de l'agent Jenkins

Lors de la création d'un modèle de pod, vous pouvez soit fournir une image Docker existante, soit créer une image personnalisée sur laquelle la plupart de vos dépendances sont installées. L'utilisation d'une image personnalisée permet de réduire la durée de compilation globale et de créer des environnements de compilation plus cohérents.

Votre image Docker personnalisée doit installer et configurer l'agent entrant Jenkins JNLP. L'agent JNLP est un logiciel qui communique avec le contrôleur Jenkins pour coordonner l'exécution de vos tâches Jenkins et la création de rapports sur leur état.

Une option consiste à ajouter FROM jenkins/inbound-agent à la configuration de l'image. Par exemple, si le processus de build de votre application dépend de l'environnement d'exécution de Go, vous pouvez créer le Dockerfile suivant pour étendre l'image existante avec vos propres dépendances et générer des artefacts.

FROM jenkins/inbound-agent
RUN apt-get update && apt-get install -y golang

Ensuite, créez et importez l'image dans le dépôt Container Registry de votre projet en exécutant les commandes suivantes :

docker build -t gcr.io/[PROJECT]/my-jenkins-image .
gcloud auth configure-docker
docker push gcr.io/[PROJECT]/my-jenkins-image

Lors de la création d'un modèle de pod, vous pouvez désormais définir le champ Image Docker sur la chaîne suivante, en remplaçant [PROJECT] par le nom de votre projet et [IMAGE_NAME] par le nom de l'image.

gcr.io/[PROJECT]/[IMAGE_NAME]

L'exemple ci-dessus garantit que l'environnement d'exécution de langage Go est pré-installé lors du démarrage de votre tâche Jenkins.

Créer des images Docker dans Jenkins

Vous pouvez utiliser Cloud Build depuis vos tâches Jenkins pour créer des images Docker sans devoir héberger votre propre daemon Docker. Votre tâche Jenkins doit disposer d'identifiants de compte de service auxquels le rôle cloudbuild.builds.editor a été attribué.

Pour obtenir un exemple de fichier de pipeline Jenkins, consultez ce dépôt GitHub.

Les utilisateurs qui souhaitent créer des conteneurs dans leurs clusters peuvent également utiliser Kaniko. Il ne nécessite pas la présence d'un daemon Docker pour créer des images et les transférer vers un registre distant.

Pour obtenir un exemple d'utilisation de Kaniko dans Jenkins, consultez ce dépôt GitHub.

Étapes suivantes