fundamentals tekton

Tekton: Criando sua Primeira Pipeline

Aprenda a criar uma pipeline CI/CD completa com Tekton - do clone ao deploy.

CodeSolve 26 Jan 2026 4 min de leitura

Neste Guide

Introducao

Tekton e uma framework cloud-native para criar pipelines CI/CD que rodam diretamente no Kubernetes. Diferente de ferramentas tradicionais como Jenkins, Tekton e declarativo, escalavel e se integra nativamente com o ecossistema Kubernetes.

Neste guide, vamos criar uma pipeline completa que:

Clona um repositorio Git
Constroi uma imagem Docker
Faz push para um registry
Atualiza um deployment via GitOps

Pre-requisitos

Antes de comecar, certifique-se de ter:

Cluster Kubernetes funcionando (minikube, kind, ou cluster real)
Tekton Pipelines instalado
kubectl configurado
Acesso a um registry de imagens (Docker Hub, Harbor, etc.)

1
2
# Verificar se Tekton esta instalado
kubectl get pods -n tekton-pipelines

Conceitos Fundamentais

Hierarquia Tekton

Pipeline
    └── Task (1..n)
           └── Step (1..n)

Conceito	Descricao
Step	Comando unico executado em um container
Task	Conjunto de steps que rodam sequencialmente
Pipeline	Orquestracao de tasks (sequencial ou paralelo)
PipelineRun	Execucao de uma pipeline

Workspaces

Workspaces sao volumes compartilhados entre tasks. Essenciais para passar artefatos (codigo clonado, binarios compilados) de uma task para outra.

Passo a Passo

1. Criar a Task de Clone

Primeiro, criamos uma task que clona o repositorio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: git-clone
spec:
  params:
    - name: url
      type: string
      description: URL do repositorio
    - name: revision
      type: string
      default: main
  workspaces:
    - name: output
      description: Onde o codigo sera clonado
  steps:
    - name: clone
      image: alpine/git:latest
      script: |
        git clone $(params.url) $(workspaces.output.path)
        cd $(workspaces.output.path)
        git checkout $(params.revision)        

2. Criar a Task de Build

Agora criamos a task que constroi a imagem Docker usando Kaniko:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: build-push
spec:
  params:
    - name: IMAGE
      type: string
      description: Nome completo da imagem (registry/repo:tag)
  workspaces:
    - name: source
      description: Codigo fonte com Dockerfile
  steps:
    - name: build-and-push
      image: gcr.io/kaniko-project/executor:latest
      args:
        - --dockerfile=$(workspaces.source.path)/Dockerfile
        - --context=$(workspaces.source.path)
        - --destination=$(params.IMAGE)

3. Criar a Pipeline

Agora orquestramos as tasks em uma pipeline:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
apiVersion: tekton.dev/v1
kind: Pipeline
metadata:
  name: ci-pipeline
spec:
  params:
    - name: git-url
      type: string
    - name: image-name
      type: string
  workspaces:
    - name: shared-workspace
  tasks:
    - name: clone
      taskRef:
        name: git-clone
      params:
        - name: url
          value: $(params.git-url)
      workspaces:
        - name: output
          workspace: shared-workspace

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

4. Executar a Pipeline

Para executar, criamos um PipelineRun:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
apiVersion: tekton.dev/v1
kind: PipelineRun
metadata:
  generateName: ci-pipeline-run-
spec:
  pipelineRef:
    name: ci-pipeline
  params:
    - name: git-url
      value: "https://github.com/seu-usuario/seu-repo.git"
    - name: image-name
      value: "docker.io/seu-usuario/sua-imagem:v1"
  workspaces:
    - name: shared-workspace
      volumeClaimTemplate:
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 1Gi

1
2
3
4
5
# Aplicar e executar
kubectl apply -f pipelinerun.yaml

# Acompanhar execucao
tkn pipelinerun logs -f

Diagrama de Fluxo

┌─────────────────────────────────────────────────────────────┐
│                    PipelineRun                               │
│  ┌─────────────────────────────────────────────────────────┐│
│  │                     Pipeline                             ││
│  │  ┌──────────┐        ┌──────────┐        ┌──────────┐   ││
│  │  │  clone   │───────▶│  build   │───────▶│  deploy  │   ││
│  │  └──────────┘        └──────────┘        └──────────┘   ││
│  │       │                   │                   │          ││
│  │       ▼                   ▼                   ▼          ││
│  │  ════════════════ shared-workspace ══════════════════   ││
│  └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘

Troubleshooting

Pipeline travada em Pending

Se a pipeline ficar travada, verifique:

PVC pendente: O cluster tem storage class configurado?
Permissoes: A ServiceAccount tem acesso ao registry?
Recursos: Ha recursos suficientes no cluster?

1
2
3
4
5
# Verificar eventos
kubectl describe pipelinerun <nome>

# Ver logs de uma task especifica
tkn taskrun logs <nome-da-taskrun>

Erro de autenticacao no registry

Configure um secret do Docker:

1
2
3
4
5
kubectl create secret docker-registry regcred \
  --docker-server=docker.io \
  --docker-username=seu-usuario \
  --docker-password=seu-token \
  --docker-email=seu@email.com

Conclusao

Voce criou sua primeira pipeline Tekton! Os proximos passos sao:

Adicionar task de testes automatizados
Configurar triggers para execucao automatica
Integrar com ArgoCD para GitOps

Precisa de ajuda implementando Tekton na sua empresa? A CodeSolve pode ajudar sua equipe a construir pipelines CI/CD enterprise-grade. Fale conosco.

tekton ci-cd kubernetes devops

Precisa de ajuda com Tekton: Criando sua Primeira Pipeline?

A CodeSolve pode ajudar sua equipe a implementar essa e outras solucoes.

Falar com a equipe