Acesse o painel da sua conta

Não tem uma conta? Registrar

Entrar em contato

Visite também nosso site craftxp.com.br

  • img
  • img
  • img
  • img
  • img
  • img

Entre em contato

Serverless Computing: AWS Lambda, Funções como Serviço e Arquiteturas Modernas sem Gerenciar Servidores

Serverless Computing: AWS Lambda, Funções como Serviço e Arquiteturas Modernas sem Gerenciar Servidores

O que é Serverless Computing?

Serverless Computing (Computação sem Servidor) é um modelo de execução em nuvem onde o provedor de cloud gerencia dinamicamente a alocação e provisionamento de servidores. O nome "serverless" não significa que não existem servidores — significa que você, como desenvolvedor, não precisa se preocupar com eles.

Neste modelo, você escreve e faz upload do seu código, e o provedor cuida de todo o resto: escalonamento, disponibilidade, segurança do infraestrutura e manutenção. Você paga apenas pelo que usa, geralmente medido em número de requisições ou tempo de execução.

AWS Lambda: O Pioneiro do FaaS

Lançado pela AWS em 2014, o AWS Lambda foi o primeiro serviço Function-as-a-Service (FaaS) amplamente adotado. Ele permite executar código sem provisionar ou gerenciar servidores, cobrando apenas pelo tempo de computação consumido.

Exemplo Básico: Função Lambda em Python

import json

def lambda_handler(event, context):
    """
    Função Lambda que processa eventos do API Gateway
    """
    nome = event.get('queryStringParameters', {}).get('nome', 'Mundo')
    
    return {
        'statusCode': 200,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        'body': json.dumps({
            'mensagem': f'Olá, {nome}!',
            'metodo': event.get('httpMethod'),
            'path': event.get('path')
        })
    }

Essa função recebe uma requisição HTTP (via API Gateway), extrai um parâmetro nome da query string e retorna uma resposta JSON. A AWS gerencia automaticamente quantas instâncias dessa função são necessárias para atender ao tráfego — de 1 requisição por dia a 100.000 por segundo.

Principais Provedores Serverless

  • AWS Lambda — O mais maduro, com suporte a Python, Node.js, Java, Go, Ruby, .NET e runtime personalizado (via layers)
  • Google Cloud Functions — Integração nativa com Firebase e serviços GCP
  • Azure Functions — Forte integração com o ecossistema Microsoft
  • Cloudflare Workers — Execução na edge (borda da rede), latência ultrabaixa
  • Deno Deploy / Vercel Functions — Foco em desenvolvedores JavaScript/TypeScript

Vantagens do Serverless

  1. Sem gerenciamento de infraestrutura — Zero preocupação com patches, atualizações de SO ou capacidade de servidores
  2. Escalabilidade automática — A função escala de zero a milhares de instâncias em segundos
  3. Modelo de pagamento por uso — Pague apenas pelo tempo de execução e memória consumida
  4. Alta disponibilidade nativa — A AWS replica funções em múltiplas zonas de disponibilidade
  5. Time-to-market reduzido — Foco total no código de negócio, não em infraestrutura

Desafios e Limitações

  • Cold starts — Quando uma função fica ociosa, a AWS "dorme" o container. A primeira requisição após o período ocioso sofre latência adicional (cold start)
  • Limite de tempo de execução — Lambda tem timeout máximo de 15 minutos por execução
  • Estado local limitado — Funções serverless são stateless por design. Para estado persistente, use serviços externos como DynamoDB ou S3
  • Vendor lock-in — Cada provedor tem APIs e limitações específicas
  • Debugging mais complexo — A execução local difere do ambiente de produção

Padrões de Arquitetura Serverless

1. API REST Serverless (API Gateway + Lambda + DynamoDB)

O padrão mais comum: o API Gateway expõe endpoints HTTP que disparam funções Lambda. As funções interagem com DynamoDB (banco NoSQL serverless) para persistência.

# Exemplo: CRUD de usuários com Lambda + DynamoDB
import boto3
import json
import os

dynamodb = boto3.resource('dynamodb')
tabela = dynamodb.Table(os.environ['TABELA_USUARIOS'])

def criar_usuario(event, context):
    dados = json.loads(event['body'])
    usuario_id = dados.get('email')
    
    tabela.put_item(
        Item={
            'pk': usuario_id,
            'nome': dados['nome'],
            'criado_em': context.aws_request_id
        }
    )
    
    return {
        'statusCode': 201,
        'body': json.dumps({'mensagem': 'Usuário criado', 'id': usuario_id})
    }

2. Processamento de Eventos Assíncronos (S3 + Lambda + SQS)

Quando um arquivo é enviado ao S3, uma função Lambda é acionada automaticamente para processá-lo. Ideal para pipelines de processamento de imagens, vídeos ou arquivos.

# Lambda acionada por upload no S3
import boto3
from PIL import Image
import io

s3 = boto3.client('s3')

