Este guia de referência rápida (Cheat Sheet) compila os comandos Kubernetes mais utilizados, organizados por funcionalidade, para otimizar o desenvolvimento e a administração de ambientes conteinerizados em clusters Kubernetes.

# Verificar a versão do cliente kubectl
kubectl version --client
 
# Exibir informações do cluster
kubectl cluster-info
 
# Listar todos os contextos disponíveis
kubectl config get-contexts
 
# Obter o contexto atual
kubectl config current-context
 
# Alternar para um contexto específico
kubectl config use-context <context-name>
 
# Exibir a configuração completa do kubeconfig
kubectl config view
 
# Definir o namespace padrão para o contexto atual
kubectl config set-context --current --namespace=<namespace>
 
# Criar um novo contexto
kubectl config set-context <context-name> --cluster=<cluster> --user=<user>

# Listar todos os namespaces
kubectl get namespaces
kubectl get ns
 
# Criar um novo namespace
kubectl create namespace <namespace-name>
 
# Deletar um namespace (e todos os recursos dentro dele)
kubectl delete namespace <namespace-name>
 
# Exibir informações detalhadas sobre um namespace
kubectl describe namespace <namespace-name>
 
# Definir um namespace como padrão para todos os comandos
kubectl config set-context --current --namespace=<namespace-name>
 
# Listar recursos em um namespace específico
kubectl get pods --namespace=<namespace-name>
kubectl get pods -n <namespace-name>

# Listar todos os pods no namespace padrão
kubectl get pods
 
# Listar todos os pods em todos os namespaces
kubectl get pods --all-namespaces
kubectl get pods -A
 
# Listar pods com informações detalhadas (IP, Node, etc.)
kubectl get pods -o wide
 
# Exibir informações detalhadas sobre um pod específico
kubectl describe pod <pod-name>
 
# Visualizar logs de um pod
kubectl logs <pod-name>
 
# Seguir logs em tempo real (similar a 'tail -f')
kubectl logs -f <pod-name>
 
# Visualizar logs de um container específico em um pod multi-container
kubectl logs <pod-name> -c <container-name>
 
# Acessar um terminal interativo dentro de um pod
kubectl exec -it <pod-name> -- /bin/bash
 
# Executar um comando específico em um pod
kubectl exec <pod-name> -- <comando>
 
# Copiar arquivos do pod para o host
kubectl cp <pod-name>:<caminho> <local-host>
 
# Copiar arquivos do host para o pod
kubectl cp <local-host> <pod-name>:<caminho>
 
# Criar um pod a partir de uma imagem Docker
kubectl run <pod-name> --image=<imagem>:<tag>
 
# Deletar um pod
kubectl delete pod <pod-name>
 
# Deletar múltiplos pods
kubectl delete pods <pod1> <pod2> <pod3>
 
# Deletar todos os pods em um namespace
kubectl delete pods --all
 
# Exibir eventos de um pod
kubectl describe pod <pod-name> | grep -A 10 Events

# Listar todos os deployments
kubectl get deployments
kubectl get deploy
 
# Exibir informações detalhadas sobre um deployment
kubectl describe deployment <deployment-name>
 
# Criar um deployment a partir de uma imagem
kubectl create deployment <deployment-name> --image=<imagem>:<tag>
 
# Escalar um deployment (aumentar/diminuir réplicas)
kubectl scale deployment <deployment-name> --replicas=<número>
 
# Atualizar a imagem de um deployment (rolling update)
kubectl set image deployment/<deployment-name> <container-name>=<nova-imagem>:<tag>
 
# Verificar o status do rollout (atualização)
kubectl rollout status deployment/<deployment-name>
 
# Visualizar o histórico de rollouts
kubectl rollout history deployment/<deployment-name>
 
# Reverter para a versão anterior do deployment
kubectl rollout undo deployment/<deployment-name>
 
# Reverter para uma revisão específica
kubectl rollout undo deployment/<deployment-name> --to-revision=<número>
 
# Pausar um rollout
kubectl rollout pause deployment/<deployment-name>
 
# Retomar um rollout pausado
kubectl rollout resume deployment/<deployment-name>
 
# Deletar um deployment
kubectl delete deployment <deployment-name>
 
# Editar um deployment (abre editor de texto)
kubectl edit deployment <deployment-name>

# Listar todos os services
kubectl get services
kubectl get svc
 
# Exibir informações detalhadas sobre um service
kubectl describe service <service-name>
 
