Configurando um Delivery Pipeline para Tekton usando o console

1. Na página “Visão geral” da sua cadeia de ferramentas, no cartão “Pipelines de entrega ”, clique no Delivery Pipeline para abrir a página Visão geral do Tekton Delivery Pipeline.

2. Clique em Configurações. Na seção Definições, conclua as tarefas a seguir:

   a. Especifique o repositório Git e a URL que contém a definição de pipeline Tekton e os artefatos relacionados. Caso o seu repositório não esteja disponível, retorne para a página Visão geral da cadeia de ferramentas e inclua o seu repositório.

   b. Selecione a ramificação dentro do repositório Git que você deseja usar ou digite uma tag.

   c. Especifique o caminho para a sua definição de pipeline dentro do repositório Git. É possível referenciar uma definição específica dentro do mesmo repositório. Também será possível incluir múltiplos repositórios de definição se eles estiverem integrados com a cadeia de ferramentas.

   d. Salve as mudanças.

   A definição de pipeline é atualizada automaticamente.

   O limite de tamanho calculado para a definição de pipeline é de 1 MB. Em caso de erros ao salvar ou executar um pipeline, talvez seja necessário reduzir o tamanho da definição de pipeline ou dividi-lo em vários pipelines.

3. Na seção Trabalhador, selecione o trabalhador compartilhado gerenciado pela IBM ou o trabalhador privado que você deseja usar para executar o seu pipeline do Tekton. Para obter mais informações sobre trabalhadores privados, consulte Trabalhando com os trabalhadores privados do Delivery Pipeline.

   O trabalhador privado deve ser definido na mesma cadeia de ferramentas que seu pipeline Tekton.

4. Na seção Propriedades de ambiente, clique em Incluir e selecione um tipo de propriedade para definir sua própria propriedade de ambiente. Por exemplo, é possível definir uma propriedade API_KEY que passa uma chave de API usada por todos os scripts no pipeline para acessar os recursos do IBM Cloud. É possível incluir os tipos de propriedades a seguir:

   • Enumeração: uma chave da propriedade com um valor que pode ser selecionado de uma lista de opções definida pelo usuário.
   • Valor seguro: uma chave da propriedade com um valor de linha único que é assegurado com a criptografia AES-128. Esse valor é exibido usando o caractere asterisco. Como alternativa, é possível clicar no ícone de chave para selecionar um segredo a partir de uma integração de área segura (como o IBM Key Protect), caso essa ferramenta esteja disponível em sua cadeia de ferramentas.
   • Valor de texto: uma chave da propriedade com um valor de texto que pode ser de linha única ou de multilinhas. Anteriormente, valores de multilinhas eram suportados por um tipo de propriedade Área de texto separado.
   • Integração de ferramenta: uma chave da propriedade com um valor que é resolvido no tempo de execução por meio de uma integração de ferramenta da cadeia de ferramentas. Por padrão, o valor é uma representação em sequência JSON da integração de ferramenta. Um campo ou subconjunto específico do objeto pode ser recuperado fornecendo um valor para o filtro JSON opcional. Por exemplo, se uma integração do GitHub for selecionada e o filtro JSON parameters.repo_url for especificado, o valor refletirá a URL do repositório Git que estiver configurada na integração de ferramenta quando o recurso PipelineRun for executado.

   É possível acessar essas propriedades em seus recursos de pipeline do Tekton. Para obter mais informações sobre essas propriedades, consulte Ambiente e recursos dos pipelines do Tekton.

   Propriedades podem ser bloqueadas para evitar que sejam substituídas. Tentar substituir uma propriedade bloqueada no tempo de execução resultará na solicitação de execução sendo rejeitada. Propriedades bloqueadas não são exibidas por padrão no painel lateral de execução, mas podem ser exibidas somente leitura ativando a opção 'Mostrar todas as propriedades'.

5. Clique em Salvar.

