Engenharia de Backends e APIs Modernas 🚀

"A base invisível que sustenta a era digital."

📖 Trilha de Aulas --- Os 16 módulos do curso passo a passo com teoria e prática. Iniciar Jornada →
📽️ Slides Práticos --- Apresentações visuais ricas e otimizadas para Reveal.js. Ver Slides →
🧠 Quizzes Interativos --- Autodiagnóstico contínuo com feedback automático e imediato. Testar Agora →
🛠️ Projetos Reais --- Laboratórios práticos e PoCs de mercado para portfólio. Ver Projetos →
✏️ Exercícios Progressivos --- Fixação do conteúdo abordado do básico ao desafio final. Praticar Agora →
⚙️ Setup e Ferramentas --- Configurações essenciais para VS Code e Ecossistema MkDocs. Configurar Ambiente →

💡 Dicas de Sucesso

Entenda os Protocolos: Domine HTTP, REST e gRPC antes de codificar.
Arquitetura Primeiro: Planeje a persistência e a escalabilidade antes da implementação.
Mantenha a Semântica: APIs de qualidade exigem nomes de recursos claros e consistentes.

➡️ Ir para a Aula 01

ℹ️ Sobre o Curso

Bem-vindo à disciplina de Backend.

🗺️ Plano de Ensino

Ementa oficial dividida em 16 módulos.

🎓 Aulas

Índice de Aulas 🧭

Acesse todo o conteúdo prático da disciplina.

Módulo 1 - Fundamentos da Web

Aula 01

Módulo 2 - Arquitetura Backend

Aula 02

Módulo 3 - Design de APIs

Aula 03

Módulo 4 - Protocolos de Comunicação

Aula 04

Módulo 5 - Sec e Autenticação

Aula 05

Módulo 6 - Persistência e Dados

Aula 06

Módulo 7 - Cache e Performance

Aula 07

Módulo 8 - Event Driven

Aula 08

Módulo 9 - Infra. Cloud Native

Aula 09

Módulo 10 - Observabilidade

Aula 10

Módulo 11 - Testes de Backend

Aula 11

Módulo 12 - Deploy e DevOps

Aula 12

Módulo 13 - Serverless e Edge

Aula 13

Módulo 14 - API Gateways

Aula 14

Módulo 15 - Ecossistemas

Aula 15

Módulo 16 - Tópicos Avançados

Aula 16

Módulo 1 – Fundamentos e Arquitetura

🌐 Aula 01 - Fundamentos da Web e Sistemas Distribuídos

Objetivo

Objetivo: Explorar a fundo os conceitos de Fundamentos da Web, abordando Arquitetura cliente-servidor, Sistemas distribuídos, HTTP/2 e Monólito e Microsserviços. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Arquitetura cliente-servidor e Sistemas distribuídos é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Fundamentos da Web, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Arquitetura cliente-servidor é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Arquitetura cliente-servidor]
    GW --> S2[Sistemas distribuídos]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em HTTP/2. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Monólito e Microsserviços. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `HTTP/2` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Fundamentos da Web.

$ docker network create backend_net
$ docker run -d --name http/2_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 01
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 01
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 01
Projeto

Aplicação prática dos conceitos da aula.

Projeto 01

➡️ Próxima Aula: Arquitetura Backend

🌐 Aula 02 - Arquitetura de Software Backend

Objetivo

Objetivo: Explorar a fundo os conceitos de Arquitetura Backend, abordando Clean Architecture, Hexagonal, DDD e CQRS. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Clean Architecture e Hexagonal é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Arquitetura Backend, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Clean Architecture é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Clean Architecture]
    GW --> S2[Hexagonal]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em DDD. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em CQRS. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `DDD` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Arquitetura Backend.

$ docker network create backend_net
$ docker run -d --name ddd_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 02
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 02
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 02
Projeto

Aplicação prática dos conceitos da aula.

Projeto 02

➡️ Próxima Aula: Design de APIs

🌐 Aula 03 - Design de APIs

Objetivo

Objetivo: Explorar a fundo os conceitos de Design de APIs, abordando REST Constraints, HATEOAS, GraphQL e Versionamento. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de REST Constraints e HATEOAS é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Design de APIs, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como REST Constraints é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[REST Constraints]
    GW --> S2[HATEOAS]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em GraphQL. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Versionamento. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `GraphQL` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Design de APIs.

$ docker network create backend_net
$ docker run -d --name graphql_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 03
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 03
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 03
Projeto

Aplicação prática dos conceitos da aula.

Projeto 03

➡️ Próxima Aula: Protocolos de Comunicação

🌐 Aula 04 - Protocolos de APIs e Comunicação

