Creazione di un Delivery Pipeline per Tekton utilizzando la console

Quando configuri un'integrazione dello strumento Delivery Pipeline, puoi selezionare il tipo di pipeline che vuoi creare.

1. Se non si dispone di una catena di strumenti, selezionare un modello per creare una catena di strumenti. A seconda del template che utilizzi, possono essere disponibili diversi campi. Rivedi i valori di campo predefiniti e se necessario, modifica queste impostazioni.

2. Se si dispone di una catena di strumenti e vi si sta aggiungendo questa integrazione di strumenti, dalla console IBM Cloud, fare clic sull'icona Menu Platform Automation > Toolchains. Nella pagina Toolchain, fare clic sulla toolchain per aprire la relativa pagina Panoramica. In alternativa, nella pagina della panoramica della tua applicazione, nella scheda di fornitura continua, fai clic su View toolchain. Fai quindi clic su Overview.

3. Aggiungi l'integrazione della pipeline di fornitura alla tua toolchain:

   a. Fai clic su Add tool.

   b. Nella sezione Integrazioni strumento, fai clic su Delivery Pipeline.

4. Specifica un nome per la tua nuova pipeline.

5. Seleziona Tekton per creare una Delivery Pipeline Tekton. È possibile visualizzare l'output delle esecuzioni della pipeline Tekton su un cluster Kubernetes definito, con il supporto per la configurazione dei repository delle definizioni della pipeline, dei trigger della pipeline, del luogo di esecuzione della pipeline e di semplici segreti.

6. Se hai intenzione di utilizzare la tua pipeline per distribuire un'interfaccia utente, seleziona la casella di spunta Mostra applicazioni nel menu Visualizza applicazioni. Tutte le applicazioni create dalla tua pipeline vengono visualizzate nell'elenco Visualizza applicazione nella pagina di panoramica della toolchain.

7. Fai clic su Create Integration per aggiungere la Delivery Pipeline alla tua toolchain.

   header['x-github-event'] == 'pull_request' &&
      (body.action == 'opened' || body.action == 'synchronize') &&
      body.pull_request.base.ref == 'main'

   header['x-github-event'] == 'push' && body.ref == 'refs/heads/main'

   header['x-github-event'] == 'push' &&
      body.ref == 'refs/heads/main' &&
      !body.head_commit.message.contains("skip run")

   header['x-github-event'] == 'issue_comment' &&
      body.action == 'created' && has(body.issue.pull_request) &&
      body.comment.body.contains('/lgtm')

   header['x-github-event'] == 'issues' &&
      body.action == 'opened' &&
      body.issue.labels.exists(label, label.name == 'urgent')

   header['x-gitlab-event'] == 'Merge Request Hook' &&
      (body.object_attributes.action == 'open' || body.object_attributes.action == 'update') &&
      body.object_attributes.target_branch == 'main'

   header['x-gitlab-event'] == 'Push Hook' && body.ref == 'refs/heads/main'

   header['x-gitlab-event'] == 'Push Hook' &&
      body.ref == 'refs/heads/main' &&
      !body.object_attributes.last_commit.message("skip run")

   header['x-gitlab-event'] == 'Note Hook' &&
      body.object_attributes.noteable_type == 'MergeRequest' &&
      body.object_attributes.action == 'create' &&
      body.object_attributes.note.contains('/lgtm')

   header['x-gitlab-event'] == 'Issue Hook' &&
      (body.object_attributes.action == 'open') &&
      body.object_attributes.labels.exists(label, label.name == 'urgent')

   (header['x-event-key'] == 'pullrequest:created' || header['x-event-key'] == 'pullrequest:updated') &&
       body.pullrequest.destination.branch.name == 'main'

   header['x-event-key'] == 'repo:push' && body.push.changes[0].new.name == 'main'

   header['x-event-key'] == 'repo:push' &&
      body.push.changes[0].new.name == 'main' &&
      !body.push.changes[0].commits[0].message("skip run")

   header['x-event-key'] == 'pullrequest:comment_created' &&
      body.comment.content.raw.contains('/lgtm')

   header['x-event-key'] == 'issue:created' &&
      body.issue.kind == 'bug'

