Forem: Railander Marques

Automação de Backups para SFTP Externo

Railander Marques — Wed, 07 Jan 2026 20:26:59 +0000

Visão Geral

Este tutorial documenta uma solução completa e robusta para a transferência automática de backups do Amazon S3 (arquivos dump do PostgreSQL, entre 5 GB e 10 GB) para servidores SFTP externos utilizando uma infraestrutura serverless da AWS em conjunto com uma instância EC2 como ponte de processamento.

Arquitetura da Solução

O sistema implementa um fluxo de trabalho event-driven que:

Detecta automaticamente novos backups depositados no S3
Valida e filtra arquivos baseado em critérios específicos (prefixo, sufixo, nome)
Aciona uma função Lambda que dispara comandos remotos via AWS Systems Manager
Processa o download seguro do S3 para uma instância EC2 (EC2 evita o timeout de execução da Lambda)
Transfere os arquivos para o servidor SFTP com verificação de integridade (EC2 para evitar o timeout)
Garante confiabilidade através de retry automático, validação MD5 e logs detalhados

Características Principais

✅ Upload resiliente: Retry automático com backoff configurável
✅ Integridade garantida: Verificação MD5 e validação de tamanho
✅ Upload multipart: Transferência otimizada para arquivos grandes (chunks de 64KB)
✅ Temporary naming: Upload com extensão .part antes da finalização
✅ Logs completos: Rastreamento detalhado em /var/log/sftp_uploader/
✅ Configuração flexível: Variáveis de ambiente via .env
✅ Autenticação múltipla: Suporte para senha ou chave SSH (RSA/OpenSSH)

Fluxo de Operação

S3 Event (PUT) → Lambda (filtro) → SSM Run Command → EC2 (download S3) 
→ Validação Local → Upload SFTP (com retry) → Verificação MD5 → Conclusão

1. Criação da Lambda

No console AWS Lambda: Create function → Author from scratch
- Name: BackupTransferLambda
- Runtime: Python 3.13
- Role: Crie uma role com permissões SSM SendCommand e S3 read.
Configure environment variables se necessário.
Faça upload do código da Lambda (arquivo lambda_function.py fornecido).

2. Configuração da Trigger do S3

No bucket S3 company-backups-bucket → Properties → Event notifications → Create Event Notification
Configurações:
- Name: TriggerBackupUpload
- Event type: PUT
- Prefix: db/daily/
- Suffix: .dump
- Destination: Lambda function → BackupTransferLambda
Salve.

3. Permissões Necessárias

EC2 Role (Alterar o nome do bucket)

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject","s3:ListBucket"],
      "Resource": [
        "arn:aws:s3:::company-backups-bucket",
        "arn:aws:s3:::company-backups-bucket/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": ["ssm:SendCommand","ssm:GetCommandInvocation"],
      "Resource": "*"
    }
  ]
}

Lambda Role (Alterar id da conta AWS, região e instancia)

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ssm:SendCommand",
        "ssm:GetCommandInvocation"
      ],
      "Resource": [
        "arn:aws:ec2:us-east-1:123456789012:instance/i-XXXXXXXXXX",
        "arn:aws:ssm:us-east-1::document/AWS-RunShellScript"
      ]
    }
  ]
}

4. Preparação da EC2 Ubuntu 24.04 e Testes

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-pip python3-venv unzip curl
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
aws --version

cd /opt
sudo mkdir sftp_uploader_app
sudo chown ubuntu:ubuntu sftp_uploader_app
cd sftp_uploader_app
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install paramiko python-dotenv boto3
python3 -c "import paramiko; import boto3; import dotenv; print('Módulos OK')"

5. Estrutura de Pastas

/opt/sftp_uploader_app/
├── sftp_uploader.py
├── sftp_uploader_main.py
├── logrotate_sftp_uploader
├── sftp-uploader.service
├── sftp-uploader.timer
├── id_rsa
├── .env
└── venv/

/var/tmp/sftp_uploader → temporário
/var/log/sftp_uploader → logs

sudo mkdir -p /var/tmp/sftp_uploader
sudo mkdir -p /var/log/sftp_uploader
sudo chown -R ubuntu:ubuntu /var/tmp/sftp_uploader /var/log/sftp_uploader

6. Configuração do Arquivo .env

Crie o arquivo /opt/sftp_uploader_app/.env com o seguinte conteúdo:

# Configuração SFTP
SFTP_HOST=sftp.external-server.com
SFTP_PORT=22
SFTP_USER=transfer_user
SFTP_PASSWORD=your_secure_password_here
SFTP_KEY_PATH=/opt/sftp_uploader_app/id_rsa
SFTP_KEY_PASSPHRASE=your_key_passphrase

# Pasta local (temporária para download S3)
LOCAL_DIR=/var/tmp/sftp_uploader

# Pasta remota SFTP
REMOTE_DIR=/

# Apagar arquivos locais após envio
DELETE_AFTER_UPLOAD=True

# Número de tentativas em caso de falha
RETRY_ATTEMPTS=3
RETRY_DELAY_SECONDS=10

# Logs
LOG_DIR=/var/log/sftp_uploader

# MD5 para verificação de integridade
VERIFY_MD5=True

# Bucket S3
S3_BUCKET_NAME=company-backups-bucket

7. Como descompactar o zip atualizado

cd /opt
sudo unzip sftp_uploader_app.zip -d /opt/sftp_uploader_app
sudo chown -R ubuntu:ubuntu /opt/sftp_uploader_app

Conteúdo do ZIP:

env (renomear para .env)
id_rsa (chave SSH privada)
lambda_handler.py
logrotate_sftp_uploader
sftp_uploader_main.py
sftp_uploader.py
sftp-uploader.service
sftp-uploader.timer

8. Teste manual e logs

source /opt/sftp_uploader_app/venv/bin/activate
python3 /opt/sftp_uploader_app/sftp_uploader_main.py

Logs em /var/log/sftp_uploader/sftp_uploader.log
Run Command history na Lambda console

Exemplo de log:

2026-01-07 09:00:01 [INFO] Conectado ao SFTP sftp.external-server.com:22
2026-01-07 09:00:02 [INFO] Processando arquivo: /var/tmp/sftp_uploader/backup.dump -> /
2026-01-07 09:00:05 [INFO] Upload concluído (temp): backup.dump -> /backup.dump.part
2026-01-07 09:00:06 [INFO] Arquivo movido para destino: /backup.dump
2026-01-07 09:00:06 [INFO] Processamento concluído

Log Completo:

2026-01-07 10:54:12,561 [INFO] Baixando s3://company-backups-bucket/db/daily/database_client_backup.dump para /var/tmp/sftp_uploader/database_client_backup.dump
2026-01-07 10:54:12,581 [INFO] Found credentials from IAM Role: ssm
2026-01-07 10:54:36,407 [INFO] Connected (version 2.0, client AWS_SFTP_1.2)
2026-01-07 10:54:36,519 [INFO] Auth banner: b'Welcome to External SFTP Server!\n'
2026-01-07 10:54:36,520 [INFO] Authentication (publickey) successful!
2026-01-07 10:54:36,690 [INFO] [chan 0] Opened sftp connection (server version 3)
2026-01-07 10:54:36,690 [INFO] Conectado ao SFTP sftp.external-server.com:22 (attempt 1)
2026-01-07 10:54:36,691 [INFO] Processando arquivo: /var/tmp/sftp_uploader/database_client_backup.dump -> /
2026-01-07 10:54:42,737 [INFO] database_client_backup.dump - 50.0 MB enviados (1.69%)
2026-01-07 10:54:47,352 [INFO] database_client_backup.dump - 100.0 MB enviados (3.39%)
2026-01-07 10:54:52,081 [INFO] database_client_backup.dump - 150.0 MB enviados (5.08%)
[...]
2026-01-07 10:59:36,365 [INFO] Upload concluído (temp): /var/tmp/sftp_uploader/database_client_backup.dump -> /database_client_backup.dump.part
2026-01-07 11:26:07,525 [INFO] Arquivo movido para destino: /database_client_backup.dump
2026-01-07 11:26:07,676 [INFO] Arquivo local removido após upload: /var/tmp/sftp_uploader/database_client_backup.dump
2026-01-07 11:26:07,676 [INFO] Processamento concluído
2026-01-07 11:26:07,676 [INFO] [chan 0] sftp session closed.

9. Troubleshooting

Chave PPK não funciona: Paramiko precisa de chave OpenSSH (.pem ou sem conversão). Converta: puttygen chave.ppk -O private-openssh -o id_rsa
Permissões: chmod 600 id_rsa
Upload falha: Verifique prefix/suffix S3 e paths locais/remotos
SSM não executa: Confirme role da Lambda e permissões da EC2
Timeout: Ajuste TimeoutSeconds na Lambda ou banner_timeout no Paramiko
MD5 não bate: Verifique se o arquivo foi completamente transferido ou se houve corrupção

Detalhes Técnicos da Implementação

Processo de Upload Seguro

Download do S3: Arquivo baixado para /var/tmp/sftp_uploader/
Filtro: Apenas arquivos contendo palavra-chave no nome são processados (configurável)
Upload temporário: Arquivo enviado com extensão .part
Validações:
- Comparação de tamanho (bytes locais vs remotos)
- Checksum MD5 (local vs remoto)
Rename atômico: .part → nome final
Cleanup opcional: Remoção do arquivo local se DELETE_AFTER_UPLOAD=True

Mecanismo de Retry

Tentativas configuráveis via RETRY_ATTEMPTS (padrão: 3)
Delay entre tentativas: RETRY_DELAY_SECONDS (padrão: 10s)
Retry aplicado em:
- Conexão SFTP
- Upload de arquivo
- Validação MD5

Logs e Monitoramento

Logs da Lambda: CloudWatch Logs
Logs SSM: Run Command history no console AWS Systems Manager
Logs EC2: /var/log/sftp_uploader/sftp_uploader.log
Formato de log: timestamp [LEVEL] mensagem

Opção 2: Lambda com Conexão Direta SSH à EC2

Esta opção remove o SSM Run Command e estabelece uma conexão SSH direta da Lambda para a EC2 através de uma interface de rede na mesma VPC.

1. Configurar SSH no EC2

Criar arquivo de configuração para liberar login por senha apenas para o usuário sftp_user:

sudo tee /etc/ssh/sshd_config.d/10-password-auth.conf > /dev/null <<'EOF'
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM yes

Match User sftp_user
    PasswordAuthentication yes
    AuthenticationMethods password
EOF

Reiniciar o serviço SSH:

sudo systemctl restart ssh

Validar se as diretivas foram aplicadas:

sudo sshd -T | grep -E 'password|challenge|usepam'

2. Criar usuário `sftp_user`

#!/bin/bash
#############################################
# Script de Criação de Usuário Administrativo
#############################################

set -e

if [ "$EUID" -ne 0 ]; then
    echo "❌ Este script precisa ser executado como root (sudo)"
    exit 1
fi

echo "📝 Criando novo usuário administrativo..."
read -p "Nome do usuário: " username

if [ -z "$username" ]; then
    echo "❌ Nome de usuário não pode ser vazio!"
    exit 1
fi

if id "$username" &>/dev/null; then
    echo "⚠️ Usuário já existe."
    USER_EXISTS=true
else
    USER_EXISTS=false
fi

echo ""
echo "🔐 Configuração de senha"
while true; do
    read -sp "Senha: " password
    echo ""
    read -sp "Confirme: " confirm
    echo ""
    [ "$password" = "$confirm" ] && break
    echo "Senhas não coincidem!"
done

if [ "$USER_EXISTS" = false ]; then
    useradd -m -s /bin/bash "$username"
fi

echo "$username:$password" | chpasswd

for grp in sudo wheel adm systemd-journal; do
    if getent group "$grp" >/dev/null; then
        usermod -aG "$grp" "$username"
    fi
done

SUDOERS_FILE="/etc/sudoers.d/$username"
cat > "$SUDOERS_FILE" <<INNER_EOF
$username ALL=(ALL:ALL) NOPASSWD: ALL
INNER_EOF

chmod 0440 "$SUDOERS_FILE"
visudo -c -f "$SUDOERS_FILE" >/dev/null && echo "✓ Sudo configurado"

echo "✅ Usuário $username criado com sucesso!"

Execute o script /tmp/create_user.sh para gerar o usuário.

3. Configuração de rede e segurança

Adicione política à Lambda para conseguir gerar uma interface de rede:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateNetworkInterface",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DeleteNetworkInterface"
            ],
            "Resource": "*"
        }
    ]
}

Criar interface de rede (ENI) da Lambda na mesma VPC da EC2.
No Security Group da EC2, liberar porta 22 somente para o SG da Lambda.

4. Preparar Lambda

Alterar no handler os dados de conexão:

EC2_HOST = "<IP_PRIVADO_DA_EC2>"
EC2_USER = "sftp_user"
EC2_PASSWORD = "<SENHA_DO_USUARIO>"

Deploy da Lambda usando o arquivo ZIP com as bibliotecas necessárias (paramiko, etc)

Resumo

SSH do EC2 permite login por senha apenas para sftp_user.
Lambda conecta usando usuário e senha definidos no handler.
Porta 22 liberada apenas para a Lambda na VPC.

Arquivos de Código

lambda_function.py (Opção 1: SSM)

import boto3
import logging

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

# Configurações
EC2_INSTANCE_ID = "i-XXXXXXXXXX"
S3_BUCKET = "company-backups-bucket"
S3_PREFIX = "db/daily/"

# Cliente SSM
ssm = boto3.client('ssm')

def lambda_handler(event, context):
    try:
        # Obter arquivo do evento S3
        record = event['Records'][0]
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']

        logger.info(f"Evento recebido do S3: bucket={bucket}, key={key}")

        # Verifica se é do bucket e prefixo correto
        if bucket != S3_BUCKET or not key.startswith(S3_PREFIX):
            logger.info(f"Ignorando arquivo fora do prefixo/bucket: {key}")
            return {"status": "ignored", "key": key}

        # Verifica se contém palavra-chave
        if 'client_backup' not in key:
            logger.info(f"Ignorando arquivo (não contém 'client_backup'): {key}")
            return {"status": "ignored", "key": key}

        # Verifica EC2 definido
        if not EC2_INSTANCE_ID:
            logger.error("EC2_INSTANCE_ID não definido!")
            return {"status": "error", "message": "EC2_INSTANCE_ID não definido"}

        # Comando a ser executado na EC2
        command = f"/opt/sftp_uploader_app/venv/bin/python3 /opt/sftp_uploader_app/sftp_uploader.py --s3-file s3://{bucket}/{key}"
        logger.info(f"Enviando comando SSM para EC2 {EC2_INSTANCE_ID}: {command}")

        # Envia comando SSM
        response = ssm.send_command(
            Targets=[{'Key': 'InstanceIds', 'Values': [EC2_INSTANCE_ID]}],
            DocumentName="AWS-RunShellScript",
            Parameters={'commands': [command]},
            TimeoutSeconds=900  # 15 minutos
        )

        command_id = response['Command']['CommandId']
        logger.info(f"Comando enviado com sucesso! CommandId: {command_id}")
        return {"status": "command_sent", "command_id": command_id, "key": key}

    except Exception as e:
        logger.exception(f"Erro ao processar evento S3: {e}")
        return {"status": "error", "message": str(e)}

lambda_function.py (Opção 2: SSH Direto)

import json
import paramiko
import time

# ============================
# CONFIGURAÇÕES FIXAS
# ============================
EC2_HOST = "10.0.1.100"  # IP privado da EC2
EC2_USER = "sftp_user"
EC2_PASSWORD = "your_secure_password"

# Caminhos no servidor EC2
PYTHON_PATH = "/opt/sftp_uploader_app/venv/bin/python3"
SCRIPT_PATH = "/opt/sftp_uploader_app/sftp_uploader.py"
LOG_PATH = "/var/log/sftp_trigger.log"
SFTP_LOG_DIR = "/var/log/sftp_uploader"
SFTP_LOG_FILE = "/var/log/sftp_uploader/sftp_uploader.log"
TEMP_DIR = "/var/tmp/sftp_uploader"

def should_process_file(filename):
    """
    Verifica se o arquivo deve ser processado.
    """
    filename_lower = filename.lower()

    if not filename_lower.endswith('.dump'):
        return False, "Arquivo não termina com .dump"

    if 'client_backup' not in filename_lower:
        return False, "Arquivo não contém 'client_backup' no nome"

    return True, "OK"

def lambda_handler(event, context):
    ssh = None
    try:
        # Extrai informações do evento S3
        record = event['Records'][0]
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        s3_file = f"s3://{bucket}/{key}"

        filename = key.split('/')[-1]

        print(f"[INFO] Arquivo detectado: {s3_file}")
        print(f"[INFO] Nome do arquivo: {filename}")

        # Validação
        should_process, reason = should_process_file(filename)

        if not should_process:
            message = f"Arquivo ignorado: {reason}"
            print(f"[INFO] {message}")
            return {
                "statusCode": 200,
                "body": json.dumps({
                    "message": message,
                    "s3_file": s3_file,
                    "filename": filename,
                    "processed": False
                })
            }

        print(f"[INFO] Conectando na EC2 {EC2_HOST}...")

        # Conexão SSH
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect(
            hostname=EC2_HOST,
            username=EC2_USER,
            password=EC2_PASSWORD,
            timeout=20,
        )

        print("[INFO] Conexão SSH estabelecida com sucesso")

        # Preparar diretórios
        setup_commands = f"""
mkdir -p {SFTP_LOG_DIR}
chmod 777 {SFTP_LOG_DIR}
touch {SFTP_LOG_FILE}
chmod 666 {SFTP_LOG_FILE}
mkdir -p {TEMP_DIR}
chmod 777 {TEMP_DIR}
"""

        print("[INFO] Configurando diretórios...")
        stdin, stdout, stderr = ssh.exec_command(setup_commands)
        stdout.channel.recv_exit_status()

        # Monta comando
        command = (
            f"nohup {PYTHON_PATH} {SCRIPT_PATH} "
            f"--s3-file '{s3_file}' >> {LOG_PATH} 2>&1 & "
            f"echo $!"
        )

        print(f"[INFO] Executando comando: {command}")

        # Executa comando e captura PID
        stdin, stdout, stderr = ssh.exec_command(command)
        pid = stdout.read().decode().strip()

        if pid and pid.isdigit():
            print(f"[INFO] Processo iniciado com PID: {pid}")
            status_message = f"Processo iniciado com sucesso (PID: {pid})"
        else:
            print(f"[ERROR] Falha ao obter PID")
            status_message = "Falha ao iniciar processo"

        ssh.close()

        return {
            "statusCode": 200,
            "body": json.dumps({
                "message": status_message,
                "s3_file": s3_file,
                "filename": filename,
                "pid": pid if pid and pid.isdigit() else None,
                "processed": True
            })
        }

    except Exception as e:
        error_msg = f"Erro: {str(e)}"
        print(f"[ERROR] {error_msg}")
        import traceback
        print(f"[ERROR] Traceback:\n{traceback.format_exc()}")
        return {
            "statusCode": 500,
            "body": json.dumps({"error": error_msg})
        }

    finally:
        if ssh:
            try:
                ssh.close()
            except:
                pass

