Utilisation du déclencheur Docker dans Code Stream pour exécuter un pipeline de livraison continue

En tant qu'administrateur ou développeur de Code Stream, vous pouvez utiliser le déclencheur Docker dans Code Stream. Le déclencheur Docker exécute un pipeline de livraison continue (CD) autonome lors de la création ou de la mise à jour d'un artefact de build. Le déclencheur Docker exécute votre pipeline de livraison continue, qui transfère le nouvel artefact ou l'artefact mis à jour en tant qu'image de conteneur vers un référentiel Docker Hub. Le pipeline de livraison continue peut s'exécuter dans le cadre de vos builds automatisées.

Par exemple, pour déployer continuellement votre image de conteneur mise à jour dans votre pipeline de livraison continue, utilisez le déclencheur Docker. Lorsque votre image de conteneur est archivée dans le registre Docker, le Webhook du Docker Hub informe Code Stream que l'image a changé. Cette notification déclenche l'exécution du pipeline de livraison continue avec l'image de conteneur mise à jour et télécharge l'image vers le référentiel Docker Hub.

Pour utiliser le déclencheur Docker, vous effectuez plusieurs étapes dans Code Stream.

Tableau 1. Utilisation du déclencheur Docker
Actions...	Plus d'informations sur cette action…
Créez un point de terminaison de registre Docker.	Pour que Code Stream déclenche votre pipeline, vous devez disposer d'un point de terminaison de registre Docker. Si le point de terminaison n'existe pas, vous pouvez sélectionner une option qui le crée lorsque vous ajoutez le Webhook pour le déclencheur Docker. Le point de terminaison du registre Docker inclut l'URL vers le référentiel Docker Hub.
Ajoutez des paramètres d'entrée au pipeline qui injecte automatiquement des paramètres Docker lors de son exécution.	Vous pouvez injecter automatiquement des paramètres Docker dans le pipeline. Ces paramètres peuvent inclure le nom du propriétaire de l'événement Docker, l'image, le nom du référentiel, l'espace de noms du référentiel et la balise. Dans votre pipeline de livraison continue, vous incluez les paramètres d'entrée que le Webhook Docker transmet au pipeline avant que le pipeline ne se déclenche.
Créez un Webhook Docker.	Lorsque vous créez le Webhook Docker dans Code Stream, cette action déclenche également la création d'un Webhook correspondant dans Docker Hub. Le Webhook Docker dans Code Stream se connecte à Docker Hub via l'URL que vous incluez dans le Webhook. Les Webhooks communiquent entre eux et déclenchent le pipeline lorsqu'un artefact est créé ou mis à jour dans Docker Hub. Si vous mettez à jour ou supprimez le Webhook Docker dans Code Stream, le Webhook de Docker Hub est également mis à jour ou supprimé.
Ajoutez et configurez une tâche Kubernetes dans votre pipeline.	Lorsqu'un artefact est créé ou mis à jour dans le référentiel Docker Hub, le pipeline se déclenche. Ensuite, il déploie l'artefact via le pipeline sur l'hôte Docker de votre cluster Kubernetes.
Incluez une définition YAML locale dans la tâche.	La définition YAML que vous appliquez à la tâche de déploiement inclut l'image de conteneur Docker. Si vous devez télécharger une image à partir d'un référentiel privé, le fichier YAML doit inclure une section avec le secret de configuration Docker. Reportez-vous à la partie CD de la section Planification d'une build native CICD dans Code Stream avant d'utiliser le modèle de pipeline intelligent.

Lorsqu'un artefact est créé ou mis à jour dans le référentiel Docker Hub, le Webhook de Docker Hub en informe le Webhook dans Code Stream, qui déclenche le pipeline. Les actions suivantes se produisent :

Docker Hub envoie une demande POST à l'URL du Webhook.
Code Stream exécute le déclencheur Docker.
Le déclencheur Docker démarre votre pipeline de livraison continue.
Le pipeline de livraison continue transfère l'artefact vers le référentiel Docker Hub.
Code Stream déclenche son Webhook Docker, qui exécute un pipeline de livraison continue qui déploie l'artefact sur votre hôte Docker.

