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
4.IAM / Funções / Selecionar função criada para Lambda / Ações / Excluir função
5.IAM / Políticas / Selecionar política criada para Lambda / Ações / Excluir política

--- CRIAR FUNÇÃO LAMBDA ---
Lambda / Criar função
- Criar função do zero
- Nome: logLambdaCloudWatch
- 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 logLambdaCloudWatch / Aba Código / Editar código:
import json
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    logger.info("Função Lambda executada com sucesso!")
    return {
        'statusCode': 200,
        'body': json.dumps('Log enviado ao CloudWatch!')
    }
- No VSCode da AWS, clicar em Deploy

--- TESTAR FUNÇÃO LAMBDA ---
Lambda / Selecionar função logLambdaCloudWatch / Aba Testar / Evento de teste
- Ação de evento de teste: Criar novo evento
- Nome do evento: eventoTesteLog1
Salvar e Testar

--- VERIFICAR LOGS NO CLOUDWATCH ---
CloudWatch / Logs / Selecionar grupo de logs / Selecionar grupo / Aba Streams de log / Selecionar fluxo / Verificar logs

--- CRIAR ALARME NO CLOUDWATCH ---
CloudWatch / Alarmes / Criar alarme
- Selecionar métrica / Lambda by Function name / Selecionar logLambdaCloudWatch invocations / Selecionar e continuar
- Período: 1 minuto
- Condição: Maior que ou igual a 1
Avançar
- Nome do alarme: AlertaExecucaoLambda
Avançar / Criar alarme

--- TESTAR ALARME NO CLOUDWATCH ---
Lambda / Selecionar função logLambdaCloudWatch / Aba Testar / Evento de teste
- Ação de evento de teste: Selecionar eventoTesteLog1
Testar
- CloudWatch / Alarmes / Selecionar AlertaExecucaoLambda / Verificar estado do alarme (Ok -> Em alarme)

--- Exclusões ---
1.CloudWatch / Alarmes / Selecionar AlertaExecucaoLambda / Ações / Excluir
2.CloudWatch / Logs / Selecionar grupo de logs / Ações / Excluir grupo de logs
3.Lambda / Selecionar função logLambdaCloudWatch / Ações / Excluir

--- CRIAR TÓPICO SNS ---
SNS / Tópicos / Criar tópico
- Nome: meu-topico-sns1
- Tipo: Padrão
Criar tópico (anotar ARN gerado)

--- CRIAR FILA SQS ---
SQS / Filas / Criar fila
- Tipo: Padrão
- Nome: minha-fila-sqs1
Criar fila (anotar ARN gerado)

--- CONECTAR SNS COM SQS ---
SNS / Tópicos / Selecionar meu-topico-sns1 / Aba Assinaturas / Criar assinatura
- Protocolo: Amazon SQS
- Endpoint: ARN da fila SQS
Criar assinatura

--- CRIAR FUNÇÃO LAMBDA ---
Lambda / Criar função
- Criar função do zero
- Nome: lambda-processa-sqs1
- 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 lambda-processa-sqs1 / Aba Código / Editar código:
import json

def process_text_message(text):
    text = text.strip()
    if not text:
        print("Mensagem vazia ou somente espaços - ignorando")
        return
    print("Mensagem final:", text)

def lambda_handler(event, context):
    for record in event.get('Records', []):
        body = record.get('body', '')
        try:
            parsed = json.loads(body)
        except Exception:
            parsed = None

        if isinstance(parsed, dict) and 'Message' in parsed:
            msg = parsed.get('Message', '')
            try:
                inner = json.loads(msg)
                print("Mensagem original (JSON):")
                print(json.dumps(inner, ensure_ascii=False))
            except Exception:
                process_text_message(msg)

        elif isinstance(parsed, dict):
            print("Mensagem recebida (body JSON):")
            print(json.dumps(parsed, ensure_ascii=False))
        
        else:
            process_text_message(body)

    return {"statusCode": 200, "body": json.dumps("OK")}
- No VSCode da AWS, clicar em Deploy

--- IAM PERMITIR LAMBDA ACESSAR FILA SQS ---
Lambda / Selecionar função lambda-processa-sqs1 / Aba Configurações / Permissões / Função de execução / Clicar no nome da função (irá para tela IAM)
- Políticas de permissões / Adicionar permissões / Criar política em linha / Aba JSON:
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowLambdaToAccessSQS",
      "Effect": "Allow",
      "Action": [
        "sqs:ReceiveMessage",
        "sqs:DeleteMessage",
        "sqs:GetQueueAttributes",
        "sqs:ChangeMessageVisibility"
      ],
      "Resource": "ARN-SUA-FILA-SQS-AQUI"
    }
  ]
}

Avançar
- Nome da política: LambdaSQSAccessPolicy1
Criar política

--- CONECTAR FILA SQS À LAMBDA ---
Lambda / Selecionar função lambda-processa-sqs1 / Aba Configurações / Gatilhos / Adicionar gatilho
- Configuração do gatilho: Selecionar SQS
- Fila: minha-fila-sqs1
Adicionar
- Habilitar gatilho: Aba Gatilhos / Clicar no gatilho SQS / Aba Triggers do Lambda (verificar se trigger está habilitado)

--- PUBLICAR MENSAGEM NO TÓPICO SNS ---
SNS / Tópicos / Selecionar meu-topico-sns1 / Publicar mensagem
- Assunto: Novo pedido 1
- Corpo da mensagem: Pedido de compra UB Social
Publicar mensagem

--- VER LOG NO CLOUDWATCH ---
CloudWatch / Logs / Selecionar grupo de logs / Aba Streams de log / Selecionar fluxo / Verificar logs (deve conter mensagem "Mensagem recebida: Pedido de compra UB Social")

--- Exclusões ---
1.Lambda / Selecionar função lambda-processa-sqs1 / Ações / Excluir
2.SQS / Filas / Selecionar minha-fila-sqs1 / Ações / Excluir fila
3.SNS / Tópicos / Selecionar meu-topico-sns1 / Ações / Excluir tópico
4.CloudWatch / Logs / Selecionar grupo de logs / Ações / Excluir grupo de logs
5.IAM / Funções / Selecionar função criada para Lambda / Ações / Excluir função
6.IAM / Políticas / Selecionar política LambdaSQSAccessPolicy1 / Ações / Excluir política

--- CRIAR TEMPLATE CLOUDFORMATION ---
- Criar arquivo s3-bucket-simple.yaml:
AWSTemplateFormatVersion: "2010-09-09"
Description: Template CloudFormation simples que cria um bucket S3
Resources:
    MeuBucketS3:
        Type: AWS::S3::Bucket
        Properties:
            BucketName: !Sub "${AWS::AccountId}-meu-bucket-exemplo"
            VersioningConfiguration:
                Status: Suspended