sftp_uploader.py

#!/usr/bin/env python3
"""
sftp_uploader.py - Upload de arquivos grandes para SFTP com download do S3
"""
import os
import sys
import time
import hashlib
import logging
from pathlib import Path
from dotenv import load_dotenv
import paramiko
import argparse
import boto3

# Carrega .env
ENV_PATH = Path(__file__).parent / '.env'
if not ENV_PATH.exists():
    ENV_PATH = Path('/opt/sftp_uploader_app/.env')
load_dotenv(dotenv_path=str(ENV_PATH))

# Configurações
SFTP_HOST = os.getenv('SFTP_HOST')
SFTP_PORT = int(os.getenv('SFTP_PORT', '22'))
SFTP_USER = os.getenv('SFTP_USER')
SFTP_PASSWORD = os.getenv('SFTP_PASSWORD') or None
SFTP_KEY_PATH = os.getenv('SFTP_KEY_PATH') or None
SFTP_KEY_PASSPHRASE = os.getenv('SFTP_KEY_PASSPHRASE') or None
LOCAL_DIR = Path(os.getenv('LOCAL_DIR', '/var/tmp/sftp_uploader'))
REMOTE_DIR = os.getenv('REMOTE_DIR', '/')
DELETE_AFTER_UPLOAD = os.getenv('DELETE_AFTER_UPLOAD', 'False').lower() in ('1','true','yes')
RETRY_ATTEMPTS = int(os.getenv('RETRY_ATTEMPTS', '3'))
RETRY_DELAY_SECONDS = int(os.getenv('RETRY_DELAY_SECONDS', '10'))
LOG_DIR = Path(os.getenv('LOG_DIR', '/var/log/sftp_uploader'))
TMP_DIR = Path(os.getenv('TMP_DIR', '/var/tmp/sftp_uploader'))
VERIFY_MD5 = os.getenv('VERIFY_MD5', 'True').lower() in ('1','true','yes')

LOG_DIR.mkdir(parents=True, exist_ok=True)
TMP_DIR.mkdir(parents=True, exist_ok=True)
LOCAL_DIR.mkdir(parents=True, exist_ok=True)

# Logging
LOG_FILE = LOG_DIR / 'sftp_uploader.log'
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler(LOG_FILE),
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger('sftp_uploader')

# Helpers
def md5_of_file(path: Path):
    h = hashlib.md5()
    with open(path, 'rb') as f:
        for chunk in iter(lambda: f.read(65536), b''):
            h.update(chunk)
    return h.hexdigest()

def md5_of_remote(sftp, remote_path):
    h = hashlib.md5()
    try:
        with sftp.open(remote_path, 'rb') as rf:
            for chunk in iter(lambda: rf.read(65536), b''):
                h.update(chunk)
        return h.hexdigest()
    except Exception as e:
        logger.warning(f'Falha ao calcular MD5 remoto {remote_path}: {e}')
        return None

def connect_sftp():
    last_exc = None
    for attempt in range(1, RETRY_ATTEMPTS + 1):
        try:
            transport = paramiko.Transport((SFTP_HOST, SFTP_PORT))
            transport.banner_timeout = 600
            transport.connect_timeout = 600
            if SFTP_KEY_PATH and Path(SFTP_KEY_PATH).exists():
                key = paramiko.RSAKey.from_private_key_file(SFTP_KEY_PATH, password=SFTP_KEY_PASSPHRASE)
                transport.connect(username=SFTP_USER, pkey=key)
            else:
                transport.connect(username=SFTP_USER, password=SFTP_PASSWORD)
            sftp = paramiko.SFTPClient.from_transport(transport)
            sftp.get_channel().settimeout(600)
            logger.info(f'Conectado ao SFTP {SFTP_HOST}:{SFTP_PORT} (attempt {attempt})')
            return transport, sftp
        except Exception as e:
            last_exc = e
            logger.warning(f'Falha conexão SFTP (attempt {attempt}): {e}')
            time.sleep(RETRY_DELAY_SECONDS)
    raise last_exc

def ensure_remote_dir(sftp, remote_path):
    parts = Path(remote_path).parts
    cur = ''
    for p in parts:
        if p == '/':
            continue
        cur = cur + '/' + p
        try:
            sftp.stat(cur)
        except IOError:
            try:
                sftp.mkdir(cur)
                logger.info(f'Criado dir remoto: {cur}')
            except Exception as e:
                logger.warning(f'Não foi possível criar {cur}: {e}')

def upload_file(sftp, local_path: Path, remote_dir: str):
    remote_name = local_path.name
    remote_tmp = remote_dir.rstrip('/') + '/' + remote_name + '.part'
    remote_final = remote_dir.rstrip('/') + '/' + remote_name
    last_exc = None
    for attempt in range(1, RETRY_ATTEMPTS + 1):
        try:
            filesize = local_path.stat().st_size
            with open(local_path, 'rb') as f:
                with sftp.open(remote_tmp, 'wb') as rf:
                    transferred = 0
                    while True:
                        data = f.read(65536)
                        if not data:
                            break
                        rf.write(data)
                        transferred += len(data)
                        if transferred % (50*1024*1024) < 65536:
                            logger.info(f"{local_path.name} - {transferred/1024/1024:.1f} MB enviados ({transferred/filesize*100:.2f}%)")
            logger.info(f'Upload concluído (temp): {local_path} -> {remote_tmp}')
            r_size = sftp.stat(remote_tmp).st_size
            if r_size != filesize:
                raise IOError(f'Tamanho diferente após upload (local={filesize}, remoto={r_size})')
            if VERIFY_MD5:
                local_md5 = md5_of_file(local_path)
                remote_md5 = md5_of_remote(sftp, remote_tmp)
                if remote_md5 != local_md5:
                    raise IOError(f'MD5 inválido (local={local_md5}, remoto={remote_md5})')
            try:
                sftp.rename(remote_tmp, remote_final)
            except Exception:
                try: sftp.remove(remote_final)
                except Exception: pass
                sftp.rename(remote_tmp, remote_final)
            logger.info(f'Arquivo movido para destino: {remote_final}')
            return True
        except Exception as e:
            last_exc = e
            logger.warning(f'Falha upload (attempt {attempt}): {e}')
            try: sftp.remove(remote_tmp)
            except Exception: pass
            time.sleep(RETRY_DELAY_SECONDS)
    logger.error(f'Upload definitivamente falhou: {local_path} - {last_exc}')
    return False

# Argumentos CLI
parser = argparse.ArgumentParser()
parser.add_argument("--s3-file", help="Arquivo S3 no formato s3://bucket/key")
args = parser.parse_args()

# Se fornecido --s3-file, baixa o arquivo
if args.s3_file:
    if not args.s3_file.startswith("s3://"):
        logger.error(f"Formato S3 inválido: {args.s3_file}")
        sys.exit(1)
    bucket, key = args.s3_file[5:].split("/", 1)
    local_path = LOCAL_DIR / Path(key).name
    logger.info(f"Baixando {args.s3_file} para {local_path}")
    s3 = boto3.client("s3")
    s3.download_file(bucket, key, str(local_path))

# Processamento
def process_once():
    transport = None
    sftp = None
    try:
        transport, sftp = connect_sftp()
        ensure_remote_dir(sftp, REMOTE_DIR)
        for root, dirs, files in os.walk(LOCAL_DIR):
            for fname in files:
                if "client_backup" not in fname:
                    logger.info(f"Arquivo ignorado (não contém 'client_backup'): {fname}")
                    continue
                local_path = Path(root) / fname
                rel = local_path.relative_to(LOCAL_DIR)
                remote_subdir = REMOTE_DIR.rstrip('/') + '/' + str(rel.parent).replace('\\','/') if str(rel.parent) != '.' else REMOTE_DIR
                ensure_remote_dir(sftp, remote_subdir)
                logger.info(f'Processando arquivo: {local_path} -> {remote_subdir}')
                ok = upload_file(sftp, local_path, remote_subdir)
                if ok and DELETE_AFTER_UPLOAD:
                    try:
                        local_path.unlink()
                        logger.info(f'Arquivo local removido após upload: {local_path}')
                    except Exception as e:
                        logger.warning(f'Falha ao remover local {local_path}: {e}')
        logger.info('Processamento concluído')
    except Exception as e:
        logger.error(f'Erro no processo: {e}')
    finally:
        if sftp: 
            try: sftp.close()
            except Exception: pass
        if transport:
            try: transport.close()
            except Exception: pass

if __name__ == '__main__':
    process_once()

logrotate_sftp_uploader

/var/log/sftp_uploader/sftp_uploader.log {
    daily
    rotate 14
    compress
    missingok
    notifempty
    copytruncate
}

sftp-uploader.service

[Unit]
Description=SFTP Uploader Service
After=network.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/bin/python3 /opt/sftp_uploader_app/sftp_uploader.py
User=root
Group=root
EnvironmentFile=/opt/sftp_uploader_app/.env
TimeoutStartSec=1800

sftp-uploader.timer

[Unit]
Description=Run SFTP uploader periodically

[Timer]
OnBootSec=2min
OnUnitActiveSec=60min
Unit=sftp-uploader.service

[Install]
WantedBy=timers.target

Conclusão

Este sistema fornece uma solução robusta e escalável para transferência automatizada de backups do S3 para servidores SFTP externos, com alta confiabilidade através de validação MD5, retry automático e logs detalhados.

As duas opções apresentadas (SSM Run Command e SSH direto) oferecem flexibilidade dependendo das necessidades de segurança e arquitetura da sua infraestrutura.

Dashboard Interativo de CVE's - AWS Inspector + Lambda + S3

Railander Marques — Thu, 06 Mar 2025 20:57:13 +0000

Este tutorial descreve como configurar uma solução na AWS para processar relatórios do AWS Inspector, armazená-los em um bucket S3, processá-los com uma função Lambda e gerar um dashboard HTML interativo.

Dashboard ScreenShot:

1. Resumo da Solução

A solução automatiza o processamento de relatórios de vulnerabilidades gerados pelo AWS Inspector. Aqui está uma visão geral:

AWS Inspector: Gera relatórios de vulnerabilidades em formato JSON e os armazena em um bucket S3 privado.
S3: Armazena os relatórios JSON no caminho /report e os relatórios HTML processados no caminho /final.
AWS KMS: Criptografa os dados no bucket S3 para segurança.
AWS Lambda: Processa os relatórios JSON usando Python 3.13, com a biblioteca AWS Lambda Powertools, e gera um dashboard HTML interativo.
Dashboard HTML: Exibe estatísticas e detalhes das vulnerabilidades encontradas em instâncias EC2 e imagens ECR.

A Lambda é acionada por eventos S3, processa apenas arquivos .json no caminho /report, e salva o resultado no caminho /final.

2. Diagrama da Solução

Fluxo:
1. AWS Inspector → Gera relatório JSON → S3 (Bucket: seu-bucket, Path: /report).
2. S3 → Evento notifica a Lambda.
3. Lambda → Lê o JSON, processa com KMS para descriptografia, gera HTML.
4. Lambda → Salva o HTML no S3 (Path: /final).
Componentes:
- AWS Inspector, S3, KMS, Lambda.
Conexões:
- Inspector usa KMS para criptografia.
- Lambda acessa S3 e KMS.

3. Configuração do AWS KMS para o AWS Inspector

O AWS Key Management Service (KMS) é usado para criptografar os relatórios do Inspector no S3. Abaixo está o passo a passo para criar e configurar uma chave KMS (Customer Managed Key - CMK).

Passo a Passo

Acesse o Console KMS:
- No console AWS, vá para Key Management Service (KMS).
- Clique em Create key (Criar chave) no canto superior direito.
Configure as Opções da Chave:
- Key type: Mantenha como Symmetric.
- Key usage: Escolha Encrypt and decrypt (Criptografar e descriptografar).
- Key material origin: Mantenha como KMS.
- Clique em Next.
Adicione Descrição e Tags:
- Alias: Insira um nome, por exemplo, inspector-report-key.
- Description: "Chave para criptografia de relatórios do AWS Inspector".
- Tags: Adicione tags opcionais (ex.: Project=Security).
- Clique em Next.
Definir Administradores da Chave:
- Na seção Key administrators, adicione os usuários/roles que gerenciarão a chave.
- Exemplo: Selecione uma role IAM como [ROLE_ADMINISTRATOR_MASKED].
- Esses administradores terão permissões para criar, excluir e gerenciar a chave.
Definir Usuários da Chave:
- Na seção Key usage permissions, adicione quem pode usar a chave para criptografia/descriptografia.
- Exemplo: Adicione [ROLE_ADMINISTRATOR_MASKED] para uso geral.
Revisar e Criar:
- Revise as configurações e clique em Create key.
- Anote o ARN da chave gerada (ex.: arn:aws:kms:us-east-1:[ACCOUNT_ID_MASKED]:key/[KEY_ID]).

Política da Chave (Key Policy)

A política abaixo define quem tem acesso à chave e como ela pode ser usada. Substitua [ACCOUNT_ID_MASKED] pelo seu ID de conta e [ROLE_ADMINISTRATOR_MASKED] pela sua role de administrador.

