IBM Cloud Docs
Trabalhando com pipelines Tekton

Trabalhando com pipelines Tekton

O Tekton Pipelines é um projeto de código aberto que você pode usar para configurar e executar pipelines de Integração Contínua e Continuous Delivery em um cluster Kubernetes. Os pipelines Tekton são definidos em arquivos yaml, geralmente armazenados em um repositório Git.

Pipelines híbridos do " caption-side="bottom"} de pipelines{: caption="do Tekton*

A Tekton fornece um conjunto de extensões de recursos personalizados para o site Kubernetes para definir pipelines. Os recursos básicos a seguir do Tekton Pipeline estão incluídos nessas extensões:

Recursos do gasoduto Tekton
Recurso Descrição
Task Define um conjunto de etapas de construção, como compilar código, executar testes, construir e implementar imagens.
TaskRun Instancia uma tarefa para execução com entradas, saídas e parâmetros de execução específicos. Você pode iniciar a tarefa por conta própria ou como parte de um pipeline.
Pipeline Define o conjunto de tarefas que compõem um pipeline.
PipelineRun Instancia um pipeline para execução com entradas, saídas e parâmetros de execução específicos.

Você pode aproveitar os seguintes recursos quando se usa Tekton Pipelines:

  • Nativo da nuvem: os Tekton Pipelines são executados no Kubernetes, usam clusters Kubernetes como um tipo de primeira classe e usam contêineres como seus blocos de construção.
  • Desacoplado: é possível usar um pipeline para implementar em qualquer cluster Kubernetes. É possível executar as tarefas que compõem um pipeline isoladamente. E é possível alternar recursos (como repositórios Git) entre execuções do pipeline.
  • Definido em tipos: é possível alternar implementações para tipos específicos de recursos, como imagens.

O projeto Tekton Pipelines é uma liberação beta. Deve-se atualizar seu pipeline com cada nova versão do Tekton. Para obter mais informações sobre a versão mais recente do Tekton, consulte https://github.com/tektoncd/pipeline/releases.

O IBM Cloud® Continuous Delivery fornece dois tipos de pipelines de entrega que podem ser usados para construir, testar e implementar seus aplicativos.

  • Classic: os pipelines de entrega Classic são criados graficamente, com o status integrado ao diagrama de pipeline. Esses pipelines podem ser executados em trabalhadores compartilhados na nuvem ou em trabalhadores privados executados em seus próprios clusters Kubernetes.
  • Tekton: os pipelines de entrega Tekton são criados em arquivos yaml que definem pipelines como um conjunto de recursos do Kubernetes. Você pode editar esses arquivos yaml para alterar o comportamento de um pipeline. Os pipelines Tekton podem ser executados em trabalhadores privados que são executados em seu próprio cluster. Eles também podem ser executados em trabalhadores privados IBM na nuvem pública. A integração da Tekton fornece um painel que você pode usar para visualizar o status das execuções do pipeline da Tekton e acionar novas execuções. Ele também fornece mecanismos para especificar os acionadores de pipeline, as definições de pipeline, o trabalhador no qual o pipeline é executado e as propriedades do pipeline

Ambos os tipos de pipeline isolam tarefas ou etapas uma da outra executando em contêineres separados e usando uma imagem de sua preferência. Os pipelines Classic e Tekton existem em uma cadeia de ferramentas e dependem dela para adicionar mais integrações de ferramentas que são usadas no processo de criação, teste e implantação.

Em 20 de novembro de 2020, o Dockerhub introduziu a limitação de taxa sobre extrações de imagem anônimas. Essa mudança pode impactar os usuários que estão executando tarefas que referenciam as imagens hospedadas pelo Dockerhub. É recomendado que você use um registro alternativo, como o IBM Cloud Container Registry.

Pré-requisitos

