Linux para DevOps: comandos essenciais

1. Navegação e Gerenciamento de Arquivos

Os comandos fundamentais de navegação são a base de qualquer operação em sistemas Linux. No contexto DevOps, dominar ls, cd, pwd, mkdir, rm, cp e mv é essencial para manipular arquivos de configuração, Dockerfiles e manifests Kubernetes.

# Navegação básica
pwd                              # /home/devops/projeto
ls -la                           # Lista detalhada com permissões
cd /etc/docker                   # Navega para diretório do Docker
mkdir -p volumes/{nginx,postgres} # Cria estrutura de diretórios

Permissões de arquivos têm impacto direto em containers. O comando chmod e chown são cruciais ao montar volumes:

# Ajustando permissões para containers
chmod 644 config.yaml            # Leitura para todos, escrita apenas para dono
chown 1000:1000 dados/           # Altera dono para UID 1000 (comum em containers)
umask 022                        # Define permissões padrão: 755 para diretórios

Links simbólicos (ln -s) são amplamente utilizados em volumes Docker para apontar configurações:

# Link simbólico para volume Docker
ln -s /mnt/nfs/configuracoes/nginx.conf ./nginx.conf
docker run -v $(pwd)/nginx.conf:/etc/nginx/nginx.conf:ro nginx

2. Processos e Monitoramento do Sistema

Identificar gargalos em clusters Kubernetes começa com comandos de monitoramento Linux:

# Visualização de processos
ps aux | grep kubelet            # Filtra processos do Kubernetes
top -b -n 1 | head -20          # Snapshot único do topo
htop                             # Monitor interativo (instalar se necessário)

Gerenciamento de processos com sinais é vital para orquestração:

# Sinais em containers
kill -SIGTERM 1234              # Encerramento gracioso (usado pelo Kubernetes)
killall -9 nginx                # Força parada (último recurso)
nice -n 10 backup.sh            # Executa com baixa prioridade
renice -n -5 -p 5678            # Aumenta prioridade de processo

Monitoramento de recursos para diagnóstico em clusters:

# Recursos do sistema
free -h                          # Memória RAM e swap
df -h /var/lib/docker            # Espaço em disco do Docker
du -sh /var/log/pods/            # Tamanho dos logs de pods
vmstat 2 5                       # Estatísticas de CPU, memória e I/O
iostat -x 1 3                    # I/O detalhado por dispositivo

3. Redes e Conectividade

Diagnóstico de rede é crítico para troubleshooting em Kubernetes:

# Diagnóstico básico
ping -c 4 8.8.8.8                # Testa conectividade
traceroute -n 10.96.0.1         # Rastreia rota até service Kubernetes
netstat -tulpn | grep 6443      # Portas listening (API server)
ss -tulpn | grep :443           # Socket statistics moderno
nslookup kubernetes.default.svc.cluster.local  # DNS interno

Configuração de interfaces e bridges Docker:

# Interfaces de rede
ip addr show docker0             # Bridge padrão do Docker
ifconfig                         # Interfaces (legado)
ip route show default            # Rota padrão

Firewall e portas para segurança de clusters:

# iptables e netcat
iptables -L -n -v               # Regras do firewall (usado pelo kube-proxy)
ufw allow 6443/tcp              # Firewall simplificado
nc -zv 10.96.0.1 443            # Testa porta TCP (health check)
nc -lu 1234                     # Escuta UDP (útil para logs)

4. Gerenciamento de Pacotes e Repositórios

Para ambientes conteinerizados, o gerenciamento de pacotes no host é necessário para ferramentas auxiliares:

# APT (Debian/Ubuntu)
apt update
apt install -y docker.io kubectl helm
apt remove --purge containerd
add-apt-repository ppa:longsleep/golang-backports

# YUM/DNF (Red Hat/CentOS)
yum install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum install docker-ce kubectl
dnf groupinstall "Development Tools"

Snap e Flatpak são alternativas para ferramentas DevOps:

# Snap para ferramentas
snap install kubectl --classic
snap install helm --classic
snap list

5. Systemd e Gerenciamento de Serviços

Systemd é o sistema de init padrão e controla serviços como Docker e kubelet:

# Controle de serviços
systemctl start docker
systemctl stop kubelet
systemctl restart containerd
systemctl enable docker         # Inicia na boot
systemctl disable firewalld     # Desabilita firewall

Análise de logs com journalctl:

# Logs de serviços
journalctl -u docker.service --since "1 hour ago"
journalctl -u kubelet -f        # Segue logs em tempo real
journalctl -p err -b            # Apenas erros desde boot
journalctl --since "2024-01-01" --until "2024-01-02"

Criação de unit personalizada para container:

# /etc/systemd/system/minha-app.service
[Unit]
Description=Minha aplicação containerizada
After=docker.service
Requires=docker.service

[Service]
ExecStart=/usr/bin/docker run --name minha-app minha-imagem:latest
ExecStop=/usr/bin/docker stop minha-app
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

6. Manipulação de Texto e Logs

Filtros e busca são essenciais para analisar logs de pods:

# grep e sed em logs
kubectl logs pod-xyz | grep ERROR
kubectl logs --tail=100 pod-xyz | sed 's/\[ERROR\]/[CRITICO]/g'
awk '{print $1, $5}' /var/log/syslog | sort | uniq -c
cut -d' ' -f1-3 /var/log/kube-apiserver.log

Visualização e monitoramento de logs:

# Visualização
cat /var/log/pods/default_pod-xyz_*.log
less /var/log/syslog
tail -f /var/log/docker.log | grep error
head -20 /etc/kubernetes/manifests/kube-apiserver.yaml

Redirecionamento e pipes para processamento:

# Pipes e redirecionamento
docker logs container-abc 2>&1 | tee logs.txt
docker ps -a | grep Exited | awk '{print $1}' | xargs docker rm
kubectl get pods -o wide > pods.txt
echo "DEBUG=true" >> .env

7. Automação e Scripting Básico

Variáveis de ambiente são configuradas em Dockerfiles e scripts:

# Variáveis de ambiente
export KUBECONFIG=~/.kube/config-prod
env | grep KUBE
printenv PATH
echo "export DOCKER_HOST=tcp://192.168.1.100:2375" >> ~/.bashrc

Comandos condicionais e loops em scripts shell:

# Script de health check
#!/bin/bash
for pod in $(kubectl get pods -o name); do
  if kubectl exec $pod -- curl -s http://localhost:8080/health; then
    echo "$pod: saudável"
  else
    echo "$pod: falha"
  fi
done

Agendamento de tarefas para clusters:

# Cron job para backup de etcd
0 2 * * * /usr/local/bin/etcd-backup.sh

# Systemd timer para limpeza de imagens Docker
[Unit]
Description=Limpa imagens Docker não utilizadas

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target

Referências