Outputs:
    BucketName:
        Description: "Nome do bucket criado"
        Value: !Ref MeuBucketS3

--- CRIAR PILHA CLOUDFORMATION ---
AWS / CloudFormation / Pilhas / Criar pilha / Com novos recursos (padrão)
- Preparar modelo: Escolher um modelo existente
- Especificar modelo: Fazer upload de um arquivo de modelo
Avançar
- Nome da pilha: exemplo-s3-iac
Avançar / Enviar
- Verificar criação da pilha (Status CREATE_IN_PROGRESS - aguardar até CREATE_COMPLETE)

--- VERIFICAR BUCKET S3 CRIADO ---
S3 / Buckets / Verificar bucket criado com nome ID-CONTA-meu-bucket-exemplo

--- Exclusões ---
1.CloudFormation / Pilhas / Selecionar exemplo-s3-iac / Ações / Excluir
2.Verificar exclusão do bucket S3 (deve ser excluído automaticamente junto com pilha)

--- CRIAR REPOSITÓRIO GITHUB ---
GitHub / New repository
- Nome: meu-site-demo1
- Visibilidade: Público
Criar repositório
- Acessar repositório / Adicionar arquivo / Create new file
- Nome do arquivo: index.html, conteúdo:
<h1>Meu Site Demo 1</h1>
Commit changes

--- CRIAR BUCKET S3 ---
S3 / Buckets / Criar bucket
- Nome: meu-site-demo1-ubsocial
- Bloquear todo o acesso público: desabilitar
Criar bucket
S3 / Buckets / Selecionar bucket / Aba Propriedades / Hospedagem de site estático / Editar / Ativar
- Documento de índice: index.html
Salvar alterações (aba Propriedades / Hospedagem de site estático / Copiar URL do endpoint)
S3 / Buckets / Selecionar bucket / Aba Permissões / Editar política de bucket, informando conteúdo:
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": "*",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::meu-site-demo1-ubsocial/*"
            ]
        }
    ]
}

- Salvar alterações

--- CRIAR PIPELINE CODEPIPELINE ---
AWS / CodePipeline / Pipelines / Criar pipeline
- Category: Criar pipeline personalizado
Avançar
- Nome: meu-site-demo1-pipeline
- Função de serviço: Nova função de serviço
- Nome da função: CodePipelineServiceRole1
Avançar
- Origem (provedor): GitHub (por meio do aplicativo OAuth)
- Conectar ao GitHub / Autorizar AWS CodePipeline
- Repositório: selecionar meu-site-demo1
- Ramificação: main
Avançar
- Compilação: ignorar etapa de compilação
- Teste: ignorar etapa de teste
- Implantação (Provedor): Amazon S3
- Bucket: meu-site-demo1-ubsocial
- Chave do objeto: site1.zip
- Extraia o arquivo antes de implantar: habilitar
Avançar / Criar pipeline

--- CONFERIR CRIAÇÃO DO PIPELINE ---
CodePipeline / Pipelines / Selecionar meu-site-demo1-pipeline / Verificar execução do pipeline (Status: Succeeded)
S3 / Buckets / Selecionar meu-site-demo1-ubsocial / Verificar arquivo site1.zip criado
- Acessar no browser: URL endpoint do bucket S3 (urlBucket/site.zip/index.html)

--- ALTERAR ARQUIVO NO REPOSITÓRIO GITHUB ---
GitHub / Repositório meu-site-demo1 / Selecionar arquivo index.html / Editar
- Alterar conteúdo do arquivo:
<h1>Meu Site Demo 1 - Atualizado</h1>
Commit changes

--- CONFERIR EXECUÇÃO DO PIPELINE APÓS ALTERAÇÃO ---
CodePipeline / Pipelines / Selecionar meu-site-demo1-pipeline / Verificar nova execução automática do pipeline (Status: Succeeded)
S3 / Buckets / Selecionar meu-site-demo1-ubsocial / Verificar arquivo site1.zip atualizado
- Atualizar no browser: URL endpoint do bucket S3 (urlBucket/site.zip/index.html)

--- Exclusões ---
1.CodePipeline / Pipelines / Selecionar meu-site-demo1-pipeline / Ações / Excluir pipeline
2.S3 / Buckets / Selecionar meu-site-demo1-ubsocial / Ações / Excluir bucket
3.IAM / Funções / Selecionar CodePipelineServiceRole1 / Ações / Excluir função
4.IAM / Políticas / Selecionar AWSCodePipelineServiceRole-sa-east-1-meu-site-demo1-pipeline / Ações / Excluir política
5.(Opcional) GitHub / Repositório meu-site-demo1 / Settings / Delete this repository

--- CRIAR INSTÂNCIA EC2 Server 1 ---
EC2 / Instâncias / Executar instâncias
- Nome: web-server-1
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Criar par de chaves:
-- Nome: curso-elb-key1
-- Tipo: RSA
-- Formato: conforme SO de sua máquina
- Rede: Editar
-- Atribuir IP público automaticamente: habilitar
-- Grupo de segurança: criar novo grupo de segurança
--- Nome: grupoSeg-web-elb1
--- Descrição: HTTP-SSH-EC2-ELB-ubsocial
--- Regras de entrada:
---- Tipo: SSH / Protocolo: TCP / Intervalo de portas: 22 / Tipo de origem: Qualquer local-IPv4 (0.0.0.0/0)
---- Tipo: HTTP / Protocolo: TCP / Intervalo de portas: 80 / Tipo de origem: Qualquer local-IPv4 (0.0.0.0/0)
-- Armazenamento: 8GB (nível gratuito)
-- Dados do usuário (User Data - inserir comandos):
#!/bin/bash
apt update -y
DEBIAN_FRONTEND=noninteractive apt install -y apache2
systemctl enable apache2 --now
echo "<h1>Servidor 1: $(hostname)</h1>" > /var/www/html/index.html
- Executar instância

--- CRIAR INSTÂNCIA EC2 Server 2 ---
EC2 / Instâncias / Executar instâncias
- Nome: web-server-2
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Par de chaves: Selecionar curso-elb-key1
- Rede: Selecionar grupo de segurança comuns: grupoSeg-web-elb1
- Armazenamento: 8GB (nível gratuito)
- Dados do usuário (User Data - inserir comandos):
#!/bin/bash
apt update -y
DEBIAN_FRONTEND=noninteractive apt install -y apache2
systemctl enable apache2 --now
echo "<h1>Servidor 2: $(hostname)</h1>" > /var/www/html/index.html
- Executar instância

