AWS

--- CRIAR INSTÂNCIA AWS ---
EC2 / Instâncias / Executar instâncias
- Nome: ubuntuNginxTeste1
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Criar par de chaves:
-- Nome: keyNginxTeste1
-- Tipo: RSA
-- Formato: conforme SO de sua máquina
- Rede:
-- Atribuir IP público automaticamente: habilitar
-- Grupo de segurança criado automaticamente, com regras:
--- Permitir tráfego HTTP qualquer lugar
--- Permitir tráfego HTTPS qualquer lugar
--- Permitir tráfego SSH qualquer lugar
OBS: Após instância criada, pode-se editar regras de entrada do grupo de segurança, para permitir acesso apenas de IPs e portas específicas (EC2 / Grupos de segurança / Selecionar grupo / Editar regras de entrada)
- Armazenamento: 8GB (nível gratuito)
Executar instância

--- CONECTAR INSTÂNCIA AWS ---
EC2 / Instâncias / Selecionar instância / Ações / Conectar
- Connection type: IP público
- Endereço IPv4 público: selecionar (guardar IPv4 para acesso futuro)
Conectar

--- OPERAR INSTÂNCIA AWS ---
Na instância EC2 Ubuntu CLI, executar comandos:
- sudo apt update && sudo apt install nginx -y && sudo systemctl enable nginx --now && sudo su
- echo '<h1>Servidor EC2 UB Social</h1>' > /var/www/html/index.html

--- ACESSAR INSTÂNCIA AWS ---
- Acessar no browser: http://IPv4-PUBLICO-INSTANCIA
- Via Linux: ssh -i "sua-chave.pem" ubuntu@DNS-PUBLICO-INSTANCIA

--- CRIAR BUCKET S3 ---
S3 / Buckets / Criar bucket
- Nome: bucket-ubsocial-teste1
- Propriedade de objeto: Marcar ACLs desabilitadas (recomendado)
- Configurações de bloqueio do acesso público deste bucket: desabilitar tudo
Criar bucket

--- UPLOAD ARQUIVOS NO BUCKET S3 ---
- Baixar arquivos do site estático: https://github.com/mateusschwede/workover_aws/archive/refs/heads/main.zip
- Descompactar arquivos baixados (site está em 2_buckets_s3, pasta ubsocial.github.io)

- S3 / Buckets / Selecionar bucket / Aba Objetos / Carregar
- Adicionar pastas: selecionar pasta ubsocial.github.io
Carregar

