Configuracao

Home	Sprints	Requisitos	Arquitetura	Configuração	Mockups	Banco de Dados	Instalação	Git

AWS Elastic Container Registry (ECR)

Para o processo de deploy da nossa aplicação, utilizaremos o AWS Elastic Container Registry (ECR). O ECR é um serviço totalmente gerenciado de registro de contêineres, projetado para fornecer uma hospedagem de alto desempenho para imagens de contêineres. Com o ECR, podemos armazenar, gerenciar e distribuir nossas imagens de contêineres de forma confiável e segura. Ele garante a disponibilidade e a replicação das imagens em diferentes regiões, permitindo implantar nossas aplicações em qualquer lugar.

Fonte: https://aws.amazon.com/pt/ecr/

AWS Elastic Container Service (ECS)

Na arquitetura da nuvem do nosso projeto, faremos uso principal do serviço ECS (Elastic Container Service) da AWS. O ECS é um serviço totalmente gerenciado de orquestração de contêineres, projetado para facilitar a implantação, o gerenciamento e a escalabilidade de aplicações baseadas em contêineres. Ele nos oferece recursos robustos para execução, monitoramento e escalonamento de aplicações, garantindo uma infraestrutura confiável e segura para nossa aplicação.

Fonte: https://aws.amazon.com/pt/ecs/

O diagrama ilustra como o Amazon ECS executa, monitora e escala aplicações em opções flexíveis de computação, com integrações automáticas com outros serviços da AWS. Desenvolvedores descrevem suas aplicações e recursos, enquanto o ECS cuida do restante. Operadores realizam operações do sistema, criam regras de escalabilidade e capacidade, e consultam logs e telemetria. O ECS é representado por um ícone na segunda seção, com setas indicando configuração e implantação/escalabilidade. A terceira seção mostra integrações automatizadas com serviços como Elastic Load Balancing, AWS Secrets Manager e Amazon Elastic File System. Também exibe opções flexíveis de computação, como AWS Fargate, Amazon EC2 Graviton, Amazon ECS Anywhere, AWS Outposts, zonas locais da AWS e AWS Wavelength. O Amazon Elastic Container Registry é mencionado como local para criar e armazenar imagens de contêineres.

AWS Fargate

Dentro do ECS, utilizaremos o AWS Fargate, que é um mecanismo de computação sem servidor e com pagamento conforme o uso. O Fargate permite que nos concentremos exclusivamente na construção da aplicação, sem a necessidade de provisionar ou gerenciar servidores subjacentes. Ele fornece um ambiente de execução isolado para os contêineres, garantindo a segurança e o isolamento dos recursos. Com o Fargate, podemos escalar automaticamente nossa aplicação com base na demanda, sem se preocupar com a infraestrutura subjacente.

Usamos a seguinte configuração para nossa aplicação:

{
    "taskDefinitionArn": "arn:aws:ecs:us-east-2:<ACCOUNT_ID>:task-definition/connectpharmacy-task-db-backend-frontend:9",
    "containerDefinitions": [
        {
            "name": "database",
            "image": "<ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com/connectpharmacy:db",
            "cpu": 0,
            "portMappings": [
                {
                    "name": "database-5432-tcp",
                    "containerPort": 5432,
                    "hostPort": 5432,
                    "protocol": "tcp",
                    "appProtocol": "http"
                }
            ],
            "essential": true,
            "environment": [
                {
                    "name": "POSTGRES_USER",
                    "value": "connectpharmacy"
                },
                {
                    "name": "POSTGRES_PASSWORD",
                    "value": "senha_do_banco"
                },
                {
                    "name": "POSTGRES_DB",
                    "value": "connectpharmacy"
                }
            ],
            "environmentFiles": [],
            "mountPoints": [],
            "volumesFrom": [],
            "ulimits": []
        },
        {
            "name": "backend",
            "image": "<ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com/connectpharmacy:backend_V4",
            "cpu": 0,
            "portMappings": [
                {
                    "name": "backend-3001-tcp",
                    "containerPort": 3001,
                    "hostPort": 3001,
                    "protocol": "tcp",
                    "appProtocol": "http"
                }
            ],
            "essential": false,
            "environment": [
                {
                    "name": "JWT_SECRET",
                    "value": "4ACB7CA3C7A9714555AB4A9F7114C"
                },
                {
                    "name": "DATABASE_URL",
                    "value": "postgresql://connectpharmacy:senha_do_banco@localhost:5432/connectpharmacy"
                }
            ],
            "environmentFiles": [],
            "mountPoints": [],
            "volumesFrom": [],
            "dependsOn": [
                {
                    "containerName": "database",
                    "condition": "START"
                }
            ]
        },
        {
            "name": "frontend",
            "image": "<ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com/connectpharmacy:frontend_V4",
            "cpu": 0,
            "portMappings": [
                {
                    "name": "frontend-80-tcp",
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp",
                    "appProtocol": "http"
                }
            ],
            "essential": false,
            "environment": [],
            "environmentFiles": [],
            "mountPoints": [],
            "volumesFrom": []
        }
    ],
    "family": "connectpharmacy-task-db-backend-frontend",
    "taskRoleArn": "arn:aws:iam::<ACCOUNT_ID>:role/ecsTaskExecutionRole",
    "executionRoleArn": "arn:aws:iam::<ACCOUNT_ID>:role/ecsTaskExecutionRole",
    "networkMode": "awsvpc",
    "revision": 9,
    "volumes": [],
    "status": "ACTIVE",
    "requiresAttributes": [
        {
            "name": "com.amazonaws.ecs.capability.ecr-auth"
        },
        {
            "name": "com.amazonaws.ecs.capability.task-iam-role"
        },
        {
            "name": "ecs.capability.container-ordering"
        },
        {
            "name": "ecs.capability.execution-role-ecr-pull"
        },
        {
            "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
        },
        {
            "name": "ecs.capability.task-eni"
        }
    ],
    "placementConstraints": [],
    "compatibilities": [
        "EC2",
        "FARGATE"
    ],
    "requiresCompatibilities": [
        "FARGATE"
    ],
    "cpu": "256",
    "memory": "512",
    "runtimePlatform": {
        "cpuArchitecture": "X86_64",
        "operatingSystemFamily": "LINUX"
    },
    "registeredAt": "2023-06-12T21:42:18.902Z",
    "registeredBy": "arn:aws:iam::<ACCOUNT_ID>:user/connectpharmacy",
    "tags": [
        {
            "key": "Project",
            "value": "Connect Pharmacy"
        },
        {
            "key": "Owner",
            "value": "connectpharmacy"
        }
    ]
}

Com essa configuração fomos capazes de fazer o deploy da aplicação no mesmo service do ECS, usando uma unica TASK do AWS Fargate.

Fonte: https://aws.amazon.com/pt/fargate/

Fluxo do Deploy

O fluxo do nosso processo de deploy seguirá as seguintes etapas:

Envio das Imagens para o ECR: Inicialmente, enviaremos as imagens conteinerizadas da nossa aplicação para o ECR. Teremos três imagens no total: uma para o frontend, uma para o backend e uma para o banco de dados. O ECR garantirá que essas imagens sejam armazenadas de forma segura e prontas para serem implantadas no ambiente do ECS.
Configuração do ECS: Com as imagens armazenadas no ECR, passaremos para a configuração do ECS. No ECS, criaremos uma task definition (definição de tarefa) que define como nossa aplicação será executada em contêineres. Nessa definição, especificaremos as imagens a serem utilizadas, a configuração de recursos, as variáveis de ambiente, as portas de comunicação e outros detalhes necessários para a execução correta da aplicação.
Criação do Serviço com o Fargate: Com a task definition configurada, iremos criar um serviço no ECS utilizando o AWS Fargate. Esse serviço representará a instância em execução da nossa aplicação, garantindo que ela esteja sempre disponível e escalável. O Fargate cuidará do provisionamento dos recursos necessários, como capacidade de computação e memória, conforme a demanda da aplicação.

Ao seguir esse fluxo de deploy, garantiremos a implantação automatizada, segura e escalável da nossa aplicação