Objetivo

Objetivo: Explorar a fundo os conceitos de Protocolos de Comunicação, abordando gRPC, WebSockets, Streaming e SSE. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de gRPC e WebSockets é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Protocolos de Comunicação, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como gRPC é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[gRPC]
    GW --> S2[WebSockets]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Streaming. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em SSE. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Streaming` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Protocolos de Comunicação.

$ docker network create backend_net
$ docker run -d --name streaming_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 04
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 04
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 04
Projeto

Aplicação prática dos conceitos da aula.

Projeto 04

➡️ Próxima Aula: Sec e Autenticação

Módulo 2 – Segurança, Dados e Mensageria

🌐 Aula 05 - Autenticação, Autorização e Segurança

Objetivo

Objetivo: Explorar a fundo os conceitos de Sec e Autenticação, abordando JWT, OAuth 2.0, OpenID e OWASP API. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de JWT e OAuth 2.0 é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Sec e Autenticação, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como JWT é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[JWT]
    GW --> S2[OAuth 2.0]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em OpenID. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em OWASP API. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `OpenID` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Sec e Autenticação.

$ docker network create backend_net
$ docker run -d --name openid_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 05
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 05
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 05
Projeto

Aplicação prática dos conceitos da aula.

Projeto 05

➡️ Próxima Aula: Persistência e Dados

🌐 Aula 06 - Persistência e Camada de Dados

Objetivo

Objetivo: Explorar a fundo os conceitos de Persistência e Dados, abordando Relacional, NoSQL, ACID e Eventual Consistency. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Relacional e NoSQL é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Persistência e Dados, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Relacional é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Relacional]
    GW --> S2[NoSQL]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em ACID. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Eventual Consistency. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `ACID` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Persistência e Dados.

$ docker network create backend_net
$ docker run -d --name acid_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 06
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 06
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 06
Projeto

Aplicação prática dos conceitos da aula.

Projeto 06

➡️ Próxima Aula: Cache e Performance

🌐 Aula 07 - Cache e Performance

Objetivo

Objetivo: Explorar a fundo os conceitos de Cache e Performance, abordando Redis, CDN, Cache aside e Pagination. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Redis e CDN é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Cache e Performance, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Redis é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Redis]
    GW --> S2[CDN]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Cache aside. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Pagination. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Cache aside` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Cache e Performance.

$ docker network create backend_net
$ docker run -d --name cache_aside_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 07
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 07
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 07
Projeto

Aplicação prática dos conceitos da aula.

Projeto 07

➡️ Próxima Aula: Event Driven

🌐 Aula 08 - Mensageria e Arquitetura Orientada a Eventos

Objetivo

Objetivo: Explorar a fundo os conceitos de Event Driven, abordando Kafka, RabbitMQ, Pub/Sub e Event Streaming. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Kafka e RabbitMQ é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Event Driven, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Kafka é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Kafka]
    GW --> S2[RabbitMQ]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Pub/Sub. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Event Streaming. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Pub/Sub` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Event Driven.

$ docker network create backend_net
$ docker run -d --name pub/sub_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 08
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 08
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 08
Projeto

Aplicação prática dos conceitos da aula.

Projeto 08

➡️ Próxima Aula: Infra. Cloud Native

Módulo 3 – Cloud, Monitoramento e Testes

🌐 Aula 09 - Infraestrutura Cloud Native

Objetivo

Objetivo: Explorar a fundo os conceitos de Infra. Cloud Native, abordando Docker, Kubernetes, Service Discovery e Autoscaling. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Docker e Kubernetes é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Infra. Cloud Native, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Docker é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Docker]
    GW --> S2[Kubernetes]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Service Discovery. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Autoscaling. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Service Discovery` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Infra. Cloud Native.

$ docker network create backend_net
$ docker run -d --name service_discovery_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 09
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 09
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 09
Projeto

Aplicação prática dos conceitos da aula.

Projeto 09

➡️ Próxima Aula: Observabilidade

🌐 Aula 10 - Observabilidade e Monitoramento

Objetivo

Objetivo: Explorar a fundo os conceitos de Observabilidade, abordando Prometheus, Grafana, Tracing e OpenTelemetry. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Prometheus e Grafana é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Observabilidade, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Prometheus é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Prometheus]
    GW --> S2[Grafana]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Tracing. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em OpenTelemetry. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Tracing` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Observabilidade.

$ docker network create backend_net
$ docker run -d --name tracing_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 10
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 10
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 10
Projeto

Aplicação prática dos conceitos da aula.

Projeto 10

➡️ Próxima Aula: Testes de Backend

🌐 Aula 11 - Testes de Backend

Objetivo

Objetivo: Explorar a fundo os conceitos de Testes de Backend, abordando Testes Unitários, Postman, Pact e K6. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Testes Unitários e Postman é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Testes de Backend, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Testes Unitários é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Testes Unitários]
    GW --> S2[Postman]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Pact. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em K6. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Pact` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Testes de Backend.