--- TESTAR APACHE NAS INSTÂNCIAS EC2 ---
- Server 1: EC2 / Instâncias / Selecionar web-server-1 / Copiar IPv4 público (abrir no browser: http://IP-PUBLICO-SERVER-1)
- Server 2: EC2 / Instâncias / Selecionar web-server-2 / Copiar IPv4 público (abrir no browser: http://IP-PUBLICO-SERVER-2)

--- CRIAR GRUPO DE DESTINO ---
EC2 / Grupos de Destino / Criar grupo de destino
- Tipo de destino: Instâncias
- Nome: grupo-destino-web1-ubsocial
- Protocolo: HTTP
- Porta: 80
- Tipo de endereço IP: IPv4
- VPC: padrão (mesmo das instâncias EC2)
- Verificações de integridade:
-- Protocolo: HTTP
-- Caminho da verificação de integridade: /
-- Intervalo: 30 segundos (padrão)
-- Tempo limite: 5 segundos (padrão)
Avançar
- Registrar destinos:
-- Selecionar web-server-1 e web-server-2
-- Porta para instâncias: 80
Incluir como pendente abaixo / Criar grupo de destino

--- CRIAR APPLICATION LOAD BALANCER (ALB) ---
EC2 / Load Balancers / Criar Load Balancer / Application Load Balancer / Criar
- Nome: alb-web1-ubsocial
- Esquema: Voltado para a internet
- Tipo de endereço IP: IPv4
- Zonas de disponibilidade: selecionar todas disponíveis (padrão)
- Grupos de segurança: Selecionar grupoSeg-web-elb1
- Listeners e roteamento: Protocolo: HTTP / Porta: 80
- Ação padrão:
-- Encaminhar aos grupos de destino
-- Selecionar grupo-destino-web1-ubsocial
Criar Load Balancer (copiar DNS do ALB gerado)

--- TESTAR APPLICATION LOAD BALANCER (ALB) ---
- Acessar no browser: DNS-ALB-GERADO (recarregar página várias vezes, deve alternar entre Server 1 e Server 2)

--- Exclusões ---
1.EC2 / Load Balancers / Selecionar alb-web1-ubsocial / Ações / Excluir
2.EC2 / Grupos de Destino / Selecionar grupo-destino-web1-ubsocial / Ações / Excluir
3.EC2 / Instâncias / Selecionar web-server-1 / Ações / Instância de estado / Parar, depois Terminar
4.EC2 / Instâncias / Selecionar web-server-2 / Ações / Instância de estado / Parar, depois Terminar
5.EC2 / Grupos de segurança / Selecionar grupoSeg-web-elb1 / Ações / Excluir
6.EC2 / Pares de chaves / Selecionar curso-elb-key1 / Ações / Excluir par de chaves

--- CRIAR INSTÂNCIA EC2 (web1) ---
EC2 / Instâncias / Executar instâncias
- Nome: web1
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Criar par de chaves:
-- Nome: route53-key1
-- Tipo: RSA
-- Formato: conforme SO de sua máquina
- Rede: Editar
-- Atribuir IP público automaticamente: habilitar
-- Grupo de segurança: criar novo grupo de segurança
--- Nome: grupoSeg-route53-ssh-http
--- Descrição: SSH-HTTP-EC2-Route53-ubsocial
--- Regras de entrada:
---- Tipo: SSH / Protocolo: TCP / Intervalo de portas: 22 / Tipo de origem: Qualquer local-IPv4 (0.0.0.0/0)
---- Tipo: HTTP / Protocolo: TCP / Intervalo de portas: 80 / Tipo de origem: Qualquer local-IPv4 (0.0.0.0/0)
-- Armazenamento: 8GB (nível gratuito)
-- Dados do usuário (User Data - inserir comandos):
#!/bin/bash
apt update -y
DEBIAN_FRONTEND=noninteractive apt install -y apache2 dnsutils
systemctl enable apache2 --now
echo "<h1>web1: $(hostname)</h1>" > /var/www/html/index.html
- Executar instância (anotar IPv4 público e privado da instância)

--- CRIAR INSTÂNCIA EC2 (web2) ---
EC2 / Instâncias / Executar instâncias
- Nome: web2
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Par de chaves: Selecionar route53-key1
- Rede: Selecionar grupo de segurança comuns: grupoSeg-route53-ssh-http
- Armazenamento: 8GB (nível gratuito)
- Dados do usuário (User Data - inserir comandos):
#!/bin/bash
apt update -y
DEBIAN_FRONTEND=noninteractive apt install -y apache2 dnsutils
systemctl enable apache2 --now
echo "<h1>web2: $(hostname)</h1>" > /var/www/html/index.html
- Executar instância (anotar IPv4 público e privado da instância)

--- CRIAR ZONA PRIVADA ROUTE 53 ---
Route 53 / Zonas hospedadas / Criar zona hospedada
- Nome do domínio: ubsocial.local
- Tipo de zona hospedada: Privada para VPC
- VPCs associadas:
-- Região: selecionar região atual
-- VPC: selecionar VPC padrão
Criar zona hospedada

--- CRIAR REGISTROS DNS NA ZONA PRIVADA ---
Route 53 / Zonas hospedadas / Selecionar ubsocial.local / Criar registro
- Nome: web1 (ficará web1.ubsocial.local)
- Tipo: A - endereço IPv4
- Valor: IPv4 privado da instância web1
Adicionar outro registro

- Nome: web2 (ficará web2.ubsocial.local)
- Tipo: A - endereço IPv4
- Valor: IPv4 privado da instância web2
Criar registros

--- TESTAR RESOLUÇÃO DNS VIA INSTÂNCIAS EC2 (via SSH Linux) ---
- Baixar arquivo route53-key1.pem
- Ajustar permissão da chave: chmod 400 route53-key1.pem

- Acessar instância web1 via SSH: ssh -i route53-key1.pem ubuntu@IP-PUBLICO-WEB1
- Criar link para mudar DNS para AWS: sudo ln -sf /run/systemd/resolve/resolv.conf /etc/resolv.conf
- Editar configurações: sudo nano /etc/systemd/resolved.conf (inserir conteúdo abaixo no final do arquivo:)
DNS=169.254.169.253
Domains=sa-east-1.compute.internal
- Reiniciar serviços: sudo systemctl restart systemd-resolved

- Testar resolução DNS web2.ubsocial.local: dig web2.ubsocial.local +short
- Acessar web2 via DNS: curl http://web2.ubsocial.local

- Acessar instância web2 via SSH: ssh -i route53-key1.pem ubuntu@IP-PUBLICO-WEB2
- Testar resolução DNS web1.ubsocial.local: dig web1.ubsocial.local +short
- Acessar web1 via DNS: curl http://web1.ubsocial.local

--- Exclusões ---
1.EC2 / Instâncias / Selecionar web1 / Ações / Instância de estado / Parar, depois Terminar
2.EC2 / Instâncias / Selecionar web2 / Ações / Instância de estado / Parar, depois Terminar
3.EC2 / Grupos de segurança / Selecionar grupoSeg-route53-ssh-http / Ações / Excluir
4.EC2 / Pares de chaves / Selecionar route53-key1 / Ações / Excluir par de chaves
5.Route 53 / Zonas hospedadas / Selecionar ubsocial.local / Selecionar todos os registros (exceto NS e SOA) / Ações / Excluir registros
6.Route 53 / Zonas hospedadas / Selecionar ubsocial.local / Ações / Excluir zona hospedada

--- CRIAR REPOSITÓRIO GITHUB ---
GitHub / New repository
- Nome: amplify-vue-demo1
- Visibilidade: Público
Criar repositório
- Clonar repositório localmente: git clone URL-DO-REPOSITORIO && cd amplify-vue-demo1

--- CRIAR APP VUE 3 COM VITE + TYPESCRIPT ---
- Instalar projeto: npm create vite@latest amplify-vue-demo -- --template vue-ts
- Entrar na pasta do projeto: cd amplify-vue-demo
- Instalar dependências: npm install
- Instalar Amplify: npm install aws-amplify @aws-amplify/ui-vue
- Construir projeto: npm run build
- Instalar Amplify: npm create amplify@latest
- Em .gitignore, remover linha /dist
- Publicar código no GitHub: git add . && git commit -m "Projeto inicial" && git push && git status

--- CONECTAR AMPLIFY AO REPOSITÓRIO GITHUB ---
Amplify / Implantar um app
- Provedor: GitHub (conectar)
- Selecionar repositório: amplify-vue-demo1 / Ramificação: main (padrão)
- Nome da aplicação: amplify-vue-demo1
- Editar arquivo YML:
version: 1
applications:
  - frontend:
      phases:
        preBuild:
          commands:
            - cd amplify-vue-demo
            - npm install
        build:
          commands:
            - npm run build
      artifacts:
        baseDirectory: amplify-vue-demo/dist
        files:
          - "**/*"
      cache:
        paths:
          - amplify-vue-demo/node_modules/**/*

- Salvar e implantar
- Testar app no browser: clicar em URL gerada pelo Amplify

--- Exclusões ---
1.Amplify / Aplicativos / Selecionar amplify-vue-demo1 / Ações / Excluir aplicativo
2.(Opcional) GitHub / Repositório amplify-vue-demo1 / Settings / Delete this repository

--- CRIAR CLUSTER EKS FARGATE ---
EKS / Clusters / Criar cluster
- Opções de configuração: Configuração rápida (com o modo automático do EKS)
- Nome: eks-fargate-tutorial1

- Perfil do IAM do cluster: Criar perfil recomendado (redirecionará para IAM)
-- Tipo de entidade confiável: Serviço AWS
-- Serviço ou caso de uso: EKS - Auto Cluster
Avançar
--- Nome da função: AmazonEKSAutoClusterRole
Criar perfil / Voltar ao EKS / Atualizar / Selecionar esse perfil do cluster (AmazonEKSAutoClusterRole)

- Perfil do IAM do nó: Criar perfil recomendado (redirecionará para IAM)
-- Tipo de entidade confiável: Serviço AWS
-- Serviço ou caso de uso: EKS - Auto Node
Avançar
--- Nome da função: AmazonEKSAutoNodeRole
Criar perfil / Voltar ao EKS / Atualizar / Selecionar esse perfil do nó (AmazonEKSAutoNodeRole)
Criar

--- CONFIGURAR CLUSTER VIA CLOUDSHELL ---
CloudShell / Abrir terminal
- Acessar cluster: aws eks update-kubeconfig --name eks-fargate-tutorial1 --region sa-east-1
- Verificar clusters: aws eks list-clusters --region sa-east-1
- Verificar nós do cluster: kubectl get nodes
- Criar namespace: kubectl create namespace fargate-demo
- Verificar namespaces: kubectl get namespaces
- Associar Fargate ao namespace: kubectl annotate namespace fargate-demo eks.amazonaws.com/compute-type=fargate
- Verificar anotação: kubectl get namespace fargate-demo -o jsonpath='{.metadata.annotations}'
- Implantar app simples: kubectl apply -f https://k8s.io/examples/application/deployment.yaml -n fargate-demo
- Verificar pods: kubectl get pods -n fargate-demo (status Running)

Pod nginx sem load balancer, acessível via proxy kubectl:
- Expôr app via Service, sem gerar Load Balancer: kubectl expose deployment nginx-deployment --port=80 --type=ClusterIP -n fargate-demo
- Verificar Service: kubectl get services -n fargate-demo
- Acessar pod nginx via proxy kubectl: kubectl port-forward svc/nginx-deployment 8080:80 -n fargate-demo
- Testar acesso ao nginx via host docker: curl http://localhost:8080

--- Exclusões ---
1.CloudShell, excluir namespace: kubectl delete namespace fargate-demo
2.EKS / Clusters / Selecionar eks-fargate-tutorial1 / Ações / Excluir cluster
3.IAM / Funções / Selecionar AmazonEKSAutoClusterRole / Ações / Excluir função
4.IAM / Funções / Selecionar AmazonEKSAutoNodeRole / Ações / Excluir função

--- CRIAR TRAIL CLOUDTRAIL ---
CloudTrail / Trilhas / Criar trilha
- Nome: curso-cloudtrail1
Criar trilha (criará bucket S3)

--- ENVIAR LOGS PARA CLOUDWATCH LOGS ---
CloudTrail / Trilhas / Selecionar curso-cloudtrail1 / Editar
- CloudWatch Logs: Editar e habilitar
- Grupo de logs: Criar novo
-- Nome: curso-cloudtrail-logs1
- Função do IAM: Criar nova função
-- Nome: CloudTrailToCloudWatchLogsRole1
Salvar alterações

--- TESTAR GERAÇÃO DE LOGS ---
EC2 / Instâncias / Executar instâncias
- Nome: ubuntuTeste1
- AMI: Ubuntu Server (nível gratuito)
- Tipo: t3.micro (verificar se região é t2 ou t3 nível gratuito)
- Criar par de chaves:
-- Nome: keyTeste1
-- 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)
Executar instância

--- VERIFICAR LOGS NO CLOUDTRAIL E CLOUDWATCH LOGS ---
CloudTrail / Eventos / Verificar eventos recentes (deve listar evento RunInstances)
CloudWatch / Logs / Grupos de logs / Selecionar curso-cloudtrail-logs1 / Verificar streams de logs (deve listar evento RunInstances)

--- Exclusões ---
1.EC2 / Instâncias / Selecionar ubuntuTeste1 / Ações / Instância de estado / Parar, depois Terminar
2.EC2 / Pares de chaves / Selecionar keyTeste1 / Ações / Excluir par de chaves
3.EC2 / Grupos de segurança / Selecionar grupo criado automaticamente / Ações / Excluir
4.CloudTrail / Trilhas / Selecionar curso-cloudtrail1 / Ações / Excluir trilha (deletará bucket S3)
5.IAM / Funções / Selecionar CloudTrailToCloudWatchLogsRole1 / Ações / Excluir função
6.CloudWatch / Logs / Grupos de logs / Selecionar curso-cloudtrail-logs1 / Ações / Excluir grupo de logs
7.S3 / Buckets / Selecionar bucket criado pelo CloudTrail / Ações / Excluir bucket
8.EventBridge / Regras / Selecionar regra criada automaticamente pelo CloudTrail / Ações / Excluir regra

--- CRIAR FUNÇÃO LAMBDA ---
Lambda / Funções / Criar função
- Criar função do zero
- Nome: evento_logger_curso1
- 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 evento_logger_curso1 / Aba Código / Editar código:
import json
def lambda_handler(event, context):
    print("EVENTO RECEBIDO:")
    print(json.dumps(event, indent=2, ensure_ascii=False))
    return {"status": "ok"}

- No VSCode da AWS, clicar em Deploy

--- TESTAR FUNÇÃO LAMBDA ---
Lambda / Selecionar função evento_logger_curso1 / Aba Testar / Evento de teste
- Ação de evento de teste: Criar novo evento
- Nome do evento: teste_evento1
- JSON do evento (inserir conteúdo abaixo):
{"teste": "ok"}
Salvar e Testar
- Verificar resultado: status ok (gerará logs em grupo de logs no CloudWatch)

--- CRIAR BARRAMENTO DE EVENTOS CUSTOMIZADO ---
EventBridge / Barramentos de eventos / Criar barramento de eventos
- Nome: prj_cafe_bus1
Criar

--- CRIAR REGRA EVENTBRIDGE ---
EventBridge / Barramentos de eventos / Selecionar prj_cafe_bus1 / Aba Regras / Criar regra
- Nome: regra_pedido_curso1
- Tipo de regra: Regra com um padrão de eventos
Avançar
- Fonte do evento: Outros
- Método de criação: Padrão personalizado (editor JSON)
- Padrão de evento (inserir conteúdo abaixo):
{
  "source": ["app.cafes"],
  "detail-type": ["pedido_realizado1"]
}
- Avançar
- Tipos de destino: Serviço da AWS (Função do Lambda)
- Local do destino: Destino nessa conta (evento_logger_curso1)
Avançar / Criar regra

--- PUBLICAR EVENTO NO BARRAMENTO EVENTBRIDGE ---
EventBridge / Barramentos de eventos / Selecionar prj_cafe_bus1 / Enviar eventos
- Barramento de eventos: prj_cafe_bus1
- Fonte do evento: app.cafes
- Tipo de detalhe: pedido_realizado1
- Detalhes do evento (inserir conteúdo abaixo):
{
  "id_pedido": "12345",
  "valor": 49.90,
  "cliente": "João"
}
- Enviar (aparecerá mensagem de envio de sucesso)

--- VERIFICAR EVENTO RECEBIDO NA LAMBDA ---
Lambda / Selecionar função evento_logger_curso1 / Aba Monitoramento / Visualizar logs no CloudWatch
- Selecionar stream de logs mais recente / Verificar evento recebido (deve listar o evento enviado)

--- VERIFICAR LOGS NO CLOUDWATCH ---
CloudWatch / Logs / Grupos de logs / Selecionar /aws/lambda/evento_logger_curso1 / Selecionar stream de logs mais recente / Verificar evento recebido (deve listar o evento enviado)

--- Exclusões ---
1.Lambda / Selecionar função evento_logger_curso1 / Ações / Excluir função
2.EventBridge / Barramentos de eventos / Selecionar prj_cafe_bus1 / Aba Regras / Selecionar regra_pedido_curso1 / Ações / Excluir
3.EventBridge / Barramentos de eventos / Selecionar prj_cafe_bus1 / Ações / Excluir barramento de eventos
4.IAM / Funções / Selecionar função criada automaticamente para a Lambda (Amazon_EventBridge_Invoke_Lambda_...) / Ações / Excluir função
5.IAM / Políticas / Selecionar política criada automaticamente para a Lambda (Amazon_EventBridge_Invoke_Lambda_...) / Ações / Excluir política
6.CloudWatch / Logs / Grupos de logs / Selecionar /aws/lambda/evento_logger_curso1 / Ações / Excluir grupo de logs

--- CRIAR FUNÇÃO LAMBDA ---
Lambda / Funções / Criar função
- Criar função do zero
- Nome: hello-stepfn1
- 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 (anotar ARN da função)

--- ADICIONAR CÓDIGO NA FUNÇÃO LAMBDA ---
Lambda / Selecionar função hello-stepfn1 / Aba Código / Editar código:
def lambda_handler(event, context):
    if "Payload" in event:
        event = event["Payload"]
    nome = event.get("nome", "mundo")
    return {
        "greeting": f"Olá, {nome}!"
    }
- No VSCode da AWS, clicar em Deploy

--- TESTAR FUNÇÃO LAMBDA ---
Lambda / Selecionar função hello-stepfn1 / Aba Testar / Evento de teste
- Ação de evento de teste: Criar novo evento
- Nome do evento: teste_hello1
- JSON do evento (inserir conteúdo abaixo): {"nome": "UB Social"}
Salvar e Testar
- Verificar resultado: deve retornar "Olá, UB Social!"

--- CRIAR MÁQUINA DE ESTADO STEP FUNCTIONS ---
Step Functions / Máquinas de estado / Criar máquina de estado
- Criar do zero
- Nome: HelloStepFunction1
- Tipo de máquina de estado: Padrão
Avançar
- Definição da máquina de estado (inserir conteúdo abaixo) - aba Código:
{
  "Comment": "Exemplo Step Function em Lambda",
  "StartAt": "InvocarLambdaHello1",
  "States": {
    "InvocarLambdaHello1": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Parameters": {
        "FunctionName": "ARN-FUNCAO-LAMBDA-AQUI",
        "Payload.$": "$"
      },
      "End": true
    }
  }
}
- Aba Configuração / Permissões
- Perfil de execução: Criar novo perfil
Criar e Confirmar

