Création d'une chaîne d'outils à partir d'un modèle avec Git Repos and Issue Tracking ou GitHub à l'aide de la console

Vous pouvez utiliser un modèle comme point de départ pour créer une chaîne d'outils incluant soit une intégration de l'outil Git Repos and Issue Tracking, soit celle de l'outil GitHub. Découvrez comment utiliser les modèles proposés par la méthode IBM Cloud ' Garage.

1. Connectez-vous à IBM Cloud.

2. Dans la console IBM Cloud, cliquez sur l' Menu > Automatisation de la plateforme > Chaînes d'outils.

3. Dans le tableau de bord DevOps, dans la page Chaînes d'outils, cliquez sur Créer une chaîne d'outils.

4. Sur la page Créer une chaîne d'outils, cliquez sur un modèle de chaîne d'outils.

5. Examinez le diagramme de la chaîne d'outils que vous être sur le point de créer. Ce diagramme montre chaque intégration d'outils dans sa phase de cycle de vie au sein de la chaîne d'outils.

6. Vérifiez les valeurs par défaut des paramètres de la chaîne d'outils :

   • Le nom de la chaîne d'outils l'identifie dans IBM Cloud. Si vous désirez utiliser un nom différent, modifiez le nom de la chaîne d'outils.
   • La région de création de la chaîne d'outils. Si vous souhaitez utiliser une région différente, sélectionnez-la dans la liste des régions disponibles.
   • Groupe de ressources pour la création de la chaîne d'outils dans. Si vous souhaitez utiliser un autre groupe de ressources, sélectionnez-le dans la liste des groupes de ressources disponibles.
   • Le fournisseur de votre référentiel source, tel que GitHub ou GitLab. Si vous voulez utiliser un fournisseur de source différent, sélectionnez-le dans la liste des référentiels disponibles.

7. Dans la section Intégrations d'outils, sélectionnez chaque intégration d'outils à configurer pour votre chaîne d'outils. Pour plus d'informations sur la configuration des intégrations d'outils, voir Configuration des intégrations d'outils.

8. Cliquez sur Créer. Plusieurs étapes s'exécutent automatiquement pour configurer votre chaîne d'outils. Les intégrations d'outils définies sont différentes selon le modèle de chaîne d'outils que vous avez sélectionné. Par exemple, lorsque vous créez une chaîne d'outils Microservices sur IBM Cloud Public, les étapes suivantes sont exécutées :

   • La chaîne d'outils est créée.
   • Si vous avez configuré Delivery Pipeline, les pipelines sont créés et déclenchés.
   • Si vous avez configuré Sauce Labs, la chaîne d'outils est configurée pour ajouter des travaux de test Sauce Labs aux pipelines.
   • Si vous avez configuré l' Event Notifications, la chaîne d'outils est configurée pour envoyer des notifications d'événements au service Event Notifications que vous avez spécifié.
   • Si vous avez configuré PagerDuty, la chaîne d'outils est configurée pour envoyer des notifications d'alerte au service PagerDuty que vous avez indiqué.
   • Si vous avez configuré Slack, la chaîne d'outils est configurée pour envoyer au canal Slack que vous avez spécifié des notifications sur le statut de déploiement.
   • Si vous avez configuré une intégration d'outils de code source, comme GitHub, le référentiel exemple GitHub est cloné dans votre compte GitHub.

   Vous pouvez désormais distribuer des notifications d'événements en utilisant l'intégration de l'outil Event NotificationsIBM Cloud Event Notifications est la méthode préférée pour distribuer des notifications à PagerDuty et à d'autres canaux de communication tels que Slack, email, SMS, notifications push, webhook, Microsoft® Teams, ServiceNow, et IBM Cloud Functions. Pour plus d'informations sur l'utilisation de Event Notifications, voir Activation des notifications d'événements pour les chaînes d'outils.

Création d'une chaîne d'outils à partir d'un modèle avec Git Repos and Issue Tracking ou GitHub avec l'API

Vous pouvez créer une chaîne d'outils à partir d'un modèle uniquement à l'aide de la console. Pour afficher les étapes d'utilisation de la console, passez aux instructions de l'interface utilisateur.

Pour plus d'informations sur la création d'une chaîne d'outils avec l'API au lieu d'utiliser un modèle, voir Ajout de l'intégration d'outils Git à une chaîne d'outils existante avec l'API.

Création d'une chaîne d'outils à partir d'un modèle avec Git Repos and Issue Tracking ou GitHub avec Terraform

Vous pouvez créer une chaîne d'outils à partir d'un modèle uniquement à l'aide de la console. Pour afficher les étapes d'utilisation de la console, passez aux instructions de l'interface utilisateur.