$ docker network create backend_net
$ docker run -d --name pact_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 11
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 11
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 11
Projeto

Aplicação prática dos conceitos da aula.

Projeto 11

➡️ Próxima Aula: Deploy e DevOps

🌐 Aula 12 - Deploy e DevOps

Objetivo

Objetivo: Explorar a fundo os conceitos de Deploy e DevOps, abordando CI/CD, Blue/Green, Canary e Feature Flags. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de CI/CD e Blue/Green é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Deploy e DevOps, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como CI/CD é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[CI/CD]
    GW --> S2[Blue/Green]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Canary. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Feature Flags. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Canary` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Deploy e DevOps.

$ docker network create backend_net
$ docker run -d --name canary_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 12
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 12
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 12
Projeto

Aplicação prática dos conceitos da aula.

Projeto 12

➡️ Próxima Aula: Serverless e Edge

Módulo 4 – Serverless e API Management

🌐 Aula 13 - Serverless e Edge Computing

Objetivo

Objetivo: Explorar a fundo os conceitos de Serverless e Edge, abordando AWS Lambda, FaaS, Workers e Vercel. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de AWS Lambda e FaaS é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Serverless e Edge, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como AWS Lambda é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[AWS Lambda]
    GW --> S2[FaaS]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Workers. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Vercel. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Workers` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Serverless e Edge.

$ docker network create backend_net
$ docker run -d --name workers_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 13
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 13
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 13
Projeto

Aplicação prática dos conceitos da aula.

Projeto 13

➡️ Próxima Aula: API Gateways

🌐 Aula 14 - API Management e Gateways

Objetivo

Objetivo: Explorar a fundo os conceitos de API Gateways, abordando Kong, Apigee, Rate Limiting e Load Balancing. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Kong e Apigee é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com API Gateways, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Kong é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Kong]
    GW --> S2[Apigee]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em Rate Limiting. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Load Balancing. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `Rate Limiting` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de API Gateways.

$ docker network create backend_net
$ docker run -d --name rate_limiting_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 14
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 14
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 14
Projeto

Aplicação prática dos conceitos da aula.

Projeto 14

➡️ Próxima Aula: Ecossistemas

🌐 Aula 15 - Ecossistemas de Backend (visão geral)

Objetivo

Objetivo: Explorar a fundo os conceitos de Ecossistemas, abordando Node.js, Spring Boot, .NET e Go. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Node.js e Spring Boot é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Ecossistemas, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Node.js é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Node.js]
    GW --> S2[Spring Boot]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em .NET. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Go. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `.NET` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Ecossistemas.

$ docker network create backend_net
$ docker run -d --name .net_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 15
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 15
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 15
Projeto

Aplicação prática dos conceitos da aula.

Projeto 15

➡️ Próxima Aula: Tópicos Avançados

🌐 Aula 16 - Tópicos Avançados e Tendências

Objetivo

Objetivo: Explorar a fundo os conceitos de Tópicos Avançados, abordando Service Mesh, RAG APIs, AI Backend e Webhooks. Construiremos uma base teórica e prática com diagramas, comandos interativos e matemática aplicada à ciência da computação.

1. Visão Geral Teórica 🧠

O estudo de Service Mesh e RAG APIs é fundamental para sistemas de alta disponibilidade.

Definição Técnica

Aplicações cloud-native exigem tolerância a falhas. Segundo o Teorema CAP, não podemos ter Consistência, Disponibilidade e Partição simultaneamente em sistemas distribuídos.

Quando lidamos com Tópicos Avançados, a performance pode ser modelada através da Lei de Amdahl: $$ S_{latency}(s) = \frac{1}{(1 - p) + \frac{p}{s}} $$ Onde $p$ é a porção paralelizável.

2. Arquitetura e Modelagem 📊

Abaixo, a representação de como Service Mesh é adotado em escala industrial.

graph TD
    Client[Cliente API] -->|Requisita| GW[API Gateway]
    GW --> S1[Service Mesh]
    GW --> S2[RAG APIs]
    S1 -.->|Consistência| DB1[(Banco Y)]
    S2 -.->|Mensageria| B[Broker Kafka]

2.1 Comparativo de Tecnologias

Abordagem AAbordagem B

Focada em AI Backend. Maior curva de aprendizado, porém mais controle sobre o I/O.