--- EXECUTAR MÁQUINA DE ESTADO ---
Step Functions / Selecionar HelloStepFunction1 / Executar
- Nome da execução: exec_hello_1
- Entrada: { "nome": "Mateus" }
Iniciar execução
- Verificar status: Succeeded (ver aba Entrada e Saída - retornará "Olá, mundo!")

--- Exclusões ---
1.Step Functions / Selecionar HelloStepFunction1 / Ações / Excluir máquina de estado
2.Lambda / Selecionar função hello-stepfn1 / Ações / Excluir função
3.IAM / Funções / Selecionar função criada automaticamente para a Step Function (AWSServiceRoleForStepFunctions...) / Ações / Excluir função
4.IAM / Políticas / Selecionar política criada automaticamente para a Step Function (AWSServiceRoleForStepFunctions...) / Ações / Excluir política
5.CloudWatch / Logs / Grupos de logs / Selecionar /aws/vendedlogs/states/HelloStepFunction1 / Ações / Excluir grupo de logs

--- CRIAR NOTEBOOK SAGEMAKER ---
SageMaker AI / Notebooks / Criar instância de bloco de anotações
- Nome: notebook-ml-free-tier
- Tipo de instância: nível gratuito
- Permissões e criptografia: Criar nova função do IAM (com Qualquer bucket do S3)
Criar bloco de anotações