Pour plus d'informations sur la création d'une chaîne d'outils avec Terraform au lieu d'utiliser un modèle, voir Ajout de l'intégration d'outils Git à une chaîne d'outils existante avec Terraform.

Ajout de l'intégration d'outils Git à une chaîne d'outils existante à l'aide de la console

Vous pouvez ajouter une intégration d'outils Git à n'importe quelle chaîne d'outils existante à l'aide de la console.

1. Connectez-vous à IBM Cloud.
2. Dans la console d' IBM Cloud, cliquez sur l'icône de menu ( ) et sélectionnez Liste des ressources.
3. Dans la liste des ressources, développez la section Developer tools.
4. Cliquez sur une chaîne d'outils à laquelle vous souhaitez ajouter une intégration d'outils Git ou créez une chaîne d'outils. Pour plus d'informations sur la création de chaînes d'outils, voir Création de chaînes d'outils.
5. Sur la page Présentation de la chaîne d'outils, cliquez sur Ajouter un outil, puis sélectionnez GitHub ou Git Repos and Issue Tracking pour ajouter l'une ou l'autre de ces intégrations d'outils à votre chaîne d'outils.
6. Selon l'intégration d'outils Git que vous sélectionnez, vous pouvez configurer l'intégration d'outils GitHub ou vous pouvez configurer l'intégration d'outils Git Repos and Issue Tracking.

Ajout de l'intégration d'outils Git à une chaîne d'outils existante à l'aide de l'API

Vous pouvez ajouter une intégration d'outils Git à n'importe quelle chaîne d'outils existante à l'aide de l'API.

1. Obtenez un jeton bearer IAM. Sinon, si vous utilisez un SDK, obtenez une clé d'API IAM et définissez les options client à l'aide de variables d'environnement.

   export CD_TOOLCHAIN_AUTH_TYPE=iam && \
   export CD_TOOLCHAIN_APIKEY={iam_api_key} && \
   export CD_TOOLCHAIN_URL=https://api.{region}.devops.cloud.ibm.com/toolchain/v2
   

2. Déterminez la région et l'ID de la chaîne d'outils à laquelle vous souhaitez ajouter l'intégration d'outils Git.

3. Ajoutez l'intégration de l'outil Git à la chaîne d'outils. L'exemple suivant montre comment ajouter une intégration d'outils Git qui est liée à un référentiel existant sur github.com. Vous pouvez également ajouter une intégration d'outil Git avec des instructions pour créer, dévier ou cloner un nouveau référentiel. Vous pouvez également ajouter des outils d'intégration pour d'autres serveurs GitHub, GitLab, ou Bitbucket.

   curl -X POST \
     https://api.{region}.devops.cloud.ibm.com/toolchain/v2/toolchains/{toolchain_id}/tools \
     -H 'Authorization: Bearer {token}' \
     -H 'Accept: application/json` \
     -H 'Content-Type: application/json' \
       -d '{
       "tool_type_id": "githubconsolidated",
       "name": "{tool_integration_name}",
       "parameters": {
         "type": "link",
         "git_id": "github",
         "repo_url": "https://github.com/{git_org}/{git-repo}.git",
         "has_issues": true
       }
     }'
   

   const CdToolchainV2 = require('@ibm-cloud/continuous-delivery/cd-toolchain/v2');
   const toolchainService = CdToolchainV2.newInstance();
   ...
   (async() => {
      const gitToolModel = {
         toolchainId: {toolchain_id},
         toolTypeId: 'githubconsolidated',
         name: {tool_integration_name},
         parameters: {
            type: 'link',
            git_id: 'github',
            repo_url: 'https://github.com/{git_org}/{git-repo}.git',
            has_issues: true,
         }
      };
      const gitTool = await toolchainService.createTool(gitToolModel);
   })();
   

   import (
   	   "github.com/IBM/continuous-delivery-go-sdk/cdtoolchainv2"
   )
   ...
   toolchainClientOptions := &cdtoolchainv2.CdToolchainV2Options{}
   toolchainClient, err := cdtoolchainv2.NewCdToolchainV2UsingExternalConfig(toolchainClientOptions)
   createGitToolOptions := toolchainClient.NewCreateToolOptions({toolchain_id}, "githubconsolidated")
   gitParameters := map[string]interface{}{
    "type": "link",
    "git_id": "github",
    "repo_url": "https://github.com/{git_org}/{git-repo}.git",
    "has_issues": true,
   }
   createGitToolOptions.SetName({tool_integration_name})
   createGitToolOptions.SetParameters(gitParameters)
   gitTool, response, err := toolchainClient.CreateTool(createGitToolOptions)
   

   from ibm_continuous_delivery.cd_toolchain_v2 import CdToolchainV2
   ...
   toolchain_service = CdToolchainV2.new_instance()
   git_parameters = {
      "type": "link",
      "git_id": "github",
      "repo_url": "https://github.com/{git_org}/{git-repo}.git",
      "has_issues": True
   }
   git_tool = toolchain_service.create_tool(
      name = {tool_integration_ame},
      toolchain_id = {toolchain_id},
      tool_type_id = "githubconsolidated",
      parameters = git_parameters
   )
   

   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.CdToolchain;
   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.model.*;
   ...
   CdToolchain toolchainService = CdToolchain.newInstance();
   HashMap<String, Object> gitParameters = new HashMap<>();
   gitParameters.put("type", "link");
   gitParameters.put("git_id", "github");
   gitParameters.put("repo_url", "https://github.com/{git_org}/{git-repo}.git");
   gitParameters.put("has_issues", true);
   CreateToolOptions createGitToolOptions = new CreateToolOptions.Builder()
      .name({tool_integration_name})
      .parameters(gitParameters)
      .toolchainId({toolchain_id})
      .toolTypeId("githubconsolidated")
      .build();
   Response<ToolchainToolPost> response = toolchainService.createTool(createGitToolOptions).execute();
   ToolchainToolPost gitTool = response.getResult();
   

