Projeto Serverless AWS

Analise de Sentimentos com Inteligencia Artificial

Um pipeline serverless que recebe arquivos de texto no S3, processa com Amazon Comprehend (IA) e salva os resultados no DynamoDB - tudo automatizado via AWS Lambda.

Amazon S3
AWS Lambda
Amazon Comprehend
DynamoDB

Fluxo da Arquitetura

Como os dados fluem entre os servicos AWS

Amazon S3

Usuario faz upload de um arquivo .txt no bucket S3

AWS Lambda

O S3 dispara um evento que aciona a funcao Lambda

Amazon Comprehend

A Lambda envia o texto para o Comprehend analisar o sentimento

DynamoDB

O resultado da analise e salvo no banco de dados

Bônus: Simulador (prévia no navegador)

Esta é uma simulação local (frontend) para você “sentir” o fluxo. O resultado não é o Amazon Comprehend — serve como uma prévia didática antes de configurar a AWS.

Dica: experimente usar “não” antes de palavras (ex.: “não gostei”).

Resultado simulado

POSITIVE

Positive72%
Negative0%
Neutral28%
Mixed0%

O que influenciou

Palavras que este simulador reconheceu como positivas/negativas.

Positivas

felizincrivel

Negativas

Nenhuma detectada.

Passo 1: Configurar o DynamoDB

Antes de escrever qualquer codigo, precisamos criar a tabela onde os resultados da analise serao armazenados.

1

Acesse o console do DynamoDB e clique em "Create table"

2

Defina o Table name como: AnaliseSentimentos

3

Defina a Partition key como: id (tipo String)

4

Mantenha as demais configuracoes como padrao e crie a tabela

Passo 2: Codigo da Lambda

Crie uma funcao Lambda com runtime Python 3.x e cole o codigo abaixo. O codigo utiliza a biblioteca boto3 (SDK da AWS para Python).

lambda_handler.py
import boto3      # SDK da AWS para Python
import uuid       # Gera IDs unicos para cada registro
import json       # Manipulacao de dados JSON

# ============================================
# Inicializando os clientes AWS
# Cada cliente se conecta a um servico diferente
# ============================================
s3 = boto3.client('s3')              # Cliente para ler arquivos do S3
comprehend = boto3.client('comprehend')  # Cliente para analise de sentimento (IA)
dynamodb = boto3.resource('dynamodb')    # Cliente para o banco de dados
table = dynamodb.Table('AnaliseSentimentos')  # Referencia a tabela criada

def lambda_handler(event, context):
    """
    Funcao principal que a AWS Lambda executa.
    - event: contem os dados do evento S3 (qual arquivo foi enviado)
    - context: informacoes do ambiente de execucao
    """
    
    # PASSO 1: Extrair o nome do bucket e do arquivo
    # O evento S3 envia essas informacoes automaticamente
    bucket_name = event['Records'][0]['s3']['bucket']['name']
    file_key = event['Records'][0]['s3']['object']['key']
    
    try:
        # PASSO 2: Ler o conteudo do arquivo de texto no S3
        # get_object retorna o objeto, .read() le o conteudo
        response = s3.get_object(Bucket=bucket_name, Key=file_key)
        texto_para_analisar = response['Body'].read().decode('utf-8')
        
        # PASSO 3: Enviar o texto para o Amazon Comprehend
        # detect_sentiment analisa se o texto e POSITIVO, NEGATIVO, etc.
        # LanguageCode='pt' indica que o texto esta em portugues
        resultado_ia = comprehend.detect_sentiment(
            Text=texto_para_analisar,
            LanguageCode='pt'
        )
        
        # Extrair os resultados da analise
        sentimento = resultado_ia['Sentiment']      # Ex: POSITIVE, NEGATIVE
        confianca = resultado_ia['SentimentScore']   # Porcentagem de confianca
        
        # PASSO 4: Salvar o resultado no DynamoDB
        # put_item insere um novo registro na tabela
        item_id = str(uuid.uuid4())  # Gera um ID unico
        table.put_item(
            Item={
                'id': item_id,
                'arquivo': file_key,
                'texto': texto_para_analisar[:100],  # Primeiros 100 chars
                'sentimento': sentimento,
                'confianca': json.dumps(confianca)
            }
        )
        
        # Retorna sucesso com o resultado
        return {
            'statusCode': 200,
            'body': f"Analise concluida para {file_key}: {sentimento}"
        }
        
    except Exception as e:
        # Em caso de erro, registra no CloudWatch e relanca
        print(f"Erro: {str(e)}")
        raise e

Passo 3: Permissoes IAM

Importante: A Lambda nao consegue acessar S3, Comprehend ou DynamoDB sem permissoes. No console IAM, a Role da sua Lambda deve ter estas politicas anexadas.

AmazonS3ReadOnlyAccess

Permite que a Lambda leia arquivos do bucket S3

ComprehendFullAccess

Permite que a Lambda use a IA do Amazon Comprehend