Focada em Webhooks. Mais rápida para o mercado (Time-to-Market).

3. Prática: Hands-on em `AI Backend` 💻

Vamos subir nosso ambiente local para explorar as particularidades tecnológicas de Tópicos Avançados.

$ docker network create backend_net
$ docker run -d --name ai_backend_svc -p 8080:8080 my-backend-image
# Inicializando o servidor...
[OK] Service started on port 8080.

Analisando o Código fonte

main.py

def processar_requisicao(payload):
    # (1) Validar contrato da API
    if not isinstance(payload, dict):
        raise ValueError("Invalid format")  
    return {"status": "success", "data": payload}

A validação antecipada (fail-fast) evita perda de processamento em camadas mais profundas.

🔗 Materiais da Aula

Slides

Material visual com diagramas e conceitos-chave.

Slide 16
Quiz

Teste seu conhecimento com 10 questões interativas.

Quiz 16
Exercícios

5 exercícios progressivos (básico → desafio).

Exercício 16
Projeto

Aplicação prática dos conceitos da aula.

Projeto 16

Parabéns!

Você concluiu todos os módulos do curso de Engenharia de Backends!

🏆 Voltar à Trilha de Aulas

📚 Materiais

Materiais Complementares 📚

Slides Slides
Exercícios Exercícios
Quizzes Quizzes
Projetos Projetos
Setups Setups

Slides

Slides Práticos 🧭

Acesse todo o conteúdo visual e interativo da disciplina.

Módulo 2 – Segurança, Dados e Mensageria

Slide 05 - Sec e Autenticação
Slide 06 - Persistência e Dados
Slide 07 - Cache e Performance
Slide 08 - Event Driven

Módulo 3 – Cloud, Monitoramento e Testes

Slide 09 - Infra. Cloud Native
Slide 10 - Observabilidade
Slide 11 - Testes de Backend
Slide 12 - Deploy e DevOps

Módulo 4 – Serverless e API Management

Slide 13 - Serverless e Edge
Slide 14 - API Gateways
Slide 15 - Ecossistemas
Slide 16 - Tópicos Avançados

Exercícios

Exercícios Práticos 🧭

Acesse todo o conteúdo prático da disciplina.

Módulo 1 – Fundamentos e Arquitetura

Exercício 01 - Fundamentos da Web
Exercício 02 - Arquitetura Backend
Exercício 03 - Design de APIs
Exercício 04 - Protocolos de Comunicação

Módulo 2 – Segurança, Dados e Mensageria

Exercício 05 - Sec e Autenticação
Exercício 06 - Persistência e Dados
Exercício 07 - Cache e Performance
Exercício 08 - Event Driven

Módulo 3 – Cloud, Monitoramento e Testes

Exercício 09 - Infra. Cloud Native
Exercício 10 - Observabilidade
Exercício 11 - Testes de Backend
Exercício 12 - Deploy e DevOps

Módulo 4 – Serverless e API Management

Exercício 13 - Serverless e Edge
Exercício 14 - API Gateways
Exercício 15 - Ecossistemas
Exercício 16 - Tópicos Avançados

Exercício 01 - Fundamentos da Web 🧩

🟢 Básicos

Defina o conceito principal por trás de Arquitetura cliente-servidor.
Quais as vantagens operacionais de adotar Sistemas distribuídos neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente HTTP/2 com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Monólito e Microsserviços.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 02 - Arquitetura Backend 🧩

🟢 Básicos

Defina o conceito principal por trás de Clean Architecture.
Quais as vantagens operacionais de adotar Hexagonal neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente DDD com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de CQRS.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 03 - Design de APIs 🧩

🟢 Básicos

Defina o conceito principal por trás de REST Constraints.
Quais as vantagens operacionais de adotar HATEOAS neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente GraphQL com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Versionamento.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 04 - Protocolos de Comunicação 🧩

🟢 Básicos

Defina o conceito principal por trás de gRPC.
Quais as vantagens operacionais de adotar WebSockets neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Streaming com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de SSE.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 05 - Sec e Autenticação 🧩

🟢 Básicos

Defina o conceito principal por trás de JWT.
Quais as vantagens operacionais de adotar OAuth 2.0 neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente OpenID com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de OWASP API.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 06 - Persistência e Dados 🧩

🟢 Básicos

Defina o conceito principal por trás de Relacional.
Quais as vantagens operacionais de adotar NoSQL neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente ACID com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Eventual Consistency.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 07 - Cache e Performance 🧩

🟢 Básicos

Defina o conceito principal por trás de Redis.
Quais as vantagens operacionais de adotar CDN neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Cache aside com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Pagination.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 08 - Event Driven 🧩

