How jgpjuniorj/desafio-app works
A seguir, segue uma explicação detalhada sobre como desenhar o diagrama de arquitetura para este projeto, focando na representação clara dos componentes essenciais e suas interações, baseando-se na estrutura de arquivos e nas informações contidas no README.
Identificação do Projeto e Propósito
• Trata-se de um projeto de containerização e deploy de aplicações Python – especificamente, um webserver Flask (app) e um proxy reverso (redirect) – que são executadas no mesmo container.
• O deployment é realizado na AWS utilizando o ECS (Fargate), com a infraestrutura provisionada via Terraform e um pipeline de CI/CD implementado com GitHub Actions.
• O README detalha as decisões de arquitetura, estruturas de infraestrutura (VPC, ECS Cluster, ECR, Task Definition, Service, Security Group) e o fluxo de CI/CD.
Análise da Estrutura de Arquivos
• Diretórios principais:
• O diretório “app” contém os arquivos de código da aplicação (app.py, redirect.py) e o Dockerfile, além de scripts para inicialização (start.sh).
• O diretório “terraform” possui a infraestrutura como código, com arquivos que definem VPC, ECS, IAM, providers, outputs e variáveis.
• O diretório “.github/workflows” contém os workflows do GitHub Actions para deploy e provisionamento via Terraform.
• Esses elementos indicam que o projeto está estruturado para cobrir tanto a construção e containerização da aplicação quanto o deployment e o gerenciamento de infraestrutura, seguindo boas práticas de CI/CD.
Principais Componentes a Serem Representados no Diagrama
a. Container e Aplicações:
• Representar o container Docker que abriga as duas aplicações:
• Componente “App” que roda o webserver Flask.
• Componente “Redirect” atuando como proxy reverso.
• Indicar que ambas são iniciadas por “start.sh” e compartilham o mesmo ambiente.
b. AWS ECS & Fargate:
• Representar um componente “ECS Cluster” no qual os containers são executados.
• Destacar a “Task Definition” que engloba os dois containers e o “Service” que garante a alta disponibilidade.
• Mostrar os “Security Groups” com as regras para as portas 5000 (App) e 5001 (Redirect).
c. Infraestrutura Provisionada com Terraform:
• Incluir módulos como “VPC” (com sub-redes públicas e privadas), “ECR” para repositório de imagens e “IAM” para políticas de segurança.
• Indicar que o Terraform é responsável pela criação e gerenciamento dessas infraestruturas para o deployment.
d. CI/CD com GitHub Actions:
• Representar o pipeline de CI/CD que:
• Constrói a imagem Docker.
• Realiza o push da imagem para o repositório ECR.
• Provisiona/atualiza a infraestrutura com Terraform.
• Dispara o deploy na AWS ECS.
• Destacar as workflows “deploy.yml” e “terraform.yml” localizados em .github/workflows.
Relacionamentos e Fluxo de Dados
• Use setas direcionais para indicar o fluxo:
• Do código fonte e Dockerfile na pasta “app” para a criação da imagem Docker.
• Do pipeline (GitHub Actions) para o push da imagem no ECR e para a execução dos scripts do Terraform.
• Do ECR para o ECS, onde a image é retirada e executada no cluster.
• Do usuário (através de curl ou navegador) para os endpoints expostos pelo ECS (nas portas 5000 e 5001).
Diretrizes para o Diagrama
• Separe os componentes em categorias (por exemplo, “Aplicação”, “Infraestrutura AWS”, “CI/CD”).
• Utilize cores ou formas diferentes para distinguir:
• Containers e aplicações.
• Componentes de infraestrutura (VPC, ECS, ECR, IAM, etc.).
• Fluxos de CI/CD e pipelines.
• Rotule cada componente de maneira clara e inclua setas que indiquem a direção de comunicação e dependências (por exemplo, “Build”, “Push”, “Deploy”, “Provisionamento”).
Personalizando para este Projeto
• Para este full-stack deployment (mesmo que se trate de um único container com múltiplos serviços), destaque a separação lógica entre a camada de aplicação (app e redirect) e a camada de infraestrutura gerenciada (AWS ECS, VPC, ECR, etc.).
• Enfatize o uso de ferramentas de automação (GitHub Actions para CI/CD e Terraform para provisionamento) como parte integral do fluxo.
• Indique o papel de cada componente e como o processo se integra para proporcionar um deploy automatizado e robusto nas nuvens AWS sem a necessidade de gerenciamento direto de servidores.
Em resumo, o diagrama deverá ilustrar os seguintes pontos:
• Uma caixa representando o “Container Docker” com duas subdivisões para “App (Flask Webserver)” e “Redirect (Proxy Reverso)”, vinculadas por um script “start.sh”.
• Uma seta apontando do container para o “ECR” (onde a imagem é armazenada após o build).
• Uma caixa maior denominada “AWS Infrastructure” contendo:
• “ECS Cluster” (Fargate) com “Task Definition” e “Service” (setas representando a extração da imagem do ECR e a execução do container).
• “Security Group” regulando tráfego nas portas 5000 e 5001.
• “VPC” com sub-redes (pode ser detalhado se necessário).
• “IAM” (para roles e políticas).
• Uma caixa separada para “CI/CD Pipeline (GitHub Actions)” que exibe os passos: Build da imagem → Push ao ECR → Provisionamento com Terraform → Deploy no ECS.
• Utilize setas e legendas para mostrar as interações e fluxos de dados entre estes componentes.
Esta abordagem garantirá que o diagrama seja abrangente e exato, ajudando a visualizar claramente tanto a arquitetura de deployment na AWS quanto o fluxo contínuo de integração e entrega adotado no projeto.