AmazonDynamoDBFullAccess

Permite que a Lambda grave dados no DynamoDB

AWSLambdaBasicExecutionRole

Permite gerar logs no CloudWatch para monitoramento

Passo 4: Gatilho do S3

Configure o S3 para disparar a Lambda automaticamente sempre que um novo arquivo for enviado ao bucket.

1

Crie um bucket S3 (ex: meu-projeto-sentimentos-input)

2

Na funcao Lambda, clique em "Add trigger"

3

Selecione S3 e escolha o seu bucket

4

Em "Event type", escolha "All object create events"

5

Marque a ciencia de "Recursive invocation" e adicione

Custos e Free Tier (sem sustos)

Objetivo: te ajudar a começar na nuvem com segurança. Os valores variam por região e mudam com o tempo, então trate esta seção como um guia de boas práticas — e confirme no console/páginas oficiais da AWS.

Free Tier (Nível Gratuito)

A AWS tem Free Tier para vários serviços. Antes de testar em produção, confira o Free Tier e os preços atuais do S3, Lambda, Comprehend e DynamoDB na sua região.

Alertas e controle de gastos

Ative alertas de billing e use AWS Budgets para receber notificações quando passar de um valor definido (ex.: R$ 10 / US$ 5).

Teste pequeno, iterando

Para aprender, use arquivos curtos e poucos uploads. Isso reduz risco e te dá previsibilidade durante a fase de testes.

Checklist rápido

  • Defina um orçamento e um alerta (Budgets).
  • Use logs (CloudWatch) para depurar sem “tentar no escuro”.
  • Remova recursos de teste quando terminar (bucket/trigger/tabela, se não precisar mais).

Passo 5: Como Testar

Agora que tudo esta configurado, vamos testar o pipeline completo.

Criar arquivo de teste

Crie um arquivo teste.txt com a frase: "Eu estou muito feliz com os servicos da AWS, a escalabilidade e incrivel!"

Fazer upload

Envie o arquivo para o bucket S3 configurado

Verificar logs

Acesse o CloudWatch Logs da Lambda para ver o processamento

Conferir resultado

Acesse o DynamoDB e verifique o item criado com o sentimento analisado

Se tudo funcionou, voce vera no DynamoDB um registro com o sentimento POSITIVE e as porcentagens de confianca do Comprehend. Parabens, seu pipeline serverless esta funcionando!

Bônus: Subir tudo via CLI (AWS SAM)

Se você quiser o “pulo do gato”: além do tutorial manual no console, este repo agora inclui um bônus com infra como código usando AWS SAM.

O que o SAM cria

  • 1 bucket S3 para receber uploads
  • 1 tabela DynamoDB (PAY_PER_REQUEST)
  • 1 Lambda Python + permissões mínimas
  • Trigger S3 → Lambda (ObjectCreated)

Quando usar

Ideal para quem quer repetir o deploy em outra conta/região, ter versionamento e evitar “cliques” no console. O modo manual continua sendo ótimo para aprender — este é um extra opcional.

template.yaml
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: >
  Pipeline serverless de analise de sentimentos:
  S3 (upload .txt) -> Lambda (Python) -> Comprehend -> DynamoDB.

Globals:
  Function:
    Timeout: 30
    Runtime: python3.12
    Architectures:
      - x86_64
    MemorySize: 256
    Tracing: Active
    Environment:
      Variables:
        TABLE_NAME: AnaliseSentimentos
        LANGUAGE_CODE: pt
        TEXT_PREVIEW_CHARS: "160"

Resources:
  InputBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: AES256

  AnaliseSentimentosTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: AnaliseSentimentos
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      KeySchema:
        - AttributeName: id
          KeyType: HASH

  SentimentFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: lambda/
      Handler: app.lambda_handler
      Description: Processa textos do S3, detecta sentimento no Comprehend e salva no DynamoDB.
      Policies:
        - Version: "2012-10-17"
          Statement:
            - Effect: Allow
              Action:
                - s3:GetObject
              Resource:
                - !Sub "${InputBucket.Arn}/*"
            - Effect: Allow
              Action:
                - dynamodb:PutItem
              Resource:
                - !GetAtt AnaliseSentimentosTable.Arn
            - Effect: Allow
              Action:
                - comprehend:DetectSentiment
              Resource: "*"
      Events:
        S3Upload:
          Type: S3
          Properties:
            Bucket: !Ref InputBucket
            Events: s3:ObjectCreated:*

Outputs:
  BucketName:
    Description: Bucket para upload dos .txt
    Value: !Ref InputBucket
  TableName:
    Description: Tabela DynamoDB para resultados
    Value: !Ref AnaliseSentimentosTable
  FunctionName:
    Description: Nome da Lambda
    Value: !Ref SentimentFunction

Observação: o handler usa variáveis de ambiente (ex.: `LANGUAGE_CODE` e `TABLE_NAME`) e grava um preview do texto. Ajuste conforme sua necessidade.