🟢 Básicos

Defina o conceito principal por trás de Kafka.
Quais as vantagens operacionais de adotar RabbitMQ neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Pub/Sub com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Event Streaming.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 09 - Infra. Cloud Native 🧩

🟢 Básicos

Defina o conceito principal por trás de Docker.
Quais as vantagens operacionais de adotar Kubernetes neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Service Discovery com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Autoscaling.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 10 - Observabilidade 🧩

🟢 Básicos

Defina o conceito principal por trás de Prometheus.
Quais as vantagens operacionais de adotar Grafana neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Tracing com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de OpenTelemetry.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 11 - Testes de Backend 🧩

🟢 Básicos

Defina o conceito principal por trás de Testes Unitários.
Quais as vantagens operacionais de adotar Postman neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Pact com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de K6.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 12 - Deploy e DevOps 🧩

🟢 Básicos

Defina o conceito principal por trás de CI/CD.
Quais as vantagens operacionais de adotar Blue/Green neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Canary com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Feature Flags.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 13 - Serverless e Edge 🧩

🟢 Básicos

Defina o conceito principal por trás de AWS Lambda.
Quais as vantagens operacionais de adotar FaaS neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Workers com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Vercel.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 14 - API Gateways 🧩

🟢 Básicos

Defina o conceito principal por trás de Kong.
Quais as vantagens operacionais de adotar Apigee neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente Rate Limiting com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Load Balancing.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 15 - Ecossistemas 🧩

🟢 Básicos

Defina o conceito principal por trás de Node.js.
Quais as vantagens operacionais de adotar Spring Boot neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente .NET com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Go.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Exercício 16 - Tópicos Avançados 🧩

🟢 Básicos

Defina o conceito principal por trás de Service Mesh.
Quais as vantagens operacionais de adotar RAG APIs neste modelo arquitetural?

🟡 Intermediários

Compare detalhadamente AI Backend com uma arquitetura monolítica tradicional.
Escreva um pseudo-código ou comando CLI que inicie um serviço de Webhooks.

🔴 Desafio

Projete a arquitetura de um ecommerce que deve suportar picos na Black Friday usando os conceitos listados nesta aula. Considere resiliência e failover.

Acessar Soluções

Quizzes

Quizzes Interativos 🧭

Acesse todo o conteúdo prático da disciplina.

Módulo 1 – Fundamentos e Arquitetura

Quiz 01 - Fundamentos da Web
Quiz 02 - Arquitetura Backend
Quiz 03 - Design de APIs
Quiz 04 - Protocolos de Comunicação

Módulo 2 – Segurança, Dados e Mensageria

Quiz 05 - Sec e Autenticação
Quiz 06 - Persistência e Dados
Quiz 07 - Cache e Performance
Quiz 08 - Event Driven

Módulo 3 – Cloud, Monitoramento e Testes

Quiz 09 - Infra. Cloud Native
Quiz 10 - Observabilidade
Quiz 11 - Testes de Backend
Quiz 12 - Deploy e DevOps

Módulo 4 – Serverless e API Management

Quiz 13 - Serverless e Edge
Quiz 14 - API Gateways
Quiz 15 - Ecossistemas
Quiz 16 - Tópicos Avançados

Quiz 01 - Fundamentos da Web 🌐

1. Pergunta em desenvolvimento sobre Fundamentos da Web?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Fundamentos da Web?

Opção A

Opção B

Opção C

Opção D

Quiz 02 - Arquitetura Backend 🌐

1. Pergunta em desenvolvimento sobre Arquitetura Backend?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Arquitetura Backend?

Opção A

Opção B

Opção C

Opção D

Quiz 03 - Design de APIs 🌐

1. Pergunta em desenvolvimento sobre Design de APIs?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Design de APIs?

Opção A

Opção B

Opção C

Opção D

Quiz 04 - Protocolos de Comunicação 🌐

1. Pergunta em desenvolvimento sobre Protocolos de Comunicação?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Protocolos de Comunicação?

Opção A

Opção B

Opção C

Opção D

Quiz 05 - Segurança em APIs 🌐

1. Pergunta em desenvolvimento sobre Segurança em APIs?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Segurança em APIs?

Opção A

Opção B

Opção C

Opção D

Quiz 06 - Persistência e Bancos de Dados 🌐

1. Pergunta em desenvolvimento sobre Persistência e Bancos de Dados?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Persistência e Bancos de Dados?

Opção A

Opção B

Opção C

Opção D

Quiz 07 - Cache e Performance 🌐

1. Pergunta em desenvolvimento sobre Cache e Performance?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Cache e Performance?

Opção A