Filtri

I filtri consentono agli utenti di affinare le richieste di pull in base a criteri specifici. Il campo filtro supporta attualmente la specificazione di etichette nelle richieste di pull, controllando così l'esecuzione della pipeline in base alla loro presenza o assenza. Tuttavia, non attiva una pipeline quando le etichette vengono aggiunte o rimosse; piuttosto, verifica le etichette della PR prima di consentire l'esecuzione della pipeline.

Come funziona:

• Se si verifica un evento PR (come l'aggiunta di un nuovo commit), la pipeline controlla le etichette della PR.
• Se il PR soddisfa le condizioni dell'etichetta (ad esempio, ha l'etichetta "approvato"), la pipeline viene eseguita.
• Se la PR non soddisfa le condizioni di etichetta, la pipeline non verrà eseguita.

Configurazione di esempio

La schermata seguente mostra un esempio in cui il trigger è configurato per le etichette "approvato" e "rivisto".

• La pipeline PR viene attivata solo se sono presenti entrambe le etichette.
• Se manca una delle due etichette, la pipeline non verrà eseguita.

Controllo del carico utile dell'evento

Quando si scrivono espressioni CEL per il filtraggio degli eventi, è necessario comprendere la struttura e il contenuto del payload del webhook rispetto al quale verrà valutata l'espressione. È possibile ispezionare il payload di una sessione esistente dalla pagina dei dettagli della sessione Pipeline.

Per visualizzare il payload dell'evento, accedere alla pagina dei dettagli dell'esecuzione della pipeline e fare clic su Mostra contesto. È possibile visualizzare il payload del webhook grezzo che ha attivato l'esecuzione della pipeline e confermare i campi pertinenti per le espressioni CEL in modo che corrispondano alle condizioni desiderate.

Creazione di un Delivery Pipeline per Tekton con l'API

1. Ottieni un token di connessione IAM. In alternativa, se stai utilizzando un SDK, ottieni una chiave API IAM e imposta le opzioni client utilizzando le variabili di ambiente.

   export CD_TEKTON_PIPELINE_APIKEY={api_key}
   

2. Determina la regione e l'ID della toolchain a cui vuoi aggiungere l'integrazione dello strumento Delivery Pipeline.