--- TREINAR MODELO ML ---
SageMaker AI / Notebooks / Selecionar notebook-ml-free-tier / Abrir JupyterLab
- Criar novo notebook conda_python3
- Inserir código abaixo em células do notebook:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
df = pd.read_csv(url)
print("Dataset carregado!\n")
print(df.head())
df = df.copy()

df['Age'] = df['Age'].fillna(df['Age'].mean())
df['Embarked'] = df['Embarked'].fillna(df['Embarked'].mode()[0])
df['Cabin'] = df['Cabin'].fillna('U')
df['Cabin'] = df['Cabin'].apply(lambda x: x[0])
print("\nValores únicos em 'Cabin' após tratamento:", df['Cabin'].unique())

df = pd.get_dummies(df, columns=['Sex', 'Embarked', 'Cabin'], drop_first=True)
X = df.drop(['Survived', 'Name', 'Ticket'], axis=1)
y = df['Survived']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
acc = accuracy_score(y_test, y_pred)

print(f"\nAcurácia do modelo: {acc:.2f}")
print("\nRelatório de classificação:\n")
print(classification_report(y_test, y_pred))

passageiro_exemplo = pd.DataFrame([X_test.iloc[0]], columns=X_test.columns)
previsao = model.predict(passageiro_exemplo)[0]
print(f"\nPrevisão (1 = Sobreviveu, 0 = Não sobreviveu): {previsao}")