Opção B

Opção C

Opção D

Quiz 08 - Arquitetura Event Driven 🌐

1. Pergunta em desenvolvimento sobre Arquitetura Event Driven?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Arquitetura Event Driven?

Opção A

Opção B

Opção C

Opção D

Quiz 09 - Cloud Native 🌐

1. Pergunta em desenvolvimento sobre Cloud Native?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Cloud Native?

Opção A

Opção B

Opção C

Opção D

Quiz 10 - Observabilidade 🌐

1. Pergunta em desenvolvimento sobre Observabilidade?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Observabilidade?

Opção A

Opção B

Opção C

Opção D

Quiz 11 - Testes de Software Backend 🌐

1. Pergunta em desenvolvimento sobre Testes de Software Backend?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Testes de Software Backend?

Opção A

Opção B

Opção C

Opção D

Quiz 12 - Deploy e DevOps 🌐

1. Pergunta em desenvolvimento sobre Deploy e DevOps?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Deploy e DevOps?

Opção A

Opção B

Opção C

Opção D

Quiz 13 - Serverless e Edge 🌐

1. Pergunta em desenvolvimento sobre Serverless e Edge?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Serverless e Edge?

Opção A

Opção B

Opção C

Opção D

Quiz 14 - API Gateways 🌐

1. Pergunta em desenvolvimento sobre API Gateways?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre API Gateways?

Opção A

Opção B

Opção C

Opção D

Quiz 15 - Ecossistemas de Backend 🌐

1. Pergunta em desenvolvimento sobre Ecossistemas de Backend?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Ecossistemas de Backend?

Opção A

Opção B

Opção C

Opção D

Quiz 16 - Tópicos Avançados 🌐

1. Pergunta em desenvolvimento sobre Tópicos Avançados?

Opção A

Opção B

Opção C

Opção D

2. Pergunta em desenvolvimento sobre Tópicos Avançados?

Opção A

Opção B

Opção C

Opção D

Projetos

Projetos Práticos 🧭

Acesse todo o conteúdo prático da disciplina.

Módulo 1 – Fundamentos e Arquitetura

Projeto 01 - Fundamentos da Web
Projeto 02 - Arquitetura Backend
Projeto 03 - Design de APIs
Projeto 04 - Protocolos de Comunicação

Módulo 2 – Segurança, Dados e Mensageria

Projeto 05 - Sec e Autenticação
Projeto 06 - Persistência e Dados
Projeto 07 - Cache e Performance
Projeto 08 - Event Driven

Módulo 3 – Cloud, Monitoramento e Testes

Projeto 09 - Infra. Cloud Native
Projeto 10 - Observabilidade
Projeto 11 - Testes de Backend
Projeto 12 - Deploy e DevOps

Módulo 4 – Serverless e API Management

Projeto 13 - Serverless e Edge
Projeto 14 - API Gateways
Projeto 15 - Ecossistemas
Projeto 16 - Tópicos Avançados

Projeto 01 - Fundamentos da Web 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Arquitetura cliente-servidor e Sistemas distribuídos utilizando as boas práticas da engenharia moderna baseada em HTTP/2.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Monólito e Microsserviços.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 02 - Arquitetura Backend 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Clean Architecture e Hexagonal utilizando as boas práticas da engenharia moderna baseada em DDD.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do CQRS.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 03 - Design de APIs 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de REST Constraints e HATEOAS utilizando as boas práticas da engenharia moderna baseada em GraphQL.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Versionamento.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 04 - Protocolos de Comunicação 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de gRPC e WebSockets utilizando as boas práticas da engenharia moderna baseada em Streaming.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do SSE.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 05 - Sec e Autenticação 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de JWT e OAuth 2.0 utilizando as boas práticas da engenharia moderna baseada em OpenID.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do OWASP API.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 06 - Persistência e Dados 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Relacional e NoSQL utilizando as boas práticas da engenharia moderna baseada em ACID.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Eventual Consistency.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 07 - Cache e Performance 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Redis e CDN utilizando as boas práticas da engenharia moderna baseada em Cache aside.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Pagination.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 08 - Event Driven 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Kafka e RabbitMQ utilizando as boas práticas da engenharia moderna baseada em Pub/Sub.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Event Streaming.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 09 - Infra. Cloud Native 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Docker e Kubernetes utilizando as boas práticas da engenharia moderna baseada em Service Discovery.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Autoscaling.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 10 - Observabilidade 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Prometheus e Grafana utilizando as boas práticas da engenharia moderna baseada em Tracing.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do OpenTelemetry.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 11 - Testes de Backend 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Testes Unitários e Postman utilizando as boas práticas da engenharia moderna baseada em Pact.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do K6.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 12 - Deploy e DevOps 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de CI/CD e Blue/Green utilizando as boas práticas da engenharia moderna baseada em Canary.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Feature Flags.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 13 - Serverless e Edge 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de AWS Lambda e FaaS utilizando as boas práticas da engenharia moderna baseada em Workers.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Vercel.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 14 - API Gateways 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Kong e Apigee utilizando as boas práticas da engenharia moderna baseada em Rate Limiting.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Load Balancing.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 15 - Ecossistemas 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Node.js e Spring Boot utilizando as boas práticas da engenharia moderna baseada em .NET.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Go.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Projeto 16 - Tópicos Avançados 💼