3. Aggiungi l'integrazione dello strumento Delivery Pipeline alla toolchain.

   curl -X POST \
     https://api.{region}.devops.cloud.ibm.com/toolchain/v2/toolchains/{toolchain_id}/tools \
     -H 'Authorization: Bearer {iam_token}' \
     -H 'Accept: application/json` \
     -H 'Content-Type: application/json' \
     -d '{
       "tool_type_id": "pipeline",
       "parameters": {
         "name": "{tool_integration_name}",
         "type" : "tekton"
       }
     }'
   

   const CdToolchainV2 = require('@ibm-cloud/continuous-delivery/cd-toolchain/v2');
   ...
   (async () => {
      const toolchainService = CdToolchainV2.newInstance();
      const pipelinePrototypeModel = {
         toolchainId: {toolchain_id},
         toolTypeId: 'pipeline',
         name: {tool_integration_name},
         type: "tekton"
      };
      const pipelineTool = await toolchainService.createTool(pipelinePrototypeModel);
   })();
   

   import (
   	   "github.com/IBM/continuous-delivery-go-sdk/cdtoolchainv2"
   )
   ...
   toolchainClientOptions := &cdtoolchainv2.CdToolchainV2Options{}
   toolchainClient, err := cdtoolchainv2.NewCdToolchainV2UsingExternalConfig(toolchainClientOptions)
   createPipelineToolOptions := toolchainClient.NewCreateToolOptions({toolchain_id}, "pipeline")
   createPipelineToolOptions.SetName({tool_integration_name})
   createPipelineToolOptions.SetType("tekton")
   pipelineTool, response, err := toolchainClient.CreateTool(createPipelineToolOptions)
   

   from ibm_continuous_delivery.cd_toolchain_v2 import CdToolchainV2
   ...
   toolchain_service = CdToolchainV2.new_instance()
   pipeline_tool = toolchain_service.create_tool(
      name = {tool_integration_name},
      toolchain_id = {toolchain_id},
      tool_type_id = "pipeline",
      type = "tekton"
   )
   

   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.CdToolchain;
   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.model.*;
   ...
   CdToolchain toolchainService = CdToolchain.newInstance();
   CreateToolOptions createPipelineToolOptions = new CreateToolOptions.Builder()
      .name({tool_integration_name})
      .toolchainId({toolchain_id})
      .toolTypeId("pipeline")
      .type("tekton")
      .build();
   Response<ToolchainToolPost> response = toolchainService.createTool(createPipelineToolOptions).execute();
   ToolchainToolPost pipelineTool = response.getResult();
   

   La seguente tabella elenca e descrive ciascuna delle variabili utilizzate nel passo precedente.

   Variabili per aggiungere l'integrazione dello strumento Delivery Pipeline con l'API

   Variabile	Descrizione
   {region}	La regione in cui si trova la toolchain, ad esempio us-south.
   {tool_integration_name}	Un nome per l'integrazione dello strumento, ad esempio ci-pipeline.
   {toolchain_id}	L'ID della toolchain a cui aggiungere l'integrazione dello strumento.
   {iam_token}	Un token portatore IAM valido.

4. Configura Delivery Pipeline per utilizzare i nodi di lavoro gestiti pubblici nelle regioni specificate.

   curl -X POST \
      https://api.{region}.devops.cloud.ibm.com/pipeline/v2/tekton_pipelines \
      -H 'Authorization: Bearer {iam_token}' \
      -H 'Accept: application/json` \
      -H 'Content-Type: application/json' \
      -d '{
         "id": "{pipeline_id}",
         "worker": { "id": "public" }
      }'
   

   const CdTektonPipelineV2 = require('@ibm-cloud/continuous-delivery/cd-tekton-pipeline/v2');
   ...
   (async () => {
      const tektonService = CdTektonPipelineV2.newInstance();
      const workerIdentityModel = {
         id: 'public',
      };
      const params = {
         id: {pipeline_id},
         worker: workerIdentityModel,
      };
      const res = await tektonService.createTektonPipeline(params);
   })();
   

   import {
      "github.com/IBM/continuous-delivery-go-sdk/cdtektonpipelinev2"
   }
   ...
   cdTektonPipelineOptions := &cdtektonpipelinev2.CdTektonPipelineV2Options{}
   pipelineSvc, err = cdtektonpipelinev2.NewCdTektonPipelineV2UsingExternalConfig(cdTektonPipelineOptions)
   createTektonPipelineOptions := pipelineSvc.NewCreateTektonPipelineOptions(
      {pipeline_id}
   )
   workerIdentityModel := &cdtektonpipelinev2.WorkerIdentity{
      ID: core.StringPtr("public"),
   }
   createTektonPipelineOptions.SetWorker(workerIdentityModel)
   tektonPipeline, response, err := pipelineSvc.CreateTektonPipeline(createTektonPipelineOptions)
   

   from ibm_continuous_delivery.cd_tekton_pipeline_v2 import CdTektonPipelineV2
   ...
   pipeline_service = CdTektonPipelineV2.new_instance()
   worker_identity_model = {
      'id': 'public',
   }
   response = pipeline_service.create_tekton_pipeline(
      id = {pipeline_id},
      worker = worker_identity_model
   )
   tekton_pipeline = response.get_result()
   

   import com.ibm.cloud.continuous_delivery.cd_tekton_pipeline.v2.CdTektonPipeline;
   import com.ibm.cloud.continuous_delivery.cd_tekton_pipeline.v2.model.*;
   ...
   CdTektonPipeline pipelineSvc = CdTektonPipeline.newInstance();
   WorkerIdentity workerIdentityModel = new WorkerIdentity.Builder()
      .id("public")
      .build();
   CreateTektonPipelineOptions createTektonPipelineOptions = new CreateTektonPipelineOptions.Builder()
      .id({pipeline_id})
      .worker(workerIdentityModel)
      .build();
   Response<TektonPipeline> response = pipelineSvc.createTektonPipeline(createTektonPipelineOptions).execute();
   TektonPipeline tektonPipeline = response.getResult();
   

   La seguente tabella elenca e descrive ciascuna delle variabili utilizzate nel passo precedente.

   Variabili per configurare la Delivery Pipeline con l'API

   Variabile	Descrizione
   {region}	La regione in cui si trova la toolchain, ad esempio us-south.
   {pipeline_id}	L'ID della pipeline restituita dal passo precedente in cui è stata creata l'integrazione dello strumento pipeline.
   {iam_token}	Un token portatore IAM valido.