{
    "Version": "2012-10-17",
    "Id": "key-consolepolicy-3",
    "Statement": [
        {
            "Sid": "Enable IAM User Permissions",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:root"
            },
            "Action": "kms:*",
            "Resource": "*"
        },
        {
            "Sid": "Allow access for Key Administrators",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:role/[ROLE_ADMINISTRATOR_MASKED]"
            },
            "Action": [
                "kms:Create*",
                "kms:Describe*",
                "kms:Enable*",
                "kms:List*",
                "kms:Put*",
                "kms:Update*",
                "kms:Revoke*",
                "kms:Disable*",
                "kms:Get*",
                "kms:Delete*",
                "kms:TagResource",
                "kms:UntagResource",
                "kms:ScheduleKeyDeletion",
                "kms:CancelKeyDeletion",
                "kms:RotateKeyOnDemand"
            ],
            "Resource": "*"
        },
        {
            "Sid": "Allow use of the key",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:role/[ROLE_ADMINISTRATOR_MASKED]"
            },
            "Action": [
                "kms:Encrypt",
                "kms:Decrypt",
                "kms:ReEncrypt*",
                "kms:GenerateDataKey*",
                "kms:DescribeKey"
            ],
            "Resource": "*"
        },
        {
            "Sid": "Allow attachment of persistent resources",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:role/[ROLE_ADMINISTRATOR_MASKED]"
            },
            "Action": [
                "kms:CreateGrant",
                "kms:ListGrants",
                "kms:RevokeGrant"
            ],
            "Resource": "*",
            "Condition": {
                "Bool": {
                    "kms:GrantIsForAWSResource": "true"
                }
            }
        },
        {
            "Sid": "Allow Amazon Inspector to use the key",
            "Effect": "Allow",
            "Principal": {
                "Service": "inspector2.amazonaws.com"
            },
            "Action": [
                "kms:Decrypt",
                "kms:GenerateDataKey*"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "[ACCOUNT_ID_MASKED]"
                },
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:inspector2:us-east-1:[ACCOUNT_ID_MASKED]:report/*"
                }
            }
        }
    ]
}

Explicação:
- Root: Permite que a conta raiz gerencie a chave.
- Administradores: A role [ROLE_ADMINISTRATOR_MASKED] pode gerenciar a chave (ex.: rotacionar, excluir).
- Uso da Chave: A mesma role pode usá-la para criptografia/descriptografia.
- Recursos Persistentes: Permite grants para recursos AWS.
- Inspector: O serviço inspector2.amazonaws.com pode gerar chaves de dados e descriptografar, restrito à sua conta e relatórios.
Aplicar a Política:
- Após criar a chave, edite a Key Policy no console KMS e cole a política acima (com a adição do SID do AWS Inspector com seus ajustes).

4. Configuração do Bucket S3 e Lambda

Configuração do Bucket S3

Criar o Bucket:
- No console AWS, vá para S3 e clique em Create bucket.
- Nome: seu-bucket-inspector-report (substitua por um nome único).
- Região: Escolha sua região (ex.: us-east-1).
- Desative ACLs e mantenha o bucket privado (padrão).
Estrutura de Pastas:
- Crie manualmente os caminhos:
  - /report: Para relatórios JSON do Inspector.
  - /final: Para relatórios HTML gerados pela Lambda.
Bucket Policy:
- Na aba Permissions, edite a Bucket Policy e aplique:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "allow-inspector",
            "Effect": "Allow",
            "Principal": {
                "Service": "inspector2.amazonaws.com"
            },
            "Action": [
                "s3:PutObject",
                "s3:PutObjectAcl",
                "s3:AbortMultipartUpload"
            ],
            "Resource": "arn:aws:s3:::seu-bucket-inspector-report/*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "[ACCOUNT_ID_MASKED]"
                },
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:inspector2:us-east-1:[ACCOUNT_ID_MASKED]:report/*"
                }
            }
        }
    ]
}

Explicação: Permite que o Inspector grave objetos no bucket, restrito à sua conta e relatórios.

Configuração da Lambda

Criar a Função Lambda:
- No console AWS, vá para Lambda e clique em Create function.
- Nome: process-inspector-report.
- Runtime: Python 3.13.
- Clique em Create.
- Clique em Configuration > Edit > Altere o Timeout para 1 min.
- Altere a memória para 300 megas.
Adicionar o Código:
- Coloque referências à empresa "SUA-EMPRESA":
  - No código, troque para seu bucket "seu-bucket-inspector-report".
  - No HTML, substitua o logo <img src="https://www.xpto.com.br/images/xpto-logo.svg" por <img src="https://seusite.com/logo.svg".
  - Troque "SUA-EMPRESA" por "Seu Projeto" no título e rodapé.
- Copie e cole o código fornecido (com essas alterações) na aba Code.
- Código Lambda para referência:

import json
import boto3
import logging
import os
from datetime import datetime
from collections import Counter, defaultdict
from typing import Dict, List, Any, Tuple
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.utilities.data_classes import S3Event, event_source

logger = Logger()
tracer = Tracer()

s3_client = boto3.client('s3')

@logger.inject_lambda_context
@tracer.capture_lambda_handler
@event_source(data_class=S3Event)
def lambda_handler(event: S3Event, context):
    """
    Lambda function to process AWS Inspector reports stored in S3.

    The function:
    1. Gets the report JSON file from the source bucket
    2. Processes the findings to extract relevant information
    3. Generates an HTML dashboard report
    4. Uploads the HTML report to the destination bucket
    """
    try:
        # Get the source bucket and key from the event
        source_bucket = event.bucket_name
        source_key = event.object_key

        if not source_key.endswith('.json'):
            logger.info(f"Skipping non-JSON file: {source_key}")
            return {
                'statusCode': 200,
                'body': 'Skipped non-JSON file'
            }

        # Get the object from S3
        logger.info(f"Processing file {source_key} from bucket {source_bucket}")
        response = s3_client.get_object(Bucket=source_bucket, Key=source_key)
        file_content = response['Body'].read().decode('utf-8')
        findings = json.loads(file_content).get('findings', [])

        if not findings:
            logger.warning("No findings in the report")
            return {
                'statusCode': 200,
                'body': 'No findings to process'
            }

        # Process the findings
        processed_data = process_findings(findings)

        # Generate HTML report
        html_content = generate_html_report(processed_data)

        # Define the destination key
        timestamp = datetime.now().strftime("%d%m%Y-%H%M%S")
        destination_bucket = "seu-bucket-inspector-report"
        destination_key = f"final/aws-inspector-report-{timestamp}.html"

        # Upload the HTML file to S3
        s3_client.put_object(
            Bucket=destination_bucket,
            Key=destination_key,
            Body=html_content,
            ContentType='text/html'
        )

        logger.info(f"Successfully uploaded report to s3://{destination_bucket}/{destination_key}")

        return {
            'statusCode': 200,
            'body': f'Successfully processed {len(findings)} findings and uploaded report to {destination_bucket}/{destination_key}'
        }

    except Exception as e:
        logger.exception("Error processing report")
        raise e

def process_findings(findings: List[Dict]) -> Dict:
    """
    Process the findings to extract relevant information for the report.

    Args:
        findings: List of finding dictionaries from the AWS Inspector report

    Returns:
        Dictionary with processed data for the HTML report
    """
    severity_counts = Counter()
    service_vulnerability_counts = defaultdict(int)

    ecr_findings = []
    ec2_findings = []

    # Process each finding
    for finding in findings:
        severity = finding.get('severity', 'UNKNOWN')
        severity_counts[severity] += 1

        # Determine the resource type and collect relevant findings
        resources = finding.get('resources', [])
        for resource in resources:
            resource_type = resource.get('type', '')

            if resource_type == 'AWS_ECR_CONTAINER_IMAGE':
                service_vulnerability_counts['ECR'] += 1
                details = resource.get('details', {}).get('awsEcrContainerImage', {})

                ecr_finding = {
                    'description': finding.get('description', ''),
                    'score': finding.get('epss', {}).get('score', 'N/A'),
                    'exploitAvailable': finding.get('exploitAvailable', 'N/A'),
                    'fixAvailable': finding.get('fixAvailable', 'N/A'),
                    'inspectorScore': finding.get('inspectorScore', 'N/A'),
                    'referenceUrls': finding.get('packageVulnerabilityDetails', {}).get('referenceUrls', []),
                    'sourceUrl': finding.get('packageVulnerabilityDetails', {}).get('sourceUrl', ''),
                    'vendorSeverity': finding.get('packageVulnerabilityDetails', {}).get('vendorSeverity', ''),
                    'vulnerabilityId': finding.get('packageVulnerabilityDetails', {}).get('vulnerabilityId', ''),
                    'imageHash': details.get('imageHash', ''),
                    'repositoryName': details.get('repositoryName', ''),
                    'title': finding.get('title', ''),
                    'severity': severity,
                    'vulnerability_details': []
                }

                # Extract vulnerable package details
                vuln_packages = finding.get('packageVulnerabilityDetails', {}).get('vulnerablePackages', [])
                for package in vuln_packages:
                    package_detail = {
                        'filePath': package.get('filePath', ''),
                        'type': package.get('packageManager', ''),
                        'fixedInVersion': package.get('fixedInVersion', ''),
                        'name': package.get('name', ''),
                        'packageManager': package.get('packageManager', ''),
                        'version': package.get('version', '')
                    }
                    ecr_finding['vulnerability_details'].append(package_detail)

                ecr_findings.append(ecr_finding)

            elif resource_type == 'AWS_EC2_INSTANCE':
                service_vulnerability_counts['EC2'] += 1
                details = resource.get('details', {}).get('awsEc2Instance', {})

                ec2_finding = {
                    'description': finding.get('description', ''),
                    'score': finding.get('epss', {}).get('score', 'N/A'),
                    'exploitAvailable': finding.get('exploitAvailable', 'N/A'),
                    'fixAvailable': finding.get('fixAvailable', 'N/A'),
                    'inspectorScore': finding.get('inspectorScore', 'N/A'),
                    'referenceUrls': finding.get('packageVulnerabilityDetails', {}).get('referenceUrls', []),
                    'sourceUrl': finding.get('packageVulnerabilityDetails', {}).get('sourceUrl', ''),
                    'vendorSeverity': finding.get('packageVulnerabilityDetails', {}).get('vendorSeverity', ''),
                    'vulnerabilityId': finding.get('packageVulnerabilityDetails', {}).get('vulnerabilityId', ''),
                    'id': resource.get('id', ''),
                    'title': finding.get('title', ''),
                    'name': resource.get('tags', {}).get('Name', ''),
                    'severity': severity,
                    'vulnerability_details': []
                }

                # Extract vulnerable package details
                vuln_packages = finding.get('packageVulnerabilityDetails', {}).get('vulnerablePackages', [])
                for package in vuln_packages:
                    package_detail = {
                        'filePath': package.get('filePath', ''),
                        'type': package.get('packageManager', ''),
                        'fixedInVersion': package.get('fixedInVersion', ''),
                        'name': package.get('name', ''),
                        'packageManager': package.get('packageManager', ''),
                        'version': package.get('version', '')
                    }
                    ec2_finding['vulnerability_details'].append(package_detail)

                ec2_findings.append(ec2_finding)

            else:
                service_vulnerability_counts['Other'] += 1

    # Sort findings by severity
    severity_order = {
        'CRITICAL': 0,
        'HIGH': 1,
        'MEDIUM': 2,
        'LOW': 3,
        'INFORMATIONAL': 4,
        'UNTRIAGED': 5,
        'UNKNOWN': 6
    }

    ecr_findings.sort(key=lambda x: severity_order.get(x['severity'], 999))
    ec2_findings.sort(key=lambda x: severity_order.get(x['severity'], 999))

    # Get top 5 services with most vulnerabilities
    top_services = dict(sorted(service_vulnerability_counts.items(), key=lambda item: item[1], reverse=True)[:5])

    # Get top 5 vulnerabilities
    vuln_counts = Counter(finding['packageVulnerabilityDetails'].get('vulnerabilityId', 'UNKNOWN') 
                         for finding in findings if 'packageVulnerabilityDetails' in finding)
    top_vulns = vuln_counts.most_common(5)
    top_vulns_data = [
        {'vuln': vuln, 'count': count}
        for vuln, count in top_vulns
    ]

    # Get top 5 servers (ECR repos + EC2 instances)
    server_counts = Counter()
    for finding in ecr_findings:
        server_counts[finding['repositoryName']] += 1
    for finding in ec2_findings:
        server_counts[finding['name'] or finding['id']] += 1
    top_servers = server_counts.most_common(5)
    top_servers_data = [
        {'server': server, 'count': count}
        for server, count in top_servers
    ]

    return {
        'timestamp': datetime.now().strftime("%d-%m-%Y"),
        'total_findings': len(findings),
        'severity_counts': severity_counts,
        'service_vulnerability_counts': service_vulnerability_counts,
        'service_data': [
            {'service': k, 'count': v}
            for k, v in top_services.items()
        ],
        'ecr_findings': ecr_findings,
        'ec2_findings': ec2_findings,
        'top_vulns_data': top_vulns_data,
        'top_servers_data': top_servers_data
    }

def generate_html_report(data: Dict) -> str:
    """
    Generate a modern HTML report for AWS Inspector findings with updated design.

    Args:
        data: Dictionary with processed finding data

    Returns:
        HTML content as a string
    """
    service_js_data = json.dumps(data['service_data'])
    top_vulns_js_data = json.dumps(data['top_vulns_data'])
    top_servers_js_data = json.dumps(data['top_servers_data'])

    # Organize ECR findings by repository
    ecr_by_repo = defaultdict(list)
    for finding in data['ecr_findings']:
        ecr_by_repo[finding['repositoryName']].append(finding)

    # Organize EC2 findings by instance
    ec2_by_instance = defaultdict(list)
    for finding in data['ec2_findings']:
        instance_key = finding['name'] or finding['id']
        ec2_by_instance[instance_key].append(finding)

    # Define the JavaScript section with escaped curly braces for objects
    script_content = """
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/chartjs-plugin-datalabels"></script>
    <script>
        function showSection(sectionId) {{
            document.querySelectorAll('.resource-section').forEach(function(section) {{
                section.style.display = 'none';
                section.style.overflow = 'visible';
                section.style.maxHeight = 'none';
                section.style.height = 'auto';
                section.style.flexShrink = '0'; // Ensure no flex shrinking
            }});

            // If sectionId is 'none', don't show any section (Clear Selection functionality)
            if (sectionId === 'none') {{
                return;
            }}

            const selectedSection = document.getElementById(sectionId);
            if (selectedSection) {{
                selectedSection.style.display = 'block';
                selectedSection.style.overflow = 'visible';
                selectedSection.style.maxHeight = 'none';
                selectedSection.style.height = 'auto';
                selectedSection.style.flexShrink = '0'; // Ensure no flex shrinking
            }} else {{
                console.error('Section not found: ' + sectionId);
            }}
        }}

        document.addEventListener('DOMContentLoaded', function() {{
            Chart.register(ChartDataLabels);

            const serviceData = JSON.parse('{0}');
            const servicesCtx = document.getElementById('servicesChart') ? document.getElementById('servicesChart').getContext('2d') : null;
            if (servicesCtx) {{
                new Chart(servicesCtx, {{
                    type: 'doughnut',
                    data: {{
                        labels: serviceData.map(function(d) {{ return d.service; }}),
                        datasets: [{{
                            data: serviceData.map(function(d) {{ return d.count || 0; }}),
                            backgroundColor: ['#6366f1', '#8b5cf6', '#22c55e', '#0ea5e9', '#475569'],
                            borderWidth: 2,
                            borderColor: '#fff',
                            hoverOffset: 10
                        }}]
                    }},
                    options: {{
                        cutout: '65%',
                        plugins: {{
                            legend: {{ position: 'bottom', labels: {{ padding: 20, font: {{ size: 12 }} }} }},
                            datalabels: {{
                                color: '#fff',
                                font: {{ weight: '600', size: 12 }},
                                formatter: function(value, ctx) {{
                                    const total = ctx.dataset.data.reduce(function(a, b) {{ return a + b; }}, 0);
                                    return total === 0 ? '0%' : ((value / total) * 100).toFixed(1) + '%';
                                }}
                            }}
                        }}
                    }},
                    plugins: [ChartDataLabels]
                }});
            }} else {{
                console.error('Canvas for servicesChart not found');
            }}

            const vulnsData = JSON.parse('{1}');
            const vulnsCtx = document.getElementById('vulnsChart') ? document.getElementById('vulnsChart').getContext('2d') : null;
            if (vulnsCtx) {{
                new Chart(vulnsCtx, {{
                    type: 'bar',
                    data: {{
                        labels: vulnsData.map(function(d) {{ return d.vuln.substring(0, 20) + (d.vuln.length > 20 ? '...' : ''); }}),
                        datasets: [{{
                            label: 'Count',
                            data: vulnsData.map(function(d) {{ return d.count || 0; }}),
                            backgroundColor: '#6366f1',
                            borderRadius: 8,
                            barThickness: 18
                        }}]
                    }},
                    options: {{
                        scales: {{
                            y: {{ beginAtZero: true, display: false }},
                            x: {{ grid: {{ display: false }} }}
                        }},
                        plugins: {{
                            legend: {{ display: false }},
                            datalabels: {{
                                anchor: 'end',
                                align: 'top',
                                color: '#0f172a',
                                font: {{ weight: '600', size: 12 }}
                            }}
                        }}
                    }},
                    plugins: [ChartDataLabels]
                }});
            }} else {{
                console.error('Canvas for vulnsChart not found');
            }}

            const serversData = JSON.parse('{2}');
            const serversCtx = document.getElementById('serversChart') ? document.getElementById('serversChart').getContext('2d') : null;
            if (serversCtx) {{
                new Chart(serversCtx, {{
                    type: 'bar',
                    data: {{
                        labels: serversData.map(function(d) {{ return d.server.substring(0, 20) + (d.server.length > 20 ? '...' : ''); }}),
                        datasets: [{{
                            label: 'Count',
                            data: serversData.map(function(d) {{ return d.count || 0; }}),
                            backgroundColor: '#22c55e',
                            borderRadius: 8,
                            barThickness: 18
                        }}]
                    }},
                    options: {{
                        scales: {{
                            y: {{ beginAtZero: true, display: false }},
                            x: {{ grid: {{ display: false }} }}
                        }},
                        plugins: {{
                            legend: {{ display: false }},
                            datalabels: {{
                                anchor: 'end',
                                align: 'top',
                                color: '#0f172a',
                                font: {{ weight: '600', size: 12 }}
                            }}
                        }}
                    }},
                    plugins: [ChartDataLabels]
                }});
            }} else {{
                console.error('Canvas for serversChart not found');
            }}
        }});
    </script>
    """.format(service_js_data, top_vulns_js_data, top_servers_js_data)

    # Main HTML content with updated CSS and Bootstrap override
    html = f'''<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AWS Inspector Dashboard - SUA-EMPRESA</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.2/css/all.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/chart.js@3.9.1/dist/chart.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/chartjs-plugin-datalabels@2.2.0/dist/chartjs-plugin-datalabels.min.js"></script>
    <style>
        :root {{
            --bg-color: linear-gradient(135deg, #eef2ff 0%, #dbeafe 100%);
            --card-bg: rgba(255, 255, 255, 0.95);
            --primary: #6366f1;
            --secondary: #475569;
            --text: #0f172a;
            --critical: #f43f5e;
            --high: #fb923c;
            --medium: #facc15;
            --low: #22c55e;
            --info: #0ea5e9;
            --shadow: 0 8px 32px rgba(31, 41, 55, 0.1);
            --transition: all 0.3s ease;
        }}

        body {{
            font-family: 'Inter', sans-serif;
            background: var(--bg-color);
            color: var(--text);
            margin: 0;
            padding: 0;
            min-height: 100vh;
        }}

        .header {{
            background: var(--primary);
            color: white;
            padding: 2rem 0;
            text-align: center;
            box-shadow: var(--shadow);
            position: relative;
            overflow: hidden;
        }}

        .header::before {{
            content: '';
            position: absolute;
            top: -50%;
            left: -50%;
            width: 200%;
            height: 200%;
            background: radial-gradient(circle, rgba(255, 255, 255, 0.2) 0%, transparent 70%);
            transform: rotate(30deg);
        }}

        .header-content {{
            position: relative;
            z-index: 1;
        }}

        .header img {{
            height: 50px;
            margin-bottom: 1rem;
        }}

        .header h1 {{
            font-size: 2.25rem;
            font-weight: 700;
            margin: 0;
            letter-spacing: -0.025em;
        }}

        .header p {{
            font-size: 1rem;
            opacity: 0.9;
            margin: 0.5rem 0 0;
        }}

        .container {{
            max-width: 1400px;
            margin: 0 auto;
            padding: 2rem;
            position: relative;
            z-index: 1;
        }}

        .stats-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 1.5rem;
            margin-top: -2.5rem;
            margin-bottom: 3rem;
        }}

        .stat-card {{
            background: var(--card-bg);
            border-radius: 1.25rem;
            padding: 1.5rem;
            box-shadow: var(--shadow);
            text-align: center;
            backdrop-filter: blur(10px);
            transition: var(--transition);
        }}

        .stat-card:hover {{
            transform: scale(1.03);
            box-shadow: 0 12px 40px rgba(31, 41, 55, 0.15);
        }}

        .stat-card h3 {{
            font-size: 2rem;
            font-weight: 700;
            margin: 0;
        }}

        .stat-card p {{
            font-size: 0.9rem;
            color: var(--secondary);
            margin: 0;
            text-transform: uppercase;
            letter-spacing: 0.05em;
        }}

        .charts-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
            gap: 2rem;
            margin-bottom: 3rem;
        }}

        .chart-card {{
            background: var(--card-bg);
            border-radius: 1.25rem;
            padding: 1.5rem;
            box-shadow: var(--shadow);
            backdrop-filter: blur(10px);
        }}

        .chart-card h3 {{
            font-size: 1.25rem;
            font-weight: 600;
            margin-bottom: 1rem;
            color: var(--primary);
        }}

        .section-card {{
            background: var(--card-bg);
            border-radius: 1.25rem;
            padding: 2rem;
            box-shadow: var(--shadow);
            backdrop-filter: blur(10px);
            margin-bottom: 2rem;
            overflow: visible; /* Ensure section-card allows overflow */
            max-height: none; /* Remove any max-height constraint */
            height: auto; /* Allow natural height */
            min-height: 0; /* Ensure no minimum height restricts expansion */
        }}

        .section-card h2 {{
            font-size: 1.5rem;
            font-weight: 600;
            margin-bottom: 1.5rem;
            color: var(--text);
        }}

        .dropdown {{
            margin-bottom: 1.5rem;
            position: relative;
            z-index: 1000;
        }}

        .dropdown-toggle {{
            background: var(--primary);
            border: none;
            border-radius: 0.75rem;
            padding: 0.75rem 1.5rem;
            font-weight: 600;
            box-shadow: 0 4px 14px rgba(99, 102, 241, 0.3);
            transition: var(--transition);
        }}

        .dropdown-toggle:hover {{
            background: #4f46e5;
            box-shadow: 0 6px 20px rgba(99, 102, 241, 0.4);
            transform: translateY(-2px);
        }}

        .dropdown-menu {{
            border: none;
            border-radius: 0.75rem;
            box-shadow: var(--shadow);
            background: var(--card-bg);
            backdrop-filter: blur(10px);
            padding: 0.5rem;
            z-index: 1050;
        }}

        .dropdown-item {{
            border-radius: 0.5rem;
            padding: 0.5rem 1rem;
            transition: var(--transition);
        }}

        .dropdown-item:hover {{
            background: #eef2ff;
            color: var(--primary);
        }}

        .finding-card {{
            background: var(--card-bg);
            border-radius: 0.75rem;
            padding: 1.25rem;
            margin-bottom: 1rem;
            border-left: 5px solid;
            transition: var(--transition);
            overflow: visible; /* Ensure finding-card allows overflow */
            max-height: none; /* Remove any max-height constraint */
            height: auto; /* Allow natural height */
            min-height: 0; /* Ensure no minimum height restricts expansion */
            /* Override Bootstrap .d-flex to ensure child expansion */
            flex-direction: column !important; /* Stack children vertically */
            flex-wrap: wrap !important; /* Allow wrapping if needed */
            align-items: flex-start !important; /* Align children to start */
            flex-shrink: 0 !important; /* Prevent flex shrinking */
            flex-basis: auto !important; /* Allow natural size */
            flex-grow: 1 !important; /* Allow growth if needed */
        }}

        .finding-card:hover {{
            transform: translateY(-3px);
            box-shadow: 0 6px 20px rgba(31, 41, 55, 0.12);
        }}

        .resource-section {{
            overflow: visible; /* Ensure resource-section allows overflow */
            max-height: none; /* Remove any max-height constraint */
            height: auto; /* Allow natural height */
            min-height: 0; /* Ensure no minimum height restricts expansion */
            flex-shrink: 0; /* Prevent flex shrinking */
            flex-basis: auto; /* Allow natural size */
            flex-grow: 1; /* Allow growth if needed */
        }}

        .severity-badge {{
            padding: 0.35rem 0.8rem;
            font-size: 0.85rem;
            font-weight: 600;
            border-radius: 2rem;
            color: white;
            margin-right: 0.75rem;
            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
        }}

        .critical {{ border-color: var(--critical); }}
        .high {{ border-color: var(--high); }}
        .medium {{ border-color: var(--medium); }}
        .low {{ border-color: var(--low); }}
        .informational {{ border-color: var(--info); }}
        .untriaged, .unknown {{ border-color: var(--secondary); }}

        .badge-critical {{ background: var(--critical); }}
        .badge-high {{ background: var(--high); }}
        .badge-medium {{ background: var(--medium); color: var(--text); }}
        .badge-low {{ background: var(--low); }}
        .badge-info {{ background: var(--info); }}
        .badge-untriaged, .badge-unknown {{ background: var(--secondary); }}

        .details {{
            margin-top: 1rem;
            background: rgba(248, 250, 252, 0.9);
            padding: 1rem;
            border-radius: 0.5rem;
            border-left: 3px solid var(--primary);
            /* Ensure no constraints interfere */
            height: auto;
            max-height: none;
            min-height: 0;
            flex-shrink: 0; /* Prevent flex shrinking */
            flex-basis: auto; /* Allow natural size */
            flex-grow: 1; /* Allow growth if needed */
        }}

        .footer {{
            text-align: center;
            padding: 2rem;
            color: var(--secondary);
            font-size: 0.9rem;
            background: var(--card-bg);
            border-top-left-radius: 2rem;
            border-top-right-radius: 2rem;
            box-shadow: var(--shadow);
            backdrop-filter: blur(10px);
        }}

        @media (max-width: 768px) {{
            .header h1 {{ font-size: 1.75rem; }}
            .stat-card h3 {{ font-size: 1.5rem; }}
            .charts-grid {{ grid-template-columns: 1fr; }}
        }}
    </style>