# Criar um service do tipo ClusterIP (padrão, acesso interno)
kubectl expose deployment <deployment-name> --type=ClusterIP --port=80 --target-port=8080
 
# Criar um service do tipo NodePort (acesso externo via porta do node)
kubectl expose deployment <deployment-name> --type=NodePort --port=80 --target-port=8080
 
# Criar um service do tipo LoadBalancer (acesso externo com IP balanceado)
kubectl expose deployment <deployment-name> --type=LoadBalancer --port=80 --target-port=8080
 
# Deletar um service
kubectl delete service <service-name>
 
# Obter o IP externo de um LoadBalancer service
kubectl get service <service-name> -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
 
# Listar endpoints de um service (pods que o service roteia tráfego)
kubectl get endpoints <service-name>

# Listar todos os ConfigMaps
kubectl get configmaps
kubectl get cm
 
# Criar um ConfigMap a partir de um arquivo
kubectl create configmap <configmap-name> --from-file=<arquivo>
 
# Criar um ConfigMap a partir de um diretório
kubectl create configmap <configmap-name> --from-file=<diretório>
 
# Criar um ConfigMap a partir de pares chave-valor
kubectl create configmap <configmap-name> --from-literal=chave1=valor1 --from-literal=chave2=valor2
 
# Exibir o conteúdo de um ConfigMap
kubectl get configmap <configmap-name> -o yaml
 
# Deletar um ConfigMap
kubectl delete configmap <configmap-name>
 
# Listar todos os Secrets
kubectl get secrets
 
# Criar um Secret genérico
kubectl create secret generic <secret-name> --from-literal=username=user --from-literal=password=pass
 
# Criar um Secret a partir de um arquivo
kubectl create secret generic <secret-name> --from-file=<arquivo>
 
# Criar um Secret do tipo docker-registry (para autenticação em registries privados)
kubectl create secret docker-registry <secret-name> --docker-server=<registry> --docker-username=<user> --docker-password=<pass>
 
# Exibir o conteúdo de um Secret (codificado em base64)
kubectl get secret <secret-name> -o yaml
 
# Decodificar um valor base64 de um Secret
kubectl get secret <secret-name> -o jsonpath='{.data.chave}' | base64 --decode
 
# Deletar um Secret
kubectl delete secret <secret-name>

# Listar todos os Persistent Volumes
kubectl get persistentvolumes
kubectl get pv
 
# Listar todos os Persistent Volume Claims
kubectl get persistentvolumeclaims
kubectl get pvc
 
# Exibir informações detalhadas sobre um PV
kubectl describe pv <pv-name>
 
# Exibir informações detalhadas sobre um PVC
kubectl describe pvc <pvc-name>
 
# Criar um PVC a partir de um manifesto YAML
kubectl apply -f <arquivo-pvc.yaml>
 
# Deletar um PVC
kubectl delete pvc <pvc-name>
 
# Deletar um PV
kubectl delete pv <pv-name>
 
# Listar Storage Classes disponíveis
kubectl get storageclasses
kubectl get sc

# Listar todos os Ingress
kubectl get ingress
 
# Exibir informações detalhadas sobre um Ingress
kubectl describe ingress <ingress-name>
 
# Criar um Ingress a partir de um manifesto YAML
kubectl apply -f <arquivo-ingress.yaml>
 
# Deletar um Ingress
kubectl delete ingress <ingress-name>
 
# Obter o IP ou hostname do Ingress
kubectl get ingress <ingress-name> -o jsonpath='{.status.loadBalancer.ingress[0].ip}'

# Deletar todos os recursos em um namespace
kubectl delete all --all -n <namespace>
 
# Deletar todos os pods em um namespace
kubectl delete pods --all -n <namespace>
 
# Deletar todos os deployments em um namespace
kubectl delete deployments --all -n <namespace>
 
# Deletar todos os services em um namespace
kubectl delete services --all -n <namespace>
 
# Deletar todos os ConfigMaps em um namespace
kubectl delete configmaps --all -n <namespace>
 
# Deletar todos os Secrets em um namespace
kubectl delete secrets --all -n <namespace>
 
# Deletar todos os PVCs em um namespace
kubectl delete pvc --all -n <namespace>
 
# Deletar recursos por label
kubectl delete pods -l app=myapp
 
# Deletar recursos por tipo e label
kubectl delete deployment,service -l app=myapp

# Exibir o uso de CPU e memória dos pods
kubectl top pods
 
# Exibir o uso de CPU e memória dos nodes
kubectl top nodes
 