- Executar células (Shift + Enter) para treinar modelo e testar predições

--- Exclusões ---
1.SageMaker AI / Notebooks / Selecionar notebook-ml-free-tier / Ações / Excluir instância de bloco de anotações
2.IAM / Funções / Selecionar função criada automaticamente para o SageMaker (AmazonSageMaker-ExecutionRole-...) / Ações / Excluir função
3.IAM / Políticas / Selecionar política criada automaticamente para o SageMaker (AmazonSageMaker-ExecutionRole-...) / Ações / Excluir política
4.CloudWatch / Logs / Grupos de logs / Selecionar /aws/sagemaker/Endpoints/notebook-ml-free-tier / Ações / Excluir grupo de logs

OBS: Necessário alterar região para Norte da Virgínia (us-east-1)

--- CRIAR FUNÇÃO LAMBDA ---
Lambda / Funções / Criar função
- Criar função do zero
- Nome: cafePreco1
- 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 cafePreco1 / Aba Código / Editar código:
import logging
import json
from http import HTTPStatus
from typing import Dict, Any

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
    try:
        logger.info("Evento recebido: %s", json.dumps(event))
        action_group = event.get("actionGroup") or event.get("action_group")
        function = event.get("function", "ConsultarPreco")
        parameters = event.get("parameters", [])
        message_version = str(event.get("messageVersion", "1.0"))

        if not action_group:
            raise KeyError("actionGroup ausente no evento")

        tipo_cafe = "capuccino"
        for p in parameters:
            if p.get("name") == "tipo_cafe":
                tipo_cafe = p.get("value", "capuccino")

        precos = {
            "capuccino": 9,
            "espresso": 7,
            "latte": 10
        }
        preco = precos.get(tipo_cafe.lower(), 9)

        response_body = {
            "TEXT": {
                "body": f"Valor do {tipo_cafe} é {preco}"
            }
        }

        final_response = {
            "response": {
                "actionGroup": action_group,
                "function": function,
                "functionResponse": {
                    "responseBody": response_body
                }
            },
            "messageVersion": message_version
        }

        logger.info("Response final: %s", json.dumps(final_response))
        return final_response

    except KeyError as e:
        logger.error("Campo ausente: %s", str(e))
        return {
            "statusCode": HTTPStatus.BAD_REQUEST,
            "body": json.dumps({"error": f"Campo ausente: {str(e)}"})
        }
    except Exception as e:
        logger.error("Erro interno: %s", str(e))
        return {
            "statusCode": HTTPStatus.INTERNAL_SERVER_ERROR,
            "body": json.dumps({"error": "Erro interno"})
        }
- No VSCode da AWS, clicar em Deploy

--- TESTAR FUNÇÃO LAMBDA ---
Lambda / Selecionar função cafePreco1 / Aba Testar / Evento de teste
- Ação de evento de teste: Criar novo evento
- Nome do evento: teste_cafe1
- JSON do evento (inserir conteúdo abaixo):
{
  "actionGroup": "ConsultarPrecoCafe__cafePreco1",
  "function": "ConsultarPreco",
  "parameters": [
    {
      "name": "tipo_cafe",
      "value": "capuccino"
    }
  ],
  "messageVersion": "1.0"
}
- Salvar e Testar (deve retornar preço do café)

--- CRIAR AGENTE DE IA BEDROCK ---
Bedrock / Agentes de IA / Criar agente de IA
- Nome: agente_cafe1
Criar
- Modelo de linguagem: Amazon Nova Pro
- Instruções para agentes: Você é um assistente especializado em cafés. Responda perguntas sobre tipos de café e seus preços. Se a pergunta envolver preços, consulte a função Lambda cafePreco1 para obter o preço correto
- Grupos de Ação / Adicionar:
-- Nome: ConsultarPrecoCafe
-- Tipo de ação: Definir com detalhes da função
-- Selecione uma função do Lambda existente (selecionar cafePreco1)
- Função de ação: cafePreco1
- Parâmetros:
-- Nome: tipo_cafe
-- Descrição: Tipo de café para consultar o preço
-- Tipo: String
-- Obrigatório: True
Criar, Salvar e sair

