Kubernetes Primeiros passos

Note

Este artigo foi inicialmente verificado em relação às notas de versão do Ubuntu 26.04 LTS de abril de 2026. As versões do componente Kubernetes e os detalhes da implantação de produção ainda precisam de validação contínua em relação aos MicroK8s e atualizações upstream.

Kubernetes (abreviado como K8s) é a plataforma de orquestração de contêineres mais popular atualmente, de código aberto do Google e doada à CNCF (Cloud Native Computing Foundation). Ele automatiza a implantação, o dimensionamento e o gerenciamento de aplicativos em contêineres e é a base da arquitetura moderna nativa da nuvem.

Ubuntu é uma das principais distribuições Linux para executar Kubernetes. A Canonical também oferece MicroK8s – uma distribuição Kubernetes leve e fácil de instalar, ideal para cenários de desenvolvimento, teste e computação de ponta.

O que é K8s e por que você precisa dele

Pontos problemáticos antes dos K8s

Na era da conteinerização, Docker resolveu o problema de “empacotamento e execução de aplicativos”. Mas quando você tem dezenas ou até centenas de contêineres para gerenciar, surgem novos desafios:

Se um contêiner travar, quem o reinicia automaticamente?
Quando o tráfego aumenta, como você faz o escalonamento automático?
Como os contêineres descobrem e se comunicam entre si?
Como você executa atualizações contínuas sem interrupção do serviço?
Como você agenda contêineres em vários servidores?

O que K8s resolve

Kubernetes foi criado para resolver exatamente estes problemas:

Recurso	Descrição
Autocura	Reinicia automaticamente contêineres travados; migra cargas de trabalho quando os nós falham
Escalonamento horizontal	Aumenta ou diminui automaticamente as instâncias de contêiner com base na carga
Descoberta de serviço	Os contêineres se registram automaticamente e acessam uns aos outros por meio de nomes DNS
Atualizações contínuas	Substitui gradualmente versões antigas para implantações com tempo de inatividade zero
Balanceamento de carga	Distribui automaticamente o tráfego entre várias instâncias de contêiner
Gerenciamento de configuração	Gerenciamento centralizado de configurações e segredos de aplicativos

Instalação do MicroK8s

MicroK8s é o Kubernetes leve da Canonical, instalado via Snap com um único comando.

Instalando MicroK8s


# Install MicroK8s
# Choose the latest stable channel; check snap info microk8s for available versions
sudo snap install microk8s --classic --channel=1.33/stable
 
# Add current user to the microk8s group (avoid sudo every time)
sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube
 
# Re-login for group permissions to take effect
newgrp microk8s
 
# Check installation status
microk8s status --wait-ready

Habilitando complementos comuns

MicroK8s vem com muitos complementos integrados:


# Enable DNS (internal cluster name resolution -- almost always required)
microk8s enable dns
 
# Enable local storage
microk8s enable hostpath-storage
 
# Enable Dashboard (web management interface)
microk8s enable dashboard
 
# Enable Ingress (HTTP reverse proxy)
microk8s enable ingress
 
# Enable container image registry
microk8s enable registry
 
# Enable multiple add-ons at once
microk8s enable dns hostpath-storage dashboard ingress
 
# View all available add-ons
microk8s status

Configurando o alias do kubectl

MicroK8s inclui microk8s kubectl, mas digitá-lo sempre é entediante. Você pode configurar um alias:


# Option 1: Use an alias
alias kubectl='microk8s kubectl'
echo "alias kubectl='microk8s kubectl'" >> ~/.bashrc
 
# Option 2: Export config for a standalone kubectl installation
microk8s config > ~/.kube/config

Operações básicas do kubectl

kubectl é a ferramenta de linha de comando para interagir com clusters Kubernetes.

Informações do cluster


# View cluster information
kubectl cluster-info
 
# View all nodes
kubectl get nodes
 
# View node details
kubectl describe node <node-name>
 
# View cluster component status
kubectl get componentstatuses

Visualizando Recursos


# View all Pods
kubectl get pods
 
# View Pods across all namespaces
kubectl get pods --all-namespaces
# Or shorthand
kubectl get pods -A
 
# View Pod details (wide output)
kubectl get pods -o wide
 
# View all Deployments
kubectl get deployments
 