# Exibir o uso detalhado de recursos em todos os namespaces
kubectl top pods --all-namespaces
 
# Exibir o uso de recursos de um pod específico
kubectl top pod <pod-name>

# Aplicar um manifesto YAML (criar ou atualizar)
kubectl apply -f <arquivo.yaml>
 
# Aplicar todos os manifestos em um diretório
kubectl apply -f <diretório>
 
# Aplicar um manifesto com validação prévia (dry-run)
kubectl apply -f <arquivo.yaml> --dry-run=client
 
# Aplicar e visualizar as mudanças que serão feitas
kubectl apply -f <arquivo.yaml> --dry-run=server
 
# Deletar recursos definidos em um manifesto
kubectl delete -f <arquivo.yaml>
 
# Exibir o manifesto de um recurso em formato YAML
kubectl get <tipo> <nome> -o yaml
 
# Exibir o manifesto de um recurso em formato JSON
kubectl get <tipo> <nome> -o json
 
# Editar um recurso diretamente
kubectl edit <tipo> <nome>
 
# Aplicar um patch (modificação parcial) a um recurso
kubectl patch <tipo> <nome> -p '{"spec":{"replicas":3}}'

# Listar recursos com um label específico
kubectl get pods -l app=myapp
 
# Listar recursos com múltiplos labels
kubectl get pods -l app=myapp,tier=frontend
 
# Listar recursos que NÃO possuem um label
kubectl get pods -l '!app'
 
# Adicionar um label a um pod
kubectl label pod <pod-name> app=myapp
 
# Remover um label de um pod
kubectl label pod <pod-name> app-
 
# Adicionar um label a todos os pods com um seletor
kubectl label pods -l app=oldname app=newname --overwrite
 
# Exibir labels de um recurso
kubectl get pods --show-labels

# Encaminhar uma porta local para um pod
kubectl port-forward pod/<pod-name> 8080:8080
 
# Encaminhar uma porta local para um service
kubectl port-forward service/<service-name> 8080:80
 
# Encaminhar uma porta local para um deployment
kubectl port-forward deployment/<deployment-name> 8080:8080
 
# Encaminhar em background
kubectl port-forward pod/<pod-name> 8080:8080 &

# Verificar o status de um rollout
kubectl rollout status deployment/<deployment-name>
 
# Visualizar o histórico de revisões
kubectl rollout history deployment/<deployment-name>
 
# Visualizar detalhes de uma revisão específica
kubectl rollout history deployment/<deployment-name> --revision=<número>
 
# Reverter para a versão anterior
kubectl rollout undo deployment/<deployment-name>
 
# Reverter para uma revisão específica
kubectl rollout undo deployment/<deployment-name> --to-revision=<número>
 
# Pausar um rollout
kubectl rollout pause deployment/<deployment-name>
 
# Retomar um rollout pausado
kubectl rollout resume deployment/<deployment-name>
 
# Reiniciar um deployment (mata todos os pods e cria novos)
kubectl rollout restart deployment/<deployment-name>

# Descrever um recurso (informações detalhadas e eventos)
kubectl describe <tipo> <nome>
 
# Visualizar eventos do cluster
kubectl get events
 
# Visualizar eventos de um namespace específico
kubectl get events -n <namespace>
 
# Visualizar eventos ordenados por timestamp
kubectl get events --sort-by='.lastTimestamp'
 
# Verificar a saúde de um node
kubectl describe node <node-name>
 
# Listar todos os nodes
kubectl get nodes
 
# Exibir informações detalhadas de um node
kubectl describe node <node-name>
 
# Verificar os logs do kubelet em um node (requer acesso SSH)
journalctl -u kubelet -n 100
 
# Executar um comando de debug em um pod
kubectl debug pod/<pod-name> -it --image=busybox
 
# Criar um pod de debug efêmero
kubectl run -it --rm debug --image=busybox --restart=Never -- sh
 
# Verificar a capacidade de um node
kubectl describe node <node-name> | grep -A 5 "Allocated resources"

# Listar todos os Custom Resource Definitions
kubectl get crd
 
# Exibir informações sobre um CRD
kubectl describe crd <crd-name>
 
# Listar recursos customizados de um tipo específico
kubectl get <custom-resource-type>
 
# Deletar um recurso customizado
kubectl delete <custom-resource-type> <nome>

# Listar todas as Roles
kubectl get roles
 
# Listar todas as ClusterRoles
kubectl get clusterroles
 
# Exibir informações sobre uma Role
kubectl describe role <role-name>
 
