Dominando Tekton em Kubernetes: Pipelines Cloud-Native do Zero em Projetos Reais Já leu

O que é Tekton e por que você precisa aprender

Tekton é um framework open-source de CI/CD (Integração Contínua e Entrega Contínua) construído nativamente para Kubernetes. Diferente de ferramentas como Jenkins ou GitLab CI, o Tekton não é um serviço separado que se comunica com seu cluster — ele é um conjunto de controladores Kubernetes que trabalham dentro do seu cluster, criando e orquestrando pipelines como recursos nativos do Kubernetes.

A razão pela qual você deve dominar Tekton está diretamente ligada à adoção de arquiteturas cloud-native. Quando você trabalha com microserviços, containers e Kubernetes, ter uma ferramenta de automação que também é um recurso nativo do cluster elimina complexidades de integração, reduz dependências externas e permite escalabilidade automática. Tekton segue a filosofade "tudo como código" (Infrastructure as Code) e oferece excelente integração com ecossistemas como GitOps, observabilidade e security scanning.

Conceitos Fundamentais do Tekton

Task: A Unidade Atômica de Trabalho

Uma Task no Tekton é a menor unidade executável — pense nela como uma função reutilizável que executa um conjunto de ações em um container. Cada Task é declarada como um recurso Kubernetes (CustomResourceDefinition) e contém etapas sequenciais que rodam em containers dedicados.

apiVersion: tekton.dev/v1beta1
kind: Task
metadata:
  name: print-hello
spec:
  params:
    - name: message
      type: string
      default: "Hello, World!"
  steps:
    - name: echo
      image: alpine:3.13
      command:
        - /bin/sh
      args:
        - -c
        - echo $(params.message)
    - name: verify
      image: alpine:3.13
      command:
        - /bin/sh
      args:
        - -c
        - echo "Task completed successfully"

Cada step dentro de uma Task executa em seu próprio container, mas compartilha um workspace comum. Isso é crucial: se você precisa compilar código e depois empacotá-lo, a primeira etapa escreve no workspace, e a segunda lê do mesmo lugar. Tasks são completamente reutilizáveis — você define uma vez e a utiliza em múltiplos pipelines.

Pipeline: Orquestração de Tasks

Um Pipeline é uma composição de múltiplas Tasks conectadas com dependências de execução. Um Pipeline define a ordem em que as Tasks rodam, quais parâmetros cada uma recebe e como os dados fluem entre elas.

apiVersion: tekton.dev/v1beta1
kind: Pipeline
metadata:
  name: ci-pipeline
spec:
  params:
    - name: repo-url
      type: string
    - name: image-name
      type: string
  workspaces:
    - name: shared-workspace
  tasks:
    - name: clone-repo
      taskRef:
        name: git-clone
      params:
        - name: url
          value: $(params.repo-url)
      workspaces:
        - name: output
          workspace: shared-workspace

    - name: build-image
      taskRef:
        name: build-docker
      params:
        - name: image
          value: $(params.image-name)
      runAfter:
        - clone-repo
      workspaces:
        - name: source
          workspace: shared-workspace

    - name: push-image
      taskRef:
        name: push-docker
      params:
        - name: image
          value: $(params.image-name)
      runAfter:
        - build-image

Note o campo runAfter — isso cria dependências explícitas entre Tasks. Quando você não especifica runAfter, Tekton executa as Tasks em paralelo quando possível, maximizando eficiência. O workspaces compartilhado permite que o código clonado na primeira Task seja acessado pelas Tasks subsequentes.

PipelineRun: Execução de um Pipeline

Uma PipelineRun é uma instância específica de execução de um Pipeline. Ela especifica valores concretos para parâmetros, seleciona quais workspaces usar e dispara a execução. É a diferença entre definir uma função (Pipeline) e chamá-la com argumentos específicos (PipelineRun).

apiVersion: tekton.dev/v1beta1
kind: PipelineRun
metadata:
  name: app-deploy-run-001
spec:
  pipelineRef:
    name: ci-pipeline
  params:
    - name: repo-url
      value: "https://github.com/seu-usuario/seu-repo.git"
    - name: image-name
      value: "gcr.io/seu-projeto/minha-app:v1.0"
  workspaces:
    - name: shared-workspace
      volumeClaimTemplate:
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 1Gi

Quando você cria uma PipelineRun, o Tekton começa a orquestrar a execução imediatamente. Você pode monitorar o progresso com kubectl logs ou kubectl describe pipelinerun app-deploy-run-001.

Instalação e Ambiente Prático

Pré-requisitos e Instalação do Tekton

Você precisa de um cluster Kubernetes funcional (versão 1.21 ou superior). Se não possui, pode usar Minikube, Kind ou um provedor cloud como GKE, EKS ou AKS. A instalação do Tekton é simples: você aplica manifestos YAML que registram as CustomResourceDefinitions e deployam os controladores.