Le tableau suivant répertorie et décrit chacune des variables utilisées dans les étapes précédentes.

Pour plus d'informations sur chacune des intégrations d'outils Git, y compris sur les paramètres supplémentaires que vous pouvez configurer, voir les rubriques suivantes:

• Configuration de Bitbucket
• Configuration de GitHub
• Configuration de Git Repos and Issue Tracking
• Configuration de GitLab

Ajout de l'intégration d'outils Git à une chaîne d'outils existante avec Terraform

Vous pouvez ajouter une intégration d'outil Git à n'importe quelle chaîne d'outils existante avec Terraform.

1. Pour installer l'interface de ligne de commande de Terraform et configurer le plug-in IBM Cloud Provider pour Terraform, suivez le tutoriel d'initiation à Terraform sur IBM Cloud.

2. Localisez le fichier Terraform (par exemple, main.tf) qui contient le bloc de ressources de la chaîne d'outils à laquelle vous souhaitez ajouter l'intégration d'outils Git. Dans ce fichier, ajoutez la configuration pour créer l'intégration d'outils.

   L'exemple suivant crée la chaîne d'outils si elle n'existe pas, puis ajoute une intégration d'outils Git qui se lie à un référentiel existant sur github.com à l'aide de la ressource ibm_cd_toolchain_tool_githubconsolidated. Vous pouvez également ajouter une intégration d'outil Git avec des instructions pour créer, dévier ou cloner un nouveau référentiel. Vous pouvez également ajouter des outils d'intégration pour d'autres serveurs GitHub, GitLab, ou Bitbucket.

   data "ibm_resource_group" "group" {
     name = "default"
   }
   resource "ibm_cd_toolchain" "cd_toolchain" {
     name              = "my toolchain"
     resource_group_id = data.ibm_resource_group.group.id
   }
   resource "ibm_cd_toolchain_tool_githubconsolidated" "my-github-tool-integration" {
     toolchain_id = ibm_cd_toolchain.cd_toolchain.id
     initialization {
       git_id = "github"
       repo_url = "https://github.com/my-org/my-repo.git"
       type = "link"
       auth_type = "pat"
       api_token = "<TOKEN>"
     }
     parameters {
       has_issues = true
     }
   }
   

   Où <TOKEN> représente un jeton d'accès personnel (PAT) qui appartient au compte GitHub qui accorde l'accès au référentiel cible.

3. Initialisez l'interface de ligne de commande de Terraform.

   terraform init
   

4. Créez un plan d'exécution Terraform. Ce plan récapitule toutes les actions à exécuter pour ajouter l'intégration d'outils DevOps Insights à la chaîne d'outils.

   terraform plan
   

5. Appliquer le plan d'exécution Terraform. Terraform effectue toutes les actions requises pour ajouter l'intégration d'outils DevOps Insights à la chaîne d'outils.

   terraform apply
   

Pour plus d'informations sur chacune des ressources d'intégration d'outil Git, y compris les paramètres supplémentaires que vous pouvez configurer, voir les détails de référence des arguments dans la documentation du registre Terraform:

• Bitbucket : ibm_cd_toolchain_tool_bitbucketgit
• GitHub: ibm_cd_toolchain_tool_githubconsolidated
• Git Repos and Issue Tracking: ibm_cd_toolchain_tool_hostedgit
• GitLab: ibm_cd_toolchain_tool_gitlab

Pour plus d'informations sur l'utilisation de Terraform avec Continuous Delivery, voir Configuration de Terraform pour Continuous Delivery.