Linux Essencial para Backend
Linux é o sistema operacional de 99% dos servidores. Como backend developer, você vai rodar sua aplicação em Linux — entender o terminal é obrigatório.
Comandos Essenciais
# Navegação
pwd # diretório atual
ls -la # listar arquivos (incluindo ocultos)
cd /caminho/para/pasta # entrar na pasta
cd .. # voltar um nível
cd ~ # ir para home
# Arquivos e pastas
mkdir minha-pasta # criar pasta
touch arquivo.txt # criar arquivo vazio
cp origem destino # copiar
mv origem destino # mover / renomear
rm arquivo.txt # remover arquivo
rm -rf pasta/ # remover pasta (cuidado!)
cat arquivo.txt # ler arquivo
less arquivo.txt # ler paginado
grep "texto" arq.txt # buscar texto no arquivo
grep -r "texto" . # buscar em todos os arquivos do dir
# Permissões
chmod 755 script.sh # rwxr-xr-x
chmod +x script.sh # dar permissão de execução
chown user:group arq # mudar dono do arquivo
ls -la # ver permissões: drwxrwxrwx
Processos e Serviços
# Processos
ps aux # listar todos os processos
top / htop # monitor de processos em tempo real
kill 1234 # matar processo pelo PID
kill -9 1234 # forçar matar (SIGKILL)
pkill python # matar pelo nome
# Rodar em background
python app.py & # roda em background
nohup python app.py & # roda mesmo após fechar o terminal
jobs # listar jobs em background
fg # trazer para foreground
# Systemd — gerenciar serviços
systemctl start nginx # iniciar serviço
systemctl stop nginx # parar
systemctl restart nginx # reiniciar
systemctl enable nginx # iniciar com o sistema
systemctl status nginx # ver status
journalctl -u nginx -f # ver logs em tempo real
Variáveis de Ambiente e Shell Script
# Variáveis de ambiente
export DATABASE_URL="postgresql://user:pass@localhost/db"
export SECRET_KEY="minha-chave-secreta"
echo $DATABASE_URL # ler variável
# Arquivo .env (python-dotenv carrega automaticamente)
# .env
DATABASE_URL=postgresql://user:pass@localhost/db
SECRET_KEY=minha-chave
# Shell script básico
#!/bin/bash
set -e # para ao primeiro erro
echo "Iniciando deploy..."
git pull origin main
pip install -r requirements.txt
python manage.py migrate
systemctl restart myapp
echo "Deploy concluído!"
⚠ Nunca commite .env
Adicione
.env ao .gitignore. Variáveis de ambiente guardam segredos (senhas, tokens, chaves) — nunca devem ir para o repositório. Em produção, configure via painel do servidor ou secrets do CI/CD.
Exercício 1: Como ver os logs de uma aplicação Python rodando como serviço systemd?
→ journalctl -u nome-do-servico -f — o -f segue os logs em tempo real.
journalctl lê os logs do systemd. -u filtra por unidade (serviço). -f funciona como tail -f — atualiza conforme novos logs chegam. Essencial para debugar aplicações em produção.
Docker e Containers
Docker empacota a aplicação e todas as suas dependências em um container — ambiente isolado e reproduzível. "Funciona na minha máquina" deixa de existir.
Container vs VM
VM: virtualiza hardware inteiro — SO completo, pesada (GBs).
Container: compartilha o kernel do host — leve (MBs), inicia em segundos.
Conceitos Docker
Image: template imutável (receita).
Container: instância rodando da image.
Dockerfile: instruções para build da image.
Registry: repositório de images (Docker Hub).
Comandos Docker Essenciais
# Images
docker pull python:3.11 # baixar image
docker images # listar images locais
docker rmi python:3.11 # remover image
docker build -t minha-app . # build da image (usa Dockerfile)
# Containers
docker run -p 8000:8000 minha-app # rodar container
docker run -d -p 8000:8000 minha-app # em background
docker run -e DATABASE_URL=... minha-app # com variável de ambiente
docker run -v $(pwd):/app minha-app # montar volume local
docker ps # containers rodando
docker ps -a # todos (incluindo parados)
docker stop container_id # parar container
docker rm container_id # remover container
docker logs -f container_id # ver logs
docker exec -it container_id bash # entrar no container
Dockerfile para FastAPI
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
# Copiar requirements primeiro (cache de layers)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copiar código
COPY . .
# Expor porta
EXPOSE 8000
# Comando de inicialização
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
# Build e run:
# docker build -t minha-api .
# docker run -p 8000:8000 minha-api
Docker Compose — múltiplos serviços
# docker-compose.yml
version: '3.8'
services:
api:
build: .
ports:
- "8000:8000"
environment:
- DATABASE_URL=postgresql://user:pass@db:5432/mydb
- SECRET_KEY=minha-chave
depends_on:
- db
volumes:
- .:/app # hot reload em dev
db:
image: postgres:15
environment:
- POSTGRES_USER=user
- POSTGRES_PASSWORD=pass
- POSTGRES_DB=mydb
volumes:
- postgres_data:/var/lib/postgresql/data
redis:
image: redis:7-alpine
volumes:
postgres_data:
# Comandos:
# docker-compose up -d # subir todos
# docker-compose down # parar todos
# docker-compose logs -f api # logs do serviço api
# docker-compose exec api bash # entrar no container api
⚠ Docker em produção
Containers são
efêmeros — dados dentro do container somem ao removê-lo. Use
volumes para persistir dados do banco. Em produção, use
Kubernetes ou serviços gerenciados (Railway, Render, ECS) para orquestrar containers.
Exercício 2: Por que copiar requirements.txt antes do código no Dockerfile?
→ Para aproveitar o cache de layers do Docker — dependências mudam menos que o código.
Docker cria uma camada por instrução. Se o requirements.txt não mudou, o Docker reutiliza a camada do pip install sem reinstalar. Se o código mudar (COPY . .), só as camadas abaixo são reconstruídas. Reduz o tempo de build drasticamente.
Redes e Protocolos
Modelo TCP/IP
| Camada | Protocolos | O que faz |
|---|
| Aplicação | HTTP, HTTPS, DNS, FTP, SMTP | Protocolos que aplicações usam |
| Transporte | TCP, UDP | Controle de conexão e entrega |
| Internet | IP, ICMP | Endereçamento e roteamento |
| Acesso à Rede | Ethernet, Wi-Fi | Transmissão física dos dados |
TCP vs UDP
TCP: confiável, orientado a conexão, garante entrega e ordem. Usado em HTTP, APIs, banco de dados.
UDP: rápido, sem garantia de entrega. Usado em streaming, jogos, DNS.
Portas importantes
22 — SSH
80 — HTTP
443 — HTTPS
5432 — PostgreSQL
3306 — MySQL
6379 — Redis
8000/8080 — APIs Python
DNS — Domain Name System
# DNS resolve nomes para IPs
# gabrielborges240.github.io → 185.199.108.153
# Ferramentas de diagnóstico de rede
ping google.com # testa conectividade
nslookup meusite.com # resolve DNS
dig meusite.com # DNS detalhado
curl -I https://meusite.com # headers da resposta HTTP
traceroute google.com # rota dos pacotes
netstat -tlnp # portas abertas no sistema
ss -tlnp # alternativa ao netstat
lsof -i :8000 # processo usando porta 8000
HTTPS e TLS/SSL
HTTPS = HTTP + TLS (Transport Layer Security). Criptografa a comunicação entre cliente e servidor. Em produção, toda API deve usar HTTPS — nunca HTTP puro.
# Nginx como proxy reverso com HTTPS (Certbot/Let's Encrypt grátis)
server {
listen 443 ssl;
server_name minha-api.com;
ssl_certificate /etc/letsencrypt/live/minha-api.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/minha-api.com/privkey.pem;
location / {
proxy_pass http://localhost:8000; # sua API Python
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
}
# Certificado gratuito com Certbot
certbot --nginx -d minha-api.com
Exercício 3: Qual a diferença entre TCP e UDP?
→ TCP é confiável (garante entrega e ordem). UDP é rápido (sem garantias).
APIs REST usam TCP (HTTP) — cada request/response deve chegar completo. Streaming de vídeo usa UDP — um frame perdido é tolerável, mas atraso não.
Cloud e Deploy
Opções de Deploy para Backend Python
| Opção | Facilidade | Controle | Custo | Quando usar |
|---|
| Railway / Render | Muito fácil | Baixo | Médio | Projetos pessoais, portfólio |
| Heroku | Fácil | Médio | Alto | Startups, protótipos |
| VPS (DigitalOcean, Linode) | Médio | Total | Baixo | Controle total, custo baixo |
| AWS / GCP / Azure | Difícil | Total | Variável | Produção empresarial, escala |
Deploy no Railway (mais simples)
# 1. Instalar Railway CLI
npm install -g @railway/cli
# 2. Login e deploy
railway login
railway init # inicializa projeto
railway up # faz deploy
# 3. Adicionar variáveis de ambiente
railway variables set DATABASE_URL=postgresql://...
railway variables set SECRET_KEY=minha-chave
# 4. Ver logs
railway logs
Deploy em VPS (Ubuntu) — Fluxo Completo
# 1. Conectar via SSH
ssh root@ip-do-servidor
# 2. Criar usuário não-root
adduser deploy
usermod -aG sudo deploy
# 3. Instalar dependências
apt update && apt upgrade -y
apt install python3-pip python3-venv nginx git -y
# 4. Clonar e configurar aplicação
git clone https://github.com/usuario/minha-api.git /app
cd /app
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
# 5. Criar serviço systemd
# /etc/systemd/system/minha-api.service
[Unit]
Description=Minha API FastAPI
After=network.target
[Service]
User=deploy
WorkingDirectory=/app
Environment="DATABASE_URL=postgresql://..."
ExecStart=/app/venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000
Restart=always
[Install]
WantedBy=multi-user.target
# 6. Ativar serviço
systemctl enable minha-api
systemctl start minha-api
# 7. Configurar Nginx como proxy reverso
# (aponta porta 80/443 para 8000)
Serviços AWS mais usados em Backend
| Serviço AWS | O que é | Equivalente simples |
|---|
| EC2 | Servidor virtual na nuvem | VPS |
| RDS | Banco de dados gerenciado | PostgreSQL hospedado |
| S3 | Armazenamento de arquivos | Google Drive via API |
| Lambda | Funções serverless | Código que roda sob demanda |
| ECS/EKS | Orquestração de containers | Docker em escala |
| CloudFront | CDN global | Cache distribuído |
⚠ Segurança em servidores
Sempre: desabilitar login root por SSH, usar chave SSH (não senha), firewall ativo (ufw allow 22,80,443), atualizar pacotes regularmente. Porta 8000 da API deve ser acessada só pelo Nginx, não exposta diretamente.
📝 Cola — Infraestrutura
Comandos Linux mais usados
ls -la | grep -r | chmod +x | ps aux | kill -9
systemctl start/stop/status/enable
journalctl -u servico -f
lsof -i :8000 | netstat -tlnp
Docker — Fluxo básico
docker build -t app .
docker run -d -p 8000:8000 --env-file .env app
docker-compose up -d
docker logs -f container_id
docker exec -it container_id bash
Portas importantes
| Porta | Serviço |
|---|
| 22 | SSH |
| 80 / 443 | HTTP / HTTPS |
| 5432 | PostgreSQL |
| 6379 | Redis |
| 8000 | FastAPI/Uvicorn |
⭐ Regras de Ouro
Regra
Nunca commite
.env — adicione ao .gitignore
Regra
Copie requirements.txt antes do código no Dockerfile — aproveita
cache de layersRegra
Container é efêmero — dados do banco precisam de
volumeRegra
Nunca exponha a API diretamente — use
Nginx como proxy reverso
Regra
Em produção: HTTPS obrigatório, login root desabilitado, firewall ativo