--- PUBLICAR SITE ESTÁTICO NO S3 ---
S3 / Buckets / Selecionar bucket / Aba Propriedades / Hospedagem de site estático / Editar / Ativar
- Documento de índice: index.html (se não estiver em uma pasta)
S3 / Buckets / Selecionar bucket / Aba Permissões / Editar política de bucket, informando conteúdo:
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::bucket-ubsocial-teste1/*"
        }
    ]
}
- Salvar

--- ACESSAR SITE ESTÁTICO NO S3 ---
S3 / Buckets / Selecionar bucket / Aba Propriedades / Hospedagem de site estático
- Copiar URL do endpoint
- Acessar no browser: urlEndpoint/ubsocial.github.io/index.html

--- CRIAR BANCO DE DADOS RDS ---
Aurora and RDS / Bancos de dados / Criar banco de dados
- Método de criação: Padrão
- Opções de mecanismo: MySQL
- Modelos: Nível gratuito
- Configurações:
-- Identificador do banco de dados: ubsocial-mysql-teste1
-- Nome do usuário principal: admin
-- Senha: UBsocial123
- Configuração da instância:
-- Tipo de instância: (ver opções disponíveis no nível gratuito)
- Armazenamento:
-- Tipo de armazenamento: SSD de uso geral (gp2)
-- Armazenamento alocado: 20GB
-- Escalabilidade automática do armazenamento: desabilitar (para evitar custos extras)
- Conectividade:
-- Recurso de computação: Não se conectar a um recurso de computação do EC2
-- VPC: padrão
-- Grupo de sub-redes de banco de dados: padrão
-- Acesso público: Sim
-- Grupo de segurança de VPC (firewall): criar novo grupo de segurança
--- Nome: grupoSegurancaRDS1
-- Porta do banco de dados: 3306 (padrão MySQL)
- Configuração adicional:
-- Nome do banco de dados inicial: ubsocialdb1
Criar banco de dados

--- HABILITAR PORTA DE ACESSO RDS ---
EC2 / Grupos de segurança / Selecionar grupoSegurancaRDS1 / Editar regras de entrada (adicionar nova regra)
- Tipo: MySQL/Aurora
- Protocolo: TCP (padrão)
- Porta: 3306 (padrão MySQL)
- Origem: Qualquer local-IPv4 (0.0.0.0/0)
Salvar regras

--- ACESSAR BANCO DE DADOS RDS ---
RDS / Bancos de dados / Selecionar banco de dados / Aba Segurança e conexão / Copiar endpoint do RDS
No editor SQL, criar conexão:
- Host: Endpoint do RDS (sem "https://")
- Porta: 3306
- User: admin
- Senha: UBsocial123
- (opcional) Database: ubsocialdb1
Testar conexão e Conectar

Editor SQL, executar comandos:
CREATE TABLE tableTeste (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE
);
INSERT INTO tableTeste (nome, email) VALUES ('UB Social','ubsocial@example.com'),('UB Social 2','ubsocial2@example.com');
SELECT * FROM tableTeste;

RDS / Bancos de dados / Selecionar banco de dados / Aba Logs e eventos / Selecionar log de auditoria / Visualizar

--- CRIAR TABLE DYNAMODB ---
DynamoDB / Tabelas / Criar tabela
- Nome da tabela: usuarios-teste1
- Chave primária: user_id (String)
- Configurações da tabela: padrão
Criar tabela

--- INSERIR DADOS NA TABLE ---
DynamoDB / Tabelas / Selecionar usuarios-teste1 / Explorar itens da tabela / Criar item
- user_id: 1
Adicionar novo atributo (String)
- nome: 'UB Social'
Adicionar novo atributo (String)
- email: 'ubsocial@example.com'
Criar item

DynamoDB / Tabelas / Selecionar usuarios-teste1 / Explorar itens da tabela / Criar item
- user_id: 2
- nome: 'UB Social 2'
- email: 'ubsocial2@example.com'
Criar item

--- CONSULTAR DADOS NA TABLE ---
DynamoDB / Tabelas / Selecionar usuarios-teste1 / Explorar itens da tabela / Verificar ou consultar itens
- Tipo: Consulta
- Selecionar projeção de atributos: Atributos específicos
- Atributos específicos do projeto: nome
- Chave de partição (user_id): 1
Executar

--- CONSULTAR DADOS NA TABLE - CloudShell ---
Canto superior direito do console AWS / CloudShell, e executar comandos:
- aws dynamodb scan --table-name usuarios-teste1
- aws dynamodb put-item --table-name usuarios-teste1 --item '{"user_id":{"S":"u003"},"nome":{"S":"UB Social 3"},"email":{"S":"ubsocial3@example.com"}}'
- aws dynamodb get-item --table-name usuarios-teste1 --key '{"user_id": {"S": "u003"}}'
- aws dynamodb scan --table-name usuarios-teste1 --filter-expression "#n = :nomeVal AND email = :emailVal" --expression-attribute-names '{"#n":"nome "}' --expression-attribute-values '{":nomeVal":{"S":"UB Social 2"},":emailVal":{"S":"ubsocial2@example.com"}}'

--- CRIAR CLUSTER FARGATE ---
ECS / Clusters / Criar cluster
- Nome: ecs-fargate-nginx-demo
- Infraestrutura: Somente Fargate
Criar

--- CRIAR DEFINIÇÃO DE TAREFA ---
ECS / Definições de tarefa / Criar nova definição de tarefa
- Nome: nginx-fargate-demo
- Tipo de inicialização: AWS Fargate
- CPU: .25vCPU
- Memória: .5GB
- Função da tarefa: Nenhum
- Função de execução de tarefas: ecsTaskExecutionRole
- Container 1:
-- Nome: nginx
-- URI da imagem: nginx:alpine
- Mapeamentos de porta:
-- Porta do container: 80
-- Protocolo: TCP
- Coleção de logs: desabilitar
Criar

--- CRIAR GRUPO DE SEGURANÇA ---
EC2 / Grupos de segurança / Criar grupo de segurança
- Nome: grupoSeg-ecs-fargate-http
- Descrição: Permitir acesso HTTP externo ao Nginx ECS
- VPC: padrão
- Regras de entrada (adicionar nova regra):
-- Tipo: HTTP
-- Protocolo: TCP (padrão)
-- Intervalo de portas: 80 (padrão)
-- Origem: Qualquer local-IPv4 (0.0.0.0/0)
Criar

--- EXECUTAR TAREFA ---
ECS / Clusters / Selecionar ecs-fargate-nginx-demo / Aba Tarefas / Executar nova tarefa
- Família da definição de tarefa: nginx-fargate-demo
- Opções de computação: Selecionar Tipo de inicialização
- Tipo de inicialização: Fargate
- Rede:
-- VPC: padrão
-- Sub-redes: padrão
-- Nome do grupo de segurança: grupoSeg-ecs-fargate-http
-- IP público: Habilitar
Criar

--- ACESSAR CONTAINER ECS FARGATE ---
ECS / Clusters / Selecionar ecs-fargate-nginx-demo / Aba Tarefas / Selecionar tarefa em execução / Aba Associações de rede / Copiar IP público
- Acessar no browser: http://IP-PUBLICO-TAREFA (abrirá página padrão do Nginx)
- Via Linux: curl http://IP-PUBLICO-TAREFA

--- Exclusões ---
1.ECS / Clusters / Selecionar ecs-fargate-nginx-demo / Aba Tarefas / Selecionar tarefa em execução / Ações / Parar
2.ECS / Clusters / Selecionar ecs-fargate-nginx-demo / Excluir cluster
3.ECS / Definições de tarefa / Selecionar definição / nginx-fargate-demo / Ações / Cancelar registro, depois Excluir
4.EC2 / Grupos de segurança / Selecionar grupoSeg-ecs-fargate-http / Excluir

--- CRIAR FUNÇÃO LAMBDA ---
Lambda / Criar função
- Criar função do zero
- Nome da função: hello-serverless
- Tempo de execução: Python
- Permissões / Alterar a função de execução padrão: Selecionar 'Criar uma função com permissões básicas do Lambda'
Criar função

--- ADICIONAR CÓDIGO NA FUNÇÃO LAMBDA ---
Lambda / Selecionar função hello-serverless / Aba Código / Editar código:
def lambda_handler(event, context):
    return {
        "statusCode": 200,
        "headers": {"Content-Type": "text/plain; charset=utf-8"},
        "body": "Olá, mundo serverless!"
    }
- No VSCode da AWS, clicar em Deploy

--- TESTAR FUNÇÃO LAMBDA ---
Lambda / Selecionar função hello-serverless / Aba Testar / Evento de teste
- Ação de evento de teste: Criar novo evento
- Nome do evento: eventoTeste1
Salvar e Testar
- Verificar resultado: Status 200, Body "Olá, mundo UB Social Serverless!"

--- CRIAR API GATEWAY ---
API Gateway / APIs / Criar API
- Tipo de API: API HTTP / Compilar
- Nome da API: api-hello-serverless
- Tipo de endereço IP: IPv4
- Integrações / Acicionar integração
-- Tipo: Lambda
-- Escolher função Lambda: localizacaoAWS:hello-serverless
Avançar
- Configurar rotas:
-- Método: GET
-- Rota: /
-- Destino: hello-serverless
Avançar
- Estágio de implantação: padrão (geralmente com implantação automática habilitada)
Avançar / Criar / Implantar

--- TESTAR API GATEWAY ---
API Gateway / APIs / Selecionar api-hello-serverless / Aba Visão geral
- Copiar URL do endpoint padrão
- Acessar no browser: urlEndpoint
- Via Linux: curl urlEndpoint
- Verificar resultado: "Olá, mundo UB Social Serverless!"

--- Exclusões ---
1.API Gateway / APIs / Selecionar api-hello-serverless / Ações / Excluir
2.Lambda / Selecionar função hello-serverless / Ações / Excluir
3.CloudWatch / Logs / Selecionar grupo de logs / Ações / Excluir grupo de logs

--- CONTAINER NO HOST DOCKER ---
1.Criar Dockerfile:
FROM nginx:latest
RUN rm -rf /usr/share/nginx/html/*
RUN echo '<h1>UB Social</h1><p>Container com servidor nginx na AWS</p>' > /usr/share/nginx/html/index.html
2.Criar Image e construir container:
- docker build -t ubsocial/meu-nginx .
- docker run -dti -p 8080:80 ubsocial/meu-nginx2
3.Acessar nginx via host docker: curl http://localhost:8080

--- CRIAR USUÁRIO AWS ---
1.IAM / Usuários / Criar usuário
- Nome: usuarioUB1
- Fornecer acesso console AWS: habilitar
- Tipo: Quero criar usuário do IAM
- Senha do console: Senha gerada automaticamente
Próximo
- Permissões: Anexar políticas diretamente
-- AmazonEC2ContainerRegistryFullAccess
-- AmazonECS_FullAccess
-- AdministratorAccess
Próximo / Criar usuário / Baixar CSV
2.Selecionar usuário / Habilitar acesso console FMA
- Nome dispositivo: ubuntuTeste1
- MFA device: Chave de acesso ou chave de segurança
Próximo / Ativar via navegador
3.Selecionar usuário / Criar chave de acesso
- Tipo: CLI
- Valor etiqueta descrição: Criar containers
Criar chave de acesso / Baixar CSV

--- INSTALAR AWS CLI ---
1.curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
2.sudo apt update && sudo apt install -y unzip
3.unzip awscliv2.zip
4.sudo ./aws/install
5.aws --version
6.aws configure
- informar keys geradas no CSV com dados de chave de acesso do usuário
- região: sa-east-1
- Default output format: json
7.Login AWS CLI: aws ecr get-login-password --region sa-east-1 | docker login --username AWS --password-stdin ID-CONTA.dkr.ecr.sa-east-1.amazonaws.com

--- PUBLICAR IMAGE NA AWS ---
1.ECR / Repositórios / Criar repositório
- Nome: ubsocial/meu-nginx
- Etiqueta: Mutable
Criar
2.No host Docker, upload Image na AWS:
- docker tag ubsocial/meu-nginx:latest ID-CONTA.dkr.ecr.sa-east-1.amazonaws.com/ubsocial/meu-nginx:latest
- docker push ID-CONTA.dkr.ecr.sa-east-1.amazonaws.com/ubsocial/meu-nginx:latest

--- CRIAR CLUSTER FARGATE ---
ECS / Clusters / Criar cluster
- Nome gerado automaticamente
- Infraestrutura: AWS Fargate (sem servidor)
Criar

--- CRIAR DEFINIÇÃO DE TAREFA ---
ECS / Definições de tarefa / Criar nova definição de tarefa
- Família: familia-task
- Tipo de inicialização: AWS Fargate
- CPU: .25vCPU
- Memória: .5GB
Container 1:
- Nome: meu-nginx-container
- URI da imagem: ID-CONTA.dkr.ecr.sa-east-1.amazonaws.com/ubsocial/meu-nginx:latest
- Porta do container: 80
Criar

--- CRIAR SERVIÇO FARGATE ---
ECS / Clusters / Selecionar cluster / Aba serviços / Criar
- Família da definição de tarefa: familia-task
- Nome do serviço gerado automaticamente
- Provedor de capacidade: Fargate (padrão)
- Tarefas desejadas: 1 (padrão)
- Rede VPC: padrão
- Sub-redes: padrão
- IP público: habilitar (padrão)
Criar

--- HABILITAR ACESSO AO CONTAINER AWS ---
ECS / Clusters / Selecionar cluster / Aba Serviços / Tarefas / Selecionar tarefa
- Aba Redes: clicar no ID da ENI
- Na ENI: clicar no grupo de segurança
- No grupo de segurança: editar regras de entrada (adicionar nova regra)
-- Tipo: HTTP
-- Protocolo: TCP (padrão)
-- Intervalo de portas: 80 (padrão)
-- Origem: Qualquer local-IPv4
-- 0.0.0.0/0
Salvar regras

--- ACESSAR CONTAINER AWS ---
ECS / Clusters / Selecionar cluster / Aba Serviços / Tarefas / Selecionar tarefa
- Aba Associações de rede: Copiar IP-AWS
- No host docker: curl http://IP-AWS

--- Exclusões ---
1.ECS / Clusters / Selecionar cluster / Excluir cluster
2.ECS / Definições de tarefa / Selecionar definição / familia-task / Ações / Cancelar registro
3.ECR / Repositórios / Selecionar repositório / Excluir
4.IAM / Usuários / Selecionar usuário / Excluir (desativar chave de acesso, e confirmar exclusão)
5.Apagar dados locais no host docker (images, container, Dockerfile)

--- CRIAR INSTÂNCIA AWS ---
EC2 / Instâncias / Executar instâncias
- Nome: ubuntuDjangoTeste1
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Criar par de chaves:
-- Nome: keyDjangoTeste1
-- Tipo: RSA
-- Formato: conforme SO de sua máquina
- Rede:
-- Atribuir IP público automaticamente: habilitar
-- Grupo de segurança criado automaticamente, com regras:
--- Permitir tráfego HTTP qualquer lugar
--- Permitir tráfego HTTPS qualquer lugar
--- Permitir tráfego SSH qualquer lugar
- Armazenamento: 8GB (nível gratuito)
Criar

--- CRIAR E ATRIBUIR GRUPO DE SEGURANÇA ---
EC2 / Grupos de segurança / Criar grupo de segurança
- Nome: grupoSegurancaTeste1
- Descrição: Grupo de seguranca para testes 1
- Regras de entrada:
-- SSH: porta 22, IP 0.0.0.0/0
-- HTTP: porta 80, IP 0.0.0.0/0
-- Personalizado TCP: porta 8000 (porta Django), IP 0.0.0.0/0
-- Personalizado TCP: porta 5173 (porta Vue.js), IP 0.0.0.0/0
Criar

EC2 / Instâncias / Selecionar instância / Ações / Segurança
- Alterar grupos de segurança para grupoSegurancaTeste1
Confirmar Executar instância (guardar IPv4 para acesso futuro)

--- CONECTAR INSTÂNCIA AWS ---
EC2 / Instâncias / Selecionar instância / Ações / Conectar CLI usando IP público (e executar comandos):
- sudo apt update && sudo apt install python3-pip npm python3-venv git -y && sudo pip3 install django djangorestframework markdown django-filter django-cors-headers pytest pytest-django pytest-html model_bakery --break-system-packages && sudo npm install -g @vue/cli
- curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt install nodejs -y
- git clone https://github.com/mateusschwede/cafe_fullstack.git && cd cafe_fullstack/paris_cafe
- python3 manage.py migrate
- nano paris_cafe/settings.py (informar conteúdo abaixo):
ALLOWED_HOSTS = [
    'ec2-54-233-2-156.sa-east-1.compute.amazonaws.com', // IPv4 da instância EC2
    'localhost',
    '127.0.0.1',
]

- cd ../ && python3 manage.py runserver 0.0.0.0:8000 &
-- Enter para sair do comando iterativo (servidor Django executando em background nohup)
- cd ../cafe-frontend
- sudo npm install
- nano vite.config.ts (informar conteúdo abaixo):
export default defineConfig({
    // outro conteúdo
    server: {
        host: '0.0.0.0',
        port: 5173,
        allowedHosts: [
            'ec2-54-233-2-156.sa-east-1.compute.amazonaws.com' // IPv4 da instância EC2
        ]
    }
})

- nano src/services/api.ts (informar conteúdo abaixo):
// outro conteúdo
baseURL: 'http://ec2-54-233-2-156.sa-east-1.compute.amazonaws.com:8000' // IPv4 da instância EC2

- sudo npx vite --host
-- Acessar API REST backend Django: http://ipv4_aws:8000
-- Acessar projeto no browser: http://ipv4_aws:5173

--- Exclusões ---
1.EC2 / Instâncias / Selecionar instância / Ações / Estado da instância / Encerrar instância
2.EC2 / Grupos de segurança / Selecionar grupoSegurancaTeste1 / Excluir
3.EC2 / Chaves de acesso / Selecionar ubuntuDjangoTeste1-key.pem / Excluir