# Instalar Tekton Pipelines (versão estável)
kubectl apply --filename https://storage.googleapis.com/tekton-releases/pipeline/latest/release.yaml

# Instalar Tekton CLI (opcional, mas muito útil)
# No macOS:
brew install tektoncd-cli

# No Linux:
curl https://github.com/tektoncd/cli/releases/download/v0.32.0/tkn_0.32.0_Linux_x86_64.tar.gz -L | tar xz
sudo mv tkn /usr/local/bin/

# Verificar instalação
kubectl get crds | grep tekton
tkn version

Após a instalação, todos os componentes do Tekton rodam no namespace tekton-pipelines. Você trabalha criando Tasks, Pipelines e PipelineRuns em qualquer namespace (recomenda-se criar um namespace dedicado como ci-cd ou tekton-workspace).

Exemplo Completo: Pipeline Real de Build e Push

Vou mostrar um exemplo realista de um pipeline que clona um repositório, constrói uma imagem Docker e a envia para um registry. Este exemplo ilustra como conceitos se conectam.

# Task 1: Clone do repositório
apiVersion: tekton.dev/v1beta1
kind: Task
metadata:
  name: git-clone-custom
spec:
  params:
    - name: git-url
      type: string
    - name: git-branch
      type: string
      default: "main"
  workspaces:
    - name: output
  steps:
    - name: clone
      image: alpine/git:v2.36.2
      script: |
        git clone --branch $(params.git-branch) $(params.git-url) /workspace/output/repo
---
# Task 2: Build da imagem
apiVersion: tekton.dev/v1beta1
kind: Task
metadata:
  name: build-image
spec:
  params:
    - name: image-tag
      type: string
  workspaces:
    - name: source
  steps:
    - name: build
      image: moby/buildkit:latest
      securityContext:
        privileged: true
      script: |
        buildctl build \
          --frontend dockerfile.v0 \
          --local context=/workspace/source/repo \
          --local dockerfile=/workspace/source/repo \
          --output type=image,name=$(params.image-tag),push=false
---
# Pipeline que orquestra tudo
apiVersion: tekton.dev/v1beta1
kind: Pipeline
metadata:
  name: build-and-push-pipeline
spec:
  params:
    - name: git-repository
      type: string
    - name: git-branch
      type: string
      default: "main"
    - name: docker-image-tag
      type: string
  workspaces:
    - name: ws
  tasks:
    - name: clone-source
      taskRef:
        name: git-clone-custom
      params:
        - name: git-url
          value: $(params.git-repository)
        - name: git-branch
          value: $(params.git-branch)
      workspaces:
        - name: output
          workspace: ws

    - name: build-and-package
      taskRef:
        name: build-image
      params:
        - name: image-tag
          value: $(params.docker-image-tag)
      runAfter:
        - clone-source
      workspaces:
        - name: source
          workspace: ws
---
# PipelineRun para disparar a execução
apiVersion: tekton.dev/v1beta1
kind: PipelineRun
metadata:
  name: build-app-v1
spec:
  pipelineRef:
    name: build-and-push-pipeline
  params:
    - name: git-repository
      value: "https://github.com/exemplo/minha-app.git"
    - name: git-branch
      value: "develop"
    - name: docker-image-tag
      value: "docker.io/meuuser/minha-app:latest"
  workspaces:
    - name: ws
      volumeClaimTemplate:
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 5Gi

Para executar este pipeline, salve o YAML em um arquivo (por exemplo, pipeline.yaml) e execute:

kubectl apply -f pipeline.yaml

# Acompanhar a execução
kubectl logs -f pipelinerun/build-app-v1

# Ou usar o CLI do Tekton
tkn pipelinerun logs build-app-v1 -f

Integração Avançada e Boas Práticas

ServiceAccount e Permissões

Tekton executa Tasks usando ServiceAccounts, que precisam de permissões específicas para acessar recursos do cluster. Por padrão, Tasks rodam como default, mas isso é insuficiente para operações como push para registries de imagem ou acesso a secrets.

# ServiceAccount dedicado para CI/CD
apiVersion: v1
kind: ServiceAccount
metadata:
  name: tekton-cicd
  namespace: ci-cd
---
# ClusterRole com permissões necessárias
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: tekton-cicd-role
rules:
  - apiGroups: [""]
    resources: ["secrets", "configmaps"]
    verbs: ["get", "list"]
  - apiGroups: [""]
    resources: ["persistentvolumes", "persistentvolumeclaims"]
    verbs: ["get", "list", "create", "delete"]
  - apiGroups: ["tekton.dev"]
    resources: ["taskruns", "pipelineruns"]
    verbs: ["get", "list", "create", "delete"]
