Toda aplicação em produção precisa das mesmas seis camadas. Leia de baixo para cima:
| Camada | O que é | Na loja |
|---|---|---|
| Dados e acesso | o que a aplicação guarda e quem pode ler | pedidos, contas, usuários do banco, chaves de API |
| Aplicação | seu código | o gateway e os serviços |
| Middleware | o que seu código precisa para rodar | JDK, servidor web, Redis |
| SO | o sistema operacional de cada máquina | Linux |
| Virtualização | hypervisor que divide um host em VMs | KVM, Xen |
| Hardware | servidores, discos, rede, energia, refrigeração | o datacenter |
Da esquerda para a direita, o provedor assume mais da pilha: você opera · provedor opera
Pizza como serviço. On-premises: você cozinha em casa · IaaS: você aluga uma cozinha · PaaS: você pede delivery · SaaS: você come num restaurante — e continua decidindo quem senta à sua mesa.
Encontre o evento e leia a linha: você opera · provedor opera
A configuração usual de cada modelo. Em CaaS e PaaS a plataforma escala, mas você ainda define os limites; em Kubernetes gerenciado com node groups clássicos, o SO dos nós ainda é em parte seu.
A loja roda num PaaS e publicam uma falha no kernel do Linux. O que seu time faz?
O NIST define três modelos fundamentais: IaaS, PaaS e SaaS. Depois, o mercado acrescentou CaaS e FaaS entre eles.
Cada modelo tem as mesmas partes, para que você possa compará-los:
O que você implanta diferencia os modelos: uma VM (IaaS), uma imagem (CaaS), código (PaaS), uma função (FaaS) ou nada (SaaS).
Você aluga uma máquina e faz o resto. Você entrega datacenter, hardware e hypervisor; mantém o SO (patches, hardening), o runtime, o código, os dados, as regras de firewall e os backups.
aws ec2 run-instances --image-id <ubuntu-ami> --instance-type t3.medium --key-name <key>
ssh ubuntu@<public-ip>
sudo apt update && sudo apt install -y openjdk-21-jre-headless nginx
java -jar order.jar
E isso é só o primeiro dia: configurar o nginx, reiniciar o serviço se ele cair, aplicar patches no SO, agendar backups.
AWS EC2, Google Compute Engine, Azure Virtual Machines, DigitalOcean Droplets.
Você entrega uma imagem de container; a plataforma a executa. O provedor cuida do agendamento, da rede, da escala e da saúde das máquinas; tudo dentro da imagem (imagem base, JDK, código) continua sendo seu.
docker build -t <registry>/order:1.0 .
docker push <registry>/order:1.0
gcloud run deploy order --image <registry>/order:1.0 --region southamerica-east1 --max-instances 10
A mesma imagem que você roda com Docker Compose: mudar de provedor é enviá-la para outro lugar.
AWS ECS / Fargate, Google Cloud Run, Azure Container Apps.
Você entrega o código; a plataforma o constrói e o executa. Ela fornece SO, JDK, deploy, balanceamento de carga e escala; você mantém o código, a configuração (variáveis de ambiente, regras de escala), os dados e o acesso.
heroku create store-order
heroku addons:create heroku-postgresql:essential-0
git push heroku main
heroku ps:scale web=2
Um buildpack encontra o pom.xml e constrói o projeto: ninguém instalou um JDK nem um banco de dados.
Heroku, AWS Elastic Beanstalk, Google App Engine, Azure App Service, Railway, Render.
Você entrega uma única função; ela só roda quando algo a chama. É o PaaS levado ao extremo (serverless): instâncias sob demanda, escala até zero, pagamento por invocação e por milissegundo.
O serviço order inteiro não se encaixa bem, mas o e-mail enviado depois de cada pedido, sim:
public class OrderCreated implements RequestHandler<Map<String, Object>, String> {
@Override
public String handleRequest(Map<String, Object> event, Context context) {
// send the confirmation e-mail for this order
return "sent";
}
}
AWS Lambda, Google Cloud Functions, Azure Functions, Cloudflare Workers.
Containers serverless borram a fronteira. O Cloud Run e o Azure Container Apps também escalam até zero e cobram pelo uso, mas executam qualquer imagem. "Serverless" é o modelo de operação e não só funções.
Você usa o produto; o provedor opera todo o resto. Você mantém as contas de usuário e as permissões, os dados que insere e as integrações (APIs, webhooks).
Google Workspace, Salesforce, Slack, GitHub, Datadog, Shopify.
Nem tudo cabe na escada. O DBaaS aplica a mesma entrega a um único componente: em vez de operar um servidor Postgres, você aluga um.
| Postgres numa VM | Usando um DBaaS |
|---|---|
| Você instala e aplica patches no SO e no banco | O provedor aplica os patches numa janela que você escolhe |
| Você escreve scripts de backup e os testa | Você define o período de retenção |
| Você monta a replicação e o failover | Você liga uma opção (Multi-AZ no RDS) |
| Schema, consultas, acesso | Schema, consultas, acesso: isso continua com você |
AWS RDS, Amazon Aurora, Google Cloud SQL, Azure Database, Neon.
| Modelo | Sigla | Exemplos |
|---|---|---|
| Armazenamento como Serviço | STaaS | AWS S3, Google Cloud Storage, Backblaze B2 |
| IA / ML como Serviço | AIaaS | AWS Bedrock, Google Vertex AI, Azure AI |
| Monitoramento como Serviço | — | Datadog, New Relic, Grafana Cloud |
| Segurança como Serviço | SECaaS | Cloudflare, AWS Shield, Snyk |
| Comunicação como Serviço | CPaaS | Twilio, SendGrid, AWS SES |
Leia por linhas, observando como cada característica muda da esquerda para a direita:
| On-premises | IaaS | CaaS | PaaS | FaaS | SaaS | |
|---|---|---|---|---|---|---|
| Você implanta | tudo | uma VM | uma imagem | código | uma função | nada |
| Controle | máximo | alto | médio | médio | baixo | mínimo |
| Tempo até entrar no ar | meses | horas | minutos | minutos | minutos | imediato |
| Escala | comprar hardware | manual ou por script | automática (alguns até zero) | automática | automática até zero | automática |
| Você paga por | hardware (CapEx) | VM-hora | tempo de container | instâncias ou uso | invocações e duração | usuários ou licenças |
| Portabilidade | total | alta | alta (a imagem) | média | baixa (API do fornecedor) | baixa (exportação de dados) |
| Modelo | AWS | Google Cloud | Microsoft | Outros provedores |
|---|---|---|---|---|
| IaaS | EC2 | Compute Engine | Azure Virtual Machines | DigitalOcean Droplets, Oracle Cloud Compute, Magalu Cloud |
| CaaS | ECS / Fargate, EKS | Cloud Run, GKE | Azure Container Apps, AKS | DigitalOcean Kubernetes, Fly.io |
| PaaS | Elastic Beanstalk | App Engine | Azure App Service | Heroku, Railway, Render |
| FaaS | Lambda | Cloud Run functions | Azure Functions | Cloudflare Workers, Vercel Functions |
| SaaS | Amazon Connect, QuickSight | Google Workspace | Microsoft 365, Dynamics 365 | Salesforce, Slack, GitHub, Shopify, TOTVS |
| Blocos gerenciados | RDS, ElastiCache, MSK | Cloud SQL, Memorystore | Azure Database, Azure Cache for Redis | Neon, Upstash, Confluent Cloud |
Leia por colunas: um modelo descreve um serviço, não uma empresa — a AWS aparece em todas as linhas. As grandes nuvens oferecem quase todos os modelos; provedores menores se especializam em um degrau da pilha.
Por componente, não por sistema. Comece pela opção mais gerenciada; pergunte em ordem e pare no primeiro sim (cada não desce um degrau):
Passar cada componente pelas perguntas dá um resultado razoável, com a mesma forma do projeto do curso:
Sistemas reais misturam modelos: CaaS para os serviços, DBaaS para os dados, FaaS para o trabalho esporádico. A linha de dados e acesso continua sua em todas as caixas.
| Componente | Por conta própria | Opção gerenciada | O que muda para o time |
|---|---|---|---|
| gateway, account, order | Compose no EC2 (IaaS) | EKS ou ECS Fargate (CaaS) | sem SSH nem patches do SO; manifests no lugar |
| Postgres | Postgres no EC2 | RDS (DBaaS) | backups, replicação e failover viram opções |
| Redis | container na VM | ElastiCache (DBaaS) | sobrevive ao reinício da VM; paga por nó |
| Kafka | brokers em VMs | Amazon MSK | patches e troca de brokers passam para a AWS |
| Notificação do pedido | consumidor sempre rodando | Lambda no tópico do Kafka (FaaS) | paga por mensagem; cold starts num caminho assíncrono |
| CI/CD | Jenkins num container | GitHub Actions (SaaS) | nenhum servidor Jenkins para atualizar |
| Monitoramento | Prometheus e Grafana | Grafana Cloud ou Datadog (SaaS) | nenhum armazenamento de métricas para dimensionar |
Sistemas reais misturam modelos — a mesma forma do projeto do curso. A linha de dados e acesso nunca some: você continua decidindo quem se conecta ao RDS e quem alcança o gateway.
Onde você rodaria o exchange, que converte moedas chamando uma API externa de cotações?
0.0.0.0/0, uma access key vazada.Na página da aula: experimente os simuladores para mover a linha entre você e o provedor e comparar custos.
Objetivos: explicar o que torna um serviço "nuvem" e CapEx vs OpEx; situar IaaS, CaaS, PaaS, FaaS e SaaS na pilha de responsabilidade, dizendo quem age quando algo quebra; comparar os modelos; escolher um modelo por componente; dizer o que nunca passa para o provedor. Roteiro: (1) o que torna um serviço nuvem; (2) a pilha de responsabilidade; (3) subindo a pilha, um modelo de cada vez; (4) blocos gerenciados; (5) comparando os modelos; (6) como escolher, a loja componente por componente; (7) erros comuns.
Cada opção traça uma linha diferente entre o que seu time opera e o que outra pessoa opera. É essa linha que um modelo de serviço em nuvem define.
A distância entre a escada e a demanda é o custo de adivinhar: o laranja é dinheiro gasto em capacidade que ninguém usa e o vermelho são clientes recusados. O autoscaling no OpEx fecha essa distância, mas paga mais por unidade (veja o simulador de custo na página).
Esta é a imagem para lembrar. Peça à turma que a leia coluna por coluna antes do próximo slide.
Controle e portabilidade caem conforme o tempo até entrar no ar melhora. O FaaS é o ponto fora da curva na portabilidade: o código é escrito contra a API de um fornecedor.
A loja poderia usar um único provedor (na AWS: EKS para os serviços, RDS para o Postgres) ou misturar provedores (GitHub para o código e o CI): o que decide é o requisito de cada componente, como mostra o próximo slide. O Cloud Run functions se chamava Cloud Functions.
Setas: cliente → gateway → account e order; account e order → Postgres; order → Redis e Kafka; o Kafka aciona o Lambda, que envia o e-mail pelo SES.