En tant qu'administrateur ou développeur Code Stream, vous pouvez utiliser Code Stream 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.
Présentation du workflow de déploiement d'une application sur un cluster Kubernetes

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 sur AWS.

Workflow de publication d'une application sur un cluster 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 Code Stream 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 Code Stream et d'un hôte Docker, reportez-vous à :

Conditions préalables

  • Vérifiez que le code d'application à déployer se trouve 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 Code Stream, 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 Code Stream, 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.
    Point de terminaison Jenkins utilisé pour créer, tester et publier votre application sur un cluster Kubernetes.
  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.
    Point de terminaison Kubernetes utilisé pour déployer l'application sur un cluster Kubernetes.
  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 correspondante.
      Au cours de l'exécution du pipeline, l'ID de validation renvoyé par le déclencheur Git est affiché.
    Pipeline Kubernetes avec ensemble de propriétés d'entrée Git.
  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.
    Notifications par e-mail du pipeline et sélection d'un serveur de messagerie.
  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.
    Pipeline Kubernetes comportant les détails de la tâche de création d'une application.
  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 à Code Stream d'utiliser le déclencheur Git, qui déclenche votre pipeline lorsque les développeurs valident leur code.
    Webhook Git utilisé pour déclencher le pipeline Kubernetes.
  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 Code Stream, 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: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  ports:
    - port: 80
  selector:
    app: codestream
    tier: frontend
  type: LoadBalancer 
---
apiVersion: extensions/v1
kind: Deployment
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  selector:
    matchLabels:
      app: codestream
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: codestream
        tier: frontend
    spec:
      containers:
      - name: codestream
        image: cas.jfrog.io/codestream:${input.GIT_BRANCH_NAME}-${Dev.PublishApp.output.jobId}
        ports:
        - containerPort: 80
          name: codestream
      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 Code Stream à Jenkins, reportez-vous à la section Intégration de Code Stream à Jenkins.