DEV Community: Lucas Cândido Araújo

Configuração de API para Envio de SMS via AWS

Lucas Cândido Araújo — Fri, 13 Jun 2025 23:28:02 +0000

Este documento contém instruções para configurar um sistema de envio de SMS usando serviços AWS (API Gateway, Lambda e SNS).

Índice

Arquitetura da Solução
Código da Função Lambda
Configuração da Infraestrutura
Configuração de Autenticação com API Key
Como Usar a API
Considerações Adicionais

Arquitetura da Solução

A solução consiste em:

API Gateway: Recebe requisições HTTP POST
Lambda: Processa as requisições e chama o SNS
SNS: Envia as mensagens SMS para os destinatários

O fluxo de dados é:

Cliente envia POST para o API Gateway
API Gateway aciona a função Lambda
Lambda extrai os dados e chama o SNS
SNS envia o SMS para o número especificado

Código da Função Lambda

Arquivo: send_sms_lambda.py

import json
import boto3
import os

def lambda_handler(event, context):
    try:
        # Extrair o corpo da requisição
        if 'body' in event:
            # Se o corpo vier como string (do API Gateway), converter para dict
            if isinstance(event['body'], str):
                body = json.loads(event['body'])
            else:
                body = event['body']
        else:
            body = event

        # Extrair número e conteúdo
        phone_number = body.get('numero')
        message_content = body.get('conteudo')

        # Validar os dados
        if not phone_number or not message_content:
            return {
                'statusCode': 400,
                'body': json.dumps({
                    'message': 'Parâmetros obrigatórios: numero e conteudo'
                })
            }

        # Inicializar cliente SNS
        sns_client = boto3.client('sns')

        # Enviar SMS
        response = sns_client.publish(
            PhoneNumber=phone_number,
            Message=message_content
        )

        # Retornar resposta de sucesso
        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': 'SMS enviado com sucesso',
                'messageId': response['MessageId']
            })
        }

    except Exception as e:
        # Tratar erros
        return {
            'statusCode': 500,
            'body': json.dumps({
                'message': f'Erro ao enviar SMS: {str(e)}'
            })
        }

Configuração da Infraestrutura

Criar a função Lambda

# Primeiro, compacte o código da função
zip send_sms_function.zip send_sms_lambda.py

# Crie um perfil de execução para a Lambda com permissões para SNS
aws iam create-role \
  --role-name send-sms-lambda-role \
  --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Principal": {
          "Service": "lambda.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
      }
    ]
  }'

# Anexe a política para permitir que a Lambda envie SMS via SNS
aws iam attach-role-policy \
  --role-name send-sms-lambda-role \
  --policy-arn arn:aws:iam::aws:policy/AmazonSNSFullAccess

# Aguarde alguns segundos para a propagação do perfil
sleep 10

# Crie a função Lambda
aws lambda create-function \
  --function-name SendSMSFunction \
  --zip-file fileb://send_sms_function.zip \
  --handler send_sms_lambda.lambda_handler \
  --runtime python3.9 \
  --role $(aws iam get-role --role-name send-sms-lambda-role --query 'Role.Arn' --output text)

Criar o API Gateway

# Criar o API Gateway REST API
aws apigateway create-rest-api \
  --name "SMS-API" \
  --description "API para envio de SMS via SNS"

# Obter o ID do API Gateway criado
API_ID=$(aws apigateway get-rest-apis --query "items[?name=='SMS-API'].id" --output text)

# Obter o ID do recurso raiz
ROOT_RESOURCE_ID=$(aws apigateway get-resources --rest-api-id $API_ID --query "items[?path=='/'].id" --output text)

# Criar um recurso para o endpoint de SMS
aws apigateway create-resource \
  --rest-api-id $API_ID \
  --parent-id $ROOT_RESOURCE_ID \
  --path-part "send-sms"

# Obter o ID do recurso criado
RESOURCE_ID=$(aws apigateway get-resources --rest-api-id $API_ID --query "items[?path=='/send-sms'].id" --output text)

# Criar o método POST
aws apigateway put-method \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method POST \
  --authorization-type NONE

# Obter o ARN da função Lambda
LAMBDA_ARN=$(aws lambda get-function --function-name SendSMSFunction --query 'Configuration.FunctionArn' --output text)

# Integrar o método POST com a função Lambda
aws apigateway put-integration \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method POST \
  --type AWS_PROXY \
  --integration-http-method POST \
  --uri arn:aws:apigateway:$(aws configure get region):lambda:path/2015-03-31/functions/$LAMBDA_ARN/invocations

# Dar permissão para o API Gateway invocar a função Lambda
aws lambda add-permission \
  --function-name SendSMSFunction \
  --statement-id apigateway-test \
  --action lambda:InvokeFunction \
  --principal apigateway.amazonaws.com \
  --source-arn "arn:aws:execute-api:$(aws configure get region):$(aws sts get-caller-identity --query 'Account' --output text):$API_ID/*/POST/send-sms"

