AWS na Prática · 00 — Introdução e Preparação

Construindo um Sistema de Pedidos com Microserviços, Lambda e CloudFormation.

Sobre este módulo

O ponto de partida do projeto. Aqui você vai entender o que será construído, conhecer os conceitos fundamentais da AWS e preparar seu ambiente para os próximos módulos.

Nível: Iniciante em AWS · Duração estimada: 2-3 horas

00. Sumário

01. Boas-vindas

Antes de qualquer coisa, é importante que você entenda em que tipo de jornada está entrando. Este não é um curso teórico de certificação. É um curso de construção: você vai sair daqui com um sistema funcional rodando na AWS, provisionado por código, com microserviços se comunicando entre si, funções serverless processando eventos e infraestrutura completamente reproduzível.

O que esperar do material

Cada módulo segue o mesmo formato: começa com a teoria que você precisa para entender por que as decisões estão sendo tomadas, segue para a parte prática (o que você precisa fazer) e termina com exercícios. Os exercícios não são opcionais — eles são onde o aprendizado realmente fixa.

Você vai notar que os PDFs não trazem o código pronto das regras de negócio. Isso é proposital. O objetivo aqui é que você desenvolva o sistema, não que copie e cole um repositório. Quando aparecer código, ele será apenas para ilustrar uma configuração, um parâmetro ou um trecho que tem nuance importante.

Como estudar com este material

Algumas recomendações práticas para extrair o máximo de cada módulo:

02. Visão geral do projeto

Vamos construir um sistema de processamento de pedidos — uma versão enxuta do que existe nos bastidores de qualquer e-commerce. O objetivo não é ser um sistema completo pronto para produção, mas sim um cenário rico o suficiente para forçar o uso correto de cada serviço da AWS que vamos estudar.

Os componentes do sistema

Três microserviços independentes, cada um com sua responsabilidade clara:

Além dos microserviços, teremos um conjunto de funções Lambda tratando tarefas event-driven: envio de e-mails de confirmação, geração de relatórios diários e processamento de imagens de produtos.

Diagrama de alto nível

O fluxo completo de um pedido percorre o caminho abaixo. Não se preocupe se alguns serviços não fazem sentido ainda — vamos destrinchar cada um nos módulos seguintes.

Figura 1 — Visão de alto nível da arquitetura.

O que essa arquitetura está exercitando

03. Por que esses serviços?

AWS tem mais de 200 serviços. Por que justamente Beanstalk, Lambda e CloudFormation? A resposta tem a ver com cobrir um espectro completo de modelos de computação e operação — não com aprender ferramentas isoladas.

Elastic Beanstalk

O meio-termo gerenciado

Beanstalk é um serviço que abstrai a complexidade de subir uma aplicação tradicional na AWS. Você entrega o código, ele cuida de provisionar EC2, Load Balancer, Auto Scaling, monitoramento e deploy. É o tipo de serviço que você usa quando tem uma aplicação que precisa estar sempre ligada, com tráfego razoavelmente constante.

Nos nossos microserviços (Orders, Inventory, Payments), Beanstalk faz sentido porque são serviços que recebem requisições continuamente e precisam de baixa latência — não dá para esperar um cold start a cada chamada.

Lambda

Serverless event-driven

Lambda é o oposto do Beanstalk em filosofia. Você não pensa em servidores: escreve uma função, ela é executada em resposta a um evento (uma mensagem na fila, um arquivo no S3, um schedule), e você paga só pelo tempo de execução.

Funciona perfeitamente para tarefas que não acontecem o tempo todo: enviar um e-mail quando um pedido é pago, gerar um relatório uma vez por dia, processar uma imagem quando ela é enviada. Pagar por uma EC2 ligada 24 horas para tarefas assim seria desperdício.

CloudFormation

Infraestrutura como código

CloudFormation é o serviço que amarra tudo. Em vez de você ir clicando no console para criar VPC, security groups, banco, filas e ambientes Beanstalk, você descreve toda a infraestrutura em arquivos YAML e o CloudFormation se encarrega de criar, atualizar e destruir os recursos.

