Criando um Delivery Pipeline para Tekton usando o console

Ao configurar uma integração de ferramenta do Delivery Pipeline, é possível selecionar o tipo de pipeline que você deseja criar.

1. Se você não tiver uma cadeia de ferramentas, selecione um modelo para criar uma cadeia de ferramentas. Dependendo do modelo que usar, campos diferentes poderão estar disponíveis. Revise os valores de campo padrão e, se necessário, mude essas configurações.

2. Se você tiver uma cadeia de ferramentas e estiver adicionando essa integração de ferramentas a ela, no console IBM Cloud, clique no ícone Menu > Platform Automation > Toolchains. Na página Cadeias de ferramentas, clique na cadeia de ferramentas para abrir sua página Visão geral. Como alternativa, na página Visão Geral do seu app, no cartão Entrega contínua, clique em Visualizar a cadeia de ferramentas. Em seguida, clique em Visão geral.

3. Inclua a integração do Delivery Pipeline em sua cadeia de ferramentas:

   a. Clique em Incluir ferramenta.

   b. Na seção Integrações de ferramentas, clique em Delivery Pipeline.

4. Especifique um nome para seu novo pipeline.

5. Selecione Tekton para criar um Delivery Pipeline Tekton. Você pode visualizar a saída das execuções do pipeline do Tekton em um cluster Kubernetes definido, com suporte para configurar os repositórios de definições do pipeline, os acionadores do pipeline, onde o pipeline é executado e segredos simples.

6. Se você estiver planejando usar seu pipeline para implementar uma interface com o usuário, marque a caixa de seleção Mostrar apps no menu Visualilzar apps. Todos os apps que seu pipeline criar serão mostrados na lista Visualizar app na página Visão geral da cadeia de ferramentas.

7. Clique em Criar integração para incluir o Delivery Pipeline em sua cadeia de ferramentas.

   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'

Filtros

Os filtros permitem que os usuários refinem as solicitações pull com base em critérios específicos. O campo de filtro atualmente suporta a especificação de rótulos em pull requests, controlando assim a execução do pipeline com base em sua presença ou ausência. No entanto, ele não aciona um pipeline quando os rótulos são adicionados ou removidos; em vez disso, ele verifica os rótulos do PR antes de permitir a execução do pipeline.

** Como funciona: **

• Se ocorrer um evento de PR (como a adição de um novo commit), o pipeline verifica os rótulos no PR.
• Se o PR atender às condições do rótulo (por exemplo, tiver o rótulo "aprovado"), o pipeline será executado.
• Se o PR não atender às condições do rótulo, o pipeline não será executado.

Configuração de exemplo

A captura de tela abaixo mostra um exemplo em que o acionador está configurado para os rótulos "approved" (aprovado) e "reviewed" (revisado).

• O pipeline de PR só será acionado se ambos os rótulos estiverem presentes.
• Se um dos rótulos estiver faltando, o pipeline não será executado.

Verificação da carga útil do evento

Ao escrever expressões CEL para filtragem de eventos, você deve entender a estrutura e o conteúdo da carga do webhook em relação à qual a expressão será avaliada. Você pode inspecionar a carga útil de uma execução existente na página de detalhes da execução do pipeline.

Para visualizar a carga útil do evento, vá para a página de detalhes da execução do pipeline e clique em Mostrar contexto. Você pode visualizar a carga bruta do webhook que acionou a execução do pipeline e confirmar os campos relevantes para que suas expressões CEL correspondam às condições desejadas.

Criando um Delivery Pipeline para Tekton com a API

1. Obter um token de portador de IAM. Alternativamente, se você estiver usando um SDK, obtenha uma chave API IAM e configure as opções do cliente usando variáveis de ambiente.

   export CD_TEKTON_PIPELINE_APIKEY={api_key}
   

2. Determine a região e o ID da cadeia de ferramentas para a qual você deseja adicionar a integração da ferramenta Delivery Pipeline.