# Implantar a API
aws apigateway create-deployment \
  --rest-api-id $API_ID \
  --stage-name prod

Configuração de Autenticação com API Key

# 1. Criar uma API Key
aws apigateway create-api-key \
  --name "SMSAPIKey" \
  --description "API Key para o serviço de SMS" \
  --enabled

# Guardar o ID da API Key
API_KEY_ID=$(aws apigateway get-api-keys --query "items[?name=='SMSAPIKey'].id" --output text)

# 2. Criar um plano de uso
aws apigateway create-usage-plan \
  --name "SMSUsagePlan" \
  --description "Plano de uso para o serviço de SMS" \
  --throttle burstLimit=10,rateLimit=5 \
  --quota limit=100,offset=0,period=DAY \
  --api-stages apiId=$API_ID,stage=prod

# Guardar o ID do plano de uso
USAGE_PLAN_ID=$(aws apigateway get-usage-plans --query "items[?name=='SMSUsagePlan'].id" --output text)

# 3. Associar a API Key ao plano de uso
aws apigateway create-usage-plan-key \
  --usage-plan-id $USAGE_PLAN_ID \
  --key-id $API_KEY_ID \
  --key-type "API_KEY"

# 4. Atualizar o método para exigir API Key
aws apigateway update-method \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method POST \
  --patch-operations op=replace,path=/apiKeyRequired,value=true

# 5. Reimplantar a API para aplicar as alterações
aws apigateway create-deployment \
  --rest-api-id $API_ID \
  --stage-name prod

# Obter o valor da API Key
aws apigateway get-api-key \
  --api-key $API_KEY_ID \
  --include-value

Como Usar a API

Após a implantação, você terá um endpoint com o seguinte formato:

https://{API_ID}.execute-api.{region}.amazonaws.com/prod/send-sms

Para enviar um SMS, faça uma requisição POST para este endpoint com o seguinte corpo JSON:

{
  "numero": "+5511999999999",
  "conteudo": "Segue abaixo o código de autenticação: 000000"
}

Exemplo de como fazer isso com curl:

curl -X POST \
  https://{API_ID}.execute-api.{region}.amazonaws.com/prod/send-sms \
  -H 'Content-Type: application/json' \
  -H 'x-api-key: sua-api-key-aqui' \
  -d '{
    "numero": "+5511999999999",
    "conteudo": "Segue abaixo o código de autenticação: 000000"
  }'

Considerações Adicionais

Segurança:
- A API Key deve ser mantida em segredo
- Considere implementar autenticação mais robusta para ambientes de produção
- Todas as comunicações devem ser feitas via HTTPS
Monitoramento:
- Configure CloudWatch para monitorar as chamadas à API e à função Lambda
- Crie alarmes para notificar sobre falhas ou uso excessivo
Limites de SMS:
- Verifique os limites de envio de SMS na sua conta AWS
- Solicite aumento de limites se necessário
- Por padrão, novas contas AWS estão no modo sandbox para SMS
Custos:
- O preço do envio de SMS varia por país
- Consulte a página de preços do SNS para mais detalhes
- Configure orçamentos e alertas de custo
Conformidade:
- Certifique-se de cumprir as regulamentações locais para envio de SMS
- Obtenha consentimento dos destinatários antes de enviar mensagens

Como montar um disco de Swap no Ubuntu

Lucas Cândido Araújo — Fri, 26 Jan 2024 22:50:21 +0000

Se você se encontra em uma instância com recursos de memória limitados, mas deseja melhorar o desempenho, este tutorial é para você.Adicionar um disco de swap pode ser a solução ideal para otimizar o uso da memória.

Montando uma Partição Swap em um Disco:

1.Atualize o sistema para garantir que você tenha as versões mais recentes dos pacotes:

   sudo apt-get update && sudo apt-get upgrade -yqq

2.Configure o fuso horário para garantir registros de tempo precisos:

   sudo timedatectl set-timezone America/Sao_Paulo

3.Liste os discos disponíveis para identificar o disco desejado:

   lsblk

4.Crie uma partição Swap no disco desejado (substitua /dev/nvme1n1 pelo nome do seu disco):

   sudo mkswap /dev/nvme1n1

5.Abra o arquivo /etc/fstab para configurar a montagem automática da Swap no sistema:

   sudo nano /etc/fstab

Adicione a seguinte linha ao final do arquivo:

   UUID=<UUID_do_disco>     swap swap defaults 0 0

6.Ative a partição Swap:

   sudo swapon /dev/nvme1n1

7.Para confirmar se o Swap está ativo, digite o seguinte comando:

   free -m

Azure DevOps Pipelines e Release - Build And Push to ECR With Deploy to ECS Fargate PT-2

Lucas Cândido Araújo — Fri, 19 Jan 2024 01:01:04 +0000

Deploy no AWS ECS usando Azure DevOps

Com a nossa imagem Docker já armazenada no AWS ECR, estamos prontos para avançar para a etapa de Deploy.