</head>
<body>
    <header class="header">
        <div class="header-content">
            <img src="https://www.xpto.com.br/images/xpto-logo.svg" alt="SUA-EMPRESA">
            <h1>AWS Inspector Dashboard</h1>
            <p>Data do Relatório: {data['timestamp']}</p>
        </div>
    </header>

    <div class="container">
        <div class="stats-grid">
            <div class="stat-card">
                <h3 style="color: var(--primary)">{data['total_findings']}</h3>
                <p>Total Findings</p>
            </div>
            <div class="stat-card">
                <h3 style="color: var(--critical)">{data['severity_counts'].get('CRITICAL', 0) + data['severity_counts'].get('HIGH', 0)}</h3>
                <p>Critical/High</p>
            </div>
            <div class="stat-card">
                <h3 style="color: var(--medium)">{data['severity_counts'].get('MEDIUM', 0)}</h3>
                <p>Medium</p>
            </div>
            <div class="stat-card">
                <h3 style="color: var(--low)">{data['severity_counts'].get('LOW', 0) + data['severity_counts'].get('INFORMATIONAL', 0)}</h3>
                <p>Low/Info</p>
            </div>
        </div>

        <div class="charts-grid">
            <div class="chart-card">
                <h3>Top Services</h3>
                <canvas id="servicesChart" height="200"></canvas>
            </div>
            <div class="chart-card">
                <h3>Top 5 Vulnerabilities</h3>
                <canvas id="vulnsChart" height="200"></canvas>
            </div>
            <div class="chart-card">
                <h3>Top 5 Servers</h3>
                <canvas id="serversChart" height="200"></canvas>
            </div>
        </div>

        <!-- ECR Section -->
        <div class="section-card">
            <h2><i class="fab fa-docker me-2"></i> ECR Findings ({len(data['ecr_findings'])})</h2>
            <div class="dropdown">
                <button class="btn dropdown-toggle" type="button" id="ecrDropdown" data-bs-toggle="dropdown" aria-expanded="false">
                    Select Repository
                </button>
                <ul class="dropdown-menu" aria-labelledby="ecrDropdown">
                    <li><a class="dropdown-item" href="#" onclick="showSection('none')">Clear Selection</a></li>
                    <li><a class="dropdown-item" href="#ecr-all" onclick="showSection('ecr-all')">All Repositories</a></li>
'''
    for repo in ecr_by_repo.keys():
        html += f'''                    <li><a class="dropdown-item" href="#ecr-{repo}" onclick="showSection('ecr-{repo}')">{repo}</a></li>'''

    html += f'''                </ul>
            </div>
            <div id="ecr-all" class="resource-section" style="display:none;">
'''
    for repo, findings in ecr_by_repo.items():
        for i, finding in enumerate(findings):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                            <p class="mb-0 text-muted">Repo: {repo}</p>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
    html += f'''            </div>
'''
    for repo in ecr_by_repo.keys():
        html += f'''            <div id="ecr-{repo}" class="resource-section" style="display:none;">'''
        for i, finding in enumerate(ecr_by_repo[repo]):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
        html += f'''            </div>'''

    html += f'''        </div>

        <!-- EC2 Section -->
        <div class="section-card">
            <h2><i class="fas fa-server me-2"></i> EC2 Findings ({len(data['ec2_findings'])})</h2>
            <div class="dropdown">
                <button class="btn dropdown-toggle" type="button" id="ec2Dropdown" data-bs-toggle="dropdown" aria-expanded="false">
                    Select Instance
                </button>
                <ul class="dropdown-menu" aria-labelledby="ec2Dropdown">
                    <li><a class="dropdown-item" href="#" onclick="showSection('none')">Clear Selection</a></li>
                    <li><a class="dropdown-item" href="#ec2-all" onclick="showSection('ec2-all')">All Instances</a></li>
'''
    for instance in ec2_by_instance.keys():
        html += f'''                    <li><a class="dropdown-item" href="#ec2-{instance}" onclick="showSection('ec2-{instance}')">{instance}</a></li>'''

    html += f'''                </ul>
            </div>
            <div id="ec2-all" class="resource-section" style="display:none;">
'''
    for instance, findings in ec2_by_instance.items():
        for i, finding in enumerate(findings):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                            <p class="mb-0 text-muted">Instance: {instance}</p>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
    html += f'''            </div>
'''
    for instance in ec2_by_instance.keys():
        html += f'''            <div id="ec2-{instance}" class="resource-section" style="display:none;">'''
        for i, finding in enumerate(ec2_by_instance[instance]):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
        html += f'''            </div>'''

    html += f'''        </div>
    </div>

    <footer class="footer">
        <p>© {datetime.now().year} SUA-EMPRESA - AWS Inspector Vulnerability Report</p>
    </footer>
'''

    # Concatenate the script content at the end
    html += script_content + '''
