Automatisation de la publication d'une application dans Automation Pipelines sur un cluster Kubernetes

En tant qu'administrateur ou développeur Automation Pipelines, vous pouvez utiliser Automation Pipelines et VMware Tanzu Kubernetes Grid Integrated Edition (anciennement VMware Enterprise PKS) pour automatiser le déploiement de vos applications logicielles sur un cluster Kubernetes. Ce cas d'utilisation mentionne d'autres méthodes que vous pouvez utiliser pour automatiser la version de votre application.

Dans ce cas d'utilisation, vous allez créer un pipeline comportant deux étapes, et utiliser Jenkins pour créer et déployer votre application.

• La première étape concerne le développement. Elle utilise Jenkins pour extraire votre code d'une branche de votre référentiel GitHub, puis pour le créer, le tester et le publier.
• La seconde étape concerne le déploiement. Elle exécute une tâche d'opération utilisateur qui nécessite l'approbation des utilisateurs clés pour que le pipeline puisse déployer votre application sur votre cluster Kubernetes.

Lors de l'utilisation d'un point de terminaison d'API Kubernetes dans l'espace de travail de pipeline, Automation Pipelines crée les ressources Kubernetes nécessaires, telles que ConfigMap, Secret et Pod, pour exécuter la tâche d'intégration continue (CI) ou la tâche personnalisée. Automation Pipelines communique avec le conteneur à l'aide du port de nœud.

Pour partager des données entre des exécutions de pipeline, vous devez fournir une réclamation de volume persistant, et Automation Pipelines montera la réclamation de volume persistant sur le conteneur pour stocker les données et l'utilisera pour les exécutions de pipeline suivantes.

L'espace de travail de pipeline Automation Pipelines prend en charge Docker et Kubernetes pour les tâches d'intégration continue et les tâches personnalisées.

Pour plus d'informations sur la configuration de l'espace de travail, consultez Configuration de l'espace de travail de pipeline.

Les outils de développement, les instances de déploiement et le fichier YAML du pipeline doivent être disponibles afin que votre pipeline puisse créer, tester, publier et déployer votre application. Le pipeline déploiera votre application sur des instances de développement et de production de clusters Kubernetes.

Autres méthodes qui automatisent la publication de votre application :

• Au lieu d'utiliser Jenkins pour créer votre application, vous pouvez utiliser la fonctionnalité de build native Automation Pipelines et un hôte de build Docker.
• Au lieu de déployer votre application sur un cluster Kubernetes, vous pouvez la déployer sur un cluster Amazon Web Services (AWS).

Pour plus d'informations sur l'utilisation de la fonctionnalité de build native Automation Pipelines et d'un hôte Docker, reportez-vous à :

• Planification d'une build native CICD dans Automation Pipelines avant d'utiliser le modèle de pipeline intelligent
• Planification d'une build native CICD dans Automation Pipelines avant d'ajouter des tâches manuellement

Conditions préalables

• Vérifiez que le code d'application à déployer réside dans un référentiel GitHub opérationnel.
• Vérifiez que vous disposez d'une instance opérationnelle de Jenkins.
• Assurez-vous que vous disposez d'un serveur de messagerie opérationnel.
• Dans Automation Pipelines, créez un point de terminaison de messagerie qui se connecte à votre serveur de messagerie.
• À des fins de développement et de production, configurez deux clusters Kubernetes sur Amazon Web Services (AWS) où votre pipeline déploiera votre application.
• Vérifiez que le référentiel GitHub contient le code YAML de votre pipeline ou un fichier YAML qui définit les métadonnées et les spécifications de votre environnement.

Procédure

1. Dans Automation Pipelines, cliquez sur Points de terminaison > Nouveau point de terminaison, puis créez un point de terminaison Jenkins pour l'utiliser dans votre pipeline afin d'extraire le code du référentiel GitHub.
   
2. Pour créer des points de terminaison Kubernetes, cliquez sur Nouveau point de terminaison.
   1. Créez un point de terminaison pour votre cluster Kubernetes de développement.
   2. Créez un point de terminaison pour votre cluster Kubernetes de production.
      L'URL de votre cluster Kubernetes peut ou non inclure un numéro de port.
      Par exemple :
      https://10.111.222.333:6443
      https://api.kubernetesserver.fa2c1d78-9f00-4e30-8268-4ab81862080d.k8s-user.com
   
3. Créez un pipeline qui déploie un conteneur de votre application, comme WordPress, sur votre cluster Kubernetes de développement, et définissez les propriétés d'entrée pour le pipeline.
   1. Pour permettre à votre pipeline de reconnaître une validation de code dans GitHub qui déclenchera le pipeline, dans le pipeline, cliquez sur l'onglet Entrée et sélectionnez Injection automatique des propriétés.
   2. Ajoutez la propriété nommée GIT_COMMIT_ID, puis cliquez sur l'étoile en regard de celle-ci.
      Au cours de l'exécution du pipeline, l'ID de validation renvoyé par le déclencheur Git est affiché.
   