3. Inclua a integração de ferramenta do Delivery Pipeline na cadeia de ferramentas.

   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();
   

   A tabela a seguir lista e descreve cada uma das variáveis que são utilizadas na etapa anterior.

   Variáveis para adicionar a integração da ferramenta Delivery Pipeline com a API

   Variável	Descrição
   {region}	A região na qual a cadeia de ferramentas reside, por exemplo, us-south.
   {tool_integration_name}	Um nome para a integração de sua ferramenta, por exemplo, ci-pipeline.
   {toolchain_id}	O ID da cadeia de ferramentas para a qual adicionar a integração da ferramenta.
   {iam_token}	Um token de portador de IAM válido.

4. Configure o Delivery Pipeline para usar trabalhadores gerenciados públicos dentro das regiões especificadas.

   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();
   

   A tabela a seguir lista e descreve cada uma das variáveis que são utilizadas na etapa anterior.

   Variáveis para configurar o Delivery Pipeline com a API

   Variável	Descrição
   {region}	A região na qual a cadeia de ferramentas reside, por exemplo, us-south.
   {pipeline_id}	O ID do pipeline que é retornado da etapa anterior onde a integração da ferramenta pipeline foi criada.
   {iam_token}	Um token de portador de IAM válido.

Para obter mais informações sobre a API Delivery Pipeline, consulte os documentos da API.

Criando um Delivery Pipeline para Tekton com Terraform

1. Para instalar a CLI do Terraform e configurar o plug-in do IBM Cloud Provider para o Terraform, siga o tutorial de Introdução ao Terraform no IBM Cloud®.

2. Crie um arquivo de configuração do Terraform que seja denominado main.tf. Nesse arquivo, adicione a configuração para criar um pipeline usando a HashiCorp Configuration Language. Para obter mais informações sobre o uso dessa linguagem de configuração, consulte a documentação Terraform.

   Um pipeline deve pertencer a uma cadeia de ferramentas. Você também pode criar cadeias de ferramentas por usando Terraform.

   O exemplo a seguir cria uma cadeia de ferramentas e um pipeline usando os recursos Terraform especificados.

   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
   }
   

   Para obter mais informações sobre os recursos ibm_cd_toolchain_tool_pipeline e ibm_cd_tekton_pipeline, consulte os detalhes de referência do argumento na documentação do registro do Terraform

3. Inicialize o CLI Terraform, se necessário.

   terraform init
   

4. Crie um plano de execução do Terraform. Este plano resume todas as ações que devem ser executadas para criar uma cadeia de ferramentas.

   terraform plan
   

5. Aplique o plano de execução do Terraform. O Terraform toma todas as ações necessárias para criar a cadeia de ferramentas.

   terraform apply
   

Exclusão de um Delivery Pipeline com a API

1. Obter um token de portador de IAM. Alternativamente, se você estiver usando um SDK, obtenha uma chave API IAM e configure as opções do cliente usando variáveis de ambiente.

   export CD_TEKTON_PIPELINE_APIKEY={api_key}
   

2. Determine a região e o ID da cadeia de ferramentas que você deseja adicionar a integração da ferramenta DevOps Insights.

3. Excluir o 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();
   

A tabela a seguir lista e descreve cada uma das variáveis que são utilizadas na etapa anterior.

Como excluir um Delivery Pipeline com Terraform

1. Localize o arquivo Terraform (por exemplo, main.tf) que contém o bloco resource para o pipeline existente.

   O resource no exemplo a seguir descreve um pipeline existente.

   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. Remova os blocos ibm_cd_toolchain_tool_pipeline e ibm_cd_tekton_pipeline resource do seu arquivo Terraform.

3. Inicialize o CLI Terraform, se necessário.

   terraform init
   

4. Crie um plano de execução do Terraform. Este plano resume todas as ações que devem ser executadas para excluir o pipeline.

   terraform plan
   

5. Aplique o plano de execução do Terraform. O Terraform toma todas as ações necessárias para excluir o pipeline.

   terraform apply
   

Visualizando detalhes de um pod de TaskRun

Para exibir informações sobre o pod Kubernetes subjacente de um TaskRun específico, clique no nome Task e, em seguida, clique em Pod.

É possível visualizar detalhes do pod e quaisquer eventos relacionados relatados pelo trabalhador. Essas informações podem ajudar a depurar falhas específicas ou a determinar como o tempo é gasto durante uma execução.