</body>
</html>
'''
    return html

Configurar Layers:

Clique em Layers → Add a layer.
Escolha AWS provided e procure por AWSLambdaPowertools.
Selecione a versão mais recente para Python 3.13 e adicione.

Permissões IAM:

Crie uma IAM policy para a Lambda:
- No console IAM, crie uma policy com:
  - Política S3 + KMS:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::seu-bucket-inspector-report/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt",
                "kms:GenerateDataKey"
            ],
            "Resource": "arn:aws:kms:us-east-1:[ACCOUNT_ID_MASKED]:key/[KEY_ID]"
        }
    ]
}

Anexe essa permissão criada à Role da Lambda (alterando o ARN da para sua KMS criada).

Configurar o Gatilho S3:

Na Lambda, clique em Add trigger.
Escolha S3.
Bucket: seu-bucket-inspector-report.
Event type: All object create events.
Prefix: report/.
Suffix: .json.
Clique em Add.

Pronto! Agora você deve gerar o relatório do KMS, em .json, para o s3://seu-bucket-inspector-report/report/ e buscar o HTML gerado no path seu-bucket-inspector-report/final/.

Stream Dynamo para RDS Mysql

Railander Marques — Sun, 22 Dec 2024 15:56:24 +0000

Visão Geral

Esta implementação tem como objetivo capturar eventos de alteração na tabela DynamoDB “account_answers_full” (atraves de lambda) e replicar esses eventos para um banco de dados relacional RDS (MySQL). Para isso, utiliza duas funções Lambda que se comunicam através de uma fila SQS da AWS.

Uma Lambda captura eventos de alteração na tabela DynamoDB 'account_answers_full' e os envia como mensagens para uma fila SQS, utilizando uma DLQ para gerenciar mensagens não processadas e permitir o reprocessamento dos dados em caso de falhas temporárias. Em seguida, outra Lambda consome essas mensagens da SQS, estabelece conexão com o RDS via ENI (recomenda-se utilizar RDS Proxy para gerenciar essas conexões), processa e executa operações correspondentes no banco de dados RDS MySQL.

Passo 1: DynamoDB para SQS

Tabela DynamoDB:
- Nome: account_answers_full
- Índices Globais Secundários:
  - uid-question-index: uid (Número), question (Número)
  - uid-section_id-index: uid (Número), section_id (Número)
  - uid-usection_id-index: uid (Número), usection_id (Número)\n
Trigger Lambda 1 (dynamo-to-sqs-connector):
- Esta Lambda é acionada por eventos de alteração na tabela DynamoDB (INSERT, MODIFY, REMOVE).
- Extrai os detalhes do evento, empacota-os em uma mensagem e os envia para uma fila SQS ==(Use fila FIFO, fila standard pode causar problemas de duplicação)==.

Código da Lambda 1:

const { SendMessageCommand, SQSClient } = require("@aws-sdk/client-sqs");

const sqs = new SQSClient({});
const queueUrl = process.env.SQS_QUEUE_URL; // VARIÁVEL DE AMBIENTE COM SQS FIFO - SOMENTE FIFO FUNCIONA NESSE CÓDIGO

exports.handler = async (event) => {
  for (const record of event.Records) {
    if (['INSERT', 'MODIFY', 'REMOVE'].includes(record.eventName)) {
      try {
        const item = record.dynamodb.NewImage ?? record.dynamodb.OldImage
        const message = {
          eventName: record.eventName,
          dynamodb: record.dynamodb
        };

        // Usando usection_id, section_id e question como parte do MessageGroupId
        const usection_id = item.usection_id.N;
        const section_id = item.section_id.N;
        const question = item.question.N;
        const messageGroupId = `usection-${usection_id}-section-${section_id}-question-${question}`;


        const command = new SendMessageCommand({
          QueueUrl: queueUrl,
          MessageBody: JSON.stringify(message),
          MessageGroupId: messageGroupId
        });

        await sqs.send(command);

        console.info(`Message sent to SQS: ${JSON.stringify(message)}`);
      } catch (error) {
        console.error(`Error sending message to SQS: ${error.message}`, { error });
      }
    }
  }

  console.info('Lambda execution completed');
};

[lambda_1_eprep-9c1a3420-b362-42e0-8493-033e3e0e99b1.zip 740]
https://github.com/aldeiacloud/StreamDynamoMysql/raw/refs/heads/main/lambda_1_eprep-9c1a3420-b362-42e0-8493-033e3e0e99b1.zip

Variáveis de Ambiente:
- SQS_QUEUE_URL: URL da fila SQS para onde as mensagens são enviadas. (Perceba que tem o Endpoint).

Logs:

ScreenShot Trigger 1:

Passo 2: SQS para RDS

Trigger Lambda 2 (sqs-to-rds-connector):
- Acionada por mensagens na fila SQS FIFO (com DLQ) enviadas pela Lambda 1.
- Processa as mensagens, extrai os detalhes do evento DynamoDB e executa operações correspondentes no banco de dados RDS.

Código da Lambda 2:

const { SQSClient, SendMessageCommand, ReceiveMessageCommand, DeleteMessageCommand } = require("@aws-sdk/client-sqs");
const mysql = require('mysql');
const { promisify } = require('util')

// Configuração personalizada para aumentar o timeout nas tentativas de conexão
// Configuração do cliente DLQ com o endpoint HTTP
const dlqEndpointUrl = process.env.DLQ_ENDPOINT_URL;

const sqs = new SQSClient({
    maxRetries: 10,
    httpOptions: {
        timeout: 120000
    }
});

// Carrega as credenciais do RDS a partir das variáveis de ambiente
const dbConfig = {
    user: process.env.RDS_USERNAME,
    password: process.env.RDS_PASSWORD,
    host: process.env.RDS_HOST,
    database: process.env.RDS_DATABASE,
    port: process.env.RDS_PORT
};

// Função para conectar ao banco de dados MySQL com tentativas de retry
async function connectToMySQL(retryAttempts = 5, delay = 120000) {
    for (let attempt = 0; attempt < retryAttempts; attempt++) {
        try {
            const connection = mysql.createConnection(dbConfig);
            await promisify(connection.connect).call(connection);
            return connection;
        } catch (err) {
            console.error("Error connecting to MySQL", { error: err.message });
            if (attempt < retryAttempts - 1) {
                console.info(`Retrying in ${delay / 1000} seconds...`);
                await new Promise(res => setTimeout(res, delay));
            } else {
                throw err;
            }
        }
    }
}

// Função para processar um registro do SQS
async function processRecord(record) {
    let connection;
    try {
        console.info("Processing SQS message:", record);

        const messageBody = JSON.parse(record.body);
        console.info(`Parsed message body: ${record.body}`);

        const eventName = messageBody.eventName;
        const dynamodb = messageBody.dynamodb;

        const keys = dynamodb.Keys;
        const newImage = dynamodb?.NewImage || {};

        const usectionId = keys.usection_id.N;
        const question = keys.question.N;
        const sectionId = newImage?.section_id ? newImage?.section_id?.N : "";

        connection = await connectToMySQL();
        const query = promisify(connection.query).bind(connection);

        let sqlScript, sqlValue;

        // Realiza a operação correspondente com base no evento
        if (eventName === "INSERT") {
            sqlScript = "INSERT INTO account_answers (usection_id, question, section_id) VALUES (?, ?, ?)";
            sqlValue = [usectionId, question, sectionId];
            await query(sqlScript, sqlValue);
            console.info("Record inserted successfully into account_answers table", { sqlValue });

        } else if (eventName === "MODIFY") {
            sqlScript = "UPDATE account_answers SET section_id = ? WHERE usection_id = ? AND question = ?";
            sqlValue = [sectionId, usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record modified successfully in account_answers table", { sqlValue });

        } else if (eventName === "REMOVE") {
            sqlScript = "DELETE FROM account_answers WHERE usection_id = ? AND question = ?";
            sqlValue = [usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record removed successfully from account_answers table", { sqlValue });
        }

    } catch (err) {
        console.error("Error processing SQS message", JSON.stringify(err));
        throw new Error(err ?? "Unknow error processing SQS message");
    } finally {
        if (connection) {
            connection.end();
        }
    }
}

// Função para reprocessar mensagens da DLQ com timeout e intervalo entre tentativas
async function reprocessDlqMessages(timeoutSeconds = 300, retryIntervalSeconds = 1) {
    try {
        console.info("Starting reprocessing of DLQ messages");

        const startTime = Date.now();

        while (true) {
            // Verifica se o tempo máximo de execução foi atingido
            if ((Date.now() - startTime) > (timeoutSeconds * 1000)) {
                console.info("Timeout reached for DLQ reprocessing");
                break;
            }

            try {
                const command = new ReceiveMessageCommand({
                    QueueUrl: dlqEndpointUrl,
                    MaxNumberOfMessages: 10,
                    WaitTimeSeconds: 10
                });

                const response = await sqs.send(command)

                const messages = response.Messages || [];
                if (messages.length === 0) {
                    console.info("No more messages in DLQ");
                    break;
                }

                for (const message of messages) {
                    try {
                        await processWithRetry(message)
                        console.log('deu certo o retry dlq')
                        const command = new DeleteMessageCommand({
                            QueueUrl: dlqEndpointUrl,
                            ReceiptHandle: message.ReceiptHandle
                        });
                        await sqs.send(command);
                    } catch (err) {
                        console.error("Failed to reprocess message from DLQ", { message, error: err.message });
                    }
                }

                // Aguarda antes de tentar a próxima iteração para evitar sobrecarga no endpoint
                await new Promise(res => setTimeout(res, retryIntervalSeconds * 1000));

            } catch (err) {
                console.error("Error receiving messages from DLQ", { error: err.message });
                await new Promise(res => setTimeout(res, retryIntervalSeconds * 1000));  // Espera antes de tentar novamente em caso de falha
            }
        }

        console.info("Reprocessing of DLQ messages completed");

    } catch (err) {
        console.error("Error reprocessing DLQ messages", { error: err.message });
        throw err;
    }
}

// Função para processar um registro com tentativas de retry
async function processWithRetry(record, retries = 3, backoffInSeconds = 2) {
    let attempt = 0;
    while (attempt < retries) {
        try {
            await processRecord(record);
            console.log('sucesso')
            return;
        } catch (err) {
            attempt++;
            console.error(`Attempt ${attempt} failed: ${JSON.stringify(err)}`);
            if (attempt < retries) {
                await new Promise(res => setTimeout(res, backoffInSeconds * 1000 * (2 ** (attempt - 1))));  // Exponential backoff
            }else {
                throw err;
            }
        }
    }
}

// Função Lambda Handler
exports.handler = async (event, context) => {
    console.info("Starting the lambda_handler function for SQS to RDS");

    try {
        for (const record of event.Records) {
            try {
                await processWithRetry(record);
            } catch (err) {
                // Envia mensagem para DLQ para reprocessamento posterior
                console.error("Failed to process record after retries, sending to DLQ");
                try {
                    const command = new SendMessageCommand({
                        QueueUrl: dlqEndpointUrl,
                        MessageBody: JSON.stringify(record)
                    });

                    await sqs.send(command)
                } catch (err) {
                    console.error("Failed to send message to DLQ", { error: err.message });
                }
            }
        }

        // Reprocessa mensagens da DLQ se houver
        await reprocessDlqMessages();

    } catch (err) {
        console.error("Error processing records from SQS", { error: err.message });
    }

    console.info("lambda_handler function execution completed for SQS to RDS");
};

[ae3075c0-896a-4473-acc2-b0e151a1a280.zip 2628477]
https://github.com/aldeiacloud/StreamDynamoMysql/raw/refs/heads/main/ae3075c0-896a-4473-acc2-b0e151a1a280.zip

:::info
Explicação e Resumo do Código

:::

1. Importações e Configurações Iniciais

const { SQSClient, SendMessageCommand, ReceiveMessageCommand, DeleteMessageCommand } = require("@aws-sdk/client-sqs");
const mysql = require('mysql');
const { promisify } = require('util');

SQSClient e comandos: Importa classes para interagir com o SQS, que é um serviço de fila gerenciado da AWS.
mysql: Para conexão com um banco de dados MySQL.
promisify: Utilizado para transformar funções que usam callbacks em funções que retornam promessas, facilitando o uso de async/await.

2. Configuração do Cliente SQS


const dlqEndpointUrl = process.env.DLQ_ENDPOINT_URL;

const sqs = new SQSClient({
    maxRetries: 10,
    httpOptions: {
        timeout: 120000
    }
});

dlqEndpointUrl: URL da Dead Letter Queue (DLQ), onde mensagens falhas são enviadas.
SQSClient: Configura o cliente com um número máximo de tentativas e um timeout para requisições HTTP.

3. Configuração do Banco de Dados


const dbConfig = {
    user: process.env.RDS_USERNAME,
    password: process.env.RDS_PASSWORD,
    host: process.env.RDS_HOST,
    database: process.env.RDS_DATABASE,
    port: process.env.RDS_PORT
};

Carrega as credenciais do RDS (Relational Database Service) a partir de variáveis de ambiente.

4. Conexão ao Banco de Dados


async function connectToMySQL(retryAttempts = 5, delay = 120000) {
    // Tenta conectar ao MySQL com múltiplas tentativas
}

Tenta criar uma conexão com o banco de dados e, se falhar, aguarda um tempo antes de tentar novamente.

5. Processamento de Mensagens do SQS


async function processRecord(record) {
    let connection;
    try {
        const messageBody = JSON.parse(record.body);
        const eventName = messageBody.eventName;
        const dynamodb = messageBody.dynamodb;
        const keys = dynamodb.Keys;
        const newImage = dynamodb?.NewImage || {};

        const usectionId = keys.usection_id.N;
        const question = keys.question.N;
        const sectionId = newImage?.section_id ? newImage?.section_id?.N : "";

        connection = await connectToMySQL();
        const query = promisify(connection.query).bind(connection);

        let sqlScript, sqlValue;

        // Operações com base no tipo de evento
        if (eventName === "INSERT") {
            sqlScript = "INSERT INTO account_answers (usection_id, question, section_id) VALUES (?, ?, ?)";
            sqlValue = [usectionId, question, sectionId];
            await query(sqlScript, sqlValue);
            console.info("Record inserted successfully");

        } else if (eventName === "MODIFY") {
            sqlScript = "UPDATE account_answers SET section_id = ? WHERE usection_id = ? AND question = ?";
            sqlValue = [sectionId, usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record modified successfully");

        } else if (eventName === "REMOVE") {
            sqlScript = "DELETE FROM account_answers WHERE usection_id = ? AND question = ?";
            sqlValue = [usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record removed successfully");
        }

    } catch (err) {
        console.error("Error processing SQS message", JSON.stringify(err));
        throw new Error(err ?? "Unknown error processing SQS message");
    } finally {
        if (connection) {
            connection.end();
        }
    }
}

processRecord: Recebe uma mensagem do SQS e processa com base no tipo de evento (INSERT, MODIFY, REMOVE).
- INSERT: Adiciona um novo registro na tabela account_answers.
- MODIFY: Atualiza um registro existente.
- REMOVE: Remove um registro existente.
A conexão com o MySQL é encerrada após a operação.

6. Reprocessamento de Mensagens da DLQ


async function reprocessDlqMessages(timeoutSeconds = 300, retryIntervalSeconds = 1) {
    // Tenta reprocessar mensagens na DLQ
}

Este método tenta ler mensagens da DLQ e processá-las novamente.
Se a reprocessamento falhar, loga um erro e continua tentando.

7. Tentativas de Processamento com Retry


async function processWithRetry(record, retries = 3, backoffInSeconds = 2) {
    // Tenta processar um registro várias vezes com um intervalo entre as tentativas
}

Implementa um mecanismo de retry com um backoff exponencial, permitindo que o sistema tente processar mensagens que falharam antes.\n

8. Função Lambda Handler


exports.handler = async (event, context) => {
    // Função principal que é chamada quando a Lambda é acionada
}

Processa cada registro recebido do SQS.
Se uma mensagem falhar após as tentativas, ela é enviada para a DLQ.
Também tenta reprocessar mensagens da DLQ ao final do processamento.

Resumo

Inserção: Quando um evento de inserção ocorre, um novo registro é adicionado ao banco.
Atualização: Para eventos de modificação, um registro existente é atualizado.
Remoção: Para eventos de remoção, um registro específico é deletado.
SQS e DLQ: Mensagens são enviadas para uma fila (SQS) e, se falharem várias vezes, são redirecionadas para uma DLQ para posterior análise.
Conexões: O código gerencia as conexões ao MySQL, garantindo que sejam fechadas após o uso.

Screenshots:

Observações:
:::warning

Colocar todas as permissões dos serviços necessárias, incluindo SQS, Dynamo, CloudWatch...
A Lambda 2, que conecta no banco de dados, precisa ter uma ENI, para fazer a conexão (Verificar SG)
Esse tutorial esta configurado para fazer insert, delete ou update em 1 tabela especifica em 3 colunas, caso necessite de mais, precisa ajustar as 2 lambdas no tratamento do SQS e no script SQL.

:::

Configuração do SQS e Teste de Carga:

Filas SQS Fifo

Fila 1 - SQS

Fila 2 - SQS DLQ

:::info
Ponderações:

:::

Lambda 2

Duração baixa e quantidade de invocação alta, 100% de sucesso.

Quantidade Máxima de conexão no RDS:

Lambda 1

Percebemos um total de concurrents maior no envio do dado do Dynamo para o SQS, sem erros no envio, invocações muito altas, alimentando a fila de SQS, que contem uma outra fila DLQ para reprocessar em caso de falha temporária.

:::success
Fiz outro teste de carga, reiniciando o banco de dados antes da execução e a arquitetura conseguiu inserir as 10 mil linhas após o banco iniciar:

:::

(…)

:::success
Resultados e Observações:

Não tive problemas de muitas conexões no RDS ou problemas no SQS:

1- Endpoint SQS para evitar timeout no endpoint para conexão no SQS, tanto na DLQ tanto na principal;

2- Escolha da quantidade de concurrency da lambda 2, quanto maior, mais conexões no RDS;

3- Garantir o uso da fila do tipo Fifo com desduplicação ativa.

4- Fiz um teste reiniciando o banco de dados e os dados foram enviados para o banco após reiniciar.

:::

Exportar Voip para AWS EC2 - .vmdk ou .ova

Railander Marques — Sun, 22 Dec 2024 02:40:31 +0000

1- Vamos usar como exemplo neste tutorial uma .iso FreePBX para exportação.

Baixar .iso do FreePBX no endereço: https://downloads.freepbxdistro.org/ISO/
Neste tutorial, usei essa .iso: https://downloads.freepbxdistro.org/ISO/SNG7-FPBX-64bit-2011-5.iso

2- Usaremos o Virtual Box para instalar a .iso em .vmdk e converter para .ova

![Coloque o nome | clique em NEXT]

![Neste caso, vou usar 4GB de ram para instalação | clique em NEXT]

![Escolha criar novo disco | clique em CREATE]

![Escolha VMDK | clique em NEXT]

![Deixe em "Dynamically allocated | clique em NEXT]

![Aloque cerca de 20GB para a máquina virtual | clique em CREATE]

![Clique em SETTINGS]

![Escolha uma quantidade razoável de cores para configurarmos a máquina virtual]

![Habilitar uma placa de rede NAT]

![Clique em Storage > Empty > Icone de CD > Choose a disk file]

![Escolha a .iso a ser instalada | clique em OPEN e OK na janela anterior]

![Clique em START]

![Caso pergunte qual midia para iniciar a máquina virtual, selecione a .iso a ser instalada | clique em START]

![Neste tutorial usaremos a versão 16 | aperte ENTER]

![Escolha a opção "Graphical Installation - Output to VGA" | aperte ENTER]

![Escolha a opção "FreePBX Standard | aperte ENTER]

![............ Aguarde a instalação ............]

![Clique em "ROOT PASSWORD" para configurar uma senha para o ROOT]

![Defina uma senha e clique em DONE]

![Com a senha de root configurada, aguarde até o final da instalação]

![Clique em REBOOT]

![Desligue a maquina virtual | clique em OK]

![Com a máquina virtual em STOP | clique em SETTINGS]

![Clique em Storage > clique na ISO atachada > Clique no ícone de CD > Remove Disk from Virtual Drive > Inicie o VOIP]

![Ao iniciar, logue como usuario "root" e a senha escolhida na instalação]

3- Agora que a máquina virtual está instalada, vamos instalar o AWS SSM Agent para acesso ao terminal via AWS Console

Neste caso, instalaremos o SSM para região de Virgínia (us-east-1) na AWS, seguindo a documentação da AWS.

https://docs.aws.amazon.com/systems-manager/latest/userguide/agent-install-rhel.html

sudo yum install -y https://s3.us-east-1.amazonaws.com/amazon-ssm-us-east-1/latest/linux_amd64/amazon-ssm-agent.rpm
sudo systemctl enable amazon-ssm-agent
sudo systemctl start amazon-ssm-agent
sudo systemctl status amazon-ssm-agent

4- Agora podemos desligar a máquina virtual.

Execute o comando:

shutdown now

5- Vamos exportar a maquina virtual para .ova

![File > Export Appliance]

![Escolha FreePBX | clique em NEXT]

![Escolha o destino | clique em NEXT]

![Clique em EXPORT]

6- Criar bucket privado e fazer upload do arquivo.ovapara o AWS S3

Faça o upload do arquivo .ova para dentro do bucket criado

7- Vamos criar uma politica com o nome trust-policy.jsonno computador local

Execute o comando abaixo:

cat > "trust-policy.json" << "EOF"
{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Allow",
         "Principal": { "Service": "vmie.amazonaws.com" },
         "Action": "sts:AssumeRole",
         "Condition": {
            "StringEquals":{
               "sts:Externalid": "vmimport"
            }
         }
      }
   ]
}
EOF

![Output do comando acima]

8- Vamos criar uma Role com o nome vmimport utilizando o arquivo trust-policy.json

Para isso necessitamos exportar uma credencial programática com permissão “AdministratorAccess”* em seu terminal.

![Comando para exportar credencial no terminal, necessário instalar o AWS CLI https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html]

Execute o comando abaixo:

aws iam create-role --role-name vmimport --assume-role-policy-document "file://trust-policy.json"

9- Variáveis que iremos alterar nos arquivos a seguir

nome_do_seu_bucket="aldeiacloud"
# Apontar o diretorio/arquivo.ova
S3Key="diretorio-local/FreePBX.ova"

Esta política será anexada à Role vmimport criada na etapa anterior
Vamos alterar o bucket_name para o nome do seu bucket no AWS S3

role-policy.json

echo '{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "s3:GetBucketLocation",
            "s3:GetObject",
            "s3:ListBucket" 
         ],
         "Resource":[
            "arn:aws:s3:::'nome_do_seu_bucket'",
            "arn:aws:s3:::'nome_do_seu_bucket'/*"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "ec2:ModifySnapshotAttribute",
            "ec2:CopySnapshot",
            "ec2:RegisterImage",
            "ec2:Describe*"
         ],
         "Resource":"*"
      }
   ]
}
' | sudo tee role-policy.json

Execute o comando:

aws iam put-role-policy --role-name vmimport \
                        --policy-name vmimport \
                        --policy-document "file://role-policy.json"

10- Iniciar tarefa de exportação da .ova

Em nosso caso, iremos executar o seguinte comando para criarmos o arquivo

Execute o comando:

echo '[
  {                                          
    "Description": "FreePBX",
    "Format": "ova",
    "UserBucket": {
        "S3Bucket": "'nome_do_seu_bucket'",
        "S3Key": "'diretorio-local/FreePBX.ova'"
    }
}]
' > containers.json

Iniciar exportação

Execute o comando:

aws ec2 import-image --description "FreePBX" --disk-containers "file://containers.json"

CHECAGEM DA TASK

Verifique o status dos trabalhos de importação de VM

aws ec2 describe-import-image-tasks --import-task-ids "import-ami-xxxxxxxxxxxxxxxxx"

[Status 3]

![Status 4 | COMPLETED]

Alarme Dynamo Throttle Events - Discord

Railander Marques — Sun, 22 Dec 2024 02:34:50 +0000

Essa configuração monitora determinadas métricas de uma tabela DynamoDB e envia uma notificação para um canal Discord se forem detectados eventos de throttling.

Primeiro Passo - Configuração da Lambda

Amostragem geral:

Runtime:

Variáveis de Ambiente:

Resource-based - Policy Statements (Importante para o alarme conseguir triggar a lambda)

Configuração da resource-based policy: (ARN do alarme criado para triggar a lambda)

Permissões necessárias:

Código Lambda:

import json
import boto3
import requests
import os
from datetime import datetime, timedelta

# Configurações do Discord Webhook
DISCORD_WEBHOOK_URL = os.environ['DISCORD_WEBHOOK_URL']

# Cliente boto3 para o CloudWatch
cloudwatch = boto3.client('cloudwatch')

def send_discord_notification(message):
    data = {
        "content": message
    }
    response = requests.post(DISCORD_WEBHOOK_URL, json=data)
    if response.status_code != 204:
        raise ValueError(f"Falha ao enviar notificação para o Discord: {response.status_code}, {response.text}")

def lambda_handler(event, context):
#    print("Evento recebido:", json.dumps(event))
    print(event) 
    # Métricas a serem monitoradas
    metrics_to_monitor = [
        'WriteThrottleEvents',
        'ReadThrottleEvents'
    ]

    # Nome da tabela DynamoDB a ser monitorada
    table_name = os.environ['TABLE_NAME']
    print(f"Tabela a ser monitorada: {table_name}")

    for metric_name in metrics_to_monitor:
        print(f"Verificando métrica: {metric_name}")

        response = cloudwatch.get_metric_statistics(
            Namespace='AWS/DynamoDB',
            MetricName=metric_name,
            Dimensions=[
                {
                    'Name': 'TableName',
                    'Value': table_name
                }
            ],
            StartTime=datetime.utcnow() - timedelta(minutes=5),
            EndTime=datetime.utcnow(),
            Period=60,
            Statistics=['Sum']
        )

        print(f"Resposta da CloudWatch: {response}")

        data_points = response.get('Datapoints', [])
        if data_points:
            for point in data_points:
                print(f"Ponto de dados: {point}")
                if point['Sum'] > 0:
                    message = f"Evento de throttle ({metric_name}) detectado na tabela {table_name} com {int(point['Sum'])} eventos."
                    print(f"Enviando mensagem para o Discord: {message}")
                    try:
                        send_discord_notification(message)
                    except Exception as e:
                        print(f"Erro ao enviar notificação para o Discord: {e}")
                    else:
                        print("Notificação enviada com sucesso.")
                else:
                    print(f"Nenhum evento de throttle detectado para {metric_name}.")
        else:
            print(f"Nenhum ponto de dados encontrado para {metric_name}.")

    print("Processo de verificação concluído.")

    return {
        'statusCode': 200,
        'body': json.dumps('Notificações enviadas se algum evento de throttle for detectado.')
    }

Download Lambda Code [dynamo-throttle-events.zip]
https://github.com/aldeiacloud/DynamoThrottleEvents/raw/refs/heads/main/ecbb053f-e092-4059-b39d-f8f184166e76.zip

Função principal (lambda_handler):
- Recebe o evento e o contexto quando acionada.
- Define as métricas a serem monitoradas: WriteThrottleEvents e ReadThrottleEvents.
- Obtém o nome da tabela DynamoDB a ser monitorada a partir das variáveis de ambiente.
- Para cada métrica, consulta o CloudWatch para obter estatísticas sobre eventos de throttling nos últimos 5 minutos.
- Analisa os pontos de dados retornados:
  - Se houver eventos de throttling (soma maior que 0), envia uma notificação para o Discord com detalhes.
  - Caso contrário, indica que não foram detectados eventos de throttling.
- Finaliza o processo de verificação e retorna um status de sucesso.

A função envia uma notificação ao Discord somente se detectar eventos de throttling nas métricas monitoradas da tabela DynamoDB especificada.

Segundo Passo - Configuração do Alarme CloudWatch

Amostragem geral:

Table Name / Statistic / Period:

Condições:

Lambda action:

Feito, agora quando o alarme triggar algum throttle na leitura ou escrita da tabela configurada no alerta e nas variáveis do lambda, ele vai enviar para o grupo de texto no discord.

Após forçar um throttle, conseguimos receber o evento no Discord:

AWS Inspector - Notificação CVE - EC2 e ECR

Railander Marques — Wed, 17 Jul 2024 11:16:30 +0000

Neste tutorial, vamos explicar como criar e configurar uma função Lambda na AWS que captura eventos do AWS Inspector via SNS, formata esses eventos em um email detalhado e os envia via AWS SES para um destinatário específico.

Passos:

Criar a Função Lambda:
Primeiro, você precisa criar uma função Lambda na AWS. A função Lambda será acionada pelos eventos gerados pelo AWS Inspector através do SNS.
- Acesse o Console da AWS.
- Vá para o serviço Lambda.
- Clique em "Criar função".
- Configure o nome, a runtime (Python 3.12 ou superior recomendado) e deixe as permissões de execução padrão inicialmente. (Depois adicione AmazonEC2ReadOnlyAccess, AmazonSESFullAccess, AmazonSNSReadOnlyAccess e AmazonEC2ContainerRegistryReadOnly)
- Defina como 1 minuto o timeout da lambda.
Configurar Gatilho do SNS:
- Após criar a função Lambda, adicione um gatilho SNS.
- Selecione o tópico SNS que recebe os eventos do AWS Inspector.
- Exemplo da CloudWatch Rule de detecção do Inspector que envia para o SNS:

{
  "source": ["aws.inspector2"],
  "detail-type": ["Inspector2 Finding"],
  "detail": {
    "severity": ["HIGH", "MEDIUM", "CRITICAL"],
    "status": ["ACTIVE", "CLOSED", "SUPRESSED"]
  }
}

Configure a função lambda para ser acionada por novas mensagens no tópico SNS.

Variáveis de ambiente:

Implementar o Código da Função Lambda:

Troque o nome da empresa do código, para a empresa que deseja configurar o alerta.

import json
import boto3
import os

# Inicialize os clientes da AWS
ses_client = boto3.client('ses')
ec2_client = boto3.client('ec2')
ecr_client = boto3.client('ecr')

def send_email(subject, body):
    # Função para enviar o email usando SES
    response = ses_client.send_email(
        Source=os.environ['SOURCE_EMAIL'],
        Destination={
            'ToAddresses': [os.environ['TARGET_EMAIL']]
        },
        Message={
            'Subject': {
                'Data': subject,
                'Charset': 'UTF-8'
            },
            'Body': {
                'Html': {
                    'Data': body,
                    'Charset': 'UTF-8'
                }
            }
        }
    )
    print(f"Email enviado com sucesso: {response}")

def lambda_handler(event, context):
    for record in event['Records']:
        sns_message = json.loads(record['Sns']['Message'])
        detail = sns_message.get('detail', {})

        # Detalhes do evento
        title = detail.get('title', 'N/A')
        description = detail.get('description', 'N/A').replace('\n', '<br>')
        severity = detail.get('severity', 'N/A')
        status = detail.get('status', 'N/A')
        finding_arn = detail.get('findingArn', 'N/A')
        first_observed = detail.get('firstObservedAt', 'N/A')
        last_observed = detail.get('lastObservedAt', 'N/A')
        updated_at = detail.get('updatedAt', 'N/A')
        vulnerability_id = detail.get('packageVulnerabilityDetails', {}).get('vulnerabilityId', 'N/A')

        resources = detail.get('resources', [])

        for resource in resources:
            resource_type = resource.get('type', '')

            if resource_type == 'AWS_EC2_INSTANCE':
                # Detalhes da instância EC2
                instance_id = resource.get('id', 'N/A')
                instance_name = get_ec2_instance_name(instance_id)
                instance_profile = resource.get('details', {}).get('awsEc2Instance', {}).get('iamInstanceProfileArn', 'N/A')
                image_id = resource.get('details', {}).get('awsEc2Instance', {}).get('imageId', 'N/A')
                ipv4_addresses = ', '.join(resource.get('details', {}).get('awsEc2Instance', {}).get('ipV4Addresses', []))
                platform = resource.get('details', {}).get('awsEc2Instance', {}).get('platform', 'N/A')
                instance_type = resource.get('details', {}).get('awsEc2Instance', {}).get('type', 'N/A')

                # Construir corpo do email para EC2
                email_subject = f"Alerta de Segurança - EMPRESA XPTO - {instance_name} - {title}"
                email_body = build_ec2_email_body(instance_name, title, description, instance_id, instance_profile, image_id, ipv4_addresses, platform, instance_type, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id)
                send_email(email_subject, email_body)

            elif resource_type == 'AWS_ECR_CONTAINER_IMAGE':
                # Detalhes da imagem no ECR
                repository_name = resource.get('details', {}).get('awsEcrContainerImage', {}).get('repositoryName', 'N/A')
                image_digest = resource.get('details', {}).get('awsEcrContainerImage', {}).get('imageDigest', 'N/A')
                image_tags = ', '.join(resource.get('details', {}).get('awsEcrContainerImage', {}).get('imageTags', []))
                pushed_at = resource.get('details', {}).get('awsEcrContainerImage', {}).get('pushedAt', 'N/A')
                architecture = resource.get('details', {}).get('awsEcrContainerImage', {}).get('architecture', 'N/A')
                platform = resource.get('details', {}).get('awsEcrContainerImage', {}).get('platform', 'N/A')

                # Construir corpo do email para ECR
                email_subject = f"Alerta de Segurança - EMPRESA XPTO - {repository_name} - {title}"
                email_body = build_ecr_email_body(repository_name, title, description, image_digest, image_tags, pushed_at, architecture, platform, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id)
                send_email(email_subject, email_body)

def get_ec2_instance_name(instance_id):
    # Função para obter o nome da instância EC2 a partir do ID da instância
    instance_name = "N/A"
    if instance_id != "N/A":
        ec2_response = ec2_client.describe_instances(InstanceIds=[instance_id])
        tags = ec2_response['Reservations'][0]['Instances'][0].get('Tags', [])
        for tag in tags:
            if tag['Key'] == 'Name':
                instance_name = tag['Value']
                break
    return instance_name

def build_ec2_email_body(instance_name, title, description, instance_id, instance_profile, image_id, ipv4_addresses, platform, instance_type, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id):
    # Função para construir o corpo do email para eventos de EC2
    email_body = f"""
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Alerta de Segurança - EMPRESA XPTO PCI-DSS</title>
    <style>
        body {{
            font-family: Arial, sans-serif;
            line-height: 1.6;
            margin: 20px;
            background-color: #f5f5f5;
        }}
        h2 {{
            background-color: #333;
            color: #fff;
            padding: 10px;
            border-radius: 5px 5px 0 0;
            margin-top: 0;
        }}
        p {{
            margin-bottom: 20px;
            color: #555;
            padding: 0 10px;
        }}
        table {{
            width: 100%;
            border-collapse: collapse;
            border: 1px solid #ddd;
            border-radius: 5px;
            margin-top: 20px;
        }}
        th, td {{
            padding: 10px;
            text-align: left;
            border-bottom: 1px solid #ddd;
        }}
        th {{
            background-color: #f2f2f2;
            color: #333;
            font-weight: bold;
        }}
        tr:nth-child(even) {{
            background-color: #f9f9f9;
        }}
        td:first-child, th:first-child {{
            width: 30%;
            min-width: 120px;
            font-weight: bold;
        }}
    </style>
</head>
<body>
    <h2>Alerta de Segurança - EMPRESA XPTO PCI-DSS</h2>
    <p>Recebemos uma nova notificação de vulnerabilidade no AWS Inspector:</p>
    <table>
        <tr>
            <th colspan="2">Detalhes da Vulnerabilidade</th>
        </tr>
        <tr>
            <td><b>Título</b></td>
            <td>{title}</td>
        </tr>
        <tr>
            <td><b>Descrição</b></td>
            <td>{description}</td>
        </tr>
        <tr>
            <td><b>ID da Vulnerabilidade</b></td>
            <td>{vulnerability_id}</td>
        </tr>
        <tr>
            <td><b>Severidade</b></td>
            <td>{severity}</td>
        </tr>
        <tr>
            <td><b>Status</b></td>
            <td>{status}</td>
        </tr>
        <tr>
            <td><b>Encontrado em</b></td>
            <td>{first_observed}</td>
        </tr>
        <tr>
            <td><b>Última Observação</b></td>
            <td>{last_observed}</td>
        </tr>
        <tr>
            <td><b>Atualizado em</b></td>
            <td>{updated_at}</td>
        </tr>
        <tr>
            <th colspan="2">Detalhes da Instância EC2</th>
        </tr>
        <tr>
            <td><b>ID da Instância</b></td>
            <td>{instance_id}</td>
        </tr>
        <tr>
            <td><b>Nome da Instância</b></td>
            <td>{instance_name}</td>
        </tr>
        <tr>
            <td><b>Perfil IAM</b></td>
            <td>{instance_profile}</td>
        </tr>
        <tr>
            <td><b>ID da Imagem</b></td>
            <td>{image_id}</td>
        </tr>
        <tr>
            <td><b>Endereços IPv4</b></td>
            <td>{ipv4_addresses}</td>
        </tr>
        <tr>
            <td><b>Plataforma</b></td>
            <td>{platform}</td>
        </tr>
        <tr>
            <td><b>Tipo da Instância</b></td>
            <td>{instance_type}</td>
        </tr>
    </table>
    <p>Para mais informações, acesse o painel do AWS Inspector.</p>
</body>
</html>
"""
    return email_body

def build_ecr_email_body(repository_name, title, description, image_digest, image_tags, pushed_at, architecture, platform, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id):
    # Função para construir o corpo do email para eventos de ECR
    email_body = f"""
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Alerta de Segurança - EMPRESA XPTO PCI-DSS</title>
    <style>
        body {{
            font-family: Arial, sans-serif;
            line-height: 1.6;
            margin: 20px;
            background-color: #f5f5f5;
        }}
        h2 {{
            background-color: #333;
            color: #fff;
            padding: 10px;
            border-radius: 5px 5px 0 0;
            margin-top: 0;
        }}
        p {{
            margin-bottom: 20px;
            color: #555;
            padding: 0 10px;
        }}
        table {{
            width: 100%;
            border-collapse: collapse;
            border: 1px solid #ddd;
            border-radius: 5px;
            margin-top: 20px;
        }}
        th, td {{
            padding: 10px;
            text-align: left;
            border-bottom: 1px solid #ddd;
        }}
        th {{
            background-color: #f2f2f2;
            color: #333;
            font-weight: bold;
        }}
        tr:nth-child(even) {{
            background-color: #f9f9f9;
        }}
        td:first-child, th:first-child {{
            width: 30%;
            min-width: 120px;
            font-weight: bold;
        }}
    </style>
</head>
<body>
    <h2>Alerta de Segurança - EMPRESA XPTO PCI-DSS</h2>
    <p>Recebemos uma nova notificação de vulnerabilidade no AWS Inspector:</p>
    <table>
        <tr>
            <th colspan="2">Detalhes da Vulnerabilidade</th>
        </tr>
        <tr>
            <td><b>Título</b></td>
            <td>{title}</td>
        </tr>
        <tr>
            <td><b>Descrição</b></td>
            <td>{description}</td>
        </tr>
        <tr>
            <td><b>ID da Vulnerabilidade</b></td>
            <td>{vulnerability_id}</td>
        </tr>
        <tr>
            <td><b>Severidade</b></td>
            <td>{severity}</td>
        </tr>
        <tr>
            <td><b>Status</b></td>
            <td>{status}</td>
        </tr>
        <tr>
            <td><b>Encontrado em</b></td>
            <td>{first_observed}</td>
        </tr>
        <tr>
            <td><b>Última Observação</b></td>
            <td>{last_observed}</td>
        </tr>
        <tr>
            <td><b>Atualizado em</b></td>
            <td>{updated_at}</td>
        </tr>
        <tr>
            <th colspan="2">Detalhes da Imagem no ECR</th>
        </tr>
        <tr>
            <td><b>Nome do Repositório</b></td>
            <td>{repository_name}</td>
        </tr>
        <tr>
            <td><b>Digest da Imagem</b></td>
            <td>{image_digest}</td>
        </tr>
        <tr>
            <td><b>Tags da Imagem</b></td>
            <td>{image_tags}</td>
        </tr>
        <tr>
            <td><b>Arquitetura</b></td>
            <td>{architecture}</td>
        </tr>
        <tr>
            <td><b>Plataforma</b></td>
            <td>{platform}</td>
        </tr>
        <tr>
            <td><b>Enviado em</b></td>
            <td>{pushed_at}</td>
        </tr>
    </table>
    <p>Para mais informações, acesse o painel do AWS Inspector.</p>
</body>
</html>
"""
    return email_body

Teste de eventos:

Um teste para ser feito para EC2:

{
  "Records": [
    {
      "EventSource": "aws:sns",
      "EventVersion": "1.0",
      "EventSubscriptionArn": "arn:aws:sns:sa-east-1:530929948444:AWS-CVE-Inspector:d07cd6d8-2f8d-40c9-af6a-ecc4266e0e70",
      "Sns": {
        "Type": "Notification",
        "MessageId": "175a2902-7430-5515-bc29-7613ec172f9f",
        "TopicArn": "arn:aws:sns:sa-east-1:530929948444:AWS-CVE-Inspector",
        "Subject": null,
        "Message": "{\"version\":\"0\",\"id\":\"e7b5cb0b-b7b1-6390-fdcf-4ba7c5cf572d\",\"detail-type\":\"Inspector2 Finding\",\"source\":\"aws.inspector2\",\"account\":\"530929948444\",\"time\":\"2024-07-17T09:58:46Z\",\"region\":\"sa-east-1\",\"resources\":[\"i-09cc55700f9369d04\"],\"detail\":{\"awsAccountId\":\"530929948444\",\"description\":\"In the Linux kernel, the following vulnerability has been resolved: usb: udc: remove warning when queue disabled ep It is possible trigger below warning message from mass storage function, WARNING: CPU: 6 PID: 3839 at drivers/usb/gadget/udc/core.c:294 usb_ep_queue+0x7c/0x104 pc : usb_ep_queue+0x7c/0x104 lr : fsg_main_thread+0x494/0x1b3c Root cause is mass storage function try to queue request from main thread, but other thread may already disable ep when function disable. As there is no function failure in the driver, in order to avoid effort to fix warning, change WARN_ON_ONCE() in usb_ep_queue() to pr_debug().\",\"epss\":{\"score\":4.4E-4},\"exploitAvailable\":\"NO\",\"findingArn\":\"arn:aws:inspector2:sa-east-1:530929948444:finding/7c4806a9e2c4b7230d865d1c96d20b11\",\"firstObservedAt\":\"Tue Jul 16 21:45:59.629 UTC 2024\",\"fixAvailable\":\"YES\",\"lastObservedAt\":\"Tue Jul 16 21:45:59.629 UTC 2024\",\"packageVulnerabilityDetails\":{\"cvss\":[],\"referenceUrls\":[\"https://git.kernel.org/linus/2a587a035214fa1b5ef598aea0b81848c5b72e5e(6.9-rc2)\",\"https://ubuntu.com/security/notices/USN-6817-3\",\"https://git.kernel.org/stable/c/df5cbb908f1687e8ab97e222a16b7890d5501acf\",\"https://git.kernel.org/stable/c/99731076722eb7ed26b0c87c879da7bb71d24290\",\"https://git.kernel.org/stable/c/2b002c308e184feeaeb72987bca3f1b11e5f70b8\",\"https://git.kernel.org/stable/c/68d951880d0c52c7f13dcefb5501b69b8605ce8c\",\"https://ubuntu.com/security/notices/USN-6878-1\",\"https://git.kernel.org/stable/c/30511676eb54d480d014352bf784f02577a10252\",\"https://ubuntu.com/security/notices/USN-6816-1\",\"https://ubuntu.com/security/notices/USN-6817-2\",\"https://ubuntu.com/security/notices/USN-6817-1\",\"https://www.cve.org/CVERecord?id=CVE-2024-35822\",\"https://ubuntu.com/security/notices/USN-6896-1\",\"https://ubuntu.com/security/notices/USN-6898-1\",\"https://git.kernel.org/stable/c/3e944ddc17c042945d983e006df7860687a8849a\",\"https://git.kernel.org/stable/c/f74c5e0b54b02706d9a862ac6cddade30ac86bcf\",\"https://git.kernel.org/stable/c/2a587a035214fa1b5ef598aea0b81848c5b72e5e\",\"https://git.kernel.org/stable/c/36177c2595df12225b95ce74eb1ac77b43d5a58c\"],\"relatedVulnerabilities\":[\"USN-6816-1\",\"USN-6817-1\",\"USN-6817-2\",\"USN-6817-3\",\"USN-6896-1\",\"USN-6898-1\",\"USN-6878-1\"],\"source\":\"UBUNTU_CVE\",\"sourceUrl\":\"https://people.canonical.com/~ubuntu-security/cve/2024/CVE-2024-35822.html\",\"vendorCreatedAt\":\"Fri May 17 14:15:00.000 UTC 2024\",\"vendorSeverity\":\"medium\",\"vulnerabilityId\":\"CVE-2024-35822\",\"vulnerablePackages\":[{\"arch\":\"X86_64\",\"epoch\":0,\"fixedInVersion\":\"0:5.15.0-116.126\",\"name\":\"linux-libc-dev\",\"packageManager\":\"OS\",\"release\":\"113.123\",\"remediation\":\"apt-get update && apt-get upgrade\",\"version\":\"5.15.0\"}]},\"remediation\":{\"recommendation\":{\"text\":\"None Provided\"}},\"resources\":[{\"details\":{\"awsEc2Instance\":{\"iamInstanceProfileArn\":\"arn:aws:iam::530929948444:instance-profile/ScoutSuite\",\"imageId\":\"ami-0228d19e5bf7dc391\",\"ipV4Addresses\":[\"172.30.0.243\"],\"ipV6Addresses\":[],\"keyName\":\"b23_lnx_sec\",\"launchedAt\":\"Tue Oct 03 03:48:54.000 UTC 2023\",\"platform\":\"UBUNTU_22_04\",\"subnetId\":\"subnet-0cf6115b2cf95ddf8\",\"type\":\"c6a.xlarge\",\"vpcId\":\"vpc-00a09194848c6e5d6\"}},\"id\":\"i-09cc55700f9369d04\",\"partition\":\"aws\",\"region\":\"sa-east-1\",\"tags\":{\"BackupEC2\":\"true\",\"Name\":\"SRV-LNX-SEC\"},\"type\":\"AWS_EC2_INSTANCE\"}],\"severity\":\"MEDIUM\",\"status\":\"CLOSED\",\"title\":\"CVE-2024-35822 - linux-libc-dev\",\"type\":\"PACKAGE_VULNERABILITY\",\"updatedAt\":\"Wed Jul 17 09:58:46.559 UTC 2024\"}}",
        "Timestamp": "2024-07-17T09:59:03.737Z",
        "SignatureVersion": "1",
        "Signature": "nVpeMS7rnD1WUTmp04BwMC64Dp1Db9WagxLI+Lzlray1YTnpEtgezAoguYJY4DnPrTsouX67vq7plVEnWj5oxeTDR+GFlSCGDlzM/pQf5AO8haAuWuFWatTYudcwdma9cNnSMzmVyQ8Kqn4tJOudvPaIneuL20uxstvdLYVBb/9TznCBY2N+YBwv4BLGZEcqnY35Vf6TeDcSZInSk90z8f/9tXUdFtgHo7WuMzWAX6Eoen70XE3e1SLwE6gSTSa+mSFzCfD8Tj2n+SXQB9wE/ZTLR7UBEFmdjkvmJ2WgE810JUKFRzFFH7cWLp3gyRcXhXH5G1bTsFmc1R4Jo/ZAaQ==",
        "SigningCertUrl": "https://sns.sa-east-1.amazonaws.com/SimpleNotificationService-60eadc530605d63b8e62a523676ef735.pem",
        "UnsubscribeUrl": "https://sns.sa-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:sa-east-1:530929948444:AWS-CVE-Inspector:d07cd6d8-2f8d-40c9-af6a-ecc4266e0e70",
        "MessageAttributes": {}
      }
    }
  ]
}

Um teste para ser feito para ECR:

{
  "Records": [
    {
      "Sns": {
        "Message": "{\"detail\":{\"title\":\"High Vulnerability in ECR Image\",\"description\":\"A high severity vulnerability was detected in the container image.\",\"severity\":\"HIGH\",\"status\":\"ACTIVE\",\"findingArn\":\"arn:aws:inspector:us-east-1:123456789012:finding/finding-id\",\"firstObservedAt\":\"2024-07-16T10:00:00Z\",\"lastObservedAt\":\"2024-07-16T10:00:00Z\",\"updatedAt\":\"2024-07-16T10:00:00Z\",\"packageVulnerabilityDetails\":{\"vulnerabilityId\":\"CVE-2024-1234\"},\"resources\":[{\"type\":\"AWS_ECR_CONTAINER_IMAGE\",\"id\":\"arn:aws:ecr:us-east-1:123456789012:repository/my-repository\",\"details\":{\"awsEcrContainerImage\":{\"repositoryName\":\"my-repository\",\"imageDigest\":\"sha256:example1234\",\"imageTags\":[\"latest\"],\"pushedAt\":\"2024-07-15T10:00:00Z\",\"architecture\":\"amd64\",\"platform\":\"linux\"}}}]}}"
      }
    }
  ]
}

Notificações:

Exemplo de email fake EC2 enviado para a caixa de email

Exemplo de email fake ECR enviado para a caixa de email

Explicação do Código:

A função lambda_handler é o ponto de entrada da Lambda, que recebe eventos do SNS.
Os detalhes da vulnerabilidade são extraídos da mensagem JSON recebida.
Detalhes específicos da instância EC2 ou ECR são recuperados usando o cliente EC2 ou ECR.
Um email é construído em HTML para fornecer informações detalhadas sobre a vulnerabilidade e a instância.
O email é enviado usando o cliente SES da AWS.

Configure IOT Fake - Python MQQT - Test IoTCore

Railander Marques — Tue, 16 Jul 2024 12:52:07 +0000

Configure IOT Fake - Python MQQT - Test IoTCore

1. Configurar o IoT Core no AWS

Criar uma "Thing" no IoT Core:

No console do AWS IoT Core, vá para "Manage" e depois "Things".
Clique em "Create things" e crie uma "Thing".

Criar Certificados:

Após criar a "Thing", crie um certificado para ela.
Baixe os arquivos de certificado e chave privada.
Anexe uma política ao certificado que permita operações de publicação.

2. Criar o Script Python para Simular o Dispositivo

Instale a biblioteca paho-mqtt:

pip install paho-mqtt

Crie um script Python para simular o envio de dados de geolocalização:

import paho.mqtt.client as mqtt
import ssl
import json
import time
import random

# Configurações AWS IoT
client_id = "geolocation_device"
endpoint = "<seu-endpoint-iot>.iot.<sua-regiao>.amazonaws.com"
root_ca = "/path/to/AmazonRootCA1.pem"
certificate = "/path/to/device-certificate.pem.crt"
private_key = "/path/to/private.pem.key"
topic = "geolocation/topic"

# Callback para quando a conexão for estabelecida
def on_connect(client, userdata, flags, rc):
    print("Conectado com o código: " + str(rc))
    client.subscribe(topic)

# Callback para quando uma mensagem for recebida
def on_message(client, userdata, msg):
    print("Mensagem recebida: " + msg.topic + " -> " + msg.payload.decode())

# Inicializa o cliente MQTT
client = mqtt.Client(client_id)
client.tls_set(root_ca, certfile=certificate, keyfile=private_key, tls_version=ssl.PROTOCOL_TLSv1_2)
client.on_connect = on_connect
client.on_message = on_message

# Conecta ao AWS IoT Core
client.connect(endpoint, 8883, 60)

# Função para simular dados de geolocalização
def simulate_geolocation_data():
    data = {
        'latitude': round(random.uniform(-90.0, 90.0), 6),
        'longitude': round(random.uniform(-180.0, 180.0), 6),
        'timestamp': int(time.time())
    }
    return data

# Publica dados de geolocalização em intervalos regulares
while True:
    geolocation_data = simulate_geolocation_data()
    client.publish(topic, json.dumps(geolocation_data))
    print(f"Publicado: {geolocation_data}")
    time.sleep(5)  # Espera 5 segundos antes de enviar novos dados

# Mantém a conexão e espera por mensagens
client.loop_forever()

3. Configurar uma Instância EC2

Criar e Configurar a Instância EC2:

Lançar uma instância EC2:
- No console do EC2, escolha "Launch Instance".
- Selecione uma AMI (Amazon Machine Image), como Amazon Linux 2.
- Escolha o tipo de instância (t2.micro é suficiente para testes).
- Configure as opções da instância e adicione armazenamento, se necessário.
- Configure um security group para permitir acesso SSH (porta 22) e saída (outbound) para todos os destinos (por padrão, todas as saídas são permitidas).
Conectar à Instância EC2:
- Conecte-se à sua instância EC2 usando SSH.

   ssh -i "seu-par-de-chaves.pem" ec2-user@seu-endereço-ec2

Instalar Python e Bibliotecas Necessárias:
- Atualize os pacotes e instale o Python se não estiver instalado.

   sudo yum update -y
   sudo yum install -y python3
   sudo pip3 install paho-mqtt

Transferir o Script para a Instância EC2:
- Transfira o script Python e os arquivos de certificado para a instância EC2 usando SCP (Secure Copy).

   scp -i "seu-par-de-chaves.pem" /caminho/para/o/script.py ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/AmazonRootCA1.pem ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/device-certificate.pem.crt ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/private.pem.key ec2-user@seu-endereço-ec2:/home/ec2-user/

Executar o Script na Instância EC2:
- Navegue até o diretório onde você transferiu os arquivos e execute o script Python.

   cd /home/ec2-user/
   python3 script.py

Verificação

No console do AWS IoT Core: Verifique se os dados estão sendo publicados no tópico correto.
Logs no EC2: Verifique a saída no terminal para confirmar que os dados estão sendo enviados corretamente.

Seguindo esses passos, você conseguirá simular um dispositivo IoT que envia dados de geolocalização para o AWS IoT Core a partir de uma instância EC2. Isso permite que você teste e valide o fluxo de dados em um ambiente realista.

Configuração ProFTPD - Ubuntu 18.04 / 20.04 / 22.04

Railander Marques — Tue, 30 Jan 2024 19:06:55 +0000

Apresentamos um guia fundamental para a criação de um servidor FTP personalizado utilizando o ProFTPD. Este tutorial abrange elementos essenciais que são cruciais para a configuração eficaz do servidor, incluindo:

Definição do nome do servidor FTP,
Configuração de portas,
Especificação da faixa de portas para o modo passivo,
Ajustes relacionados a logs.

Ao seguir este tutorial, você será capaz de estabelecer um ambiente de servidor FTP personalizando as configurações conforme suas necessidades específicas.

Além disso, foi disponibilizado um script Bash para a criação de usuários FTP no ProFTPD, simplificando o processo e permitindo a rápida configuração de novos usuários com seus respectivos diretórios FTP.

Ao final do tutorial, incluímos um segmento de resolução de problemas (Troubleshooting) que aborda uma possível questão relacionada ao erro 550. O tutorial também fornece comandos úteis para corrigir permissões de diretórios específicos no servidor FTP.

Link do Vídeo: https://www.youtube.com/watch?v=3cUpCeQ5lBQ

Parte 1: Instalação do ProFTPd:

apt update
apt install proftpd -y

Parte 2: Configuração personalizada do ProFTPD:

cp /etc/proftpd/proftpd.conf /etc/proftpd/proftpd.conf.bkp
> /etc/proftpd/proftpd.conf
vim /etc/proftpd/proftpd.conf

Cole o script abaixo:

# Nome do servidor FTP
ServerName              "Seu Nome de Servidor FTP"
# Tipo de servidor (standalone = independente)
ServerType              standalone
# Define como servidor padrão
DefaultServer           on

# Porta 21 é a porta FTP padrão.
Port                    21

# Umask 022 é uma boa umask padrão para evitar que novos diretórios e arquivos
# sejam graváveis por grupo e mundo.
Umask                   022

# Para prevenir ataques DoS, defina o número máximo de processos filhos
# para 30. Se precisar permitir mais de 30 conexões simultâneas
# de uma vez, simplesmente aumente esse valor.
MaxInstances            30

# Define o usuário e grupo sob o qual o servidor será executado.
User                    nobody
Group                   nogroup

# Configuração de Faixa de Portas para Modo Passivo
PassivePorts 49152 65534

# Configurações de Log
ExtendedLog /var/log/proftpd/access.log WRITE,READ default
DisplayLogin "Bem-vindo ao meu servidor FTP"

# Desativação do Acesso Anônimo
<Anonymous ~ftp>
  DenyAll
</Anonymous>

# Configurações de usuários
<Global>
    RequireValidShell off
    DefaultRoot /var/www/html
</Global>

Script para criação de Usuários FTP:

#!/bin/bash

# Script para criar usuário FTP no ProFTPD

echo "########################################################"
read -p "Digite o username ser criado: " username
echo "########################################################"
read -p "Digite a senha do usuário: " password
echo "########################################################"

# Configurações
ftp_root="/var/www/html"
user_group="www-data"
proftpd_conf_dir="/etc/proftpd/conf.d"
user_conf_file="$proftpd_conf_dir/$username.conf"

# Criação do usuário sem pasta home
useradd -M -N -s /bin/false -g "$user_group" "$username"
echo -e "$password\n$password" | passwd "$username" > /dev/null  # Redireciona a saída para /dev/null para ocultar a saída padrão

# Criação do arquivo de configuração específico para o usuário
echo -e "\n<Directory $ftp_root>\n  UploadOnCreate on\n  ForceGroup $user_group\n  ForceUser $username\n</Directory>" > "$user_conf_file"

# Reinicia o ProFTPD
systemctl restart proftpd

# Exibe uma mensagem formatada
echo -e "\n#################################################"
echo -e "## Usuário FTP criado com sucesso:"
echo -e "## Usuário: $username"
echo -e "## Diretório FTP: $ftp_root"
echo -e "## Grupo: $user_group"

Troubleshooting:
Obs.: Utilizei o grupo www-data simulando um servidor web com apache2.

Caso receba um erro 550, pode ser a permissão da pasta, você pode corrigir executando o comando:

sudo chmod -R 0775 /var/www/

Este comando altera as permissões recursivamente para o diretório /var/www/ e todos os seus subdiretórios e arquivos. Cuidado ao executar este comando, procure saber se tem algum arquivo sensível dentro desta pasta antes de executar.

sudo chown -R www-data:www-data /var/www/html

Define o grupo (www-data) para todos os arquivos e subdiretórios recursivamente dentro de /var/www/html/uploads.

sudo chmod -R g+s /var/www/html

Define o bit setgid nos diretórios e subdiretórios, garantindo que novos arquivos criados dentro deles herdem o grupo do diretório pai (www-data).

Monitoramento de Eventos no AWS SES com Filtros no CloudWatch Logs

Railander Marques — Fri, 26 Jan 2024 11:31:35 +0000

Introdução:

No cenário da gestão de e-mails, a eficiência na monitorização e análise de eventos críticos é fundamental. Para aprimorar esse processo no AWS SES, foram desenvolvidos filtros específicos, utilizando registros do CloudWatch Logs em /aws/ses/monitoring (nome usado no vídeo deste tutorial).

Esses filtros são projetados para fornecer insights técnicos em três áreas-chave: entregas bem-sucedidas, reclamações de destinatários e bounces. Cada filtro extrai dados essenciais, como timestamp, tipo de notificação, remetente, destinatários e assunto do e-mail. Este enfoque técnico facilita a compreensão e administração direta do serviço SES.

A seguir, detalharemos cada filtro, destacando sua finalidade específica e as métricas técnicas fornecidas. Esses filtros não apenas simplificam a interpretação de eventos críticos, mas também capacitam administradores com controle técnico preciso no ambiente AWS SES.

Diagrama - Como funciona a rastreabilidade?

Link da Implementação: https://youtu.be/G5UDOBfEBZg

Filtro de Entrega:
Este filtro visa identificar eventos relacionados à entrega de e-mails.
Campos selecionados para exibição: timestamp, tipo de notificação, remetente (mail.source), destinatário principal (Recepient1), destinatário secundário (Recepient2) e assunto do e-mail (Subject).
A filtragem é realizada para selecionar apenas eventos do tipo "Delivery".
Os resultados são ordenados de forma descendente com base no timestamp.

fields @timestamp, notificationType, mail.source as Sender, mail.destination.0 as Recepient1, mail.destination.1 as Recepient2, mail.commonHeaders.subject as Subject
| filter notificationType = "Delivery"
| sort @timestamp desc

Filtro de Reclamação (Complaint):
Este filtro tem como objetivo identificar eventos relacionados a reclamações de e-mails por parte dos destinatários.
Campos selecionados para exibição: timestamp, tipo de notificação, remetente (mail.source), destinatário principal (Recepient1), destinatário secundário (Recepient2) e assunto do e-mail (Subject).
A filtragem é realizada para selecionar apenas eventos do tipo "Complaint".
Os resultados são ordenados de forma descendente com base no timestamp.

fields @timestamp, notificationType, mail.source as Sender, mail.destination.0 as Recepient1, mail.destination.1 as Recepient2, mail.commonHeaders.subject as Subject
| filter notificationType = "Complaint"
| sort @timestamp desc

Filtro de Bounce:
Este filtro visa identificar eventos relacionados a e-mails que não foram entregues corretamente e foram devolvidos (bounced).
Campos selecionados para exibição: timestamp, tipo de notificação, remetente (mail.source), destinatário principal (Recepient1), destinatário secundário (Recepient2) e assunto do e-mail (Subject).
A filtragem é realizada para selecionar apenas eventos do tipo "Bounce".
Os resultados são ordenados de forma descendente com base no timestamp.

fields @timestamp, notificationType, mail.source as Sender, mail.destination.0 as Recepient1, mail.destination.1 as Recepient2, mail.commonHeaders.subject as Subject
| filter notificationType = "Bounce"
| sort @timestamp desc

Filtro mais Abrangente:

fields @timestamp,
       notificationType,
       mail.timestamp as mail_timestamp,
       bounce.bouncedRecipients.0.status as code_status,
       mail.source as Remetente,
       mail.destination.0 as Destinatario_1,
       mail.destination.1 as Destinatario_2,
       mail.destination.2 as Destinatario_3,
       mail.commonHeaders.subject as Assunto,
       mail.commonHeaders.date as Data,
       bounce.bounceType as bounce_type,
       bounce.bounceSubType as bounce_sub_type,
       complaint.complaintFeedbackType as complaint_feedback,
       complaint.complaintSubType as complaint_sub_type,
       delivery.processingTimeMillis as delivery_time,
       delivery.smtpResponse as smtp_response,
       coalesce(bounce.bouncedRecipients[0].emailAddress, '') as bounced_email,
       coalesce(complaint.complainedRecipients[0].emailAddress, '') as complained_email,
       mail.messageId
| filter notificationType in ['Bounce', 'Complaint', 'Delivery']
| sort @timestamp desc

Extra:
Meta Redirect usado no Vídeo:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="refresh" content="0;url=https://cloudwatch.amazonaws.com/dashboard.html?dashboard=ses-monitoring&context=XXXXXXXXX---TROQUE-SUA-URL---XXXXXXXXX">
    <meta name="robots" content="noindex, nofollow">
    <title></title>
</head>
<body>
</body>
</html>

Screenshots:

Configurando autenticação no RDS SQL Server com usuários do AD em EC2

Railander Marques — Thu, 18 Jan 2024 13:09:55 +0000

Este tutorial aborda a configuração da autenticação do SQL Server no Amazon RDS usando usuários do Active Directory (AD) associados a instâncias EC2. A autenticação baseada em AD proporciona uma camada adicional de segurança e gerenciamento de identidade para seus bancos de dados SQL Server.

Pré-requisitos:

OS: Windows Server 2012/2016/2019
Possuir um RDS SQL Server
Possuir um AD em EC2
Executar 3 etapas abaixo deste link: https://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/USER_SQLServer_SelfManagedActiveDirectory.html#USER_SQLServer_SelfManagedActiveDirectory.SettingUp
- Executar Etapa 1: Criar uma unidade organizacional no AD
- Executar Etapa 2: Criar um usuário de domínio em seu AD
- Executar Etapa 3: Delegar controle ao usuário de AD

Passo 1: Configurar ambiente

Liberar as seguintes portas na entrada do security group da EC2 com AD com destino ao SG do RDS:
- TCP and UDP Port 53 (DNS)
- TCP and UDP Port 88 (Kerberos)
- TCP and UDP Port 135 (Microsoft Remote Procedure Call)
- TCP and UDP Port 389 (Lightweight Directory Access Protocol)
- TCP and UDP Port 445 (Microsoft Directory Services)
- TCP and UDP Port 464 (Alteração de senhas no sistema Kerberos)
- TCP Port 636 (Versão segura do LDAP que utiliza criptografia SSL)
- TCP Port 3268 (Consultas de catálogo global no LDAP)
- TCP Port 3269 (Consultas seguras de catálogo global no LDAP usando SSL)
- TCP Port 9389 (ADWS - Serviço da web para comunicação com o Active Directory)
- TCP Ports 49152-65535 (Dynamic and-or Private Ports)
- UDP Port 123 (NTP - Network Time Protocol)
- UDP Port 138 (Serviço de mensagens datagrama em redes NetBIOS)

Exemplo:

Passo 2: Teste no Active Directory (AD)

Para que a VPC responda ao domínio do AD no IP privado, configure um DHCP Option sets e anexe-o à sua VPC. Para a configuração, insira primeiro o IP do AD, em seguida, AmazonProvidedDNS. Veja o exemplo abaixo:

Vá em VPC's ➜ Marque sua VPC ➜ Edit VPC Settings.

Altere o DHCP option set para o recém configurado:
- Em DNS settings, deixe marcado o Enable DNS resolution e Enable DNS hostnames e clique em Save.

Agora em Systems Manager ➜ Run Command ➜ Botão Run a Command em laranja ➜ Escolha o Template ➜ AWS-RunPowerShellScript ➜ e realize o teste com o seguinte comando:

  nltest /dsgetdc:dominio.intra /force

Selecione o Target e clique em View output para ver o resultado:

Passo 3: Configurar KMS e Secrets

Configurar KMS e Secrets conforme o tutorial: Amazon RDS - Configuração do SQL Server com Active Directory
- Executar Etapa 4: Criar uma chave do AWS KMS.
- Executar Etapa 5: Criar um segredo da AWS

Passo 4: Configurar autenticação no SQL Server e AD

Selecione o banco de dados SQL Server ➜ Modify.
Em Microsoft SQL Server Windows Authentication, habilite a checkbox Enable Microsoft SQL Server Windows authentication, escolha Self-managed Microsoft Active Directory e preencha conforme o exemplo:

Observações:
- Neste caso, a Unidade Organizacional (OU) criada para autenticação no RDS se chama 'AUTH', o nome do domínio utilizado para este tutorial foi 'dominio.intra', e repeti os dois IPs privados do AD.
- Neste caso, como o 'dominio.intra' contém um '.', precisamos adicioná-lo na linguagem Distinguished Name (DN), conforme o exemplo acima. Exemplos de DN:

OU=TI,DC=departamento,DC=empresa,DC=com   # Domínio departamento.empresa.com
OU=Vendas,DC=empresa,DC=com   # Domínio empresa.com

Passo 5: Configurar autenticação no SQL Server e AD

Voltar ao AD e criar um grupo global de segurança, chamado "admindbas" (ou outro de preferência) DENTRO da delegação criada. Veja o exemplo abaixo:

Neste grupo global criado, adicione como Member Of o grupo RDS Remote Access Servers e clique em OK.

Observação: Isso permitirá que todos os os usuários que tem a permissão do grupo RDS Remote Access Servers, consigam fazer login no RDS SQL Server com Windows Authentication.

Passo 6: Habilitar o login no RDS SQL Server para os usuários do grupo 'admindbas'.

Efetuar login no SQL Server com o usuário administrador do RDS para executar os seguintes comandos SQL:

Observações:
- Em [DOMINIO\admindbas], utilizar o Distinguished Name (DN), inserindo apenas o primeiro nome em maiúsculo (ex.: DOMINIO de dominio.intra) e o estou indicando o grupo global 'admindbas' para ter acesso ao banco de dados.
- Você também pode criar logins para usuários específicos, no lugar de informar o grupo "admindbas", você informa o usuário que deseja [DOMINIO\nome.sobrenome].

  USE [master]
  GO
  CREATE LOGIN [DOMINIO\admindbas] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
  GO

  USE [master]
  GO
  GRANT ALTER ANY CONNECTION TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT ALTER ANY LINKED SERVER TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT ALTER ANY LOGIN TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT ALTER SERVER STATE TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT ALTER TRACE TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT CREATE ANY DATABASE TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT VIEW ANY DATABASE TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT VIEW ANY DEFINITION TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GRANT VIEW SERVER STATE TO [DOMINIO\admindbas] WITH GRANT OPTION;
  GO

Abaixo explico a descrição de cada comando SQL acima:

-- Define que as operações a seguir serão realizadas no banco de dados 'master'
USE [master]
GO

-- Cria um login no SQL Server associado a um grupo do AD Windows
CREATE LOGIN [DOMINIO\admindbas] FROM WINDOWS WITH DEFAULT_DATABASE = [master], DEFAULT_LANGUAGE = [us_english];
GO

-- Concede permissão para alterar qualquer conexão ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT ALTER ANY CONNECTION TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para alterar qualquer servidor vinculado ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT ALTER ANY LINKED SERVER TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para alterar qualquer login ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT ALTER ANY LOGIN TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para alterar o estado do servidor ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT ALTER SERVER STATE TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para alterar traces ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT ALTER TRACE TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para criar qualquer banco de dados ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT CREATE ANY DATABASE TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para visualizar qualquer banco de dados ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT VIEW ANY DATABASE TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para visualizar qualquer definição ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT VIEW ANY DEFINITION TO [DOMINIO\admindbas] WITH GRANT OPTION;
-- Concede permissão para visualizar o estado do servidor ao grupo [DOMINIO\admindbas] com a opção de conceder essa permissão a outros usuários
GRANT VIEW SERVER STATE TO [DOMINIO\admindbas] WITH GRANT OPTION;
GO

Passo 7: Testar autenticação no SQL Server

Logue no Windows com seu usuário do AD.
Logue no SSMS utilizando o Windows Autentication.
Lembre-se que para Logar no SQL Server o usuário do AD precisa ser membro do RDS Remote Access Servers.

Ligar e Desligar instâncias EC2 via Email

Railander Marques — Tue, 16 Jan 2024 15:51:53 +0000

Este tutorial oferece uma solução para ligar ou desligar uma instância EC2 na AWS através do envio de emails para um endereço específico. O processo é desencadeado por meio de eventos do Amazon S3, onde os emails são armazenados. O fluxo geral é explicado conforme os seguintes passos:

Configuração do SES: Criação de um subdomínio no Amazon Simple Email Service (SES) para receber os emails. Isso é necessário para garantir a correta leitura dos cabeçalhos dos emails enviados para o domínio principal.
Configuração da Regra no SES: Definição de uma regra no SES para direcionar emails específicos para um bucket no Amazon S3.
Configuração da Lambda: Implementação de uma função Lambda em Python 3.10 para processar os eventos do S3. A Lambda verifica o remetente autorizado no email, executa a ação desejada (ligar ou desligar a instância EC2), e notifica o remetente sobre a conclusão da ação.
Configuração do S3: Adição de uma trigger no bucket S3 configurada no SES para acionar a Lambda quando novos emails são recebidos.

O código Python na Lambda verifica o remetente autorizado, lê o conteúdo do email, identifica a ação desejada (ligar ou desligar) e executa a operação na instância EC2 associada. O remetente é notificado sobre o status da ação via email.

O tutorial fornece observações importantes, como a necessidade de adicionar permissões adequadas na Lambda, ajustar as tags da instância desejada e verificar os emails autorizados no código. Além disso, são apresentadas dicas úteis, como a configuração de ciclos de vida no S3 e no CloudWatch Logs.

O resultado final é uma solução eficiente para controlar instâncias EC2 na AWS por meio do envio de emails autorizados, proporcionando automação e praticidade.

Explicação básica do uso:

Você envia um email para aws@sandbox.dominio.com.br com EXATAMENTE no corpo de texto os dizeres: (não importa o assunto do email, somente o corpo do email)

Ligar VM SRV_LNX_BI
Desligar VM SRV_LNX_BI

Dai a instancia vai ligar ou desligar, se seu email estiver autorizado na lambda e no SES.

Workflow Diagram:

Passo 1: Configurar um subdomínio no SES (Ex.: sandbox.dominio.com.br) com o MailFrom habilitado. Neste caso vamos usar um subdomínio no SES porque, ao enviar um email para o domínio principal, o email não é direcionado diretamente para o SES devido às configurações MX estarem associadas a outro servidor de email (Google, Microsoft, Zimbra), com essa configuração, o Amazon SES não consegue ler corretamente o cabeçalho (header) do email e, consequentemente, não consegue enviá-lo para o Amazon S3 da maneira desejada.

Passo 2: Na pagina do SES, Vá em “Email receiving” > Você vera uma regra de “INBOUND MAIL”, clique nela > Create rule > adicione um nome como no print abaixo > Next.

Passo 2.1: Em "Recipient conditions”, insira um email que você recebera as ações solicitando o desligamento ou ligamento das instâncias (ex.: aws@sandbox.dominio.com.br), e configure-o no Workmail depois, com o subdomínio validado, clique em Next.

Passo 2.2: Clique em “add new action” > “Deliver to Amazon S3 Bucket” > Adicione um bucket para armazenar os emails recebidos, para posteriormente a Lambda ler este conteúdo automaticamente, Next e depois Create Rule.

Com isso, você fará o SES publicar os emails recebidos no bucket S3.

Passo 3: Agora precisamos configurar o código na lambda e uma trigger de eventos, que ao receber algo no S3, ira filtrar o conteúdo, e recebendo as mensagens definidas para ligar ou desligar a instancia, executar as ações pre-definidas.

Para lambda, vamos configurar um runtime python 3.10, adicionar as permissões para EC2 (Para ligar e desligar as instancias) Bucket S3 (Para ler o bucket e analisar as mensagens publicadas pelo SES), CloudWatch Logs (Para logs) e SES (Para envio de notificações).

Segue o código:

import json
import boto3
import re
import email
from botocore.exceptions import NoCredentialsError

s3 = boto3.client('s3')
ec2 = boto3.client('ec2')
ses = boto3.client('ses')

authorized_senders = [
    'railander.marques@dominio.com.br',
    'email-teste@dominio.edu.br'
]

def lambda_handler(event, context):
    print(json.dumps(event))  # Imprimir o evento

################### Verificar se o evento é do S3
    if 'Records' not in event or not event['Records'][0].get('s3'):
        return {'statusCode': 400, 'body': json.dumps('Event is not from S3')}

################### Obter o nome do bucket e do arquivo do evento
    bucket = event['Records'][0]['s3']['bucket']['name']
    key = event['Records'][0]['s3']['object']['key']

################### Baixar o arquivo do S3
    try:
        s3.download_file(bucket, key, '/tmp/email')
        print('File downloaded successfully')  # Adicionado print
    except NoCredentialsError:
        return {'statusCode': 400, 'body': json.dumps('Credentials not available')}

################### Ler o conteúdo do email
    with open('/tmp/email', 'r', encoding='utf-8') as f:
        email_content = f.read()

    print(f'Email content: {email_content}')  # Adicionado print

################### Encontrar o remetente do email
    sender_match = re.search(r'From: .*<(.+)>', email_content)

################### Se o remetente for autorizado, executar a ação
    sender_email = sender_match.group(1)

    if sender_email not in authorized_senders:
################### Enviar email de notificação para o remetente não autorizado
        send_response_email([sender_email, 'infraestrutura@dominio.com.br'], sender_email, 'Requisição de ação não autorizada', f'''