Esse é o serviço que mais vai diferenciar você de quem só sabe usar AWS no console. Saber escrever templates CloudFormation é o que separa um usuário casual de um engenheiro AWS.

04. AWS em 10 minutos

Esta seção é um sobrevoo. Não se preocupe em memorizar nada — o objetivo é você conhecer o vocabulário e ter um modelo mental antes de começar a clicar.

O que é AWS?

Amazon Web Services é o serviço de cloud computing da Amazon. Em termos práticos: você aluga capacidade computacional (servidores, bancos, redes, armazenamento) sob demanda, sem precisar comprar hardware. Você paga pelo que usa, e os recursos podem ser provisionados em minutos via API ou console.

Modelos de serviço

Os serviços da AWS se encaixam em alguns modelos. Saber identificar o modelo de cada serviço ajuda a entender o que esperar deles:

Regiões e Zonas de Disponibilidade

A AWS é organizada em regiões geográficas (São Paulo, Norte da Virgínia, Frankfurt etc.). Cada região é fisicamente separada das outras e tem várias zonas de disponibilidade (AZs), que são datacenters independentes dentro da mesma região.

Você sempre escolhe a região onde seus recursos vão ficar. Para este curso, vamos usar us-east-1 (Norte da Virgínia), que é a região com mais serviços, mais barata em geral, e onde a maioria da documentação se baseia.

05. Conceitos fundamentais

Os conceitos abaixo aparecem em todos os módulos seguintes. Se ficarem confusos agora, releia esta seção sempre que precisar.

IAM: o sistema de permissões

IAM (Identity and Access Management) é o serviço que controla quem pode fazer o quê na AWS. Tudo passa por IAM: usuários, serviços, scripts. Entender IAM é mandatório, e os erros mais frustrantes que você vai encontrar no curso provavelmente serão erros de permissão.

Princípio fundamental: least privilege

Sempre dê a menor permissão necessária. É tentador (e infelizmente comum) anexar a policy AdministratorAccess em tudo para “fazer funcionar”. Não faça. No projeto vamos escrever policies específicas, e isso é parte central do aprendizado.

Console, CLI e SDK

Existem três formas principais de interagir com a AWS:

Recursos, ARNs e tags

Tudo na AWS é um recurso — uma fila, uma função, um bucket. Cada recurso tem um identificador único chamado ARN (Amazon Resource Name). O ARN segue um padrão fixo:

arn:aws:<servico>:<regiao>:<conta>:<recurso>
 
# Exemplos:
arn:aws:sqs:us-east-1:123456789012:orders-queue
arn:aws:lambda:us-east-1:123456789012:function:send-email
arn:aws:dynamodb:us-east-1:123456789012:table/Orders

ARNs aparecem em policies IAM, em referências entre serviços, em logs de erro — acostume-se a lê-los. Você vai escrevê-los e referenciá-los muito.

Tags são pares chave-valor que você anexa a recursos para organizá-los. Vamos taguear tudo no projeto (por exemplo, Project=order-system, Environment=dev) — isso facilita encontrar e, principalmente, deletar tudo no fim.

06. Custos: o que esperar

Vamos falar de dinheiro com franqueza, porque essa é a maior fonte de ansiedade de quem está começando — e também a maior fonte de surpresas desagradáveis.

Free Tier

A AWS oferece um nível gratuito de uso (Free Tier) durante os primeiros 12 meses após a criação da conta. Inclui, entre outras coisas:

Para um curso como este, com uso comedido, é perfeitamente possível ficar dentro do Free Tier durante todo o projeto. Mas existem armadilhas.

Os principais riscos de cobrança

Configurando alertas de billing

Mesmo com cuidado, configure alertas. Você ainda não tem conta criada nesse ponto, mas guarde para fazer logo após criá-la (na seção 7):

07. Preparando seu ambiente

Hora da mão na massa. Esta seção tem cinco partes: criar a conta AWS, configurar o usuário IAM, instalar a AWS CLI, instalar o Node.js, e instalar as ferramentas auxiliares.

7.1 — Criando sua conta AWS