Per ulteriori informazioni sull'API Delivery Pipeline, consulta la Documentazione API.

Creazione di un Delivery Pipeline per Tekton con Terraform

1. Per installare la CLI Terraform e configurare il plug-in del provider IBM Cloud per Terraform, segui l'esercitazione per Introduzione a Terraform su IBM Cloud®.

2. Creare un file di configurazione di Terraform chiamato main.tf. In questo file, aggiungere la configurazione per creare una pipeline utilizzando il linguaggio di configurazione HashiCorp. Per ulteriori informazioni sull'utilizzo di questa lingua di configurazione, consultare la documentazione Terraform.

   Una pipeline deve appartenere a una toolchain. Puoi anche creare toolchain utilizzando Terraform.

   Il seguente esempio crea una toolchain e una pipeline utilizzando le risorse Terraform specificate.

   data "ibm_resource_group" "group" {
     name = "default"
   }
   
   resource "ibm_cd_toolchain" "my_toolchain" {
     name              = "terraform_toolchain"
     resource_group_id = data.ibm_resource_group.group.id
   }
   
   resource "ibm_cd_toolchain_tool_pipeline" "my_pipeline_tool" {
     parameters {
        name = "terraform-pipeline-integration"
     }
     toolchain_id = ibm_cd_toolchain.my_toolchain.id
   }
   
   resource "ibm_cd_tekton_pipeline" "my_tekton_pipeline" {
    worker {
        id = "public"
    }
    pipeline_id = ibm_cd_toolchain_tool_pipeline.my_pipeline_tool.tool_id
   }
   

   Per ulteriori informazioni relative alle ibm_cd_toolchain_tool_pipeline e alle risorse ibm_cd_tekton_pipeline, consultare i dettagli di riferimento dell'argomento nella documentazione del registro Terraform.

3. Inizializza la CLI Terraform, se necessario.

   terraform init
   

4. Creare un piano di esecuzione Terraform. Questo piano riepiloga tutte le azioni che devono essere eseguite per creare una toolchain.

   terraform plan
   

5. Applicare il piano di esecuzione di Terraform. Terraform prende tutte le azioni richieste per creare la toolchain.

   terraform apply
   

Eliminazione di un Delivery Pipeline con l'API

1. Ottieni un token di connessione IAM. In alternativa, se stai utilizzando un SDK, ottieni una chiave API IAM e imposta le opzioni client utilizzando le variabili di ambiente.

   export CD_TEKTON_PIPELINE_APIKEY={api_key}
   

2. Determina la regione e l'ID della toolchain a cui vuoi aggiungere l'integrazione dello strumento DevOps Insights.