# View all Services
kubectl get services
# Or shorthand
kubectl get svc
 
# View all resources
kubectl get all

Detalhes e registros de recursos


# View Pod details
kubectl describe pod <pod-name>
 
# View Pod logs
kubectl logs <pod-name>
 
# Follow logs in real-time
kubectl logs -f <pod-name>
 
# View logs for a specific container in a multi-container Pod
kubectl logs <pod-name> -c <container-name>
 
# Execute commands inside a Pod
kubectl exec -it <pod-name> -- /bin/bash

Conceitos Básicos

Vagem

Um pod é a menor unidade implantável em Kubernetes. Um pod contém um ou mais contêineres que compartilham rede e armazenamento.


# pod-example.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80


# Create a Pod
kubectl apply -f pod-example.yaml
 
# Check Pod status
kubectl get pod nginx-pod
 
# Delete a Pod
kubectl delete pod nginx-pod

Implantação

Uma implantação gerencia contagens de réplicas de pods, atualizações contínuas e reversões. Na prática, você quase nunca criará pods diretamente. Em vez disso, você os gerenciará por meio de implantações.


# deployment-example.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.27
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"


# Deploy the application
kubectl apply -f deployment-example.yaml
 
# View deployment status
kubectl get deployment nginx-deployment
 
# Scale up/down
kubectl scale deployment nginx-deployment --replicas=5
 
# View rolling update status
kubectl rollout status deployment nginx-deployment
 
# Update image version
kubectl set image deployment/nginx-deployment nginx=nginx:1.28
 
# Rollback to previous version
kubectl rollout undo deployment nginx-deployment
 
# View update history
kubectl rollout history deployment nginx-deployment

Serviço

Um serviço fornece um endpoint de rede estável para um conjunto de pods. Os IPs dos pods mudam dinamicamente, enquanto um serviço fornece um ponto de acesso fixo.


# service-example.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Descrições do tipo de serviço:

Tipo	Descrição
IP do cluster	Padrão; acessível apenas dentro do cluster
NodePort	Abre uma porta em cada nó; acessível externamente
Balanceador de carga	Usa o balanceador de carga do provedor de nuvem


# Create a Service
kubectl apply -f service-example.yaml
 
# View the Service
kubectl get svc nginx-service
 
# Expose a service with NodePort
kubectl expose deployment nginx-deployment --type=NodePort --port=80

Implantando seu primeiro aplicativo

Vamos implantar uma aplicação web completa do início ao fim.

Etapa 1: criar uma implantação


# Quickly create using the command line
kubectl create deployment hello-app --image=gcr.io/google-samples/hello-app:1.0
 
# Verify the Pod is running
kubectl get pods -l app=hello-app

Etapa 2: expor o serviço


# Create a NodePort Service
kubectl expose deployment hello-app --type=NodePort --port=8080
 
# View the assigned port
kubectl get svc hello-app

Etapa 3: acesse o aplicativo


# Get the access URL
# MicroK8s runs locally by default, so use localhost
NODE_PORT=$(kubectl get svc hello-app -o jsonpath='{.spec.ports[0].nodePort}')
echo "Access URL: http://localhost:$NODE_PORT"
 
# Test access
curl http://localhost:$NODE_PORT

Etapa 4: aumentar a escala


# Scale to 3 replicas
kubectl scale deployment hello-app --replicas=3
 
# View all Pods
kubectl get pods -l app=hello-app

Etapa 5: limpeza


# Delete the Service and Deployment
kubectl delete svc hello-app
kubectl delete deployment hello-app

Gerenciamento de pacotes Helm

Helm é o gerenciador de pacotes do Kubernetes, semelhante ao apt do Ubuntu. Ele usa Gráficos (pacotes) para definir, instalar e atualizar aplicativos Kubernetes complexos.

Instalando o Helm


# Option 1: Install via Snap
sudo snap install helm --classic
 
# Option 2: Install via official script
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
 
# Verify installation
helm version

Usando Helm


# Add the official stable repository
helm repo add bitnami https://charts.bitnami.com/bitnami
 
# Update repository index
helm repo update
 
# Search for Charts
helm search repo nginx
helm search repo mysql
 
# Install an application (Redis example)
helm install my-redis bitnami/redis
 