O remetente {sender_email} não está autorizado para executar essa ação.

Caso você acredite que isso seja um erro ou tenha alguma dúvida, por favor entre em contato com nossa equipe de suporte.

Atenciosamente,
Equipe de Infraestrutura
''')
        return {'statusCode': 401, 'body': json.dumps('Unauthorized sender')}
    else:
################### Se o remetente for autorizado, executar a ação
        sender_email = sender_match.group(1)

################### Localizar a ação de ligar ou desligar a instância no conteúdo do email
    body_match = re.search(r'Ligar VM SRV_LNX_BI|Desligar VM SRV_LNX_BI', email_content)

    if body_match:
        body = body_match.group(0)
        if 'Ligar VM SRV_LNX_BI' in body:
            instance_id = get_instance_id()
            print(f'Starting instance {instance_id}...')
            ec2.start_instances(InstanceIds=[instance_id])
            send_response_email([sender_email, 'infraestrutura@dominio.com.br'], sender_email, 'Ação de Instância - Ligamento', f'A instância associada à tag "SRV_LNX_BI" está sendo ligada conforme sua solicitação.Remetente Original: {sender_email}Caso você tenha mais perguntas ou precise de assistência adicional, sinta-se à vontade para entrar em contato.Atenciosamente,Equipe de Infraestrutura')
        elif 'Desligar VM SRV_LNX_BI' in body:
            instance_id = get_instance_id()
            print(f'Stopping instance {instance_id}...')
            ec2.stop_instances(InstanceIds=[instance_id])
            send_response_email([sender_email, 'infraestrutura@dominio.com.br'], sender_email, 'Ação de Instância - Desligamento', f'A instância associada à tag "SRV_LNX_BI" foi desligada conforme sua solicitação.Remetente Original: {sender_email}Caso você tenha mais perguntas ou precise de assistência adicional, sinta-se à vontade para entrar em contato.Atenciosamente,Equipe de Infraestrutura')
        else:
            print('Remetente não encontrado no email.')

    return {'statusCode': 200, 'body': json.dumps('Request was successful')}

def send_response_email(to_addresses, from_address, subject, body):
    response = ses.send_email(
        Source='infraestrutura@dominio.com.br',
        Destination={
            'ToAddresses': to_addresses
        },
        Message={
            'Subject': {
                'Data': subject
            },
            'Body': {
                'Text': {
                    'Data': body
                }
            }
        }
    )

    return response

def get_instance_id():
################### Lógica para obter o ID da instância associada à tag "SRV_LNX_BI"
    response = ec2.describe_instances(
        Filters=[
            {
                'Name': 'tag:Name',
                'Values': ['SRV_LNX_BI']
            }
        ]
    )

    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            return instance['InstanceId']

Observações:

Adicionar uma trigger para o bucket configurado no SES, você consegue fazer isso dentro do painel da lambda, em "add trigger”, escolher trigger para o s3 e “All object create events”, nada mais a alterar e ok.
Tempo de execução da lambda, 3 minutos.
Não esquecer de adicionar as permissões na lambda, para ec2, cloudwatch, ses e s3.
Alterar no código a tag name da Instancia desejada.
Add o email que vai receber uma copia das ações ex.: infraestrutura@dominio.com.br. (Verifica-los no SES)
Crie um workmail com um email usando o domínio delegado que foi verificado no SES. (Ex do código: aws@sandbox.dominio.com.br) ele que irá receber as solicitações por email.
Adicionar os emails autorizados no código lambda. (Toda a descrição do código no final da pagina)
Apenas os emails que foram verificados no SES e adicionados à Lambda receberão e terão a automação funcionando.
Faça o teste.

Resultado:

Explicação:

O código é um Lambda Function que é executado quando um novo arquivo é enviado para um bucket do S3. O arquivo é um email com uma solicitação para ligar ou desligar uma instância EC2.

O código funciona da seguinte forma:

O Lambda Function recebe o evento do S3 como entrada.
O código verifica se o evento é do S3.
O código obtém o nome do bucket e do arquivo do evento.
O código baixa o arquivo do S3 para um arquivo temporário.
O código lê o conteúdo do email.
O código encontra o remetente do email.
O código verifica se o remetente é autorizado.
Se o remetente for autorizado, o código executa a ação solicitada.
O código envia um email de notificação ao remetente.
O código retorna um código de status HTTP 200.

Aqui estão alguns detalhes adicionais sobre o código:

A função get_instance_id() é usada para obter o ID da instância associada à tag "SRV_LNX_BI".
A função send_response_email() é usada para enviar um email de notificação ao remetente.

A mensagem que o usuário envia no email está contida na variável email_content. Essa variável é definida na linha abaixo:

with open('/tmp/email', 'r', encoding='utf-8') as f:
    email_content = f.read()

O código procura os remetentes autorizados na lista authorized_senders. Essa lista está definida na linha abaixo:

authorized_senders = [
    'railander.marques@dominio.com.br',
    'email-teste@dominio.edu.br'
]

Dica:

Não esquecer de configurar um ciclo de vida no S3, para os emails recebidos e tambem não esquecer de configurar um ciclo de vida no CloudWatch logs.
É possível também fazer a configuração com um domínio free do AWS Workmail.

Script de Exportação de Hosts do Zabbix para CSV

Railander Marques — Fri, 12 Jan 2024 13:07:32 +0000

Introdução:

Este script em Python se conecta à API do Zabbix, para obter informações valiosas sobre hosts e templates. Através de chamadas à API, o script realiza o login, recupera dados sobre os hosts, incluindo seus grupos e templates associados, e organiza essas informações em um arquivo CSV.

Autenticação: Utiliza as credenciais do Zabbix (usuário e senha) para autenticar-se na API.

Obtenção de Dados: Faz chamadas à API para extrair detalhes sobre hosts, incluindo seus grupos e templates associados.

Organização e Armazenamento: Estrutura os dados em um formato legível e armazena-os em um arquivo CSV.

Passo 1. Salve esse script para exportação dos dados em python:

import requests
import json
import csv

# Configurações da API do Zabbix
url = 'https://zabbix.dominio.com.br/api_jsonrpc.php'
headers = {'Content-Type': 'application/json'}

# Credenciais de autenticação
usuario = 'seu_user'
senha = 'sua_senha'

# Função para fazer uma chamada à API do Zabbix
def zabbix_api_request(method, params, auth_token=None):
    data = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'auth': auth_token,
        'id': 1
    }
    response = requests.post(url, data=json.dumps(data), headers=headers)
    result = response.json()

    if 'error' in result:
        raise Exception(f'Erro na chamada à API do Zabbix: {result["error"]["data"]}')

    return result.get('result', None)

# Função para fazer login na API do Zabbix e obter o token de acesso
def zabbix_login(usuario, senha):
    method = 'user.login'
    params = {'user': usuario, 'password': senha}
    response = zabbix_api_request(method, params)
    return response

# Função para obter informações de hosts por grupo, incluindo templates
def obter_hosts_com_templates(auth_token):
    method = 'host.get'
    params = {
        'output': ['host', 'name', 'groups'],
        'selectGroups': 'extend',
        'selectInterfaces': ['ip'],
        'selectParentTemplates': ['templateid', 'name']
    }

    response = zabbix_api_request(method, params, auth_token)

    if response is None:
        raise Exception('Nenhuma resposta válida da chamada à API para obter hosts.')

    hosts_com_templates = {}

    for host in response:
        for group in host.get('groups', []):
            grupo_nome = group.get('name', 'Sem Grupo')
            if grupo_nome not in hosts_com_templates:
                hosts_com_templates[grupo_nome] = []
            templates = [template['name'] for template in host.get('parentTemplates', [])]
            hosts_com_templates[grupo_nome].append({
                'hostname': host.get('host', ''),
                'ip': host['interfaces'][0]['ip'] if host.get('interfaces') else '',
                'templates': templates
            })

    return hosts_com_templates

# Função para escrever as informações em um arquivo CSV
def escrever_csv(info_hosts_com_templates):
    with open('info_hosts_templates.csv', mode='w', newline='') as arquivo_csv:
        writer = csv.writer(arquivo_csv)
        writer.writerow(['Grupo', 'Hostname', 'IP', 'Templates'])

        for grupo, hosts in info_hosts_com_templates.items():
            for host in hosts:
                writer.writerow([grupo, host['hostname'], host['ip'], ', '.join(host['templates'])])

# Faz login e obtém o token de autenticação
token_autenticacao = zabbix_login(usuario, senha)

# Obtém informações de hosts por grupo, incluindo templates
info_hosts_com_templates = obter_hosts_com_templates(token_autenticacao)

# Escreve as informações em um arquivo CSV
escrever_csv(info_hosts_com_templates)

Passo 2. Para funcionamento, precisaremos do python instalado e a biblioteca requests:

No linux:

# Instalar o Python3
sudo apt update
sudo apt install python3
# Instalar o pip3 (gerenciador de pacotes do Python)
sudo apt install python3-pip
# Instalar a biblioteca requests
pip3 install requests

No Windows:

Instale o Python no repo: https://www.python.org/
Certifique-se de marcar a opção "Add Python to PATH" durante a instalação.

# Atualizar o pip
python -m pip install --upgrade pip
# Instalar a biblioteca requests
pip install requests

Passo 3. Execute o script para gerar o relatório em .csv:

python3 script.py
Pronto, o arquivo gerado chamado info_hosts_templates.csv será dessa forma:

Forem: Railander Marques

Automação de Backups para SFTP Externo

Visão Geral

Arquitetura da Solução

Características Principais

Fluxo de Operação

1. Criação da Lambda

2. Configuração da Trigger do S3

3. Permissões Necessárias

EC2 Role (Alterar o nome do bucket)

Lambda Role (Alterar id da conta AWS, região e instancia)

4. Preparação da EC2 Ubuntu 24.04 e Testes

5. Estrutura de Pastas

6. Configuração do Arquivo .env

7. Como descompactar o zip atualizado

8. Teste manual e logs

9. Troubleshooting

Detalhes Técnicos da Implementação

Processo de Upload Seguro

Mecanismo de Retry

Logs e Monitoramento

Opção 2: Lambda com Conexão Direta SSH à EC2

1. Configurar SSH no EC2

2. Criar usuário sftp_user

3. Configuração de rede e segurança

4. Preparar Lambda

Resumo

Arquivos de Código

lambda_function.py (Opção 1: SSM)

lambda_function.py (Opção 2: SSH Direto)

sftp_uploader.py

logrotate_sftp_uploader

sftp-uploader.service

sftp-uploader.timer

Conclusão

Dashboard Interativo de CVE's - AWS Inspector + Lambda + S3

1. Resumo da Solução

2. Diagrama da Solução

3. Configuração do AWS KMS para o AWS Inspector

Passo a Passo

Política da Chave (Key Policy)

4. Configuração do Bucket S3 e Lambda

Configuração do Bucket S3

Configuração da Lambda

Stream Dynamo para RDS Mysql

Visão Geral

Passo 1: DynamoDB para SQS

Passo 2: SQS para RDS

1. Importações e Configurações Iniciais

2. Configuração do Cliente SQS

3. Configuração do Banco de Dados

4. Conexão ao Banco de Dados

5. Processamento de Mensagens do SQS

6. Reprocessamento de Mensagens da DLQ

7. Tentativas de Processamento com Retry

8. Função Lambda Handler

Resumo

:::

Configuração do SQS e Teste de Carga:

Exportar Voip para AWS EC2 - .vmdk ou .ova

Alarme Dynamo Throttle Events - Discord

Primeiro Passo - Configuração da Lambda

Segundo Passo - Configuração do Alarme CloudWatch

AWS Inspector - Notificação CVE - EC2 e ECR

Passos:

Implementar o Código da Função Lambda:

Teste de eventos:

Notificações:

Explicação do Código:

Configure IOT Fake - Python MQQT - Test IoTCore

Configure IOT Fake - Python MQQT - Test IoTCore

1. Configurar o IoT Core no AWS

Criar uma "Thing" no IoT Core:

Criar Certificados:

2. Criar o Script Python para Simular o Dispositivo

3. Configurar uma Instância EC2

Criar e Configurar a Instância EC2:

Verificação

Configuração ProFTPD - Ubuntu 18.04 / 20.04 / 22.04

Monitoramento de Eventos no AWS SES com Filtros no CloudWatch Logs

2. Criar usuário `sftp_user`