Pré-requisitos:

Um Cluster ECS configurado
Definição de Tarefa (Task Definition)
Serviço de Tarefa (Service Task)

Para este processo de Deploy, optarei pelo modo clássico do Azure DevOps, pois acredito que isso facilita a visualização no dia a dia.

Na aba lateral esquerda, selecione a opção "Releases" e clique em "New" e "New release pipeline".

Para todas as etapas, utilizei apenas o Recurso Bash da Pipeline, permitindo sua utilização em outros serviços de pipeline, como GitHub Actions, GitLab, entre outros.

Os 6 passos são bem simples, foram separados para detalhar cada um deles. Obs: Nos passos seguintes, onde estiver $(NOME_VARIAVEL), você irá armazenar em variáveis.

Auth: Autenticação com a AWS para realizar os processos seguintes.

aws configure set aws_access_key_id $(AWS_ACCESS_KEY_ID)
aws configure set aws_secret_access_key $(AWS_SECRET_ACCESS_KEY)
aws configure set region $(AWS_REGION)

2.ECS Describe: Faz o download do JSON da Task Definition para criar uma nova versão.

aws ecs describe-task-definition --task-definition $(TASK_DEFINITION_NAME) --query taskDefinition | jq 'del(.taskDefinitionArn, .revision, .status, .requiresAttributes, .compatibilities, .registeredAt, .registeredBy)' > temp-task-definition.json

3.Replace Version: Altera a versão da imagem do container para a versão recém-criada na Parte 1.

jq '.containerDefinitions[0].image = "$(AWS_ECR):$(Build.BuildNumber)"' temp-task-definition.json > task-definition.json

Esse comando gera como output o número da versão da Task Definition, que será armazenado para ser usado no próximo passo.
4.Register Task Definition: Após atualizar a versão, registra a nova versão da Task Definition.

task_version=$(aws ecs register-task-definition --cli-input-json file://task-definition.json | jq --raw-output '.taskDefinition.revision')

echo "##vso[task.setvariable variable=task_version;]$task_version"

5.Update Service Cluster: Este passo realiza a efetiva publicação da nossa nova versão.

aws ecs update-service \
    --cluster $CLUSTER_NAME \
    --service $SERVICE_NAME \
    --task-definition $TASK_DEFINITION_NAME:$(task_version)

6.Wait Service Stability: Aguarda a validação do serviço para finalizar a publicação.

aws ecs wait services-stable \
    --cluster $CLUSTER_NAME \
    --service $SERVICE_NAME \

Por fim, mas não menos importante, todas as variáveis utilizadas estão armazenadas na aba "Variable".

Azure DevOps Pipelines e Release - Build And Push to ECR With Deploy to ECS Fargate PT-1

Lucas Cândido Araújo — Fri, 19 Jan 2024 00:45:33 +0000

Meu Primeiro Post!

Para começar, escolhi um tópico com pouca documentação.

Pré Requisitos:

Extensão instalada no Azure DevOps: AWS Toolkit for Azure DevOps
AWS ECR já criado
Credencial programática no AWS IAM criada

Em Pipelines, vou exemplificar no modo clássico e também com o azure-pipelines.yml.

Modo Clássico

1.Build Image: utilizará o docker@2

2.Push to ECR: utilizará a task AmazonWebServices.aws-vsts-tools.ECRPushImage.ECRPushImage@1

Modo YAML utilizando `azure-pipelines.yml`

trigger:
  branches:
    include:
    - refs/heads/master
name: $(date:yyyyMMdd)$(rev:.r)
jobs:
- job: Job_1
  displayName: BuildAndPush
  pool:
    vmImage: ubuntu-latest
  steps:
  - checkout: self
    fetchDepth: 1
  - task: Docker@2
    displayName: build
    inputs:
      repository: $(DOCKER_REPOSITORY_NAME)
      command: build
      Dockerfile: Dockerfile
      tags: $(Build.BuildNumber)
  - task: AmazonWebServices.aws-vsts-tools.ECRPushImage.ECRPushImage@1
    displayName: 'Push Image: '
    inputs:
      awsCredentials: 
      regionName: us-east-1
      sourceImageName: $(DOCKER_REPOSITORY_NAME)
      sourceImageTag: $(Build.BuildNumber)
      repositoryName: $(DOCKER_REPOSITORY_NAME)
      pushTag: $(Build.BuildNumber)

Obs. Lembre-se de armazenar as variaveis, na aba Variables

Criar Service Connection AWS

Após instalar a extensão, clique em Project Settings (ícone no canto inferior esquerdo) e, em seguida, em Service Connections. No botão New Service Connection, selecione "AWS" e insira o Access key ID e a Secret access key. Defina um nome em Service Connection name, principalmente se usar mais de uma conta AWS, e clique em Save.

Para não alongar demais este post, criarei a Parte 2 - Deploy da imagem no AWS ECS Fargate.