# View installed Releases
helm list
 
# View Release status
helm status my-redis
 
# Install with custom configuration
helm install my-nginx bitnami/nginx \
  --set replicaCount=3 \
  --set service.type=NodePort
 
# Install with a values file for custom configuration
helm install my-app bitnami/nginx -f custom-values.yaml
 
# Upgrade a Release
helm upgrade my-redis bitnami/redis --set auth.enabled=false
 
# Rollback
helm rollback my-redis 1
 
# Uninstall a Release
helm uninstall my-redis

Criando seu próprio gráfico


# Create a new Chart template
helm create my-chart
 
# Directory structure
# my-chart/
#   Chart.yaml      # Chart metadata
#   values.yaml     # Default configuration values
#   templates/       # K8s resource templates
#     deployment.yaml
#     service.yaml
#     ingress.yaml
 
# Validate the Chart
helm lint my-chart/
 
# Dry-run install (no actual deployment)
helm install my-release my-chart/ --dry-run --debug
 
# Package the Chart
helm package my-chart/

Tabela de comandos de referência rápida

Operação	Comando
Ver o status do cluster	`kubectl cluster-info`
Ver todos os pods	`kubectl get pods -A`
Ver registros do pod	`kubectl logs POD_NAME`
Insira um pod	`kubectl exec -it POD_NAME -- bash`
Crie um recurso	`kubectl apply -f file.yaml`
Excluir um recurso	`kubectl delete -f file.yaml`
Aumentar a escala	`kubectl scale deployment NAME --replicas=N`
Atualizar imagem	`kubectl set image deployment/NAME container=image`
Reverter	`kubectl rollout undo deployment/NAME`
Encaminhamento de porta	`kubectl port-forward pod/NAME 8080:80`
Ver uso de recursos	`kubectl top pods`
Status do MicroK8s	`microk8s status`
Início dos MicroK8s	`microk8s start`
Parada de MicroK8s	`microk8s stop`

Considerações de produção

Warning

MicroK8s é excelente para aprendizado e desenvolvimento, mas ao usar Kubernetes em produção, tenha estes pontos em mente:

Cluster de alta disponibilidade: a produção requer pelo menos três nós do plano de controle para evitar pontos únicos de falha
Limites de recursos: sempre defina resources.requests e resources.limits para cada contêiner para evitar que um aplicativo consuma todos os recursos do nó
Políticas de rede: configure NetworkPolicy para restringir a comunicação entre pods seguindo o princípio do menor privilégio
Permissões RBAC: não execute aplicativos com privilégios de administrador de cluster; crie ServiceAccounts dedicadas para cada serviço
Segurança de imagens: use apenas registros de imagens confiáveis, verifique regularmente as imagens em busca de vulnerabilidades e evite usar a tag latest
Fazer backup do etcd: o etcd armazena todos os dados de estado do cluster – backups regulares são essenciais
Monitoramento e alertas: implante o Prometheus + Grafana para monitorar a integridade do cluster
Coleta de logs: use EFK (Elasticsearch + Fluentd + Kibana) ou Loki para agregação de logs

Para suporte de nível empresarial, considere o Charmed Kubernetes da Canonical ou serviços K8s gerenciados de provedores de nuvem (por exemplo, AWS EKS, Google GKE, Azure AKS).

Solução de problemas comuns


# Pod stuck in Pending state
kubectl describe pod <pod-name>
# Usually caused by insufficient resources or node selector mismatch
 
# Pod in CrashLoopBackOff
kubectl logs <pod-name> --previous
# View logs from the previous crash
 
# Cannot pull image (ImagePullBackOff)
kubectl describe pod <pod-name>
# Check if the image name is correct and whether image pull credentials are needed
 
# Service inaccessible
kubectl get endpoints <service-name>
# Verify that the Service selector matches the Pod labels
 
# DNS resolution failure
kubectl run test --image=busybox --rm -it -- nslookup kubernetes.default
# Check if CoreDNS is running properly

Depois de dominar o conteúdo acima, você será capaz de executar e gerenciar cargas de trabalho básicas do Kubernetes no Ubuntu. À medida que sua experiência aumenta, você pode explorar ainda mais ConfigMap, Secret, PersistentVolume, Ingress, CronJob e outros tipos de recursos.