6. Na página “Visão geral do pipeline”, clique em “Adicionar” para criar um gatilho, selecione o tipo de gatilho a ser adicionado e associe o gatilho a um ouvinte de eventos. A lista de listeners de eventos disponíveis contém os listeners definidos no repositório de código do pipeline.

   Os gatilhos são baseados nas definições de gatilhos do Tekton. Git Os gatilhos do repo utilizam o ouvinte de eventos ao qual estão mapeados para extrair informações da carga útil do evento recebido e criar recursos d Kubernetes. Esses recursos são aplicados a um recurso PipelineRun do Tekton.

   As execuções de pipeline acionadas ocorrerão simultaneamente, a menos que o acionador seja configurado para serializar as execuções, utilizando a opção Limit concurrent runs. Quando essa opção está ativada, é possível limitar o número de execuções simultâneas que podem ser iniciadas por esse acionador. Por exemplo, se o limite máximo for definido como 1, apenas uma execução do pipeline para esse gatilho será executada por vez, e todas as outras ficarão na fila no estado “Em espera”. Um máximo de 20 execuções (5 se você estiver usando o Managed Workers d IBM ) são colocadas na fila em estado de espera antes que as solicitações subsequentes sejam automaticamente canceladas. Por padrão, todos os gatilhos temporizados estão limitados a uma execução simultânea ao usar os Managed Workers d IBM

   Quando um acionador excede seu limite de execuções simultâneas, novas execuções de pipeline são colocadas em um estado de "Espera" até que a capacidade esteja disponível. Se desejar, esse comportamento pode ser modificado para que apenas a execução mais recente fique no estado "Waiting" (Esperando) e outras execuções sejam automaticamente canceladas. Isso pode ser útil, por exemplo, para Git gatilhos, se você deseja compilar apenas o commit mais recente quando várias execuções são acionadas em um curto espaço de tempo. Para ativar esse recurso, um botão de alternância "Limit to one waiting run" (Limitar a uma execução em espera) está disponível no painel de configuração do acionador, que também pode ser definido via API usando a propriedade limit_waiting_runs (consulte os documentos da API ). Observe que essa configuração só se aplica a execuções no estado "Waiting" (Aguardando) e não afeta as execuções ativas.

   Os acionadores manuais são executados quando você clica no botão do pipeline Executar e seleciona o acionador.

   Os Acionadores do repositório Git são executados quando o tipo de evento do Git especificado ocorre para o repositório e a ramificação do Git especificados.

   É possível acessar a carga útil do webhook que é entregue a um acionador Git por meio dos seus recursos de pipeline do Tekton. Embora os campos exatos sejam específicos do repositório, a sintaxe geral para a carga útil do webhook é $(event.payloadFieldName). Antes de ser possível criar um webhook, deve-se autorizar o acesso de Administrador Git à integração do Git correspondente. Para autorizar o acesso de Administrador Git, configure e salve a integração do Git novamente.

   Os acionadores temporizados são executados em um horário programado, definido pelo valor CRON. A expressão CRON para acionadores programados baseia-se na sintaxe do crontab do UNIX e consiste em uma sequência de cinco campos de hora e data: minute, hour, day of the month, month e day of the week. Esses campos são separados por espaços no formato X X X X X. A frequência máxima de execução para um acionador cronometrado é uma vez a cada cinco minutos. Os exemplos a seguir mostram sequências que usam várias frequências cronometradas.

   • */5 * * * * - O acionador é executado a cada minutos.
   • 0 * * * * - O acionador é executado no início de cada hora.
   • 0 9 * 1 MON-FRI - O acionador é executado às 9h de cada dia da semana em janeiro.
   • 0 * * NOV,DEC 1 - O acionador é executado a cada hora nas segundas-feiras durante novembro e dezembro.

Os Acionadores de webhook genéricos são executados quando uma solicitação POST definida com a configuração secreta acessa a URL de webhook genérica. Os acionadores de webhook genéricos fornecem uma URL de webhook exclusiva para as solicitações de POST.

Como a IU do PipelineRun não oculta os valores de carga útil de webhook genérico na seção de carga útil do evento, não inclua dados sensíveis na carga útil. Em vez disso, proteja todos os dados que sejam requeridos por um webhook genérico usando as propriedades do acionador, como senhas ou segredos de chave de API.

É possível proteger os acionadores de webhook genéricos para trabalhar com o Git, um webhook de saída do Slack, um webhook do Artifactory e outros, por meio de qualquer um dos métodos a seguir:

• Correspondências de token para comparar o token salvo e o token transmitido na solicitação de POST. As origens de token suportadas incluem um cabeçalho, uma consulta ou uma carga útil. As correspondências de token são usadas pelos webhooks do GitLab e pelos webhooks de saída do Slack.
• Correspondências de compilação da carga útil para comparar a assinatura e o hash que são gerados por meio da carga útil compilada usando a compilação hex do HMAC com um token salvo. As origens de assinatura suportadas podem incluir um cabeçalho, uma consulta ou uma carga útil. Os usuários devem especificar um algoritmo digest. As correspondências de compilação de carga útil são usadas pelos webhooks do GitHub.
• A validação da tarefa do Tekton requer que os usuários validem a solicitação de webhook dentro de suas tarefas do Tekton.

Especifique os valores a seguir para usar os acionadores de webhook genéricos com os webhooks do GitHub:

• Proteção: Payload Digest Matches
• Origem da assinatura: Header
• Nome da chave do cabeçalho: X-Hub-Signature
• Algoritmo digest: sha1.

Especifique os valores a seguir para usar os acionadores de webhook genéricos com os webhooks do GitLab:

• Proteção: Token Matches
• Origem de token: Header
• Nome da chave do cabeçalho: X-Gitlab-Token

Especifique os valores a seguir para usar os acionadores de webhook genéricos com os webhooks de saída do Slack:

• Proteção: Token Matches
• Origem de token: Payload
• Chave do formulário/nome da propriedade JSON: token

O exemplo a seguir mostra como usar o comando curl com um webhook genérico que é protegido com uma regra Token Matches:

  ![Exemplo de webhook genérico](images/pipeline_tekton_generic_webhook.png){: caption="Exemplo de webhook genérico" caption-side="bottom"}