Dans cet exemple, vous créez un point de terminaison Docker et un Webhook Docker dans Code Stream qui déploie votre application sur votre cluster Kubernetes de développement. Les étapes incluent l'exemple de code de la charge utile que Docker publie sur l'URL du Webhook, le code d'API qu'il utilise et le code d'authentification avec le jeton sécurisé.

Conditions préalables

Vérifiez qu'un pipeline de livraison continue (CD) existe dans votre instance de Code Stream. Vérifiez également qu'il inclut une ou plusieurs tâches Kubernetes qui déploient votre application. Reportez-vous à la section Planification de la génération, de l'intégration et de la livraison de votre code en mode natif dans Code Stream.
Vérifiez que vous pouvez accéder à un cluster Kubernetes existant sur lequel votre pipeline de livraison continue peut déployer votre application à des fins de développement.
Assurez-vous d'être membre d'un projet dans Code Stream. Si ce n'est pas le cas, demandez à un administrateur de Code Stream de vous ajouter en tant que membre d'un projet. Reportez-vous à la section Ajout d'un projet dans Code Stream.

Procédure

Créez un point de terminaison de registre Docker.
1. Cliquez sur Points de terminaison.
2. Cliquez sur Nouveau point de terminaison.
3. Commencez à saisir le nom du projet existant.
4. Sélectionnez le type de registre Docker.
5. Entrez un nom pertinent.
6. Sélectionnez le type de serveur DockerHub.
7. Entrez l'URL du référentiel Docker Hub.
8. Entrez le nom et le mot de passe utilisés pour accéder au référentiel.
Dans votre pipeline de livraison continue, définissez les propriétés d'entrée pour injecter automatiquement les paramètres Docker lors de l'exécution du pipeline.
Créez un Webhook Docker.
1. Cliquez sur Déclencheurs > Docker.
2. Cliquez sur Nouveau Webhook pour Docker.
3. Sélectionnez un projet.
4. Entrez un nom pertinent.
5. Sélectionnez votre point de terminaison de registre Docker.
  Si le point de terminaison n'existe pas encore, cliquez sur Créer un point de terminaison et créez-le.
6. Sélectionnez le pipeline dans lequel des paramètres Docker sont injectés et que le Webhook doit déclencher. Reportez-vous à la section Étape 2.
  Si le pipeline a été configuré avec des paramètres d'entrée personnalisés supplémentaires, la liste des paramètres d'entrée affiche les paramètres et les valeurs. Vous pouvez saisir des valeurs pour les paramètres d'entrée qui seront transmis au pipeline avec l'événement déclencheur. Sinon, vous pouvez laisser les valeurs vides ou utiliser les valeurs par défaut, si elles sont définies.
  Pour plus d'informations sur les paramètres de l'onglet Entrée, reportez-vous à la section Planification d'une build native CICD dans Code Stream avant d'ajouter des tâches manuellement.
7. Entrez le jeton de l'API.
  Le jeton d'API VMware Cloud Services vous authentifie pour les connexions d'API externes avec Code Stream. Pour obtenir le jeton d'API :
  1. Cliquez sur Générer le jeton.
  2. Entrez l'adresse e-mail associée à votre nom d'utilisateur et votre mot de passe, puis cliquez sur Générer.
    Le jeton généré est valide pendant six mois. Il est également appelé jeton d'actualisation.
    
    Pour conserver le jeton sous forme de variable pour une utilisation ultérieure, cliquez sur Créer une variable, entrez un nom pour la variable et cliquez sur Enregistrer.
    
    Pour conserver le jeton sous forme de valeur de texte pour une utilisation ultérieure, cliquez sur Copier et collez le jeton dans un fichier texte pour l'enregistrer localement.
    
    Vous pouvez choisir à la fois de créer une variable et de stocker le jeton dans un fichier texte pour une utilisation ultérieure.
  3. Cliquez sur Fermer.
8. Entrez l'image de la build.
9. Entrez une balise.
10. Cliquez sur Enregistrer.
  La fiche du Webhook s'affiche avec le Webhook Docker activé. Si vous souhaitez effectuer un transfert factice vers le référentiel Docker Hub sans déclencher le Webhook Docker ni exécuter de pipeline, cliquez sur Désactiver.

Dans votre pipeline de livraison continue, configurez votre tâche de déploiement Kubernetes.

