🚀 Projeto DevOps Completo — FastAPI + AWS + Kubernetes

Pipeline DevOps completo do zero: do código à produção na AWS, com containerização, orquestração, infraestrutura como código, CI/CD automatizado e monitoramento em tempo real.

---

📋 Índice

• Sobre o Projeto
• Arquitetura
• Tecnologias Utilizadas
• Etapas do Projeto
• Estrutura de Pastas
• Como Executar
• CI/CD
• Monitoramento

---

📖 Sobre o Projeto

Este projeto foi desenvolvido com o objetivo de construir um pipeline DevOps completo e funcional, cobrindo todas as etapas de um ciclo de entrega moderno:

• Desenvolvimento de uma API REST com Python e FastAPI
• Containerização com Docker
• Orquestração com Kubernetes
• Deploy na nuvem usando serviços gerenciados da AWS (EKS + RDS)
• Infraestrutura como Código com Terraform
• CI/CD automatizado com GitHub Actions
• Monitoramento com Grafana e Prometheus

A API em si é uma aplicação CRUD simples de itens, mas o foco do projeto é a infraestrutura e o pipeline de entrega que envolve essa aplicação.

---

🏗️ Arquitetura

┌─────────────────────────────────────────────────────────────┐
│                        GitHub                                │
│  Push na main → GitHub Actions → Build → Push ECR → Deploy  │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                      AWS Cloud                               │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                    VPC                               │    │
│  │                                                      │    │
│  │  ┌──────────────────┐    ┌─────────────────────┐    │    │
│  │  │   Subnet Pública  │    │   Subnet Privada     │    │    │
│  │  │                  │    │                     │    │    │
│  │  │  ┌────────────┐  │    │  ┌───────────────┐  │    │    │
│  │  │  │    EKS     │  │    │  │   RDS MySQL   │  │    │    │
│  │  │  │            │  │    │  │               │  │    │    │
│  │  │  │ ┌────────┐ │  │    │  └───────────────┘  │    │    │
│  │  │  │ │  API   │ │  │    │                     │    │    │
│  │  │  │ │  Pod   │ │  │    │                     │    │    │
│  │  │  │ └────────┘ │  │    │                     │    │    │
│  │  │  │ ┌────────┐ │  │    │                     │    │    │
│  │  │  │ │Grafana │ │  │    │                     │    │    │
│  │  │  │ │  Pod   │ │  │    │                     │    │    │
│  │  │  │ └────────┘ │  │    │                     │    │    │
│  │  │  └────────────┘  │    └─────────────────────┘    │    │
│  │  └──────────────────┘                                │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                              │
│  Load Balancer (Público) ←── Internet                        │
└─────────────────────────────────────────────────────────────┘

---

🛠️ Tecnologias Utilizadas

Categoria	Tecnologia	Uso
API	Python 3.11, FastAPI, Uvicorn	Desenvolvimento da aplicação REST
Banco de Dados	MySQL 8.0, SQLAlchemy, PyMySQL	Persistência de dados
Containerização	Docker, Docker Compose	Empacotamento da aplicação
Orquestração	Kubernetes, kubectl, minikube	Gerenciamento de containers
Cloud	AWS EKS, Amazon RDS, Amazon ECR	Serviços gerenciados na nuvem
Rede	VPC, Security Groups, Load Balancer	Infraestrutura de rede
IaC	Terraform, AWS Provider	Infraestrutura como código
CI/CD	GitHub Actions	Automação de build e deploy
Monitoramento	Grafana, Prometheus, Helm	Observabilidade

---

📚 Etapas do Projeto

01 — API REST com FastAPI + MySQL

Desenvolvimento de uma API REST com FastAPI em Python, com:

• Rotas CRUD para gerenciamento de itens (GET, POST, PUT, DELETE)
• Conexão com banco de dados MySQL via SQLAlchemy
• Validação de dados com Pydantic
• Documentação automática via Swagger UI em /docs
• Variáveis de ambiente com python-dotenv

# Rodar localmente
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

---

02 — Containerização com Docker

Empacotamento da aplicação em containers portáteis e reproduzíveis:

• Dockerfile multi-stage otimizado com Python 3.11-slim
• Docker Compose orquestrando API + MySQL com health checks
• Volume persistente para dados do banco
• Rede interna entre os containers

# Subir os containers
docker compose up --build -d

# Ver logs
docker compose logs -f api

---

03 — Orquestração com Kubernetes

Prática de Kubernetes localmente com minikube antes de ir para a nuvem:

• Deployment com 2 réplicas da API
• Service do tipo LoadBalancer
• Secret para credenciais do banco
• ConfigMap para variáveis de ambiente
• Auto-healing: pods reiniciados automaticamente em caso de falha

# Aplicar os manifestos
kubectl apply -f k8s/

# Verificar pods
kubectl get pods

---

04 — Cloud AWS — Amazon EKS + RDS MySQL

Deploy na AWS usando serviços gerenciados:

• Amazon EKS (Elastic Kubernetes Service) para orquestrar os containers
• Amazon RDS MySQL para banco de dados com backups automáticos
• Amazon ECR como registro privado de imagens Docker
• Cluster criado com eksctl na região us-east-1

# Criar cluster EKS
eksctl create cluster --name devops-cluster --region us-east-1 \
  --nodegroup-name workers --node-type t3.small --nodes 1 --version 1.31

# Configurar kubectl
aws eks update-kubeconfig --name devops-cluster --region us-east-1

---

