# jgpjuniorj/desafio-app architecture

> Architecture diagram of the GitHub repository jgpjuniorj/desafio-app, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2025-03-31). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/jgpjuniorj/desafio-app
- Repository: https://github.com/jgpjuniorj/desafio-app

## Overview

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.

## Diagram (Mermaid)

```mermaid
flowchart TB
    %% User
    user["User (HTTP Request)"]:::userStyle

    %% Application Subgraph
    subgraph "Application: Container Docker"
        appFlask["App (Flask Webserver)"]:::app
        redirectRev["Redirect (Proxy Reverso)"]:::app
        initScript["Container Initialization Script (start.sh)"]:::app
        dockerfileNode["Docker Build Configuration (Dockerfile)"]:::app
    end

    %% AWS Infrastructure Subgraph
    subgraph "AWS Infrastructure"
        ecr["ECR Repository"]:::infra
        ecs["ECS Cluster (Fargate)"]:::infra
        security["Security Group (Ports5000&5001)"]:::infra
        vpc["VPC & Subnets"]:::infra
        iam["IAM (Roles&Policies)"]:::infra
    end

    %% CI/CD Pipeline Subgraph
    subgraph "CI/CD Pipeline (GitHub Actions)"
        deployWorkflow["Deploy Workflow (deploy.yml)"]:::cicd
        terraformWorkflow["Terraform Workflow (terraform.yml)"]:::cicd
    end

    %% Interactions within Application
    initScript -->|"triggers"| appFlask
    initScript -->|"triggers"| redirectRev

    %% From Application to CI/CD Pipeline
    dockerfileNode -->|"Build"| deployWorkflow

    %% CI/CD Pipeline actions
    deployWorkflow -->|"Push"| ecr
    terraformWorkflow -->|"Provision"| ecs
    terraformWorkflow -->|"Provision"| vpc
    terraformWorkflow -->|"Provision"| iam

    %% Deployment Flow
    ecr -->|"DeployImage"| ecs
    ecs -->|"SecuredBy"| security

    %% User accesses the deployed service
    user -->|"Access"| ecs

    %% Click Events
    click appFlask "https://github.com/jgpjuniorj/desafio-app/blob/main/app/app.py"
    click redirectRev "https://github.com/jgpjuniorj/desafio-app/blob/main/app/redirect.py"
    click initScript "https://github.com/jgpjuniorj/desafio-app/blob/main/app/start.sh"
    click dockerfileNode "https://github.com/jgpjuniorj/desafio-app/tree/main/app/Dockerfile"
    click ecs "https://github.com/jgpjuniorj/desafio-app/blob/main/terraform/ecs.tf"
    click iam "https://github.com/jgpjuniorj/desafio-app/blob/main/terraform/iam.tf"
    click vpc "https://github.com/jgpjuniorj/desafio-app/blob/main/terraform/main.tf"
    click deployWorkflow "https://github.com/jgpjuniorj/desafio-app/blob/main/.github/workflows/deploy.yml"
    click terraformWorkflow "https://github.com/jgpjuniorj/desafio-app/blob/main/.github/workflows/terraform.yml"

    %% Styles
    classDef app fill:#ffe6e6,stroke:#cc0000,stroke-width:2px;
    classDef infra fill:#e6f7ff,stroke:#007acc,stroke-width:2px;
    classDef cicd fill:#e6ffe6,stroke:#009933,stroke-width:2px;
    classDef userStyle fill:#fff2e6,stroke:#ff6600,stroke-width:2px;
```