Objetivo Prático

Criar uma implementação funcional (PoC) que unifique os conceitos de Service Mesh e RAG APIs utilizando as boas práticas da engenharia moderna baseada em AI Backend.

📋 Requisitos do Sistema

O serviço deve expor pelo menos 2 rotas configuradas.
Deve possuir tratamento de erro global para os cenários baseados na teoria do Webhooks.
Deve existir um script autônomo para inicializar e popular variáveis de teste.

🛠️ Passo a Passo

Setup: Inicie seu repósitorio e adicione seu framework Web preferido.
Modelagem: Crie os contratos baseados na OpenAPI ou modelo assíncrono.
Desenvolvimento: Construa a lógica central de negócio, desacoplando o I/O usando padrões como portas e adaptadores.
Verificação: Realize o teste com cURL, Insomnia ou Postman.

$ curl -X GET http://localhost:8080/health
[OK] {"status": "UP", "resources": "healthy"}

Soluções

Solução 01 - Fundamentos da Web 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Fundamentos da Web.

Arquitetura cliente-servidor refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Sistemas distribuídos, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando HTTP/2, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 http/2-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 02 - Arquitetura Backend 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Arquitetura Backend.

Clean Architecture refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Hexagonal, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando DDD, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 ddd-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 03 - Design de APIs 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Design de APIs.

REST Constraints refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando HATEOAS, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando GraphQL, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 graphql-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 04 - Protocolos de Comunicação 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Protocolos de Comunicação.

gRPC refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando WebSockets, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Streaming, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.

Comando CLI:

docker run -p 8080:80 streaming-service

Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 05 - Sec e Autenticação 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Sec e Autenticação.

JWT refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando OAuth 2.0, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando OpenID, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 openid-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 06 - Persistência e Dados 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Persistência e Dados.

Relacional refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando NoSQL, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando ACID, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 acid-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 07 - Cache e Performance 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Cache e Performance.

Redis refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando CDN, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Cache aside, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.

Comando CLI:

docker run -p 8080:80 cache_aside-service

Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 08 - Event Driven 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Event Driven.

Kafka refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando RabbitMQ, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Pub/Sub, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 pub/sub-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 09 - Infra. Cloud Native 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Infra. Cloud Native.

Docker refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Kubernetes, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Service Discovery, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.

Comando CLI:

docker run -p 8080:80 service_discovery-service

Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 10 - Observabilidade 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Observabilidade.

Prometheus refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Grafana, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Tracing, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 tracing-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 11 - Testes de Backend 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Testes de Backend.

Testes Unitários refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Postman, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Pact, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 pact-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 12 - Deploy e DevOps 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Deploy e DevOps.

CI/CD refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Blue/Green, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Canary, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 canary-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 13 - Serverless e Edge 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Serverless e Edge.

AWS Lambda refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando FaaS, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Workers, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 workers-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 14 - API Gateways 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em API Gateways.

Kong refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Apigee, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando Rate Limiting, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.

Comando CLI:

docker run -p 8080:80 rate_limiting-service

Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 15 - Ecossistemas 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Ecossistemas.

Node.js refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando Spring Boot, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando .NET, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.
Comando CLI:
```
docker run -p 8080:80 .net-service 
```
Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Solução 16 - Tópicos Avançados 🔑

Resolução Oficial

Aqui estão as respostas detalhadas para o exercício focado em Tópicos Avançados.

Service Mesh refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas.
Adotando RAG APIs, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente.
Considerando AI Backend, ganhamos liberdade tecnológica (poliglotismo), mas aumentamos a complexidade de rede e observabilidade comparado a um monólito que roda em um único processo da JVM/CLR/Node.

Comando CLI:

docker run -p 8080:80 ai_backend-service

Solução Arquitetural: O fluxo deveria passar por um API Gateway que realiza throttling. As chamadas síncronas iriam para os serviços críticos, e o processamento de compras seria enfileirado usando um broker para amortecer os requests.