# Listar todas as RoleBindings
kubectl get rolebindings
 
# Listar todas as ClusterRoleBindings
kubectl get clusterrolebindings
 
# Criar uma Role a partir de um manifesto
kubectl apply -f <arquivo-role.yaml>
 
# Criar uma RoleBinding
kubectl create rolebinding <binding-name> --clusterrole=<role> --serviceaccount=<namespace>:<sa>
 
# Verificar permissões de um usuário
kubectl auth can-i get pods --as=<usuário>
 
# Verificar permissões de uma service account
kubectl auth can-i get pods --as=system:serviceaccount:<namespace>:<sa>

# Exibir uso de recursos dos pods
kubectl top pods
 
# Exibir uso de recursos dos nodes
kubectl top nodes
 
# Exibir uso detalhado de recursos
kubectl top pods --all-namespaces --containers
 
# Obter informações de um pod em formato JSON
kubectl get pod <pod-name> -o json
 
# Exibir apenas o status de um pod
kubectl get pod <pod-name> -o jsonpath='{.status.phase}'
 
# Exibir o IP de um pod
kubectl get pod <pod-name> -o jsonpath='{.status.podIP}'
 
# Exibir o node em que um pod está rodando
kubectl get pod <pod-name> -o jsonpath='{.spec.nodeName}'

# Instalar o Helm (gerenciador de pacotes para Kubernetes)
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
 
# Adicionar um repositório Helm
helm repo add <repo-name> <repo-url>
 
# Listar repositórios Helm
helm repo list
 
# Buscar um chart no repositório
helm search repo <chart-name>
 
# Instalar um chart Helm
helm install <release-name> <chart-name>
 
# Listar releases Helm instalados
helm list
 
# Atualizar um release Helm
helm upgrade <release-name> <chart-name>
 
# Desinstalar um release Helm
helm uninstall <release-name>
 
# Instalar o Kustomize (ferramenta de customização de manifestos)
curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
 
# Aplicar um Kustomization
kubectl apply -k <diretório>

# Listar todas as Network Policies
kubectl get networkpolicies
 
# Exibir informações sobre uma Network Policy
kubectl describe networkpolicy <policy-name>
 
# Criar uma Network Policy a partir de um manifesto
kubectl apply -f <arquivo-networkpolicy.yaml>
 
# Deletar uma Network Policy
kubectl delete networkpolicy <policy-name>

1. Sempre use namespaces: Organize seus recursos em namespaces para melhor isolamento e gerenciamento.

2. Use labels e seletores: Labels facilitam a organização e seleção de recursos.

3. Implemente resource requests e limits: Defina requisitos de CPU e memória para evitar problemas de scheduling.

4. Use Health Checks: Configure liveness probes e readiness probes para melhor confiabilidade.

5. Versione seus manifestos: Mantenha seus arquivos YAML em controle de versão (Git).

6. Use ConfigMaps e Secrets: Separe configuração de código.

7. Implemente RBAC: Restrinja permissões usando Roles e RoleBindings.

8. Monitore seus recursos: Use `kubectl top` e ferramentas de monitoramento para acompanhar o uso de recursos.

# Listar pods com mais detalhes
alias kgp='kubectl get pods'
alias kgpa='kubectl get pods --all-namespaces'
alias kgpw='kubectl get pods -o wide'
 
# Listar deployments
alias kgd='kubectl get deployments'
alias kgda='kubectl get deployments --all-namespaces'
 
# Listar services
alias kgs='kubectl get services'
alias kgsa='kubectl get services --all-namespaces'
 
# Descrever recursos
alias kdp='kubectl describe pod'
alias kdd='kubectl describe deployment'
alias kds='kubectl describe service'
 
# Logs
alias kl='kubectl logs'
alias klf='kubectl logs -f'
 
# Executar comando em um pod
alias kex='kubectl exec -it'
 
# Aplicar manifesto
alias ka='kubectl apply -f'
 
# Deletar recurso
alias kdel='kubectl delete'
 
# Port forwarding
alias kpf='kubectl port-forward'
 
# Editar recurso
alias ke='kubectl edit'
 
# Rollout
alias kr='kubectl rollout'
 
# Contexto
alias kcc='kubectl config current-context'
alias kcu='kubectl config use-context'
 
# Namespace
alias kn='kubectl config set-context --current --namespace'
alias kgn='kubectl get namespaces'
 
# Listar todos os recursos
alias kga='kubectl get all'
 
# Obter informações do cluster
alias kci='kubectl cluster-info'
 