Antes de incluir e executar um pipeline Tekton, certifique-se de que tenha os recursos a seguir em vigor:

  • Uma cadeia de ferramentas que contém as integrações de ferramenta a seguir:

    • Uma integração de ferramenta de repositório (como a integração de ferramenta GitHub) que contém o seu código de pipeline Tekton, incluindo um arquivo yaml Tekton. Encontre exemplos de definições de pipeline e tarefas em GitHub. Para obter mais informações sobre como começar a usar os pipelines da Tekton, consulte Pipelines da Tekton.
    • Opcional. Caso você não esteja usando o trabalhador do pipeline compartilhado padrão, é possível usar uma integração de ferramenta de trabalhador privado do Delivery Pipeline que referencia o seu cluster Kubernetes. Para obter mais informações sobre trabalhadores privados, consulte Instalando os trabalhadores privados do Delivery Pipeline.
  • CLI do IBM Cloud instalada localmente.

  • kubectl instalado localmente.

  • Um cluster Kubernetes (versão 1.22 ou superior) como um cluster IBM Cloud® Kubernetes Service.

A cadeia de ferramentas e a integração de ferramenta do Delivery Pipeline Private Worker devem estar na mesma região.

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 , ícone de hambúrguer > 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.

Configurando um Delivery Pipeline para Tekton usando o console

  1. Na página Overview (Visão geral) de sua cadeia de ferramentas, no cartão Delivery pipelines (Pipelines de entrega), clique no botão Delivery Pipeline para abrir a página Overview (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 acionador, selecione o tipo de acionador a ser adicionado e associe o acionador 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 acionadores são baseados nas definições de acionamento da Tekton. Git os acionadores de repositório usam o ouvinte de eventos ao qual estão mapeados para extrair informações da carga útil do evento de entrada e criar recursos 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, caso o limite máximo seja configurado como 1, haverá apenas uma execução de pipeline por vez para esse acionador e as demais, se houver, serão enfileiradas em estado de espera. Um máximo de 20 execuções (5 se você estiver usando IBM Managed Workers) são enfileiradas em um estado de espera antes que as solicitações subsequentes sejam canceladas automaticamente. Por padrão, todos os acionadores temporizados são limitados a uma execução simultânea ao usar o IBM Managed Workers

    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 cronometrados é baseada na sintaxe crontab do UNIX e é uma sequência de cinco campos de data e hora: 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:

    Generic webhook example
    Generic webhook example

    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. Essa opção é compatível com eventos push, todos os eventos de pull request, eventos de problemas, eventos de comentários de problemas e eventos de lançamento. 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.

Visão geral da CEL

O CEL é uma linguagem de expressão avançada e flexível, projetada para avaliar condições e realizar validações de forma concisa e legível. O CEL é ideal para casos de uso que exigem lógica condicional complexa, como filtragem de eventos.

No Tekton pipeline, a opção CEL foi introduzida para oferecer uma filtragem de eventos mais avançada e flexível. A carga útil do webhook é avaliada em relação à expressão CEL fornecida pelo usuário. Se a expressão CEL for avaliada como true, a execução do pipeline será acionada.

Os seguintes recursos são compatíveis com o CEL:

  • Operadores aritméticos (+, -, *, /, %)
  • Operadores de comparação (=, !=, <, >, <=, >=)
  • Operadores lógicos (&&, ||)
  • Operadores de cadeia de caracteres (contains, matches, startsWith, endsWith)
  • Operadores de coleção (in, !in)
  • Variáveis (consulte as variáveis diretamente por seus nomes)
  • Literals (suporta literais como strings, números, booleanos e null)

O CEL inclui as seguintes extensões para oferecer mais funcionalidades à linguagem básica do CEL:

  • Sets extension para dar suporte a operações de conjunto avançadas e oferecer mais flexibilidade na filtragem de eventos. Para obter mais informações sobre essa extensão, consulte Sets.
  • matchesGlob para oferecer compatibilidade ao converter o campo de padrão existente para a nova opção de filtro CEL. O operador nativo CEL matches é recomendado para correspondências de expressões regulares mais avançadas.

Para obter mais informações sobre o CEL, consulte a documentação do CEL.

Conversão para CEL

Conclua as etapas a seguir para converter sua seleção de filtragem de eventos existente em uma expressão CEL:

  1. Edite o acionador Git que você deseja converter.

  2. Na seção Trigger on, selecione a opção CEL filter.

    CEL filter option
    CEL filter option

    Os seguintes elementos são automaticamente convertidos em uma expressão CEL equivalente:

    • Ramo ou padrão
    • Eventos, como commit push, pull request opened, updated e closed
    • Incluir eventos de rascunho de pull request
    • Incluir eventos de pull request de bifurcações
    • Filtros de Rótulos

    do filtro CEL*Conversão do filtro

    A expressão CEL gerada é gravada em um campo de área de texto, que pode ser editado conforme necessário.

    Como não existem filtros nos acionadores de Webhook genérico para conversão, a conversão para um filtro CEL se aplica somente aos acionadores Git.

    Se você salvar o acionador com a opção CEL selecionada, ele substituirá os eventos selecionados anteriormente pela expressão CEL. Se você mudar para a opção Branch ou Pattern depois de salvar a opção de filtro CEL, as seleções de eventos anteriores não serão salvas. Não há suporte para a conversão da opção CEL para a opção Branch ou Pattern.

Exemplos de expressões CEL

Os exemplos a seguir são expressões CEL comuns para cada um dos tipos de Git suportados: GitHub, GitLab e BitBucket. Você pode copiar e modificar esses exemplos para atender às suas necessidades.

GitHub:

É executado quando um pull request é aberto ou atualizado no branch especificado:

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

Executa quando um commit é enviado para a ramificação especificada:

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

Executa quando um commit é enviado para o branch especificado, mas ignora-o quando a mensagem do commit contém uma string específica:

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

Executado quando um comentário contendo a string especificada é adicionado a um pull request:

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

É executado quando um problema é criado com o rótulo especificado:

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

GitLab:

Executado quando uma solicitação de mesclagem é aberta ou atualizada no ramo especificado:

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

Executa quando um commit é enviado para a ramificação especificada:

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

Executa quando um commit é enviado para o branch especificado, mas ignora-o quando a mensagem do commit contém uma string específica:

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

Executado quando um comentário contendo a cadeia de caracteres especificada é adicionado a uma solicitação de mesclagem:

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

É executado quando um problema é criado com o rótulo especificado:

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

BitBucket:

É executado quando um pull request é aberto ou atualizado no branch especificado:

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

Executa quando um commit é enviado para a ramificação especificada:

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

Executa quando um commit é enviado para o branch especificado, mas ignora-o quando a mensagem do commit contém uma string específica:

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

Executado quando um comentário contendo a string especificada é adicionado a um pull request:

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

É executado quando um problema é criado com o rótulo especificado:

   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.

Configuração de filtros de rótulos para execução do pipeline de relações públicas
Configuração de filtros de rótulos para execução do pipeline de relações públicas

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
    

Visualizando um Delivery Pipeline para Tekton

Você pode visualizar um pipeline usando a UI do console, com a API, ou com Terraform.

Visualizando um Delivery Pipeline ao usar o console

A página Visão geral do Tekton Delivery Pipeline exibe uma tabela vazia até que pelo menos um acionador seja incluído. Após as execuções de pipeline do Tekton (manualmente ou como resultado de eventos externos), a tabela exibe dados sobre as execuções recentes que estão associadas a cada acionador no pipeline. Cada linha mostra informações sobre um único acionador e exibe um gráfico de execuções recentes associadas a esse acionador. Informações como o sucesso ou a falha dessas execuções e o horário em que a execução mais recente ocorreu também são exibidas Também é possível executar ações para cada acionador: execute o acionador manualmente, marque-o como um favorito, edite o acionador, ative ou desative-o ou exclua-o. Também é possível clicar no item no gráfico para inspecionar os detalhes desse PipelineRun individual. Ou, é possível clicar em um nome de acionador para abrir a página PipelineRuns para cada PipelineRun associado a esse acionador. Informações relacionadas como o status, o acionador e a duração de cada PipelineRun também estão disponíveis.

As execuções de pipeline podem estar em qualquer um dos estados a seguir:

  • Pendente: PipelineRun foi solicitada.
  • Em execução: PipelineRun está em execução no cluster.
  • Bem-sucedido: PipelineRun foi concluída com sucesso no cluster.
  • Com falha: PipelineRun com falha. Revise o arquivo de log da execução para determinar a causa.
  • Enfileirado: PipelineRun foi aceito para processamento e executará quando a capacidade do trabalhador estiver disponível.
  • Esperando: PipelineRun está esperando para ser enfileirado.
  • Cancelado: PipelineRun foi cancelado pelo sistema ou pelo usuário. O sistema cancela um PipelineRun quando o número de execuções em espera excede o limite permitido.
  • Erro: PipelineRun contém erros que evitaram que ele fosse aplicado no cluster. Para obter mais informações sobre a causa do erro, consulte os detalhes da execução.

Para obter informações detalhadas sobre uma execução selecionada, clique em qualquer linha na tabela para visualizar a definição Task e as etapas em cada definição PipelineRun. Também é possível visualizar o status, os logs e os detalhes de cada definição e etapa de Task, além do status geral da definição de PipelineRun.

O período de retenção para PipelineRuns e seus logs depende do plano que é selecionado para a instância de serviço Continuous Delivery. Os gasodutos Tekton sob o plano Professional são retidos durante um ano. Os oleodutos de Tekton sob o plano Lite são retidos por 30 dias. Para reter qualquer PipelineRuns além do período de retenção, na seção PipelineRuns, selecione Ações> Download** para fazer o download de um arquivo .zip.

Visualizando 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. Obtem os dados do pipeline.

    curl -X GET \
      https://api.{region}.devops.cloud.ibm.com/pipeline/v2/tekton_pipelines/{pipeline_id} \
      -H 'Authorization: Bearer {iam_token}' \
      -H 'Accept: application/json`
    
    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.getTektonPipeline(params);
    })();
    
    import {
       "github.com/IBM/continuous-delivery-go-sdk/cdtektonpipelinev2"
    }
    ...
    cdTektonPipelineOptions := &cdtektonpipelinev2.CdTektonPipelineV2Options{}
    pipelineSvc, err = cdtektonpipelinev2.NewCdTektonPipelineV2UsingExternalConfig(cdTektonPipelineOptions)
    getTektonPipelineOptions := pipelineSvc.NewGetTektonPipelineOptions(
       {pipeline_id}
    )
    tektonPipeline, response, err := pipelineSvc.GetTektonPipeline(getTektonPipelineOptions)
    
    from ibm_continuous_delivery.cd_tekton_pipeline_v2 import CdTektonPipelineV2
    ...
    pipeline_service = CdTektonPipelineV2.new_instance()
    response = pipeline_service.get_tekton_pipeline(
       id = {pipeline_id}
    )
    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();
    GetTektonPipelineOptions getTektonPipelineOptions = new GetTektonPipelineOptions.Builder()
       .id({pipeline_id})
       .build();
    Response<TektonPipeline> response = pipelineSvc.getTektonPipeline(getTektonPipelineOptions).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 visualizar o Delivery Pipeline com a API