---
# Binding do role ao ServiceAccount
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: tekton-cicd-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: tekton-cicd-role
subjects:
  - kind: ServiceAccount
    name: tekton-cicd
    namespace: ci-cd

Depois, referencie este ServiceAccount em suas PipelineRuns:

apiVersion: tekton.dev/v1beta1
kind: PipelineRun
metadata:
  name: secured-run
spec:
  serviceAccountName: tekton-cicd
  pipelineRef:
    name: build-and-push-pipeline
  # ... resto da configuração

Triggers: Automação Baseada em Eventos

Tasks e Pipelines são úteis, mas você provavelmente quer que pipelines sejam disparados automaticamente — quando código é empurrado para um repositório, por exemplo. Para isso, você usa Tekton Triggers.

# EventListener: escuta eventos do webhook do GitHub
apiVersion: triggers.tekton.dev/v1beta1
kind: EventListener
metadata:
  name: github-push-listener
  namespace: ci-cd
spec:
  serviceAccountName: tekton-cicd
  triggers:
    - name: github-push-trigger
      interceptors:
        - name: "verify-github-secret"
          ref:
            name: github-interceptors
          params:
            - name: secretRef
              value:
              name: github-secret
              key: webhook-secret
      bindings:
        - ref: github-binding
      template:
        ref: pipeline-template
---
# TriggerBinding: extrai dados do evento GitHub
apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerBinding
metadata:
  name: github-binding
  namespace: ci-cd
spec:
  params:
    - name: git-repo-url
      value: $(body.repository.clone_url)
    - name: git-branch
      value: $(body.ref)
    - name: git-commit
      value: $(body.head_commit.id)
---
# TriggerTemplate: cria PipelineRun com parâmetros extraídos
apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerTemplate
metadata:
  name: pipeline-template
  namespace: ci-cd
spec:
  params:
    - name: git-repo-url
    - name: git-branch
    - name: git-commit
  resourcetemplates:
    - apiVersion: tekton.dev/v1beta1
      kind: PipelineRun
      metadata:
        name: build-$(tt.params.git-commit)
      spec:
        pipelineRef:
          name: build-and-push-pipeline
        params:
          - name: git-repository
            value: $(tt.params.git-repo-url)
          - name: git-branch
            value: $(tt.params.git-branch)
          - name: docker-image-tag
            value: "docker.io/seu-user/seu-app:$(tt.params.git-commit)"
        workspaces:
          - name: ws
            volumeClaimTemplate:
              spec:
                accessModes:
                  - ReadWriteOnce
                resources:
                  requests:
                    storage: 5Gi

Para conectar ao GitHub, você precisa criar um webhook que aponte para o EventListener. Tekton Triggers cria um serviço automaticamente; você só precisa descobrir a URL pública (usando ingress ou port-forward) e adicionar como webhook no repositório GitHub.

Observabilidade e Logging

Tekton integra-se bem com ferramentas de logging. Você pode acompanhar execuções através de múltiplos canais:

# Logs detalhados em tempo real
tkn pipelinerun logs <nome-do-run> -f

# Listar todos os PipelineRuns
tkn pipelinerun list

# Describir um PipelineRun específico
tkn pipelinerun describe <nome-do-run>

# Ver status de TaskRuns geradas
kubectl get taskrun

Para integração com ferramentas de observabilidade (como Grafana, Prometheus), Tekton expõe métricas via Prometheus no endpoint /metrics. Você pode scrapeá-las com seu stack de observabilidade usual.

Conclusão

Você aprendeu que Tekton é CI/CD nativo de Kubernetes: não uma ferramenta externa, mas um framework de recursos Kubernetes que orquestra pipelines escaláveis e reutilizáveis. Tasks são unidades atômicas reutilizáveis, Pipelines orquestram múltiplas Tasks com dependências, e PipelineRuns executam Pipelines com parâmetros específicos — essa separação de conceitos torna o sistema extremamente modular.

A integração com Triggers permite automação real baseada em eventos (webhooks do GitHub, GitLab, etc.), transformando Tekton em um sistema de CI/CD completo sem depender de serviços externos. Com permissões corretas (ServiceAccounts e RBAC), você consegue construir pipelines seguros que acessam secrets, criam recursos no cluster e interagem com registries de imagem.

Referências

• Tekton Pipelines Documentation — Documentação oficial do Tekton, cobrindo Task, Pipeline e PipelineRun em detalhe
• Tekton Triggers — Guia completo sobre EventListener, TriggerBinding e TriggerTemplate para automação
• Kubernetes CustomResourceDefinitions — Conceitos fundamentais sobre CRDs, necessários para entender como Tekton estende Kubernetes
• Getting Started with Tekton — Tutoriais passo a passo para instalação e primeiros pipelines