# Verificar versão
alias kv='kubectl version --client'

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 15
          periodSeconds: 20
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 10

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "postgresql://db:5432/myapp"
  debug_mode: "false"
  log_level: "info"

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
stringData:
  database_user: "admin"
  database_password: "securepassword123"

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-storage
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-storage
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        ports:
        - containerPort: 3306
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: password
        volumeMounts:
        - name: mysql-storage
          mountPath: /var/lib/mysql
  volumeClaimTemplates:
  - metadata:
      name: mysql-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 10Gi

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
spec:
  selector:
    matchLabels:
      app: node-exporter
  template:
    metadata:
      labels:
        app: node-exporter
    spec:
      containers:
      - name: node-exporter
        image: prom/node-exporter:latest
        ports:
        - containerPort: 9100
        volumeMounts:
        - name: proc
          mountPath: /host/proc
          readOnly: true
        - name: sys
          mountPath: /host/sys
          readOnly: true
      volumes:
      - name: proc
        hostPath:
          path: /proc
      - name: sys
        hostPath:
          path: /sys

apiVersion: batch/v1
kind: Job
metadata:
  name: backup-job
spec:
  template:
    spec:
      containers:
      - name: backup
        image: backup-image:latest
        command: ["bash", "-c", "backup-script.sh"]
      restartPolicy: Never
  backoffLimit: 3

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-backup
spec:
  schedule: "0 2 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: backup-image:latest
            command: ["bash", "-c", "backup-script.sh"]
          restartPolicy: OnFailure

list_all_resources.sh

#!/bin/bash
# Lista todos os recursos do cluster de forma organizada
 
echo "=== NODES ==="
kubectl get nodes
 
echo -e "\n=== NAMESPACES ==="
kubectl get namespaces
 
echo -e "\n=== PODS (todos os namespaces) ==="
kubectl get pods -A
 
echo -e "\n=== DEPLOYMENTS ==="
kubectl get deployments -A
 
echo -e "\n=== SERVICES ==="
kubectl get services -A
 
echo -e "\n=== INGRESS ==="
kubectl get ingress -A
 
echo -e "\n=== PERSISTENT VOLUMES ==="
kubectl get pv
 
echo -e "\n=== PERSISTENT VOLUME CLAIMS ==="
kubectl get pvc -A
 
echo -e "\n=== CONFIGMAPS ==="
kubectl get configmaps -A
 
echo -e "\n=== SECRETS ==="
kubectl get secrets -A

cleanup_namespace.sh

#!/bin/bash
# Deleta todos os recursos em um namespace específico
 
NAMESPACE=${1:-default}
 
echo "Deletando todos os recursos no namespace: $NAMESPACE"
 
kubectl delete all --all -n $NAMESPACE
kubectl delete configmaps --all -n $NAMESPACE
kubectl delete secrets --all -n $NAMESPACE
kubectl delete pvc --all -n $NAMESPACE
 
echo "Limpeza concluída!"

monitor_resources.sh

#!/bin/bash
# Monitora o uso de recursos dos pods em tempo real
 
echo "Monitorando uso de recursos (Ctrl+C para sair)..."
watch -n 2 'kubectl top pods --all-namespaces'

# 1. Verificar o status do pod
kubectl describe pod <pod-name>
 
# 2. Verificar os logs
kubectl logs <pod-name>
 
# 3. Verificar eventos
kubectl get events --sort-by='.lastTimestamp'
 
# 4. Verificar se a imagem existe
kubectl get pod <pod-name> -o jsonpath='{.spec.containers[0].image}'
 
# 5. Verificar recursos disponíveis no node
kubectl describe node <node-name>

# 1. Verificar logs anteriores
kubectl logs <pod-name> --previous
 
# 2. Descrever o pod para ver eventos
kubectl describe pod <pod-name>
 
# 3. Verificar o comando de inicialização
kubectl get pod <pod-name> -o yaml | grep -A 5 "command:"
 
# 4. Testar a imagem localmente
docker run -it <imagem>:<tag> /bin/bash

# 1. Verificar se o service existe
kubectl get service <service-name>
 
# 2. Verificar os endpoints
kubectl get endpoints <service-name>
 
# 3. Verificar os labels do pod e do service
kubectl get pod <pod-name> --show-labels
kubectl get service <service-name> -o yaml | grep -A 5 "selector:"
 
# 4. Testar conectividade dentro do cluster
kubectl run -it --rm debug --image=busybox --restart=Never -- wget -O- http://<service-name>