Variável Descrição
{region} A região em que o pipeline reside, por exemplo, us-south.
{pipeline_id} O ID do pipeline que você deseja visualizar.
{iam_token} Um token de portador de IAM válido.

Visualizando um Delivery Pipeline com Terraform

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

  2. Inclua um bloco output no arquivo Terraform, se ele já não contém um bloco.

    O resource no exemplo a seguir descreve um pipeline existente. O bloco output instrui Terraform a saída dos atributos do recurso especificado.

    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
    }
    
    output "my_tekton_pipeline_attributes" {
      value = ibm_cd_tekton_pipeline.my_tekton_pipeline
    }
    

    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. Aplique o plano de execução Terraforme com a opção refresh-only. Terraform atualiza seu estado e exibe os atributos do recurso pipeline.

    terraform apply -refresh-only -auto-approve
    

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.

Variáveis para excluir 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.
{toolchain_id} O ID da cadeia de ferramentas que contém o pipeline para excluir.
{pipeline_id} O ID do pipeline que você deseja excluir.
{iam_token} Um token de portador de IAM válido.

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.

Saiba mais sobre os pipelines e recursos do Tekton

Para saber mais sobre os pipelines do Tekton, consulte os artigos Tekton: Uma abordagem moderna para Continuous Delivery e Ferramentas e recursos dos pipelines do Tekton IBM Cloud Continuous Delivery.

Para saber mais sobre as tarefas Tekton que você pode referenciar em seus pipelines, consulte o Open Toolchain Tekton Catalog. Este repositório GitHub contém um conjunto de tarefas que podem ser reutilizadas em seus pipelines do Tekton.