--- PERMITIR LAMBDA PARA BEDROCK ---
Lambda / Selecionar função cafePreco1 / Aba Configuração / Permissões / Adicionar permissão
- Tipo: Serviço AWS
- Serviço: Other
- ID da declaração: cafePrecoBedrockPermission1
- Entidade principal: bedrock.amazonaws.com
- ARN de origem: ARN do agente de IA criado
- Ação: lambda:InvokeFunction
Salvar

--- TESTAR AGENTE DE IA BEDROCK ---
Bedrock / Agentes de IA / Selecionar agente_cafe1 / Testar agente / Preparar
- Mensagem do usuário: Qual o preço de um cappuccino? (responderá com preço conforme função Lambda)

--- Exclusões ---
1.Bedrock / Agentes de IA / Selecionar agente_cafe1 / Ações / Excluir agente de IA
2.Lambda / Selecionar função cafePreco1 / Ações / Excluir função
3.IAM / Funções / Selecionar função criada automaticamente para o Bedrock (AmazonBedrock-InvokeLambda-...) / Ações / Excluir função
4.IAM / Políticas / Selecionar política criada automaticamente para o Bedrock (AmazonBedrock-InvokeLambda-...) / Ações / Excluir política
5.CloudWatch / Logs / Grupos de logs / Selecionar /aws/lambda/cafePreco1 / Ações / Excluir grupo de logs

--- CRIAR REDE BLOCKCHAIN ---
AMB / Redes / Aba Redes privadas / Criar rede privada
- Estrutura: Hyperledger Fabric
- Edição: starter
- Nome: rede-blockchain-curso1
Avançar
- Nome do membro: membro-curso1
- Nome de usuário do administrador: admin
- Senha do administrador: Ubsocial1
Avançar / Criar rede e membro

--- CRIAR PEER NODE ---
AMB / Redes / Selecionar rede-blockchain-curso1 / Aba Membros / Selecionar membro-curso1 / Aba Nós / Criar nó peer (dados padrão)

CONTINUA AQUI...
1.Criar rede privada e membro
2.No membro, criar nó peer
3.Conectar ao nó peer via CLI do Hyperledger Fabric
4.Criar canal, juntar canal, instalar chaincode, instanciar chaincode
5.Executar transações de gravação e consulta no ledger
6.Excluir recursos criados

- Origem do código-fonte da API Django: http://github.com/mateusschwede/workover_aws/tree/main/3_app_runner
- Região: us-east-1 (Norte da Virgínia)

--- CRIAR REPOSITÓRIO ECR ---
ECR / Repositórios / Criar repositório
- Nome: URL-DO-ECR/ubsocial/meu-app-runner
Criar (copiar URL do repositório)

--- CONSTRUIR E PUBLICAR IMAGE NO ECR ---
CloudShell:
- Logar no ECR: aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin URL-DO-REPOSITORIO
- Baixar código-fonte da API Django: curl -L https://codeload.github.com/mateusschwede/workover_aws/zip/refs/heads/main -o workover.zip && unzip workover.zip "workover_aws-main/3_app_runner/paris_cafe/*" && mv workover_aws-main/3_app_runner/paris_cafe . && rm -rf workover_aws-main workover.zip && cd paris_cafe
- Criar imagem Docker: docker build -t meu-app-runner .
- Marcar imagem para ECR: docker tag meu-app-runner:latest URL-DO-REPOSITORIO/ubsocial/meu-app-runner:latest
- Publicar imagem no ECR: docker push URL-DO-REPOSITORIO/ubsocial/meu-app-runner:latest

--- CRIAR SERVIÇO APPRUNNER ---
AWS App Runner / Criar um serviço do App Runner
- Tipo de repositório: Registro de contêiner
- Provedor: Amazon ECR
- URI da imagem de contêiner: Selecionar URL-DO-REPOSITORIO/ubsocial/meu-app-runner:latest
- Gatilho de implantação: Manual
- Função de acesso do ECR: Criar nova função de serviço
-- Nome: AppRunnerECRAccessRole1
Avançar
- Nome do serviço: meu-app-runner-service1
- Variáveis de ambiente: Adicionar variável de ambiente
-- Origem: Texto simples
-- Nome: DJANGO_SETTINGS_MODULE
-- Valor: paris_cafe.settings
Adicionar variável de ambiente
-- Origem: Texto simples
-- Nome: PYTHONUNBUFFERED
-- Valor: 1
Adicionar variável de ambiente
-- Origem: Texto simples
-- Nome: ALLOWED_HOSTS
-- Valor: *
Adicionar variável de ambiente
-- Origem: Texto simples
-- Nome: DEBUG
-- Valor: False
Adicionar variável de ambiente
-- Origem: Texto simples
-- Nome: SECRET_KEY
-- Valor: change-me-123456789
Avançar
- Porta: 8000
- Verificação de integridade:
-- Protocolo: HTTP
-- Caminho: /cafes/
-- Intervalo: 10 segundos
-- Tempo limite: 5 segundos
Criar e implantar (copiar URL do Domínio padrão)

--- ACESSAR APLICAÇÃO ---
- Acessar browser: URL-DO-DOMINIO-PADRAO/cafes/ (deve listar cafés em JSON)
- Acessar via cURL: curl https://URL-DO-DOMINIO-PADRAO/cafes/
- Adicionar café via cURL: curl -X POST https://URL-DO-DOMINIO-PADRAO/cafes/ -H "Content-Type: application/json" -d '{"nome":"UB Café","data_inauguracao":"2001-01-30","endereco":"rua frança 2","avaliacao":10}'

--- Exclusões ---
1.AWS App Runner / Selecionar meu-app-runner-service1 / Ações / Excluir serviço
2.ECR / Repositórios / Selecionar URL-DO-REPOSITORIO/ubsocial/meu-app-runner / Ações / Excluir repositório
3.IAM / Funções / Selecionar AppRunnerECRAccessRole1 / Ações / Excluir função
4.CloudWatch / Logs / Grupos de logs / Selecionar /aws/apprunner/meu-app-runner-service1 / Ações / Excluir grupo de logs

--- CRIAR CSV ---
- Criar arquivo vendas.csv com conteúdo:
venda_id,data,produto,quantidade,preco
1,2025-10-01,Caneca,2,25.50
2,2025-10-02,Bloco de notas,5,8.90
3,2025-10-03,Caneta,10,1.20