3. Elimina la pipeline.

   curl -X DELETE \
     https://api.{region}.devops.cloud.ibm.com/toolchain/v2/toolchains/{toolchain_id}/tools/{pipeline_id} \
     -H 'Authorization: Bearer {iam_token}'
   

   const CdTektonPipelineV2 = require('@ibm-cloud/continuous-delivery/cd-tekton-pipeline/v2');
   ...
   (async () => {
      const pipelineSvc = CdTektonPipelineV2.newInstance();
      const params = {
         id: {pipeline_id},
      };
      const res = await pipelineSvc.deleteTektonPipeline(params);
   })();
   

   import {
      "github.com/IBM/continuous-delivery-go-sdk/cdtektonpipelinev2"
   }
   ...
   cdTektonPipelineOptions := &cdtektonpipelinev2.CdTektonPipelineV2Options{}
   pipelineSvc, err = cdtektonpipelinev2.NewCdTektonPipelineV2UsingExternalConfig(cdTektonPipelineOptions)
   deleteTektonPipelineOptions := pipelineSvc.NewDeleteTektonPipelineOptions(
      {pipeline_id}
   )
   response, err := pipelineSvc.DeleteTektonPipeline(deleteTektonPipelineOptions)
   

   from ibm_continuous_delivery.cd_tekton_pipeline_v2 import CdTektonPipelineV2
   ...
   pipeline_service = CdTektonPipelineV2.new_instance()
   response = pipeline_service.delete_tekton_pipeline(
      id={pipeline_id}
   )
   

   import com.ibm.cloud.continuous_delivery.cd_tekton_pipeline.v2.CdTektonPipeline;
   import com.ibm.cloud.continuous_delivery.cd_tekton_pipeline.v2.model.*;
   ...
   CdTektonPipeline pipelineSvc = CdTektonPipeline.newInstance();
   DeleteTektonPipelineOptions deleteTektonPipelineOptions = new DeleteTektonPipelineOptions.Builder()
      .id({pipeline_id})
      .build();
   Response<Void> response = pipelineSvc.deleteTektonPipeline(deleteTektonPipelineOptions).execute();
   

La seguente tabella elenca e descrive ciascuna delle variabili utilizzate nel passo precedente.

Eliminazione di un Delivery Pipeline con Terraform

1. Individua il file Terraform (ad esempio main.tf) che contiene il blocco resource per la pipeline esistente.

   Il resource nel seguente esempio descrive una pipeline esistente.

   data "ibm_resource_group" "group" {
     name = "default"
   }
   
   resource "ibm_cd_toolchain" "my_toolchain" {
     name              = "terraform_toolchain"
     resource_group_id = data.ibm_resource_group.group.id
   }
   
   resource "ibm_cd_toolchain_tool_pipeline" "my_pipeline_tool" {
     parameters {
        name = "terraform-pipeline-integration"
     }
     toolchain_id = ibm_cd_toolchain.my_toolchain.id
   }
   
   resource "ibm_cd_tekton_pipeline" "my_tekton_pipeline" {
    worker {
        id = "public"
    }
    pipeline_id = ibm_cd_toolchain_tool_pipeline.my_pipeline_tool.tool_id
   }
   

2. Rimuovi i blocchi ibm_cd_toolchain_tool_pipeline e ibm_cd_tekton_pipeline resource dal file Terraform.

3. Inizializza la CLI Terraform, se necessario.

   terraform init
   

4. Creare un piano di esecuzione Terraform. Questo piano riepiloga tutte le azioni che devono essere eseguite per eliminare la pipeline.

   terraform plan
   

5. Applicare il piano di esecuzione di Terraform. Terraform intraprende tutte le azioni richieste per eliminare la pipeline.

   terraform apply
   

Visualizzazione dei dettagli per un pod TaskRun

Per visualizzare le informazioni sul pod Kubernetes sottostante per uno specifico TaskRun, fai clic sul nome Task e quindi su Pod.

Puoi visualizzare i dettagli per il pod e tutti gli eventi correlati riportati dal nodo di lavoro. Queste informazioni possono essere utili per il debug di errori specifici o per determinare dove viene impiegato il tempo durante un'esecuzione.