> ## Documentation Index
> Fetch the complete documentation index at: https://docs.casebender.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Implantar na AWS

> Implante o CaseBender no Amazon Web Services (AWS)

## Visão Geral

Este guia orienta você na implantação do CaseBender na AWS usando imagens Docker pré-construídas com o Amazon ECS (Elastic Container Service) e Fargate.

## Pré-requisitos

1. [Conta AWS](https://aws.amazon.com/)
2. [AWS CLI](https://aws.amazon.com/cli/) instalado e configurado
3. [Docker](https://docs.docker.com/get-docker/) instalado

## Passo 1: Configuração Inicial

### Instalar e Configurar AWS CLI

<CodeGroup>
  ```bash macOS theme={null}
  # Usando Homebrew
  brew install awscli

  # Configurar AWS CLI

  aws configure

  # Configurar Docker para ECR

  aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.us-east-1.amazonaws.com

  ```

  ```bash Linux theme={null}
  # Instalar AWS CLI
  curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
  unzip awscliv2.zip
  sudo ./aws/install

  # Configurar AWS CLI
  aws configure

  # Configurar Docker para ECR
  aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.us-east-1.amazonaws.com
  ```

  ```powershell Windows theme={null}
  # Baixe e execute o instalador MSI da AWS CLI
  # https://awscli.amazonaws.com/AWSCLIV2.msi

  # Configurar AWS CLI
  aws configure

  # Configurar Docker para ECR
  aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.us-east-1.amazonaws.com
  ```
</CodeGroup>

## Passo 2: Configurar Infraestrutura AWS

### Criar Bucket S3 para Armazenamento

```bash theme={null}
# Criar bucket S3
aws s3 create-bucket \
  --bucket casebender-storage \
  --region us-east-1

# Habilitar versionamento (opcional)
aws s3api put-bucket-versioning \
  --bucket casebender-storage \
  --versioning-configuration Status=Enabled

# Criar usuário IAM para acesso ao S3
aws iam create-user --user-name casebender-storage-user

# Criar e anexar política
aws iam create-policy \
  --policy-name casebender-storage-policy \
  --policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:DeleteObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::casebender-storage",
                "arn:aws:s3:::casebender-storage/*"
            ]
        }
    ]
}'

# Anexar política ao usuário
aws iam attach-user-policy \
  --user-name casebender-storage-user \
  --policy-arn arn:aws:iam::YOUR_ACCOUNT_ID:policy/casebender-storage-policy

# Criar chaves de acesso
aws iam create-access-key --user-name casebender-storage-user
```

### Criar uma VPC

```bash theme={null}
# Criar VPC
aws ec2 create-vpc \
  --cidr-block 10.0.0.0/16 \
  --tag-specifications 'ResourceType=vpc,Tags=[{Key=Name,Value=casebender-vpc}]'

# Habilitar nomes de host DNS
aws ec2 modify-vpc-attribute \
  --vpc-id <vpc-id> \
  --enable-dns-hostnames
```

### Criar Subnets

```bash theme={null}
# Criar subnets públicas
aws ec2 create-subnet \
  --vpc-id <vpc-id> \
  --cidr-block 10.0.1.0/24 \
  --availability-zone us-east-1a \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=casebender-public-1a}]'

aws ec2 create-subnet \
  --vpc-id <vpc-id> \
  --cidr-block 10.0.2.0/24 \
  --availability-zone us-east-1b \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=casebender-public-1b}]'
```

### Configurar RDS (PostgreSQL)

```bash theme={null}
# Criar grupo de subnet de banco de dados
aws rds create-db-subnet-group \
  --db-subnet-group-name casebender-db-subnet \
  --db-subnet-group-description "Grupo de subnet para CaseBender RDS" \
  --subnet-ids "<subnet-1-id>" "<subnet-2-id>"

# Criar instância RDS
aws rds create-db-instance \
  --db-instance-identifier casebender-db \
  --db-instance-class db.t3.medium \
  --engine postgres \
  --master-username superadmin \
  --master-user-password <sua-senha-segura> \
  --allocated-storage 20 \
  --db-subnet-group-name casebender-db-subnet
```

### Configurar ElastiCache (Redis)

```bash theme={null}
# Criar grupo de subnet de cache
aws elasticache create-cache-subnet-group \
  --cache-subnet-group-name casebender-cache-subnet \
  --cache-subnet-group-description "Grupo de subnet para CaseBender Redis" \
  --subnet-ids "<subnet-1-id>" "<subnet-2-id>"

# Criar cluster Redis
aws elasticache create-cache-cluster \
  --cache-cluster-id casebender-redis \
  --engine redis \
  --cache-node-type cache.t3.micro \
  --num-cache-nodes 1 \
  --cache-subnet-group-name casebender-cache-subnet
```

## Passo 3: Criar Repositórios ECR

```bash theme={null}
# Criar repositórios para cada serviço
aws ecr create-repository --repository-name casebender/app
aws ecr create-repository --repository-name casebender/workflow-processor
aws ecr create-repository --repository-name casebender/misp-processor

# Obter o ID da conta AWS
AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

# Baixar imagens do CaseBender
docker pull casebender/casebender:latest
docker pull casebender/workflow-processor:latest
docker pull casebender/misp-processor:latest

# Marcar imagens para ECR
docker tag casebender/casebender:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/app:latest
docker tag casebender/workflow-processor:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/workflow-processor:latest
docker tag casebender/misp-processor:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/misp-processor:latest

# Enviar imagens para ECR
docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/app:latest
docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/workflow-processor:latest
docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/misp-processor:latest
```

## Passo 4: Criar Cluster ECS

```bash theme={null}
# Criar cluster ECS
aws ecs create-cluster --cluster-name casebender-cluster

# Criar função de execução de tarefa
aws iam create-role \
  --role-name ecsTaskExecutionRole \
  --assume-role-policy-document file://task-execution-assume-role.json

# Anexar política
aws iam attach-role-policy \
  --role-name ecsTaskExecutionRole \
  --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
```

## Passo 5: Criar Definições de Tarefas

Crie arquivos JSON de definição de tarefa para cada serviço:

```json theme={null}
{
  "family": "casebender-app",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "1024",
  "memory": "2048",
  "executionRoleArn": "arn:aws:iam::<aws-account-id>:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "<aws-account-id>.dkr.ecr.us-east-1.amazonaws.com/casebender/app:latest",
      "portMappings": [
        {
          "containerPort": 3000,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {
          "name": "POSTGRES_PRISMA_URL",
          "value": "postgresql://superadmin:password@casebender-db.xxxxx.region.rds.amazonaws.com:5432/casebender"
        },
        {
          "name": "REDIS_URL",
          "value": "redis://casebender-redis.xxxxx.region.cache.amazonaws.com:6379"
        },
        {
          "name": "AWS_S3_BUCKET",
          "value": "casebender-storage"
        },
        {
          "name": "AWS_S3_REGION",
          "value": "us-east-1"
        }
      ],
      "secrets": [
        {
          "name": "AUTH_SECRET",
          "valueFrom": "arn:aws:secretsmanager:region:account:secret:auth-secret"
        },
        {
          "name": "AUTH_SALT",
          "valueFrom": "arn:aws:secretsmanager:region:account:secret:auth-salt"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/casebender",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "app"
        }
      }
    }
  ]
}
```

Registre as definições de tarefas:

```bash theme={null}
# Registrar definições de tarefas
aws ecs register-task-definition --cli-input-json file://app-task-definition.json
aws ecs register-task-definition --cli-input-json file://workflow-processor-task-definition.json
aws ecs register-task-definition --cli-input-json file://misp-processor-task-definition.json
```

## Passo 6: Criar Balanceador de Carga de Aplicação

```bash theme={null}
# Criar ALB
aws elbv2 create-load-balancer \
  --name casebender-alb \
  --subnets <subnet-1-id> <subnet-2-id> \
  --security-groups <security-group-id>

# Criar grupo de destino
aws elbv2 create-target-group \
  --name casebender-tg \
  --protocol HTTP \
  --port 3000 \
  --vpc-id <vpc-id> \
  --target-type ip

# Criar ouvinte
aws elbv2 create-listener \
  --load-balancer-arn <alb-arn> \
  --protocol HTTPS \
  --port 443 \
  --certificates CertificateArn=<certificate-arn> \
  --default-actions Type=forward,TargetGroupArn=<target-group-arn>
```

## Passo 7: Criar Serviços ECS

```bash theme={null}
# Criar serviço para o aplicativo principal
aws ecs create-service \
  --cluster casebender-cluster \
  --service-name casebender-app \
  --task-definition casebender-app \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-1-id>,<subnet-2-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" \
  --load-balancers "targetGroupArn=<target-group-arn>,containerName=app,containerPort=3000"

# Criar serviços para processadores
aws ecs create-service \
  --cluster casebender-cluster \
  --service-name workflow-processor \
  --task-definition casebender-workflow-processor \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-1-id>,<subnet-2-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}"

aws ecs create-service \
  --cluster casebender-cluster \
  --service-name misp-processor \
  --task-definition casebender-misp-processor \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-1-id>,<subnet-2-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}"
```

## Passo 8: Configurar Route 53 (Opcional)

Se você estiver usando um domínio personalizado:

```bash theme={null}
# Criar zona hospedada (se não existir)
aws route53 create-hosted-zone \
  --name seudominio.com \
  --caller-reference $(date +%s)

# Criar registro A
aws route53 change-resource-record-sets \
  --hosted-zone-id <zone-id> \
  --change-batch '{
    "Changes": [{
      "Action": "CREATE",
      "ResourceRecordSet": {
        "Name": "seudominio.com",
        "Type": "A",
        "AliasTarget": {
          "HostedZoneId": "<alb-hosted-zone-id>",
          "DNSName": "<alb-dns-name>",
          "EvaluateTargetHealth": true
        }
      }
    }]
  }'
```

## Monitoramento e Manutenção

### Configurar Alarmes CloudWatch

```bash theme={null}
# Criar alarme de utilização de CPU
aws cloudwatch put-metric-alarm \
  --alarm-name casebender-cpu-alarm \
  --alarm-description "Utilização de CPU excedeu 80%" \
  --metric-name CPUUtilization \
  --namespace AWS/ECS \
  --statistic Average \
  --period 300 \
  --threshold 80 \
  --comparison-operator GreaterThanThreshold \
  --dimensions Name=ClusterName,Value=casebender-cluster \
  --evaluation-periods 2 \
  --alarm-actions <sns-topic-arn>
```

### Visualizar Logs

```bash theme={null}
# Visualizar logs de serviço
aws logs get-log-events \
  --log-group-name /ecs/casebender \
  --log-stream-name app/<container-id>
```

### Atualizar Serviços

```bash theme={null}
# Atualizar serviço com nova definição de tarefa
aws ecs update-service \
  --cluster casebender-cluster \
  --service casebender-app \
  --task-definition casebender-app:NEW_REVISION
```

## Otimização de Custos

1. Use Fargate Spot para cargas de trabalho não críticas
2. Implemente auto-scaling baseado em métricas
3. Escolha tamanhos de instância apropriados
4. Use Instâncias Reservadas para cargas de trabalho previsíveis

## Melhores Práticas de Segurança

1. Use AWS Secrets Manager para dados sensíveis
2. Implemente regras WAF
3. Habilite Logs de Fluxo VPC
4. Auditorias regulares de grupo de segurança
5. Habilite AWS GuardDuty

## Próximos Passos

* Configure pipeline CI/CD com AWS CodePipeline
* Configure estratégias de backup
* Implemente monitoramento e alertas
* Revise melhores práticas de segurança