<h2>O que é Tekton e por que você precisa aprender</h2>
<p>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 <strong>é</strong> um conjunto de controladores Kubernetes que trabalham dentro do seu cluster, criando e orquestrando pipelines como recursos nativos do Kubernetes.</p>
<p>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.</p>
<h2>Conceitos Fundamentais do Tekton</h2>
<h3>Task: A Unidade Atômica de Trabalho</h3>
<p>Uma <strong>Task</strong> 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.</p>
<pre><code class="language-yaml">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"</code></pre>
<p>Cada <code>step</code> 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 <strong>completamente reutilizáveis</strong> — você define uma vez e a utiliza em múltiplos pipelines.</p>
<h3>Pipeline: Orquestração de Tasks</h3>
<p>Um <strong>Pipeline</strong> é 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.</p>
<pre><code class="language-yaml">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</code></pre>
<p>Note o campo <code>runAfter</code> — isso cria dependências explícitas entre Tasks. Quando você não especifica <code>runAfter</code>, Tekton executa as Tasks em paralelo quando possível, maximizando eficiência. O <code>workspaces</code> compartilhado permite que o código clonado na primeira Task seja acessado pelas Tasks subsequentes.</p>
<h3>PipelineRun: Execução de um Pipeline</h3>
<p>Uma <strong>PipelineRun</strong> é 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).</p>
<pre><code class="language-yaml">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</code></pre>
<p>Quando você cria uma PipelineRun, o Tekton começa a orquestrar a execução imediatamente. Você pode monitorar o progresso com <code>kubectl logs</code> ou <code>kubectl describe pipelinerun app-deploy-run-001</code>.</p>
<h2>Instalação e Ambiente Prático</h2>
<h3>Pré-requisitos e Instalação do Tekton</h3>
<p>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.</p>
<pre><code class="language-bash"># 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</code></pre>
<p>Após a instalação, todos os componentes do Tekton rodam no namespace <code>tekton-pipelines</code>. Você trabalha criando Tasks, Pipelines e PipelineRuns em qualquer namespace (recomenda-se criar um namespace dedicado como <code>ci-cd</code> ou <code>tekton-workspace</code>).</p>
<h3>Exemplo Completo: Pipeline Real de Build e Push</h3>
<p>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.</p>
<pre><code class="language-yaml"># 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</code></pre>
<p>Para executar este pipeline, salve o YAML em um arquivo (por exemplo, <code>pipeline.yaml</code>) e execute:</p>
<pre><code class="language-bash">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</code></pre>
<h2>Integração Avançada e Boas Práticas</h2>
<h3>ServiceAccount e Permissões</h3>
<p>Tekton executa Tasks usando ServiceAccounts, que precisam de permissões específicas para acessar recursos do cluster. Por padrão, Tasks rodam como <code>default</code>, mas isso é insuficiente para operações como push para registries de imagem ou acesso a secrets.</p>
<pre><code class="language-yaml"># 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</code></pre>
<p>Depois, referencie este ServiceAccount em suas PipelineRuns:</p>
<pre><code class="language-yaml">apiVersion: tekton.dev/v1beta1
kind: PipelineRun
metadata:
name: secured-run
spec:
serviceAccountName: tekton-cicd
pipelineRef:
name: build-and-push-pipeline
... resto da configuração</code></pre>
<h3>Triggers: Automação Baseada em Eventos</h3>
<p>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 <strong>Tekton Triggers</strong>.</p>
<pre><code class="language-yaml"># 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</code></pre>
<p>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.</p>
<h3>Observabilidade e Logging</h3>
<p>Tekton integra-se bem com ferramentas de logging. Você pode acompanhar execuções através de múltiplos canais:</p>
<pre><code class="language-bash"># 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</code></pre>
<p>Para integração com ferramentas de observabilidade (como Grafana, Prometheus), Tekton expõe métricas via Prometheus no endpoint <code>/metrics</code>. Você pode scrapeá-las com seu stack de observabilidade usual.</p>
<h2>Conclusão</h2>
<p>Você aprendeu que <strong>Tekton é CI/CD nativo de Kubernetes</strong>: 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.</p>
<p>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.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://tekton.dev/docs/pipelines/" target="_blank" rel="noopener noreferrer">Tekton Pipelines Documentation</a> — Documentação oficial do Tekton, cobrindo Task, Pipeline e PipelineRun em detalhe</li>
<li><a href="https://tekton.dev/docs/triggers/" target="_blank" rel="noopener noreferrer">Tekton Triggers</a> — Guia completo sobre EventListener, TriggerBinding e TriggerTemplate para automação</li>
<li><a href="https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/" target="_blank" rel="noopener noreferrer">Kubernetes CustomResourceDefinitions</a> — Conceitos fundamentais sobre CRDs, necessários para entender como Tekton estende Kubernetes</li>
<li><a href="https://tekton.dev/docs/getting-started/" target="_blank" rel="noopener noreferrer">Getting Started with Tekton</a> — Tutoriais passo a passo para instalação e primeiros pipelines</li>
</ul>
<p><!-- FIM --></p>