curl -X POST \
https://devops-api.us-south.devops.cloud.ibm.com/v1/tekton-webhook/588236be-749b-4c67-ae57-a561abbbc9a8/run/7e82880e-4223-4c98-8ca9-ef6df36bb6dc \
-H 'Content-Type: application/json' \
-H 'token: 48a0f92c0932890048596906a22ae189c48c5619fbcf9600' \
-d '{
"somekey": "somevalue"
}'

Para obter os valores de carga útil na definição de pipeline, especifique um parâmetro Triggerbinding com um valor que seja derivado do evento:

apiVersion: tekton.dev/v1beta1
kind: TriggerBinding
metadata:
name: binding
spec:
params:
- name: somekey
value: $(event.somekey)

Salve as mudanças.

Além disso, os acionadores genéricos de webhook suportam a transmissão de propriedades no corpo da solicitação do webhook. Isso permite que as propriedades sejam substituídas para o PipelineRun que é acionado pelo webhook, ou para passar propriedades adicionais que complementam as propriedades do pipeline/gatilho usadas no PipelineRun.

Se você precisar passar dados confidenciais nas propriedades de carga útil, como senhas ou segredos de chave de API, deverá usar o tipo de propriedade SECURE para essas propriedades, de modo que elas não sejam exibidas em texto simples na interface do usuário.

Além disso, uma descrição opcional pode ser passada no corpo da solicitação que descreve o PipelineRun que é acionado e que é exibido na interface do usuário ao visualizar os detalhes do PipelineRun em um navegador.

O exemplo a seguir mostra como usar o comando curl com um webhook genérico ao passar uma propriedade de texto, uma propriedade segura e uma descrição:

curl -X POST \
https://devops-api.us-south.devops.cloud.ibm.com/v1/tekton-webhook/588236be-749b-4c67-ae57-a561abbbc9a8/run/7e82880e-4223-4c98-8ca9-ef6df36bb6dc \
-H 'Content-Type: application/json' \
-H 'token: 48a0f92c0932890048596906a22ae189c48c5619fbcf9600' \
-d '{
  "description":"This text can be used to describe the PipelineRun that will be triggered by this request.",
  "properties":[
    {"name":"mytextprop","type":"TEXT","value":"my text value"},
    {"name":"mysecureprop","type":"SECURE","value":"mysecret"}
  ]
}'

Configuração de Delivery Pipeline acionadores para pipelines Tekton

Você pode configurar acionadores para os pipelines do Tekton com base em vários eventos em seu repositório do Git. Filtre os acionadores do Git usando as seguintes opções:

• Filial: Aciona o pipeline para uma ramificação específica do repositório selecionado quando ocorre o evento especificado.
• Padrão: Aciona o pipeline com base em uma correspondência glob de tags e nomes de ramificações no repositório selecionado quando ocorre o evento especificado.
• Filtro CEL: Aciona o pipeline quando o evento corresponde ao filtro CEL (Common Expression Language) fornecido.

Use as opções Branch e Pattern para especificar eventos como ' commit push, ' pull request opened, ' updated ou ' closed. Além disso, você pode especificar eventos de pull request alternando a opção Incluir eventos de pull request de rascunho para permitir ou ignorar acionadores de pipeline para pull requests de rascunho. Da mesma forma, você pode especificar se deseja permitir acionadores de pipeline para pull requests de repositórios bifurcados usando a opção Incluir eventos de pull request de bifurcações. Além disso, você pode selecionar a opção Label filters (Filtros de rótulos ) para ativar a filtragem com base nos rótulos de pull request de acordo com os critérios definidos pelo usuário na tabela de filtros.

A opção de filtro CEL oferece suporte a casos de uso mais avançados, como a correspondência com outros campos na carga útil do evento. Esta opção suporta eventos push, todos os eventos de solicitação pull, eventos de problemas, eventos de comentários sobre problemas, eventos de lançamento e eventos GitHub de fila de mesclagem. Essa opção também está disponível como um recurso opcional no acionador Generic Webhook para fornecer filtragem de eventos com base na carga útil do webhook.

   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'

Exclusão de uma cadeia de ferramentas usando a interface do usuário do console

1. No console IBM Cloud, clique no ícone Menu > Platform Automation > Toolchains.
2. Na página Cadeias de ferramentas, clique em uma cadeia de ferramentas para abrir a sua página de Visão geral. Como alternativa, na página Detalhes do app em seu app, clique no nome da cadeia de ferramentas.
3. Na seção "Pipelines de entrega", localize o pipeline que deseja excluir.
4. Clique no ícone do Menu para esse pipeline e clique na opção Excluir.
5. Confirme a exclusão clicando em “Excluir” na caixa de diálogo.

Exclusão de um “ Delivery Pipeline ” por meio da 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
   

Acionamento do pipeline via linha de comando ou API

Você pode acionar um pipeline a partir da linha de comando usando a CLI do IBM Cloud ou fazendo uma chamada direta à API usando curl.