Connexion à Event Notifications dans la console

Configurez Event Notifications pour envoyer des événements critiques à partir des chaînes d'outils et des instances d'intégration d'outils:

1. Si vous disposez d’une chaîne d’outils et que vous souhaitez y ajouter l’intégration de cet outil, dans la console d’ IBM Cloud, cliquez sur l’icône de menu ( > Automatisation de la plateforme > Chaînes d’outils. Sur la page Chaînes d'outils, cliquez sur la chaîne d'outils afin d'ouvrir sa page Vue d'ensemble.

   a. Cliquez sur Ajouter un outil.

   b. Dans la section Intégrations d'outils, cliquez sur Event Notifications.

2. Entrez le nom que vous souhaitez afficher pour cette intégration d'outils sur la carte Event Notifications de votre chaîne d'outils. Ce nom est utilisé pour identifier l'intégration d'outils dans votre chaîne d'outils.

3. Sélectionnez l'instance Event Notifications à laquelle connecter la chaîne d'outils.

4. Cliquez sur Créer une intégration pour ajouter l'intégration de l'outil Event Notifications à votre chaîne d'outils.

5. Sur la page Vue d'ensemble de votre chaîne d'outils, sur la carte des outils IBM Cloud, cliquez sur Event Notifications.

Connexion à Event Notifications avec l'API

Vous pouvez ajouter l'intégration d'outils Event Notifications à votre chaîne d'outils à 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={base_url}
   

2. Recherchez l'ID de la chaîne d'outils dans laquelle vous souhaitez créer votre intégration d'outils.

3. Spécifiez eventnotifications comme tool_type_id.

4. Spécifiez les tool_parameters suivants qui sont requis par l'intégration d'outils:

   • name: nom utilisé pour identifier l'intégration d'outils Event Notifications.
   • instance-crn: nom de ressource de cloud (CRN) de l'instance de service Event Notifications.

5. Ajouter l'intégration de l'outil au sein de la chaîne d'outils ciblée.

   curl -X POST --location --header "Authorization: Bearer {iam_token}" \
     --header "Accept: application/json" \
     --header "Content-Type: application/json" \
     --data '{ "name": "{tool_name}", "tool_type_id": "eventnotifications", "parameters": { "name": {event_notifications_tool_integration_name}, "instance-crn": {event_notifications_service_crn} } }' \
     "{base_url}/toolchains/{toolchain_id}/tools"
   

   const CdToolchainV2 = require('@ibm-cloud/continuous-delivery/cd-toolchain/v2');
   const toolchainService = CdToolchainV2.newInstance();
   ...
   (async() => {
      const toolParameters = {
         "name": {event_notifications_tool_integration_name},
         "instance-crn": {event_notifications_service_crn}
      }
      const toolPrototypeModel = {
         toolchainId: {toolchain_id},
         toolTypeId: "eventnotifications",
         name: {tool_name},
         parameters: toolParameters
      };
      const response = await toolchainService.createTool(toolPrototypeModel);
   })();
   

   import (
   	   "github.com/IBM/continuous-delivery-go-sdk/cdtoolchainv2"
   )
   ...
   toolchainClientOptions := &cdtoolchainv2.CdToolchainV2Options{}
   toolchainClient, err := cdtoolchainv2.NewCdToolchainV2UsingExternalConfig(toolchainClientOptions)
   toolParameters := map[string]interface{}{
      "name": {event_notifications_tool_integration_name},
      "instance-crn": {event_notifications_service_crn},
   }
   createToolOptions := toolchainClient.NewCreateToolOptions({toolchain_id}, "eventnotifications")
   createToolOptions.SetName({tool_name})
   createToolOptions.SetParameters(toolParameters)
   tool, response, err := toolchainClient.CreateTool(createToolOptions)
   

   from ibm_continuous_delivery.cd_toolchain_v2 import CdToolchainV2
   ...
   toolchain_service = CdToolchainV2.new_instance()
   tool_parameters = {}
   tool_parameters["name"] = {event_notifications_tool_integration_name}
   tool_parameters["instance-crn"] = {event_notifications_service_crn}
   tool = toolchain_service.create_tool(
      name = {tool_name},
      toolchain_id = {toolchain_id},
      tool_type_id = "eventnotifications",
      parameters = tool_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> toolParameters = new HashMap<>();
   toolParameters.put("name", {event_notifications_tool_integration_name});
   toolParameters.put("instance-crn", {event_notifications_service_crn});
   CreateToolOptions createToolOptions = new CreateToolOptions.Builder()
      .name({tool_name})
      .parameters(toolParameters)
      .toolchainId({toolchain_id})
      .toolTypeId("eventnotifications")
      .build();
   Response<ToolchainToolPost> response = toolchainService.createTool(createToolOptions).execute();
   ToolchainToolPost tool = response.getResult();
   

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

Ajout d'une intégration d'outils à Terraform

Vous pouvez ajouter l'intégration d'outils Event Notifications à votre chaîne d'outils à l'aide de Terraform.

IBM Cloud La version Terraform 1.53.0 provider ou ultérieure est requise pour ajouter une intégration d'outil à l'aide de Terraform.

1. Pour installer l'interface de ligne de commande (CLI) de Terraform et configurer le plug-in du fournisseur IBM Cloud pour Terraform, suivez le tutoriel Premiers pas avec Terraform disponible sur IBM Cloud®.

2. Créez un fichier de configuration Terraform nommé main.tf. Dans ce fichier, ajoutez la configuration permettant de créer des instances de ressources à l'aide du langage de configuration HashiCorp (HCL). Pour plus d'informations sur l'utilisation de ce langage de configuration, voir la documentation Terraform.

   L'exemple suivant crée une intégration d'outils Delivery Pipeline en utilisant la ressource ibm_cd_toolchain_tool_pipeline, où toolchain_id est un identificateur global unique qui représente la chaîne d'outils dans laquelle créer l'intégration d'outils.

   data "ibm_cd_toolchain" "cd_toolchain" {
     toolchain_id = {toolchain_id}
   }
   resource "ibm_cd_toolchain_tool_eventnotifications" "en_instance" {
     toolchain_id = data.ibm_cd_toolchain.cd_toolchain.id
     parameters {
       name = "{event_notifications_tool_integration_name}"
       instance_crn = "{event_notifications_service_crn}"
     }
   }
   

   Pour plus d'informations sur les ressources d'intégration d'outils, voir la liste complète des ressources d'intégration d'outils prises en charge dans le Registre Terraform IBM Cloud.

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 les actions à exécuter pour créer l'intégration d'outils.

   terraform plan
   

5. Appliquer le plan d’exécution Terraform. Terraform effectue les actions requises pour créer l'intégration d'outils.

   terraform apply
   

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