05 — Redes, Firewall e Exposição

Configuração de rede segura na AWS:

• VPC com subnets públicas (EKS) e privadas (RDS)
• Security Groups com regras mínimas necessárias
• RDS acessível somente pelos nós do EKS (porta 3306 restrita)
• API exposta na internet via AWS Load Balancer criado automaticamente pelo Kubernetes Service

---

06 — Infraestrutura como Código com Terraform

Toda a infraestrutura AWS declarada em código:

terraform/
├── main.tf       # Provider AWS
├── variables.tf  # Variáveis de entrada
├── outputs.tf    # Outputs (endpoints)
├── vpc.tf        # VPC e subnets
├── eks.tf        # Cluster EKS
└── rds.tf        # Banco RDS MySQL

# Subir toda a infraestrutura
terraform init
terraform plan
terraform apply -auto-approve

# Destruir tudo
terraform destroy -auto-approve

---

07 — CI/CD com GitHub Actions

Pipeline automatizado em .github/workflows/deploy.yml:

Push na main
    │
    ▼
Checkout do código
    │
    ▼
Configurar credenciais AWS
    │
    ▼
Login no Amazon ECR
    │
    ▼
Build da imagem Docker
    │
    ▼
Push da imagem no ECR
    │
    ▼
Configurar kubectl → EKS
    │
    ▼
kubectl set image → Deploy
    │
    ▼
kubectl rollout status → Validação

---

08 — Monitoramento com Grafana + Prometheus

Stack de observabilidade instalada no próprio cluster EKS via Helm:

helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --set grafana.service.type=LoadBalancer

Dashboards configurados:

• Node Exporter Full (ID: 1860) — CPU, memória, disco e rede dos nós
• Kubernetes Cluster (ID: 3119) — visão geral do cluster

---

📁 Estrutura de Pastas

devops-project/
├── app/
│   ├── __init__.py
│   ├── main.py           # Entrypoint da API
│   ├── database.py       # Conexão SQLAlchemy
│   ├── models.py         # Modelos ORM
│   ├── schemas.py        # Schemas Pydantic
│   └── routers/
│       ├── __init__.py
│       └── items.py      # Rotas CRUD
├── k8s/
│   ├── api-deployment.yaml    # Deployment + Service da API
│   └── mysql-deployment.yaml  # Deployment + Service do MySQL
├── terraform/
│   ├── main.tf
│   ├── variables.tf
│   ├── outputs.tf
│   ├── vpc.tf
│   ├── eks.tf
│   └── rds.tf
├── .github/
│   └── workflows/
│       └── deploy.yml    # Pipeline CI/CD
├── Dockerfile
├── docker-compose.yml
├── requirements.txt
└── .gitignore

---

🚀 Como Executar

Pré-requisitos

• Python 3.11+
• Docker e Docker Compose
• kubectl
• AWS CLI configurado
• Terraform
• eksctl
• Helm

Rodando localmente

# Clone o repositório
git clone https://github.com/mandre-dev/devops-project.git
cd devops-project

# Crie o ambiente virtual
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Configure o .env
echo 'DATABASE_URL=mysql+pymysql://root:root@localhost:3306/devopsdb' > .env

# Suba com Docker Compose
docker compose up --build -d

# Acesse a API
# http://localhost:8000/docs

Subindo na AWS com Terraform

cd terraform/

# Inicialize e aplique
terraform init
terraform apply -auto-approve

# Configure o kubectl
aws eks update-kubeconfig --name devops-cluster --region us-east-1

# Configure o acesso
aws eks create-access-entry --cluster-name devops-cluster \
  --principal-arn arn:aws:iam::<ACCOUNT_ID>:root --region us-east-1

# Deploy da aplicação
kubectl create secret generic db-secret \
  --from-literal=database_url='mysql+pymysql://devops:SenhaForte123!@<RDS_ENDPOINT>:3306/devopsdb'

kubectl apply -f ../k8s/

# Obtenha o IP público da API
kubectl get service api-service

---

⚙️ CI/CD

O pipeline é acionado automaticamente a cada push na branch main.

Secrets necessários no GitHub:

Secret	Descrição
AWS_ACCESS_KEY_ID	Chave de acesso AWS
AWS_SECRET_ACCESS_KEY	Chave secreta AWS
AWS_REGION	Região AWS (ex: us-east-1)
ECR_REGISTRY	URL do registro ECR
EKS_CLUSTER_NAME	Nome do cluster EKS

---

📊 Monitoramento

Após instalar o stack de monitoramento, acesse o Grafana:

# Obtenha o IP do Grafana
kubectl get service kube-prometheus-stack-grafana -n monitoring

# Obtenha a senha do admin
kubectl get secret --namespace monitoring kube-prometheus-stack-grafana \
  -o jsonpath='{.data.admin-password}' | base64 --decode

• URL: http://<EXTERNAL-IP>
• Usuário: admin
• Senha: resultado do comando acima

---

⚠️ Custos AWS

Para evitar cobranças desnecessárias, destrua a infraestrutura após os estudos:

cd terraform/
terraform destroy -auto-approve

Estimativa de custo por hora:

• EKS Control Plane: ~USD 0.10/h
• EC2 t3.small (1 nó): ~USD 0.023/h
• NAT Gateway: ~USD 0.045/h
• RDS db.t3.micro: gratuito no Free Tier

---

👨‍💻 Autor

Mandre — @mandre-dev

---

Projeto desenvolvido para aprendizado prático de DevOps — do código à produção. 🚀