4. Ajoutez des notifications pour envoyer un e-mail en cas de réussite ou d'échec du pipeline.
   1. Dans le pipeline, cliquez sur l'onglet Notifications, puis sur Ajouter.
   2. Pour ajouter une notification par e-mail à la fin de l'exécution du pipeline, sélectionnez E-mail et sélectionnez À l'achèvement. Ensuite, sélectionnez le serveur de messagerie, entrez les adresses e-mail, puis cliquez sur Enregistrer.
   3. Pour ajouter une autre notification par e-mail en cas d'échec du pipeline, sélectionnez En cas d'échec, puis cliquez sur Enregistrer.
   
5. Ajoutez une étape de développement à votre pipeline et ajoutez des tâches de création, de test et de publication de votre application. Ensuite, validez chaque tâche.
   1. Pour créer votre application, ajoutez une tâche Jenkins qui utilise le point de terminaison Jenkins et exécute une tâche de création à partir du serveur Jenkins. Ensuite, pour que le pipeline récupère votre code, entrez la branche Git comme suit : ${input.GIT_BRANCH_NAME}
   2. Pour tester votre application, ajoutez une tâche Jenkins qui utilise le point de terminaison Jenkins et exécute une tâche de test à partir du serveur Jenkins. Entrez ensuite la même branche Git.
   3. Pour publier votre application, ajoutez une tâche Jenkins qui utilise le point de terminaison Jenkins et exécute une tâche de publication à partir du serveur Jenkins. Entrez ensuite la même branche Git.
   
6. Ajoutez une étape de déploiement à votre pipeline. Ajoutez ensuite une tâche qui nécessite une approbation pour le déploiement de votre application, puis une autre tâche qui déploie l'application sur votre cluster Kubernetes. Ensuite, validez chaque tâche.
   1. Pour exiger une approbation sur le déploiement de votre application, ajoutez une tâche d'opération utilisateur, ajoutez des adresses e-mail pour les utilisateurs qui doivent l'approuver, puis entrez un message. Ensuite, activez Envoyer un e-mail.
   2. Pour déployer votre application, ajoutez une tâche Kubernetes. Ensuite, dans les propriétés de tâche Kubernetes, sélectionnez votre cluster Kubernetes de développement, sélectionnez l'action Créer et sélectionnez la source de charge utile Définition locale. Sélectionnez ensuite votre fichier YAML local.
7. Ajoutez un Webhook Git qui permet à Automation Pipelines d'utiliser le déclencheur Git, qui déclenche votre pipeline lorsque les développeurs valident leur code.
   
8. Pour tester votre pipeline, accédez à votre référentiel GitHub, mettez à jour le fichier YAML de votre application et validez la modification.
   1. Dans Automation Pipelines, vérifiez que la validation s'affiche.
   1. Cliquez sur Déclencheurs > Git > Activité.
   2. Recherchez le déclencheur de votre pipeline.
   3. Cliquez sur Tableaux de bord > Tableaux de bord du pipeline.
   4. Dans le tableau de bord de votre pipeline, recherchez le GIT_COMMIT_ID dans la dernière zone dans laquelle une modification a réussi.
9. Vérifiez votre code de pipeline et vérifiez que la modification s'affiche.

Résultats

Félicitations ! Vous avez automatisé le déploiement de votre application logicielle sur votre cluster Kubernetes.

Exemple : Exemple de pipeline YAML déployant une application sur un cluster Kubernetes

Pour le type de pipeline utilisé dans cet exemple, le fichier YAML ressemble au code suivant :

apiVersion: v1
kind: Namespace
metadata:
  name: ${input.GIT_BRANCH_NAME}
  namespace: ${input.GIT_BRANCH_NAME}
---  
apiVersion: v1
data:
  .dockercfg: eyJzeW1waG9ueS10YW5nby1iZXRhMi5qZnJvZy5pbyI6eyJ1c2VybmFtZSI6InRhbmdvLWJldGEyIiwicGFzc3dvcmQiOiJhRGstcmVOLW1UQi1IejciLCJlbWFpbCI6InRhbmdvLWJldGEyQHZtd2FyZS5jb20iLCJhdXRoIjoiZEdGdVoyOHRZbVYwWVRJNllVUnJMWEpsVGkxdFZFSXRTSG8zIn19
kind: Secret
metadata:
  name: jfrog
  namespace: ${input.GIT_BRANCH_NAME}
type: kubernetes.io/dockercfg
---   
apiVersion: v1
kind: Service
metadata:
  name: pipelines
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: pipelines
spec:
  ports:
    - port: 80
  selector:
    app: pipelines
    tier: frontend
  type: LoadBalancer 
---
apiVersion: extensions/v1
kind: Deployment
metadata:
  name: pipelines
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: pipelines
spec:
  selector:
    matchLabels:
      app: pipelines
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: pipelines
        tier: frontend
    spec:
      containers:
      - name: pipelines
        image: cas.jfrog.io/pipelines:${input.GIT_BRANCH_NAME}-${Dev.PublishApp.output.jobId}
        ports:
        - containerPort: 80
          name: pipelines
      imagePullSecrets:
      - name: jfrog
      

Que faire ensuite

Pour déployer votre application logicielle sur votre cluster Kubernetes de production, effectuez à nouveau la procédure et sélectionnez votre cluster de production.

Pour plus d'informations sur l'intégration de Automation Pipelines à Jenkins, reportez-vous à la section Intégration de Automation Pipelines à Jenkins.