def redimensionar_imagem(event, context):
    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        
        # Baixa imagem do S3
        response = s3.get_object(Bucket=bucket, Key=key)
        imagem = Image.open(io.BytesIO(response['Body'].read()))
        
        # Redimensiona para thumbnail
        thumbnail = imagem.resize((200, 200))
        
        # Salva thumbnail de volta no S3
        buf = io.BytesIO()
        thumbnail.save(buf, format='JPEG')
        buf.seek(0)
        
        s3.put_object(
            Bucket=bucket,
            Key=f'thumbnails/{key}',
            Body=buf,
            ContentType='image/jpeg'
        )
    
    return {'statusCode': 200}

3. Stream Processing com Kinesis + Lambda

Para processamento em tempo real de streams de dados (logs, cliques, sensores IoT), o Lambda pode consumir eventos do Kinesis Data Streams.

Serverless Framework e Ferramentas

Para facilitar o desenvolvimento e deploy de aplicações serverless, existem frameworks especializados:

  • Serverless Framework — O mais popular, multi-cloud (AWS, Azure, GCP)
  • AWS SAM (Serverless Application Model) — Extensão do CloudFormation específica para AWS
  • Terraform — Provedor serverless para quem já usa IaC
  • CDK (AWS Cloud Development Kit) — Infraestrutura como código em TypeScript, Python ou Java

Exemplo: serverless.yml com Serverless Framework

# serverless.yml
service: minha-api-serverless

provider:
  name: aws
  runtime: python3.12
  region: us-east-1
  iam:
    role:
      statements:
        - Effect: Allow
          Action: dynamodb:*
          Resource: arn:aws:dynamodb:*:*:table/Usuarios

functions:
  criarUsuario:
    handler: handlers/usuarios.criar
    events:
      - http:
          path: /usuarios
          method: post
          cors: true

  listarUsuarios:
    handler: handlers/usuarios.listar
    events:
      - http:
          path: /usuarios
          method: get
          cors: true

resources:
  Resources:
    UsuariosTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: Usuarios
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: pk
            AttributeType: S
        KeySchema:
          - AttributeName: pk
            KeyType: HASH

Serverless vs. Containers: Quando Usar Cada Um?

Uma dúvida comum é: quando escolher serverless em vez de containers (ECS/EKS, Docker)?

Critério Serverless (Lambda) Containers (ECS/EKS)
Latência previsível Cold starts podem variar Consistente, sem cold starts
Tempo de execução Máximo 15 min por execução Ilimitado (long-running)
Custo para baixo tráfego Muito baixo (pague por uso) Custo fixo do container rodando
Escalonamento Instantâneo e granular Leva segundos/minutos
Estado local Stateless (efêmero) Pode manter estado em container
Vendor lock-in Alto (FaaS proprietário) Menor (Docker é padrão aberto)

Serverless no Mundo Real: Casos de Uso

  • APIs REST e GraphQL — Backends completos sem servidor, ideais para MVPs e produtos em estágio inicial
  • Processamento de imagens e vídeos — Redimensionamento, compressão, geração de thumbnails acionados por upload
  • ETL e pipelines de dados — Transformação e carga de dados em data warehouses
  • Chatbots e webhooks — Processamento de mensagens e eventos em tempo real
  • Backends para aplicações mobile — Autenticação, notificações push, sincronização de dados
  • Automação de infraestrutura — Rotinas de backup, limpeza de recursos, resposta a alarmes do CloudWatch

Otimizando Custos em Serverless

Embora o modelo "pague por uso" seja econômico para cargas variáveis, alguns cuidados evitam surpresas na fatura:

  1. Ajuste a memória corretamente — Mais memória também significa mais CPU. Em muitos casos, aumentar a memória reduz o tempo de execução e o custo total
  2. Evite chamadas recursivas — Uma função que chama a si mesma pode gerar loops infinitos e custos exponenciais
  3. Use provisioned concurrency — Para funções críticas, mantenha algumas instâncias "quentes" para evitar cold starts
  4. Monitore com CloudWatch e AWS Cost Explorer — Acompanhe o número de invocações e o tempo médio de execução
  5. Defina budgets e alarmes — Configure notificações quando o custo se aproximar do limite

Conclusão

O Serverless Computing não é apenas uma moda passageira — é uma mudança fundamental na forma como pensamos infraestrutura. Ao eliminar a gestão de servidores, ele permite que desenvolvedores foquem no que realmente importa: entregar valor de negócio através de código.

No entanto, serverless não é a bala de prata para todos os cenários. Aplicações com workloads previsíveis e de longa duração ainda se beneficiam de containers tradicionais. A chave está em entender os trade-offs e escolher a ferramenta certa para cada problema.

Para começar hoje:

  • Crie uma conta gratuita na AWS e explore o AWS Lambda Console
  • Instale o Serverless Framework: npm install -g serverless
  • Faça o deploy do seu primeiro "Hello World" serverless em minutos
  • Experimente o AWS SAM CLI para testes locais com sam local invoke

O futuro da computação em nuvem é serverless, orientado a eventos e cada vez mais acessível. Comece hoje e prepare-se para construir sistemas que escalam do zero ao infinito sem que você precise gerenciar um único servidor.

Craft XP
Craft XP