Acesse aws.amazon.com e clique em Create an AWS Account. Você vai precisar de:

No fim do processo, escolha o plano Basic Support — Free.

7.2 — Criando seu usuário IAM de trabalho

Em vez de usar o root, vamos criar um usuário IAM específico para o curso. Faça o login como root, vá ao serviço IAM e siga:

7.3 — Gerando access keys para a CLI

Ainda dentro do usuário criado, vá na aba Security credentials e em Access keys clique em Create access key. Escolha o caso de uso Command Line Interface (CLI), confirme o aviso e gere.

7.4 — Instalando a AWS CLI

A AWS CLI v2 é o que você vai usar para configurar credenciais e fazer chamadas administrativas. Instalação:

# Linux (x86_64):
curl 'https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip' -o awscli.zip
unzip awscli.zip
sudo ./aws/install
 
# macOS (com Homebrew):
brew install awscli
 
# Windows: baixe o instalador MSI em
# https://awscli.amazonaws.com/AWSCLIV2.msi

Verifique a instalação:

aws --version
# saída esperada: aws-cli/2.x.x Python/3.x.x ...

Agora configure o perfil. Use as access keys geradas na 7.3:

aws configure --profile aws-curso
 
AWS Access Key ID:     [cole sua access key]
AWS Secret Access Key: [cole seu secret]
Default region name:   us-east-1
Default output format: json

Sobre o parâmetro --profile: ele cria um perfil nomeado em vez de sobrescrever o default. Boa prática — um dia você vai ter mais de uma conta AWS na sua máquina. Para usar o perfil, exporte a variável de ambiente:

# Linux/macOS:
export AWS_PROFILE=aws-curso
 
# Windows (PowerShell):
$env:AWS_PROFILE='aws-curso'

7.5 — Instalando Node.js

Os microserviços vão ser escritos em Node.js. Recomendo a versão LTS atual. A forma mais flexível de gerenciar versões é usando nvm:

# Linux/macOS:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
 
# reabra o terminal e:
nvm install --lts
nvm use --lts
 
node --version    # esperado: v20.x.x ou superior
npm --version

7.6 — Ferramentas auxiliares

08. Verificando que tudo funciona

Antes de seguir para o módulo 1, vamos rodar três checagens rápidas para ter certeza de que seu ambiente está pronto.

Checagem 1 — Identidade da CLI

O comando get-caller-identity retorna a identidade que está sendo usada — se ele responder, sua autenticação está correta:

aws sts get-caller-identity --profile aws-curso
 
# saída esperada (JSON):
{
    "UserId": "AIDAxxxxxxxxxxxxxxxxx",
    "Account": "123456789012",
    "Arn": "arn:aws:iam::123456789012:user/otavio-dev"
}

Checagem 2 — Listar regiões

Esse comando confirma que você consegue chamar APIs autenticadas:

aws ec2 describe-regions --profile aws-curso --output table

Você deve ver uma tabela com várias regiões. Se aparecer UnauthorizedOperation, revise a policy do usuário. Se aparecer InvalidClientTokenId, suas access keys estão erradas.

Checagem 3 — Node.js + AWS SDK

Crie uma pasta de teste e instale o SDK:

mkdir teste-aws && cd teste-aws
npm init -y
npm install @aws-sdk/client-sts

Crie um arquivo teste.js com um script que chama a mesma API via SDK:

// teste.js
import { STSClient, GetCallerIdentityCommand }
  from '@aws-sdk/client-sts';
 
const client = new STSClient({ region: 'us-east-1' });
const result = await client.send(new GetCallerIdentityCommand({}));
console.log(result);

Adicione "type": "module" ao package.json e rode:

AWS_PROFILE=aws-curso node teste.js

09. Exercícios de fixação

Os exercícios abaixo não exigem código novo — são todos sobre exploração do console e da CLI. O objetivo é você ganhar familiaridade antes de começar a construir.

10. Próximos passos

Você chegou ao fim do módulo 0. Esse é o módulo mais “de base” do curso — tudo daqui pra frente é construção concreta.

O que vem por aí

Boa jornada. Nos vemos no Módulo 01.