No coração do kit de ferramentas de qualquer administrador de Kubernetes está o kubectl — a poderosa interface de linha de comando feita para gerenciar clusters Kubernetes com eficiência.
O kubectl (pronunciado "kube-control" ou "kube-C-T-L") é sua linha direta de comunicação com o servidor de API do Kubernetes, permitindo implantar aplicações, inspecionar recursos, visualizar logs e executar praticamente qualquer operação dentro do cluster. Se você é engenheiro de DevOps, administrador de plataforma ou desenvolvedor que trabalha com aplicações em containers, dominar o kubectl é essencial para uma gestão eficaz de Kubernetes em cloud computing.
Este cheat sheet prático reúne os comandos kubectl mais úteis, com exemplos e dicas para você turbinar suas tarefas do dia a dia com Kubernetes.
Quais são as principais categorias de comandos do kubectl?
Logo do Kubectl
Os comandos do kubectl podem ser agrupados em três categorias principais, cada uma voltada a um aspecto da gestão do cluster:
1. Comandos de informações do cluster
Os comandos de informações do cluster mostram o estado e a configuração do seu cluster Kubernetes:
- Obter informações sobre os componentes do cluster
- Visualizar o status e os recursos dos nós
- Verificar a saúde do apiserver
- Inspecionar componentes do control plane
2. Comandos de gerenciamento de recursos
Os comandos de gerenciamento de recursos permitem criar, modificar, excluir e inspecionar recursos do Kubernetes:
- Criar e atualizar recursos
- Listar e descrever recursos
- Excluir recursos
- Aumentar e reduzir a escala dos recursos
- Editar recursos em tempo real
3. Comandos de implantação de aplicações
Por fim, os comandos de implantação de aplicações facilitam o deploy e a gestão do ciclo de vida da aplicação:
- Implantar aplicações a partir de YAML ou JSON
- Gerenciar deployments e rollouts
- Configurar autoscaling
- Atualizar configurações de aplicações
- Lidar com a rede da aplicação
Com essas três categorias em mente, vamos olhar mais de perto alguns comandos kubectl específicos que você vai usar bastante na sua jornada com Kubernetes.
Indo mais fundo: cheat sheet de comandos kubectl
pessoa programando no notebook
Abaixo está um cheat sheet para você manter por perto, com comandos kubectl que você provavelmente vai usar com frequência e exemplos para agilizar seus fluxos de trabalho no Kubernetes.
Pods
Pods são as menores unidades implantáveis no Kubernetes, formadas por um ou mais containers que compartilham armazenamento e recursos de rede.
Listar todos os pods:
kubectl get pods
Listar pods com mais detalhes:
kubectl get pods -o wide
Obter informações detalhadas de um pod específico:
kubectl describe pod
Criar um pod a partir de um arquivo YAML:
kubectl apply -f pod.yaml
Excluir um pod:
kubectl delete pod
Executar um comando dentro do container de um pod:
kubectl exec -it --
Obter logs do pod:
kubectl logs
Acompanhar os logs do pod em tempo real:
kubectl logs -f
Obter logs de um container específico em um pod com múltiplos containers:
kubectl logs -c
Fazer port-forward para um pod:
kubectl port-forward :
Copiar arquivos de/para um pod:
kubectl cp :/path/to/file /local/path
kubectl cp /local/path :/path/in/pod
Services
Services criam uma rede estável para os pods, facilitando a comunicação entre componentes ao funcionarem como uma camada de abstração.
Listar todos os services:
kubectl get services
Obter informações detalhadas de um service:
kubectl describe service
Criar um service a partir de um arquivo YAML:
kubectl apply -f service.yaml
Expor um deployment como um service:
kubectl expose deployment --port= --target-port=
Excluir um service:
kubectl delete service
Visualizar endpoints associados a um service:
kubectl get endpoints
Criar um service ClusterIP:
kubectl create service clusterip --tcp=:
Criar um service NodePort:
kubectl create service nodeport --tcp=:
Criar um service LoadBalancer:
kubectl create service loadbalancer --tcp=:
Deployments
Deployments oferecem atualizações declarativas para Pods e ReplicaSets, permitindo escalar e atualizar aplicações de forma simples.
Listar todos os deployments:
kubectl get deployments
Obter informações detalhadas de um deployment:
kubectl describe deployment
Criar um deployment a partir de um arquivo YAML:
kubectl apply -f deployment.yaml
Criar um deployment direto pela linha de comando:
kubectl create deployment --image=
Escalar um deployment:
kubectl scale deployment --replicas=
Atualizar a imagem de container de um deployment:
kubectl set image deployment/ =
Reverter um deployment para uma revisão anterior:
kubectl rollout undo deployment/
Visualizar o status do rollout do deployment:
kubectl rollout status deployment/
Visualizar o histórico de rollouts do deployment:
kubectl rollout history deployment/
Pausar um rollout de deployment:
kubectl rollout pause deployment/
Retomar um rollout de deployment:
kubectl rollout resume deployment/
ConfigMaps e Secrets
ConfigMaps e Secrets são usados para armazenar dados de configuração e informações sensíveis, respectivamente.
Aviso de segurança importante: tanto ConfigMaps quanto Secrets são armazenados no etcd sem criptografia por padrão. Por isso, é fundamental habilitar a criptografia em repouso ao lidar com dados sensíveis.
Listar ConfigMaps:
kubectl get configmaps
Criar um ConfigMap a partir de valores literais:
kubectl create configmap --from-literal=key1=value1 --from-literal=key2=value2
Criar um ConfigMap a partir de um arquivo:
kubectl create configmap --from-file=
Obter informações detalhadas de um ConfigMap:
kubectl describe configmap
Excluir um ConfigMap:
kubectl delete configmap
Listar Secrets:
kubectl get Secrets
Criar um Secret a partir de valores literais:
kubectl create secret generic --from-literal=key1=value1 --from-literal=key2=value2
Criar um Secret a partir de um arquivo:
kubectl create secret generic --from-file=
Obter informações detalhadas de um Secret:
kubectl describe secret
Excluir um Secret:
kubectl delete secret
Dicas avançadas para usar o kubectl
pessoa olhando o celular enquanto programa
O kubectl é indispensável para trabalhar com clusters Kubernetes e gerenciar seus recursos. Pegar o jeito da ferramenta facilita muito a vida e ajuda você a implantar, escalar e resolver problemas com mais eficiência. Com o kubectl edit, dá para alterar rapidamente recursos como pods e deployments direto da linha de comando.
Use namespaces de forma eficiente
Namespaces são um recurso central do Kubernetes que permite dividir o cluster em sub-clusters virtuais. Isso é muito útil em ambientes multi-tenant ou quando você lida com aplicações mais complexas.
Listar recursos em um namespace específico:
kubectl get -n
Criar um recurso em um namespace específico:
kubectl apply -f <file.yaml> -n
Definir o namespace padrão para todos os comandos kubectl:
kubectl config set-context --current --namespace=
Visualizar recursos em todos os namespaces:
kubectl get --all-namespaces
Criar um novo namespace:
kubectl create namespace
Vale agrupar recursos relacionados em namespaces próprios para criar limites claros entre apps ou times. Use nomes que deixem o propósito óbvio, como dev-frontend, prod-backend ou monitoring.
Seletores de label para filtrar recursos
Labels são pares chave-valor adicionados a objetos do Kubernetes. Elas são uma ótima forma de organizar, selecionar e gerenciar grupos de recursos com mais facilidade.
Listar recursos com uma label específica:
kubectl get -l key=value
Listar recursos com múltiplas condições de label:
kubectl get -l ‘key1=value1,key2=value2’
Listar recursos que tenham uma chave de label específica (independente do valor):
kubectl get -l ‘key’
Listar recursos que não tenham uma label específica:
kubectl get -l ‘!key’
Adicionar uma label a um recurso existente:
kubectl label key=value
Remover uma label de um recurso:
kubectl label key-
Manter uma estratégia consistente de labels é fundamental para gerenciar seus recursos com eficácia. Experimente labels como app, environment, tier, version e owner para criar um sistema claro e organizado.
Faça rolling updates
O Kubernetes facilita a atualização de aplicações sem downtime usando rolling updates. Essa estratégia substitui aos poucos as instâncias da versão antiga pela nova.
Atualizar um deployment com uma nova imagem (dispara o rolling update):
kubectl set image deployment/ =:
Verificar o status do rollout:
kubectl rollout status deployment/
Configurar a estratégia de atualização em um YAML de deployment:
spec:
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 25%
maxSurge: 25%
Reverter para a versão anterior caso problemas sejam detectados:
kubectl rollout undo deployment/
Pausar um rollout de deployment:
Copykubectl rollout pause deployment/
Isso é especialmente útil para deployments em estágios, permitindo liberar para um subconjunto de pods, validar o funcionamento e depois continuar o rollout após a verificação.
Retomar um rollout de deployment:
Copykubectl rollout resume deployment/
Para aplicações críticas, vale usar a flag --record ao alterar o deployment. Ela registra o comando utilizado, o que facilita acompanhar o histórico de mudanças depois:
kubectl apply -f deployment.yaml --record
Gerencie cotas e limites de recursos com cuidado
O gerenciamento de recursos tem um papel central na gestão do Kubernetes. Definir os requests e limits corretos é essencial para manter o cluster estável e garantir uma divisão justa.
Visualizar cotas de recursos em um namespace:
kubectl get resourcequota -n
Criar uma cota de recursos para um namespace:
kubectl create quota --hard=cpu=1,memory=1G,pods=10 -n
Verificar o uso de recursos dos pods:
kubectl top pods
Verificar o uso de recursos dos nós:
kubectl top nodes
Ao definir as especificações dos containers, sempre configure requests e limits de recursos:
resources:
requests:
memory: "64Mi"
cpu: "250m"
limits:
memory: "128Mi"
cpu: "500m"
Lembre-se: os requests ajudam o scheduler a decidir onde alocar seu pod, enquanto os limits definem o uso máximo antes que os containers possam ser encerrados. Uma boa regra é definir requests com base no uso esperado em estado estável e limits com base no que é aceitável em picos de uso.
Domine o debugging com kubectl
Fazer debugging é importante para manter suas apps Kubernetes rodando redondas. Felizmente, o kubectl tem vários comandos para te ajudar a resolver problemas com facilidade.
Obter logs do container:
kubectl logs -c
Debugging interativo com um pod temporário:
kubectl run debug --rm -it --image=busybox -- sh
Criar um container de debug anexado a um pod existente:
kubectl debug -it --image=busybox --share-processes --copy-to=
Visualizar eventos em um namespace:
kubectl get events -n
Verificar condições e detalhes de status do pod:
Copykubectl describe pod
Isso traz uma saída mais estruturada das condições do pod, mostrando o histórico completo de transições e o estado atual em um formato fácil de ler.
Verificar a conectividade entre pods usando um container de debug de rede:
kubectl run test-connectivity --rm -it --image=nicolaka/netshoot -- bash
Para problemas persistentes, use a flag -- previous para verificar logs de containers que travaram antes:
kubectl logs --previous
Boas práticas de segurança com o kubectl
duas pessoas programando no notebook
Manter o cluster Kubernetes seguro é fundamental, e o kubectl tem um papel importante nisso. Confira algumas boas práticas para reforçar sua segurança:
Gerencie controles de acesso com RBAC
Role-Based Access Control (RBAC) é o padrão de autorização no Kubernetes. Ele permite definir permissões detalhadas para usuários e service accounts.
Visualizar roles em um namespace:
kubectl get roles -n
Visualizar cluster roles:
kubectl get clusterroles
Visualizar role bindings:
kubectl get rolebindings -n
Visualizar cluster role bindings:
kubectl get clusterrolebindings
Criar uma role com permissões específicas:
kubectl create role developer --verb=get,list,watch --resource=pods,deployments -n
Vincular uma role a um usuário:
kubectl create rolebinding dev-user-binding --role=developer --user=dev-user -n
Sempre que possível, use RoleBindings em vez de ClusterRoleBindings para limitar as permissões a um namespace específico. Isso segue o princípio do menor privilégio, restringindo o acesso apenas aos namespaces necessários e reduzindo o impacto caso credenciais sejam comprometidas.
Siga o princípio do menor privilégio, dando a usuários e service accounts apenas as permissões necessárias para o trabalho. Crie o hábito de revisar periodicamente os role bindings para garantir que continuam fazendo sentido conforme papéis e responsabilidades mudam.
Manuseio seguro de Secrets
Os Secrets do Kubernetes precisam ser tratados com cuidado, já que armazenam informações sensíveis como chaves de API, senhas e certificados.
Criar um secret de forma segura a partir de um arquivo:
kubectl create secret generic db-credentials --from-file=./username.txt --from-file=./password.txt
Criar um secret TLS:
kubectl create secret tls tls-secret --cert=path/to/cert --key=path/to/key
Montar Secrets como variáveis de ambiente:
env:
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: db-credentials
key: password
Montar Secrets como arquivos:
volumes:
- name: secret-volume
secret:
secretName: ssl-certificates
Considere ferramentas externas de gerenciamento de secrets, como HashiCorp Vault, AWS Secrets Manager ou Sealed Secrets, para reforçar a segurança. Elas oferecem recursos úteis como rotação de secrets, trilhas de auditoria e criptografia.
Use o kubectl com contexto seguro
Sempre confirme se você está operando no contexto correto para não modificar o cluster errado por acidente.
Visualizar todos os contextos disponíveis:
kubectl config get-contexts
Mudar para um contexto específico:
kubectl config use-context
Visualizar o contexto atual:
kubectl config current-context
Definir o namespace para o contexto atual:
kubectl config set-context --current --namespace=
Em ambientes de produção críticos, vale usar pistas visuais, como prompts do shell, para mostrar o cluster e o namespace atuais. Isso ajuda a evitar ações acidentais nos recursos errados.
Use network policies
Network Policies funcionam como firewalls dentro do seu cluster Kubernetes, controlando a comunicação entre pods.
Listar network policies:
kubectl get networkpolicies
Criar uma network policy que nega todo o tráfego de entrada por padrão:
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-ingress
spec:
podSelector: {}
policyTypes:
- Ingress
EOF
Criar uma network policy que permite tráfego específico:
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-frontend-to-backend
spec:
podSelector:
matchLabels:
app: backend
ingress:
- from:
- podSelector:
matchLabels:
app: frontend
ports:
- port: 8080
EOF
Comece com uma network policy do tipo "deny-all" como base e libere apenas o tráfego que você realmente precisa. Assim, você segue o princípio do menor privilégio e mantém a superfície de ataque o menor possível.
Domine a gestão do Kubernetes com esses comandos kubectl e boas práticas
O kubectl é uma ferramenta indispensável no universo dos comandos Kubernetes, atuando como sua interface principal para gerenciar e trabalhar com clusters. Ao aprender esses comandos e seguir as boas práticas deste cheat sheet, você estará pronto para encarar os desafios das aplicações em containers com total confiança.
Lembre-se: o Kubernetes está sempre evoluindo, e o kubectl também. Fique de olho nos novos recursos e atualizações para continuar aprimorando suas habilidades de gestão de clusters.
Se você quer mergulhar em tópicos mais avançados, como expandir os intervalos de IP de service do Kubernetes, confira nosso guia detalhado sobre como expandir intervalos de IP de service sem dor de cabeça.
À medida que seu setup de Kubernetes cresce e fica mais complexo, ter as ferramentas e o conhecimento certos se torna ainda mais importante. É aí que a DoiT entra. Nosso time global de arquitetos de nuvem é especialista em ajudar empresas a construir infraestruturas em nuvem econômicas, escaláveis e resilientes. Estamos aqui para ajudar a enfrentar desafios complexos de configuração e integração do Kubernetes, resolver problemas e impulsionar a eficiência operacional.
Fale com a gente e descubra como podemos ajudar a otimizar sua estratégia de orquestração de containers para mais performance e economia.