⬅️ Voltar aos Exercícios

Configuração

Configuração do Ambiente ⚙️

Windows

Ver Setup - Linux

Ver Setup - Mac

Ver Setup

📋 Próximos Passos

Vá para o primeiro Módulo de Aulas.

Setup 01 - Instalação no Windows ⚙️

Ambiente de Desenvolvimento

Preparando sua máquina com as ferramentas adequadas para rodar os simuladores de cloud-native.

📥 Pré-requisitos

Python 3.11+
Docker Engine
Git Version Control

🚀 Passo a Passo

$ git clone https://github.com/ricardotecpro/ads_mod_07_backends_e_apis.git
$ cd ads_mod_07_backends_e_apis
$ pip install -r requirements.txt
[OK] Ambiente inicializado!

Setup 02 - Instalação no Linux ⚙️

Ambiente de Desenvolvimento

Preparando sua máquina com as ferramentas adequadas para rodar os simuladores de cloud-native.

📥 Pré-requisitos

Python 3.11+
Docker Engine
Git Version Control

🚀 Passo a Passo

$ git clone https://github.com/ricardotecpro/ads_mod_07_backends_e_apis.git
$ cd ads_mod_07_backends_e_apis
$ pip install -r requirements.txt
[OK] Ambiente inicializado!

Setup 03 - Instalação no Mac (Intel/Apple Silicon) ⚙️

Ambiente de Desenvolvimento

Preparando sua máquina com as ferramentas adequadas para rodar os simuladores de cloud-native.

📥 Pré-requisitos

Python 3.11+
Docker Engine
Git Version Control

🚀 Passo a Passo

$ git clone https://github.com/ricardotecpro/ads_mod_07_backends_e_apis.git
$ cd ads_mod_07_backends_e_apis
$ pip install -r requirements.txt
[OK] Ambiente inicializado!

Versão para Impressão

Esta página foi gerada automaticamente para impressão.

Engenharia de Backends e APIs Modernas 🚀

💡 Dicas de Sucesso

ℹ️ Sobre o Curso

🗺️ Plano de Ensino

🎓 Aulas

Índice de Aulas 🧭

Módulo 1 - Fundamentos da Web

Módulo 2 - Arquitetura Backend

Módulo 3 - Design de APIs

Módulo 4 - Protocolos de Comunicação

Módulo 5 - Sec e Autenticação

Módulo 6 - Persistência e Dados

Módulo 7 - Cache e Performance

Módulo 8 - Event Driven

Módulo 9 - Infra. Cloud Native

Módulo 10 - Observabilidade

Módulo 11 - Testes de Backend

Módulo 12 - Deploy e DevOps

Módulo 13 - Serverless e Edge

Módulo 14 - API Gateways

Módulo 15 - Ecossistemas

Módulo 16 - Tópicos Avançados

Módulo 1 – Fundamentos e Arquitetura

🌐 Aula 01 - Fundamentos da Web e Sistemas Distribuídos

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em HTTP/2 💻

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 02 - Arquitetura de Software Backend

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em DDD 💻

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 03 - Design de APIs

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em GraphQL 💻

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 04 - Protocolos de APIs e Comunicação

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em Streaming 💻

Analisando o Código fonte

🔗 Materiais da Aula

Módulo 2 – Segurança, Dados e Mensageria

🌐 Aula 05 - Autenticação, Autorização e Segurança

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em OpenID 💻

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 06 - Persistência e Camada de Dados

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em ACID 💻

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 07 - Cache e Performance

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em Cache aside 💻

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 08 - Mensageria e Arquitetura Orientada a Eventos

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

3. Prática: Hands-on em Pub/Sub 💻

Analisando o Código fonte

🔗 Materiais da Aula

3. Prática: Hands-on em `HTTP/2` 💻

3. Prática: Hands-on em `DDD` 💻

3. Prática: Hands-on em `GraphQL` 💻

3. Prática: Hands-on em `Streaming` 💻

3. Prática: Hands-on em `OpenID` 💻

3. Prática: Hands-on em `ACID` 💻

3. Prática: Hands-on em `Cache aside` 💻

3. Prática: Hands-on em `Pub/Sub` 💻

3. Prática: Hands-on em `Service Discovery` 💻

3. Prática: Hands-on em `Tracing` 💻

3. Prática: Hands-on em `Pact` 💻

3. Prática: Hands-on em `Canary` 💻

3. Prática: Hands-on em `Workers` 💻

3. Prática: Hands-on em `Rate Limiting` 💻

3. Prática: Hands-on em `.NET` 💻

3. Prática: Hands-on em `AI Backend` 💻