Dans les propriétés de la tâche Kubernetes, sélectionnez votre cluster Kubernetes de développement.
Sélectionnez l'action Créer.
Sélectionnez la définition locale correspondant à la source de la charge utile.

Sélectionnez ensuite votre fichier YAML local.

Par exemple, Docker Hub peut publier cette définition YAML locale en tant que charge utile sur l'URL du Webhook :

{
"callback_url": "https://registry.hub.docker.com/u/svendowideit/testhook/hook/2141b5bi5i5b02bec211i4eeih0242eg11000a/",
"push_data": {
"images": [
"27d47432a69bca5f2700e4dff7de0388ed65f9d3fb1ec645e2bc24c223dc1cc3",
"51a9c7c1f8bb2fa19bcd09789a34e63f35abb80044bc10196e304f6634cc582c",
"..."
],
"pushed_at": 1.417566161e+09,
"pusher": "trustedbuilder",
"tag": "latest"
},
"repository": {
"comment_count": 0,
"date_created": 1.417494799e+09,
"description": "",
"dockerfile": "#\n# BUILD\u0009\u0009docker build -t svendowideit/apt-cacher .\n# RUN\u0009\u0009docker run -d -p 3142:3142 -name apt-cacher-run apt-cacher\n#\n# and then you can run containers with:\n# \u0009\u0009docker run -t -i -rm -e http_proxy http://192.168.1.2:3142/ debian bash\n#\nFROM\u0009\u0009ubuntu\n\n\nVOLUME\u0009\u0009[\/var/cache/apt-cacher-ng\]\nRUN\u0009\u0009apt-get update ; apt-get install -yq apt-cacher-ng\n\nEXPOSE \u0009\u00093142\nCMD\u0009\u0009chmod 777 /var/cache/apt-cacher-ng ; /etc/init.d/apt-cacher-ng start ; tail -f /var/log/apt-cacher-ng/*\n",
"full_description": "Docker Hub based automated build from a GitHub repo",
"is_official": false,
"is_private": true,
"is_trusted": true,
"name": "testhook",
"namespace": "svendowideit",
"owner": "svendowideit",
"repo_name": "svendowideit/testhook",
"repo_url": "https://registry.hub.docker.com/u/svendowideit/testhook/",
"star_count": 0,
"status": "Active"
}
}

L'API qui crée le Webhook dans Docker Hub utilise ce formulaire : https://cloud.docker.com/v2/repositories/%3CUSERNAME%3E/%3CREPOSITORY%3E/webhook_pipeline/

Le corps du code JSON ressemble à ce qui suit :

{
"name": "demo_webhook",
"webhooks": [
{
"name": "demo_webhook",
"hook_url": "http://www.google.com"
}
]
}

Pour recevoir des événements du serveur Docker Hub, le schéma d'authentification correspondant au Webhook Docker que vous créez dans Code Stream utilise un mécanisme d'authentification sur liste autorisée avec un jeton de chaîne aléatoire pour le Webhook. Il filtre les événements en fonction du jeton sécurisé, que vous pouvez ajouter à hook_url.

Code Stream peut vérifier toutes les demandes du serveur Docker Hub en utilisant le jeton sécurisé configuré. Par exemple : hook_url = IP:Port/pipelines/api/docker-hub-webhooks?secureToken = ""

Créez un artefact Docker dans votre référentiel Docker Hub. Sinon, mettez à jour un artefact existant.
Pour vous assurer que le déclencheur est intervenu et afficher l'activité sur le Webhook Docker, cliquez sur Déclencheurs > Docker > Activité.
Cliquez sur Exécutions et suivez la progression de votre pipeline au fil de son exécution.
Cliquez sur l'étape d'exécution et affichez les tâches au cours de l'exécution du pipeline.

Résultats

Félicitations ! Vous avez configuré le déclencheur Docker afin qu'il exécute continuellement votre pipeline de livraison continue. Votre pipeline peut désormais télécharger des artefacts Docker nouveaux et mis à jour vers le référentiel Docker Hub.

Que faire ensuite

Vérifiez que votre nouvel artefact ou votre artefact mis à jour est déployé sur l'hôte Docker dans votre cluster Kubernetes de développement.