- AWS região: us-east-1 (Norte da Virgínia)

--- CRIAR BUCKET S3 ---
S3 / Buckets / Criar bucket
- Nome: ubsocial-glue-bucket1
- Propriedade de objeto: Marcar ACLs desabilitadas (recomendado)
- Configurações de bloqueio do acesso público deste bucket: desabilitar tudo
Criar bucket
- Fazer upload do arquivo vendas.csv para o bucket ubsocial-glue-bucket1/

--- CRIAR CRAWLER GLUE ---
AWS Glue / Crawlers / Create crawler
- Name: crawler-vendas-csv
Next
- Data sources: Add a data source
-- Data source type: S3
-- Location of S3 data: In this account
-- S3 path: selecionar bucket S3 ubsocial-glue-bucket1/
Add data source / Next
- Existing IAM role: Create new IAM role
-- Nome: AWSGlueServiceRole-vendas1
Add IAM role / Next
- Target database: Add database
-- Name: db_vendas
Create database / Selecionar db_vendas
- How should AWS Glue handle deleted objects in the data store?: Delete tables and partitions from the data catalog
- Create partition indexes automatically: Desmarcar
Next / Create crawler

--- EXECUTAR CRAWLER ---
AWS Glue / Crawlers / Selecionar crawler-vendas-csv / Run crawler
- Verificar status: Succeeded

--- VERIFICAR GLUE DATA CATALOG ---
AWS Glue / Catálogo de dados / Tables / Selecionar table ubsocial_glue_bucket1
- Verificar esquema da tabela (colunas, tipos de dados, localização em S3)

--- CONSULTAR DADOS VIA ATHENA ---
Athena / Consultas SQL
- Fonte de dados: AwsDataCatalog
- Banco de dados: db_vendas
- Localização e criptografia do resultado da consulta: Selecionar bucket S3 'ubsocial-glue-bucket1/athena-results/'
Salvar
- Consulta SQL: SELECT * FROM ubsocial_glue_bucket1;
- Visualizar resultados (deve listar dados do CSV), visualizar no bucket S3

--- Exclusões ---
1.Athena / Fontes de dados e catálogos / AwsDataCatalog / db_vendas / Selecionar e Ações / Excluir bancos de dados
2.(verificar) AWS Glue / Crawlers / Selecionar crawler-vendas-csv / Ações / Excluir crawler
3.(verificar) AWS Glue / Catálogo de dados / Tables / Selecionar table ubsocial_glue_bucket1 / Ações / Excluir tabela
4.(verificar) AWS Glue / Catálogo de dados / Databases / Selecionar db_vendas / Ações / Excluir banco de dados
5.S3 / Buckets / Selecionar ubsocial-glue-bucket1 / Ações / Esvaziar e Excluir bucket
6.IAM / Funções / Selecionar AWSGlueServiceRole-vendas1 / Ações / Excluir função
7.IAM / Políticas / Selecionar política criada automaticamente para o Glue (AWSGlueServiceRole-vendas1) / Ações / Excluir política
8.CloudWatch / Logs / Grupos de logs / Selecionar /aws-glue/crawlers/crawler-vendas-csv / Ações / Excluir grupo de logs

--- CRIAR CSV ---
- Criar arquivo vendas_amostra.csv com conteúdo:
venda_id,data,produto,quantidade,preco
1,2025-10-01,Caneca,2,25.50
2,2025-10-02,Bloco de notas,5,8.90
3,2025-10-03,Caneta,10,1.20

- AWS região: us-east-1 (Norte da Virgínia)

--- CRIAR BUCKET S3 ---
S3 / Buckets / Criar bucket
- Nome: meu-bucket-cursos-redshift1
- Propriedade de objeto: Marcar ACLs desabilitadas (recomendado)
- Configurações de bloqueio do acesso público deste bucket: desabilitar tudo
Criar bucket (anotar URI do bucket, exemplo: s3://meu-bucket-cursos-redshift1)
- Fazer upload do arquivo vendas_amostra.csv para o bucket meu-bucket-cursos-redshift1/

--- CRIAR DATA WAREHOUSE REDSHIFT SERVERLESS ---
Amazon Redshift / Redshift sem servidor / Criar grupo de trabalho
- Nome: curso-redshift-wg1
Próximo
- Namespace: Criar um namespace
-- Nome: cursodb1
- Funções do IAM associadas: Criar nova função do IAM
-- Select Access Type: Full Access
-- Especificar um bucket do S3 para a função do IAM que será acessada: Buckets do S3 específicos
--- Selecionar bucket: meu-bucket-cursos-redshift1
Criar função do IAM como padrão (anotar ARN da função)
Próximo / Criar

--- CONECTAR AO REDSHIFT SERVERLESS VIA QUERY EDITOR V2 ---
Amazon Redshift / Redshift sem servidor / Selecionar curso-redshift-wg1 / Consultar dados
- Conectar conta Redshift Query Editor V2 ao bucket S3 meu-bucket-cursos-redshift1 (autorizar acesso)
- Conectar ao Serverless workgroup: curso-redshift-wg1, banco de dados 'dev'
- Executar comandos SQL:
CREATE TABLE vendas_amostra (
  id INTEGER,
  data DATE,
  produto VARCHAR(100),
  quantidade INTEGER,
  preco NUMERIC(10,2)
);

- Executar comando SQL:
COPY vendas_amostra
FROM 's3://meu-bucket-cursos-redshift1'
IAM_ROLE 'arn:aws:iam::339712821640:role/service-role/AmazonRedshift-CommandsAccessRole-20251120T111513'
CSV
IGNOREHEADER 1;

- Executar comando SQL:
SELECT * FROM vendas_amostra;
- Pode-se conectar BD ao AWS QuickSight para criar dashboards BI

--- Exclusões ---
1.Amazon Redshift / Redshift sem servidor / Selecionar curso-redshift-wg1 / Ações / Excluir grupo de trabalho e namespace (não gerar snapshot)
2.S3 / Buckets / Selecionar meu-bucket-cursos-redshift1 / Ações / Esvaziar e Excluir bucket
3.IAM / Funções / Selecionar função criada automaticamente para o Redshift Serverless (AmazonRedshift-CommandsAccessRole-...) / Ações / Excluir função
4.IAM / Políticas / Selecionar política criada automaticamente para o Redshift Serverless (AmazonRedshift-CommandsAccessRole-...) / Ações / Excluir política
5.(verificar) CloudWatch / Logs / Grupos de logs / Selecionar /aws/redshift/serverless/curso-redshift-wg1 / Ações / Excluir grupo de logs

EM BREVE...

--- 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