En tant qu'administrateur ou développeur DevOps, vous pouvez utiliser le déclencheur Docker dans les services cloud de 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 et toute clé secrète requise pour extraire l'image du référentiel à des fins de déploiement.

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 :

  1. Docker Hub envoie une demande POST à l'URL du Webhook.
  2. Code Stream exécute le déclencheur Docker.
  3. Le déclencheur Docker démarre votre pipeline de livraison continue.
  4. Le pipeline de livraison continue transfère l'artefact vers le référentiel Docker Hub.
  5. 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

Procédure

  1. Créez un point de terminaison de registre Docker.
    1. Cliquez sur Points de terminaison.
    2. Cliquez sur Nouveau point de terminaison.
    3. Entrez un nom pertinent.
    4. Si le point de terminaison du registre Docker est sur site, sélectionnez le proxy cloud. Si le point de terminaison est basé sur le cloud, conservez le paramètre Par défaut.
    5. Sélectionnez le type de serveur Docker Hub.
    6. Entrez l'URL du référentiel Docker Hub.
    7. Entrez le nom et le mot de passe utilisés pour accéder au référentiel.
    Créer un point de terminaison de registre Docker.
  2. 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.
    Injecter automatiquement les paramètres Docker dans le pipeline.
  3. 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 CSP vous authentifie pour les connexions d'API externes avec Code Stream. Pour obtenir le jeton d'API :
      1. Connectez-vous à vRealize Automation Cloud.
      2. Cliquez sur la flèche vers le bas en regard de votre nom.
      3. Cliquez sur Mon compte.
      4. Cliquez sur Jetons d'API.
      5. Cliquez sur Générer un nouveau jeton d'API.
        1. Entrez le nom du jeton.
        2. Sous Rôles de l'organisation, sélectionnez Propriétaire de l'organisation.
        3. Sous Rôles de service, cliquez pour développer VMware Code Stream et sélectionnez Administrateur de Code Stream.
        4. Cliquez sur Générer.

          La fenêtre Jeton généré affiche un jeton avec le nom que vous avez spécifié et le nom de votre organisation.

      6. Cliquez sur l'icône COPIER.

        Cliquer sur COPIER garantit que vous capturez la chaîne exacte et qu'elle est plus fiable que l'utilisation de votre pointeur pour la copier.

    8. Entrez l'image de la build.
    9. Entrez une balise.
      Créer un Webhook pour le déclencheur Docker.
    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.
  4. Dans votre pipeline de livraison continue, configurez votre tâche de déploiement Kubernetes.
    1. Dans les propriétés de la tâche Kubernetes, sélectionnez votre cluster Kubernetes de développement.
    2. Sélectionnez l'action Créer.
    3. Sélectionnez la définition locale correspondant à la source de la charge utile.
    4. 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 = ""
  5. Créez un artefact Docker dans votre référentiel Docker Hub. Sinon, mettez à jour un artefact existant.
  6. Pour vous assurer que le déclencheur est intervenu et afficher l'activité sur le Webhook Docker, cliquez sur Déclencheurs > Docker > Activité.
    Afficher l'activité du Webhook Docker.
  7. Cliquez sur Exécutions et suivez la progression de votre pipeline au fil de son exécution.
    Surveiller le pipeline déclenché pendant son exécution.
  8. Cliquez sur l'étape d'exécution et affichez les tâches au cours de l'exécution du pipeline.
    Afficher les tâches dans le pipeline au cours de son exécution.

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.