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.

Plano de Ensino 🧭

Curso: Engenharia de Backends e APIs Modernas
Público-alvo: Estudantes de ADS, Ciência da Computação e Desenvolvedores de Software
Carga Horária: 20 Aulas (80 Horas Teórico-Práticas)

🎯 1. Objetivos do Curso

Compreender os fundamentos conceituais e arquiteturais de Engenharia de Backends e APIs Modernas.
Aplicar padrões de projeto, sintaxe moderna e boas práticas da indústria.
Desenvolver soluções completas através de exercícios práticos e desafios de projeto.

📚 2. Cronograma de Aulas (Matriz de 20 Semanas)

Aula	Tema Central	Atividades e Entregas
01	Aula 01 - Fundamentos da Web e Sistemas Distribuídos	Teoria, Prática Guiada, Quiz e Exercícios
02	Aula 02 - Arquitetura de Software Backend	Teoria, Prática Guiada, Quiz e Exercícios
03	Aula 03 - Design de APIs	Teoria, Prática Guiada, Quiz e Exercícios
04	Aula 04 - Protocolos de APIs e Comunicação	Teoria, Prática Guiada, Quiz e Exercícios
05	Aula 05 - Autenticação, Autorização e Segurança	Teoria, Prática Guiada, Quiz e Exercícios
06	Aula 06 - Persistência e Camada de Dados	Teoria, Prática Guiada, Quiz e Exercícios
07	Aula 07 - Cache e Performance	Teoria, Prática Guiada, Quiz e Exercícios
08	Aula 08 - Mensageria e Arquitetura Orientada a Eventos	Teoria, Prática Guiada, Quiz e Exercícios
09	Aula 09 - Infraestrutura Cloud Native	Teoria, Prática Guiada, Quiz e Exercícios
10	Aula 10 - Observabilidade e Monitoramento	Teoria, Prática Guiada, Quiz e Exercícios
11	Aula 11 - Testes de Backend	Teoria, Prática Guiada, Quiz e Exercícios
12	Aula 12 - Deploy e DevOps	Teoria, Prática Guiada, Quiz e Exercícios
13	Aula 13 - Serverless e Edge Computing	Teoria, Prática Guiada, Quiz e Exercícios
14	Aula 14 - API Management e Gateways	Teoria, Prática Guiada, Quiz e Exercícios
15	Aula 15 - Ecossistemas de Backend (visão geral)	Teoria, Prática Guiada, Quiz e Exercícios
16	Aula 16 - Tópicos Avançados e Tendências	Teoria, Prática Guiada, Quiz e Exercícios
17	Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC)	Teoria, Prática Guiada, Quiz e Exercícios
18	Autenticação Segura (OAuth2, OpenID Connect e JWT)	Teoria, Prática Guiada, Quiz e Exercícios
19	Rate Limiting, Throttling e Proteção contra Ataques	Teoria, Prática Guiada, Quiz e Exercícios
20	Projeto Capstone: Gateway de APIs Autônomo e Escalável	Teoria, Prática Guiada, Quiz e Exercícios

🧠 3. Metodologia de Ensino

Teoria Fundamentada: Aulas com conceitos detalhados, diagramas arquiteturais e sintaxe de referência.
Ciclo Teoria ⇄ Prática: Cada aula conta com Quiz Interativo (10 questões) para validação imediata, Lista de Exercícios Sanfonados (com Gabarito Explicado) e Desafio de Projeto Prático.
Laboratório Contínuo: Ambientes configurados passo a passo na seção de Setups da plataforma.

💼 4. Competências e Perfil Desenvolvido

Dominar as ferramentas e fluxos de desenvolvimento de Engenharia de Backends e APIs Modernas.
Resolver problemas técnicos de alta complexidade com código limpo e performático.
Construir portfólio prático com 20 projetos aplicados.

📊 5. Critérios de Avaliação

20 Listas de Exercícios: Resolução individual dividida em Básico, Intermediário e Desafio.
20 Quizzes Interativos: Validação formativa com feedback imediato via JavaScript.
20 Desafios de Projetos: Aplicações práticas consolidando o aprendizado de cada unidade.

Aulas

Aulas do Curso

Bem-vindo à seção de aulas! Aqui você encontra todo o conteúdo do curso organizado em 5 módulos estruturados.

📚 Módulos do Curso

Módulo 1: Fundamentos & Bases ---
Módulo 2: Arquitetura & Conceitos Essenciais ---
Módulo 3: Engenharia & Aplicação Prática ---
Módulo 4: Software, Ferramentas & Padrões ---
Módulo 5: Tópicos Avançados & Projeto Capstone ---

🌐 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

🌐 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

🌐 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

🌐 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

Aula 17 - Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🌐

Objetivo Pedagógico

Objetivo: Análise comparativa e arquitetura de estilos de comunicação entre serviços: RESTful com HATEOAS, GraphQL para consultas sob demanda e gRPC com Protocol Buffers.

📑 1. Fundamentos Teóricos & Análise Técnica

A escolha do protocolo e estilo arquitetural de uma API define a escalabilidade, o consumo de banda de rede e a complexidade de integração entre sistemas. No cenário de engenharia moderna, três paradigmas predominam: 1. REST (Representational State Transfer): Baseado nos verbos e códigos de status do HTTP (GET, POST, PUT, DELETE), com suporte universal a cache e HATEOAS. Contudo, padece frequentemente de problemas de Over-fetching (receber mais dados do que o necessário) ou Under-fetching (necessitar de múltiplas requisições sequenciais para montar uma tela). 2. GraphQL: Permite que o cliente defina declarativamente o formato exato da resposta através de um esquema fortemente tipado (Schema Definition Language - SDL). Resolve o over/under-fetching em uma única chamada HTTP POST, mas exige complexidade adicional para cache em nível de rede e controle de complexidade de queries. 3. gRPC (Google Remote Procedure Call): Protocolo de alta performance executado sobre HTTP/2 com serialização binária compacta através de Protocol Buffers (protobuf). É o padrão de fato para comunicação síncrona entre microsserviços internos, reduzindo drasticamente a latência e o overhead de CPU comparado ao JSON textual.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    ClientWeb["Web Client / SPA"] -->|GraphQL (Sob Demanda)| Gateway["API Gateway / BFF"]
    ClientMobile["Mobile Client"] -->|REST / JSON| Gateway
    Gateway -->|gRPC / HTTP2 Protobuf (Ultrarrápido)| ServiceAuth["Microsserviço Auth"]
    Gateway -->|gRPC / HTTP2 Protobuf| ServiceOrders["Microsserviço Pedidos"]
    Gateway -->|gRPC / HTTP2 Protobuf| ServicePayment["Microsserviço Pagamentos"]
    style ClientWeb fill:#e1f5fe,stroke:#01579b
    style Gateway fill:#fff3e0,stroke:#e65100
    style ServiceOrders fill:#e8f5e9,stroke:#2e7d32

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Contrato por Esquema Forte: Uso de arquivos .proto ou .graphql para validação bidirecional de payloads. - Multiplexação HTTP/2: Envio concorrente de múltiplas requisições em uma única conexão TCP persistente em gRPC. - Mitigação de Over-fetching: GraphQL garante payloads enxutos essenciais para conexões móveis lentas. - Idempotência em Métodos REST: Garantia de que operações PUT e DELETE possam ser repetidas com segurança em falhas de rede.

🛠️ 2. Implementação Prática em Arquitetura de APIs e Protocolos de Rede

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// order_service.proto (Contrato gRPC com Protocol Buffers v3)
syntax = "proto3";

package ecommerce.orders.v1;

option go_package = "ecommerce/orders/v1;ordersv1";

service OrderService {
  rpc CreateOrder (CreateOrderRequest) returns (OrderResponse);
  rpc StreamOrderUpdates (OrderStreamRequest) returns (stream OrderStatusUpdate);
}

message CreateOrderRequest {
  string customer_id = 1;
  repeated OrderItem items = 2;
  double total_amount = 3;
}

message OrderItem {
  string product_id = 1;
  int32 quantity = 2;
  double unit_price = 3;
}

message OrderResponse {
  string order_id = 1;
  string status = 2;
  int64 created_at_unix = 3;
}

message OrderStreamRequest {
  string order_id = 1;
}

message OrderStatusUpdate {
  string status = 1;
  string message = 2;
}

💡 Análise Passo a Passo do Código

Sintaxe Proto3 Compacta: Campos numéricos (= 1, = 2) representam tags binárias que eliminam o envio de strings de nomes de chaves na rede.
Streaming Bidirecional: stream OrderStatusUpdate permite que o servidor envie atualizações contínuas de status em tempo real via HTTP/2.
Geração de Código Multi-Linguagem: O compilador protoc gera stubs tipados automaticamente para Go, Java, Python, C# e Node.js.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Aula 18 - Autenticação Segura (OAuth2, OpenID Connect e JWT) 🔐

Objetivo Pedagógico

Objetivo: Arquitetura de autenticação e autorização stateless com tokens JWT assinados com RSA/ECDSA, fluxo OAuth 2.1 Authorization Code com PKCE e OpenID Connect.

📑 1. Fundamentos Teóricos & Análise Técnica

A segurança em ecossistemas de APIs modernas requer desacoplamento estrito entre o provedor de identidade e os serviços consumidores. O padrão de indústria consolidado fundamenta-se na tríade: 1. OAuth 2.1: Framework de autorização delegado que concede a aplicações clientes acesso restrito a recursos em nome do proprietário. O fluxo moderno obrigatório para SPAs e apps móveis é o Authorization Code Flow com PKCE (Proof Key for Code Exchange), eliminando o inseguro fluxo implícito (Implicit Grant). 2. OpenID Connect (OIDC): Camada de identidade construída sobre o OAuth 2.0 que padroniza o ID Token, permitindo que o cliente verifique a identidade do usuário final e obtenha seu perfil básico através do endpoint /userinfo. 3. JSON Web Tokens (JWT - RFC 7519): Estrutura compacta e autocontida codificada em Base64URL composta por Header, Payload e Signature.

Boas práticas críticas de segurança com JWT: - Assinatura assimétrica obrigatória com chaves públicas/privadas (RS256 ou ES256), permitindo que microsserviços validem tokens localmente sem consultar o servidor de autenticação a cada requisição. - Tokens de acesso (Access Tokens) com tempo de vida efêmero (5 a 15 minutos). - Rotação segura de Refresh Tokens armazenados exclusivamente em cookies HttpOnly; Secure; SameSite=Strict.

📐 Arquitetura Conceitual & Diagrama de Fluxo

sequenceDiagram
    autonumber
    actor U as Usuário / SPA
    participant AuthServer as Authorization Server (OIDC)
    participant Gateway as API Gateway / Backend

    U->>AuthServer: 1. Login com PKCE (Code Challenge)
    AuthServer-->>U: 2. Authorization Code
    U->>AuthServer: 3. Troca Code + Code Verifier
    AuthServer-->>U: 4. Emite Access Token (JWT) + Refresh Token
    U->>Gateway: 5. Requisição HTTP (Header: Authorization Bearer <JWT>)
    Note over Gateway: 6. Validação Criptográfica Local com Chave Pública (JWKS)
    Gateway-->>U: 7. Resposta Autorizada (200 OK)

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Autenticação Stateless: Nenhuma sessão mantida em memória no backend; a assinatura criptográfica atesta a integridade do token. - Fluxo PKCE Mandatório: Prevenção contra interceptação de código de autorização em clientes públicos. - Chaves Públicas via JWKS: Exposição de chaves públicas rotacionáveis no endpoint /.well-known/jwks.json. - Defesa em Profundidade: Validação estrita de claims (exp, iss, aud) em todas as chamadas de API.

🛠️ 2. Implementação Prática em Segurança em APIs, OAuth 2.1 e JWT

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// jwt-verifier.ts (Validação Criptográfica de JWT com JWKS)
import jwt from 'jsonwebtoken';
import jwksClient from 'jwks-rsa';

const client = jwksClient({
  jwksUri: 'https://auth.empresa.com/.well-known/jwks.json',
  cache: true,
  rateLimit: true,
  jwksRequestsPerMinute: 10
});

function getKey(header: jwt.JwtHeader, callback: jwt.SigningKeyCallback) {
  client.getSigningKey(header.kid, (err, key) => {
    if (err) return callback(err);
    const signingKey = key?.getPublicKey();
    callback(null, signingKey);
  });
}

export function verifyAccessToken(token: string): Promise<jwt.JwtPayload> {
  return new Promise((resolve, reject) => {
    jwt.verify(
      token,
      getKey,
      {
        audience: 'https://api.empresa.com',
        issuer: 'https://auth.empresa.com/',
        algorithms: ['RS256']
      },
      (err, decoded) => {
        if (err) return reject(new Error(`Token Inválido: ${err.message}`));
        resolve(decoded as jwt.JwtPayload);
      }
    );
  });
}

💡 Análise Passo a Passo do Código

Integração JWKS: O cliente jwksClient obtém a chave pública correspondente ao kid (Key ID) do cabeçalho do token em cache.
Validação de Claims: audience e issuer são estritamente verificados para impedir que tokens emitidos para outros serviços sejam aceitos.
Algoritmo RS256 Assimétrico: A chave privada nunca sai do Authorization Server; os microsserviços usam apenas a chave pública.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Aula 19 - Rate Limiting, Throttling e Proteção contra Ataques 🛡️

Objetivo Pedagógico

Objetivo: Implementação de mecanismos de contenção de tráfego com Token Bucket / Sliding Window no Redis, mitigação de DDoS e proteção contra ataques de força bruta.

📑 1. Fundamentos Teóricos & Análise Técnica

Serviços expostos à internet pública estão sujeitos a ataques de negação de serviço (DoS/DDoS), credential stuffing, raspagem agressiva de dados (scraping) e degradação de infraestrutura por clientes mal configurados. Para garantir a disponibilidade contínua do sistema (High Availability), mecanismos de controle de vazão de tráfego são imperativos.

Os dois conceitos operam em camadas distintas: 1. Rate Limiting: Política que define o número máximo de requisições que uma entidade identificada (por IP, API Key ou User ID) pode realizar em uma janela temporal (ex: 100 requisições por minuto). 2. Throttling: Técnica de estrangulamento que desacelera progressivamente o processamento das requisições excedentes ou enfileira chamadas antes de rejeitá-las abruptamente.

Os algoritmos industriais mais eficientes são: - Token Bucket: Balde virtual que recebe tokens em taxa constante. Cada requisição consome um token; se o balde esvaziar, o cliente recebe HTTP 429 Too Many Requests. Suporta rajadas curtas (bursts). - Sliding Window Log / Counter: Mantém o registro temporal exato no Redis com estruturas ZSET, calculando a soma móvel das requisições na janela deslizante com precisão milimétrica.

📐 Arquitetura Conceitual & Diagrama de Fluxo

flowchart TD
    Req["Requisição do Cliente"] --> CheckRedis["Consulta Janela no Redis (Sliding Window)"]
    CheckRedis --> LimitCheck{"Requisições na Janela < Limite?"}
    LimitCheck -->|Sim: Permitido| RegisterReq["Registra Timestamp no ZSET"]
    RegisterReq --> Forward["Encaminha para o Controller do Backend"]
    LimitCheck -->|Não: Excedido| Block["Retorna HTTP 429 Too Many Requests"]
    Block --> Headers["Headers: Retry-After, X-RateLimit-Reset"]
    style Req fill:#e1f5fe,stroke:#01579b
    style CheckRedis fill:#fff3e0,stroke:#e65100
    style Forward fill:#e8f5e9,stroke:#2e7d32
    style Block fill:#ffebee,stroke:#c62828

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Armazenamento Atômico em Redis: Execução de scripts Lua para checar e incrementar contadores em uma única operação atômica de rede. - Headers Informativos RFC 6585: Envio dos cabeçalhos X-RateLimit-Limit, X-RateLimit-Remaining e Retry-After. - Rate Limiting Multinível: Políticas globais por IP combinadas com limites estritos por usuário autenticado. - Degradação Graciosa (Graceful Degradation): Circuit Breakers que cortam integrações lentas antes que causem travamento geral do pool de threads.

🛠️ 2. Implementação Prática em Proteção de APIs, Redis e Resiliência

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// sliding_window_rate_limiter.lua (Script Lua Atômico para Redis)
-- Script Lua executado atomicamente no Redis
local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])

local clearBefore = now - window

-- 1. Remove registros fora da janela deslizante atual
redis.call('ZREMRANGEBYSCORE', key, '-inf', clearBefore)

-- 2. Conta quantas requisições restam na janela
local currentRequests = redis.call('ZCARD', key)

if currentRequests < limit then
  -- 3. Adiciona a requisição atual com score igual ao timestamp
  redis.call('ZADD', key, now, now)
  redis.call('EXPIRE', key, math.ceil(window / 1000))
  return 1 -- Permitido!
else
  return 0 -- Bloqueado (Limite Excedido)!
end

💡 Análise Passo a Passo do Código

Atomicidade Absoluta: Scripts Lua executam sem interrupção no Redis, eliminando condições de corrida (race conditions) em acessos concorrentes.
Remoção Automática: ZREMRANGEBYSCORE descarta logs antigos instantaneamente antes de calcular o total.
Precisão Temporal: A janela deslizante evita a vulnerabilidade clássica de borda das janelas fixas (Fixed Window Spikes).

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Aula 20 - Projeto Capstone: Gateway de APIs Autônomo e Escalável 🏆

Objetivo Pedagógico

Objetivo: Construção de um API Gateway autônomo e resiliente, integrando roteamento dinâmico, validação de JWT, rate limiting com Redis e métricas de observabilidade.

📑 1. Fundamentos Teóricos & Análise Técnica

O Projeto Capstone de Backends e APIs é o desafio prático culminante da disciplina. Ele coloca o estudante no papel de Arquiteto de Software responsável por projetar e implementar o ponto central de entrada de uma malha de microsserviços: o API Gateway.

O Gateway funciona como uma fachada reversa (Reverse Proxy) que abstrai a complexidade interna dos serviços downstream, centralizando requisitos não-funcionais transversais.

O projeto consolidará os seguintes componentes de engenharia: 1. Roteamento Dinâmico de Tráfego: Encaminhamento inteligente de requisições com reescrita de rotas (path rewriting) e balanceamento de carga básico. 2. Autenticação Unificada: Interceptação de cabeçalhos Authorization: Bearer <JWT>, validação da assinatura criptográfica e injeção do cabeçalho enriquecido X-User-Id para os serviços internos. 3. Mecanismo de Rate Limiting: Proteção de endpoints sensíveis (ex: /api/v1/auth/login) com Redis em janela deslizante. 4. Resiliência e Observabilidade: Implementação de timeouts agressivos, tratamento de erro 502/504 e registro estruturado de logs com correlation IDs (X-Correlation-ID).

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    Client["Clientes Externos (Web / Mobile)"] --> Gateway["API Gateway Centralizado"]
    Gateway --> RL["Redis (Rate Limiter Sliding Window)"]
    Gateway --> JWT["Validador JWT (JWKS Cache)"]
    Gateway --> ServiceUsers["Microsserviço de Usuários (Porta 3001)"]
    Gateway --> ServiceCatalog["Microsserviço de Catálogo (Porta 3002)"]
    Gateway --> ServiceOrders["Microsserviço de Pedidos (Porta 3003)"]
    style Client fill:#e1f5fe,stroke:#01579b
    style Gateway fill:#fff3e0,stroke:#e65100
    style RL fill:#e8f5e9,stroke:#2e7d32
    style ServiceOrders fill:#f3e5f5,stroke:#7b1fa2

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Padrão BFF (Backend for Frontend): Adaptação de payloads sob medida para as necessidades específicas de cada cliente. - Rastreabilidade Distribuída: Propagação do X-Correlation-ID por toda a cadeia de microsserviços para depuração com OpenTelemetry. - Isolamento de Segurança: Os microsserviços de backend não são expostos diretamente à internet pública. - Fail-Fast e Circuit Breaker: Interrupção rápida de chamadas para serviços degradados para não sobrecarregar o Gateway.

🛠️ 2. Implementação Prática em API Gateway, Proxy Reverso e Microsserviços

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// gateway-proxy.ts (Núcleo do API Gateway com Proxy e Headers)
import express, { Request, Response } from 'express';
import { createProxyMiddleware } from 'http-proxy-middleware';
import { randomUUID } from 'crypto';

const app = express();

// 1. Middleware de Correlação de Logs
app.use((req: Request, res: Response, next) => {
  const correlationId = req.headers['x-correlation-id'] || randomUUID();
  req.headers['x-correlation-id'] = correlationId;
  res.setHeader('X-Correlation-ID', correlationId);
  next();
});

// 2. Roteamento Reverso para o Microsserviço de Catálogo
app.use('/api/v1/catalog', createProxyMiddleware({
  target: 'http://localhost:3002',
  changeOrigin: true,
  pathRewrite: { '^/api/v1/catalog': '' },
  onProxyReq: (proxyReq, req) => {
    // Injeta cabeçalho de usuário autenticado
    proxyReq.setHeader('X-Gateway-Auth', 'Authorized-Internal');
  }
}));

app.listen(8080, () => {
  console.log('[API Gateway] Operando na porta 8080.');
});

💡 Análise Passo a Passo do Código

Correlation ID Global: Gera ou propaga identificador único para rastrear a requisição em todas as etapas da arquitetura distribuída.
Proxy Reverso Seguro: createProxyMiddleware redireciona o tráfego HTTP sem revelar as portas internas dos microsserviços.
Path Rewrite Automático: Limpa o prefixo do gateway (/api/v1/catalog) antes de entregar a requisição na rota raiz do serviço downstream.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Exercícios

🏋️ Exercícios do Curso

Lista completa das 20 unidades de exercicios organizadas em 5 módulos didáticos.

Módulo 1: Fundamentos (01 a 04) ---
Módulo 2: Conceitos Essenciais (05 a 08) ---
Módulo 3: Aplicação Prática (09 a 12) ---
Módulo 4: Padrões e Ferramentas (13 a 16) ---
Módulo 5: Avançado e Capstone (17 a 20) ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Fundamentos da Web. 1. **Arquitetura cliente-servidor** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Sistemas distribuídos**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 http/2-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Arquitetura Backend. 1. **Clean Architecture** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Hexagonal**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 ddd-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Design de APIs. 1. **REST Constraints** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **HATEOAS**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 graphql-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Protocolos de Comunicação. 1. **gRPC** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **WebSockets**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 streaming-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Sec e Autenticação. 1. **JWT** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **OAuth 2.0**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 openid-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Persistência e Dados. 1. **Relacional** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **NoSQL**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 acid-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Cache e Performance. 1. **Redis** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **CDN**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 cache_aside-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Event Driven. 1. **Kafka** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **RabbitMQ**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 pub/sub-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Infra. Cloud Native. 1. **Docker** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Kubernetes**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 service_discovery-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Observabilidade. 1. **Prometheus** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Grafana**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 tracing-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Testes de Backend. 1. **Testes Unitários** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Postman**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 pact-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Deploy e DevOps. 1. **CI/CD** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Blue/Green**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 canary-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Serverless e Edge. 1. **AWS Lambda** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **FaaS**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 workers-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em API Gateways. 1. **Kong** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Apigee**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 rate_limiting-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Ecossistemas. 1. **Node.js** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **Spring Boot**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 .net-service

5. **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. ---

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.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

!!! success "Resolução Oficial" Aqui estão as respostas detalhadas para o exercício focado em Tópicos Avançados. 1. **Service Mesh** refere-se ao modelo escalável onde as responsabilidades são isoladas para maior tolerância a falhas. 2. Adotando **RAG APIs**, eliminamos pontos únicos de falha e permitimos que diferentes equipes evoluam o código independentemente. 3. 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. 4. Comando CLI:

docker run -p 8080:80 ai_backend-service

5. **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. ---

Projetos

🚀 Projetos do Curso

Lista completa das 20 unidades de projetos organizadas em 5 módulos didáticos.

Módulo 1: Fundamentos (01 a 04) ---
Módulo 2: Conceitos Essenciais (05 a 08) ---
Módulo 3: Aplicação Prática (09 a 12) ---
Módulo 4: Padrões e Ferramentas (13 a 16) ---
Módulo 5: Avançado e Capstone (17 a 20) ---

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"}

Quizzes

🧠 Quizzes de Fixação

Lista completa das 20 unidades de quizzes organizadas em 5 módulos didáticos.

Módulo 1: Fundamentos (01 a 04) ---
Módulo 2: Conceitos Essenciais (05 a 08) ---
Módulo 3: Aplicação Prática (09 a 12) ---
Módulo 4: Padrões e Ferramentas (13 a 16) ---
Módulo 5: Avançado e Capstone (17 a 20) ---

🧠 Quiz 01 – Fundamentos da Web e Sistemas Distribuídos

Qual é o conceito fundamental e objetivo principal de Fundamentos da Web e Sistemas Distribuídos?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Fundamentos da Web e Sistemas Distribuídos?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Fundamentos da Web e Sistemas Distribuídos, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Fundamentos da Web e Sistemas Distribuídos?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Fundamentos da Web e Sistemas Distribuídos atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Fundamentos da Web e Sistemas Distribuídos, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 01 - Fundamentos da Web e Sistemas Distribuídos?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Fundamentos da Web e Sistemas Distribuídos estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Fundamentos da Web e Sistemas Distribuídos com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Fundamentos da Web e Sistemas Distribuídos deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 02 – Arquitetura de Software Backend

Qual é o conceito fundamental e objetivo principal de Arquitetura de Software Backend?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Arquitetura de Software Backend?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Arquitetura de Software Backend, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Arquitetura de Software Backend?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Arquitetura de Software Backend atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Arquitetura de Software Backend, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 02 - Arquitetura de Software Backend?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Arquitetura de Software Backend estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Arquitetura de Software Backend com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Arquitetura de Software Backend deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 03 – Design de APIs

Qual é o conceito fundamental e objetivo principal de Design de APIs?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Design de APIs?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Design de APIs, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Design de APIs?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Design de APIs atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Design de APIs, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 03 - Design de APIs?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Design de APIs estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Design de APIs com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Design de APIs deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 04 – Protocolos de APIs e Comunicação

Qual é o conceito fundamental e objetivo principal de Protocolos de APIs e Comunicação?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Protocolos de APIs e Comunicação?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Protocolos de APIs e Comunicação, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Protocolos de APIs e Comunicação?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Protocolos de APIs e Comunicação atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Protocolos de APIs e Comunicação, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 04 - Protocolos de APIs e Comunicação?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Protocolos de APIs e Comunicação estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Protocolos de APIs e Comunicação com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Protocolos de APIs e Comunicação deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 05 – Autenticação, Autorização e Segurança

Qual é o conceito fundamental e objetivo principal de Autenticação, Autorização e Segurança?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Autenticação, Autorização e Segurança?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Autenticação, Autorização e Segurança, Autorização e Segurança, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Autenticação, Autorização e Segurança?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Autenticação, Autorização e Segurança atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Autenticação, Autorização e Segurança, Autorização e Segurança, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 05 - Autenticação, Autorização e Segurança?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Autenticação, Autorização e Segurança estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Autenticação, Autorização e Segurança com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Autenticação, Autorização e Segurança deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 06 – Persistência e Camada de Dados

Qual é o conceito fundamental e objetivo principal de Persistência e Camada de Dados?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Persistência e Camada de Dados?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Persistência e Camada de Dados, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Persistência e Camada de Dados?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Persistência e Camada de Dados atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Persistência e Camada de Dados, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 06 - Persistência e Camada de Dados?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Persistência e Camada de Dados estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Persistência e Camada de Dados com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Persistência e Camada de Dados deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 07 – Cache e Performance

Qual é o conceito fundamental e objetivo principal de Cache e Performance?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Cache e Performance?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Cache e Performance, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Cache e Performance?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Cache e Performance atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Cache e Performance, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 07 - Cache e Performance?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Cache e Performance estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Cache e Performance com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Cache e Performance deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 08 – Mensageria e Arquitetura Orientada a Eventos

Qual é o conceito fundamental e objetivo principal de Mensageria e Arquitetura Orientada a Eventos?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Mensageria e Arquitetura Orientada a Eventos?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Mensageria e Arquitetura Orientada a Eventos, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Mensageria e Arquitetura Orientada a Eventos?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Mensageria e Arquitetura Orientada a Eventos atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Mensageria e Arquitetura Orientada a Eventos, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 08 - Mensageria e Arquitetura Orientada a Eventos?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Mensageria e Arquitetura Orientada a Eventos estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Mensageria e Arquitetura Orientada a Eventos com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Mensageria e Arquitetura Orientada a Eventos deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 09 – Infraestrutura Cloud Native

Qual é o conceito fundamental e objetivo principal de Infraestrutura Cloud Native?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Infraestrutura Cloud Native?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Infraestrutura Cloud Native, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Infraestrutura Cloud Native?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Infraestrutura Cloud Native atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Infraestrutura Cloud Native, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 09 - Infraestrutura Cloud Native?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Infraestrutura Cloud Native estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Infraestrutura Cloud Native com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Infraestrutura Cloud Native deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 10 – Observabilidade e Monitoramento

Qual é o conceito fundamental e objetivo principal de Observabilidade e Monitoramento?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Observabilidade e Monitoramento?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Observabilidade e Monitoramento, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Observabilidade e Monitoramento?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Observabilidade e Monitoramento atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Observabilidade e Monitoramento, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 10 - Observabilidade e Monitoramento?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Observabilidade e Monitoramento estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Observabilidade e Monitoramento com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Observabilidade e Monitoramento deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 11 – Testes de Backend

Qual é o conceito fundamental e objetivo principal de Testes de Backend?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Testes de Backend?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Testes de Backend, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Testes de Backend?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Testes de Backend atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Testes de Backend, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 11 - Testes de Backend?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Testes de Backend estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Testes de Backend com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Testes de Backend deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 12 – Deploy e DevOps

Qual é o conceito fundamental e objetivo principal de Deploy e DevOps?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Deploy e DevOps?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Deploy e DevOps, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Deploy e DevOps?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Deploy e DevOps atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Deploy e DevOps, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 12 - Deploy e DevOps?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Deploy e DevOps estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Deploy e DevOps com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Deploy e DevOps deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 13 – Serverless e Edge Computing

Qual é o conceito fundamental e objetivo principal de Serverless e Edge Computing?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Serverless e Edge Computing?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Serverless e Edge Computing, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Serverless e Edge Computing?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Serverless e Edge Computing atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Serverless e Edge Computing, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 13 - Serverless e Edge Computing?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Serverless e Edge Computing estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Serverless e Edge Computing com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Serverless e Edge Computing deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 14 – API Management e Gateways

Qual é o conceito fundamental e objetivo principal de API Management e Gateways?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de API Management e Gateways?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em API Management e Gateways, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em API Management e Gateways?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de API Management e Gateways atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em API Management e Gateways, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 14 - API Management e Gateways?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a API Management e Gateways estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar API Management e Gateways com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a API Management e Gateways deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 15 – Ecossistemas de Backend (visão geral)

Qual é o conceito fundamental e objetivo principal de Ecossistemas de Backend (visão geral)?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Ecossistemas de Backend (visão geral)?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Ecossistemas de Backend (visão geral), assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Ecossistemas de Backend (visão geral)?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Ecossistemas de Backend (visão geral) atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Ecossistemas de Backend (visão geral), o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 15 - Ecossistemas de Backend (visão geral)?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Ecossistemas de Backend (visão geral) estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Ecossistemas de Backend (visão geral) com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Ecossistemas de Backend (visão geral) deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 16 – Tópicos Avançados e Tendências

Qual é o conceito fundamental e objetivo principal de Tópicos Avançados e Tendências?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Tópicos Avançados e Tendências?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Tópicos Avançados e Tendências, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Tópicos Avançados e Tendências?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Tópicos Avançados e Tendências atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Tópicos Avançados e Tendências, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em 🌐 Aula 16 - Tópicos Avançados e Tendências?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Tópicos Avançados e Tendências estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Tópicos Avançados e Tendências com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Tópicos Avançados e Tendências deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 17 – Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀

Qual o propósito principal de Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀?
( ) Reduzir o espaço em disco sem validação.
(x) Garantir estruturação, eficiência e robustez no processamento do sistema.
( ) Desativar os testes unitários automatizados.
( ) Substituir a documentação técnica por código legado.
Qual benefício direto é obtido ao aplicar os padrões de Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀?
(x) Maior manutenibilidade, legibilidade e desempenho.
( ) Aumento no tempo de resposta das chamadas à API.
( ) Incompatibilidade com compiladores modernos.
( ) Bloqueio da execução assíncrona.
Em relação à arquitetura de Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀, assinale a alternativa correta:
( ) O módulo opera de forma totalmente isolada sem interface de dados.
(x) O fluxo de dados segue validação de entrada, processamento e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de apresentação.
( ) Não há suporte para testes de integração.
Qual a melhor prática ao implementar Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀?
(x) Manter o código coeso, desacoplado e devidamente documentado.
( ) Utilizar variáveis globais sem controle de acesso.
( ) Omitir o tratamento de erros em produção.
( ) Desabilitar a checagem de tipos estáticos.
Como verificar se a implementação de Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀 atingiu os objetivos de qualidade?
( ) Observando o tamanho do arquivo fonte em bytes.
(x) Executando testes automatizados de cobertura e benchmarks de desempenho.
( ) Verificando a cor do tema do editor de código.
( ) Aguardando reclamações dos usuários finais em produção.
Ao lidar com exceções em Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀, deve-se:
(x) Capturar falhas específicas e fornecer mensagens informativas com rastreamento.
( ) Ignorar todos os erros com blocos vazios try-catch.
( ) Encerrar o sistema imediatamente sem log.
( ) Modificar o sistema operacional hospedeiro.
Qual o impacto do mau uso dos conceitos de Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀?
(x) Degradação de desempenho, vulnerabilidades de segurança e débito técnico.
( ) Redução automática no uso de memória RAM.
( ) Melhoria na taxa de transferência de dados da rede.
( ) Formatação automática de arquivos Markdown.
O princípio da responsabilidade única aplicado a Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀 determina que:
(x) Cada classe ou função deve ter apenas uma razão para mudar.
( ) Todas as funções do sistema devem residir no mesmo arquivo.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os comentários de código devem ser removidos antes da compilação.
Na integração de Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀 com outros componentes do ecossistema:
(x) Deve-se utilizar interfaces bem definidas e contratos claros (APIs/DTOs).
( ) Deve-se utilizar acesso direto às estruturas privadas de outros módulos.
( ) É proibido transmitir dados pela rede.
( ) Todos os dados devem ser trafegados em formato de texto bruto desformatado.
A documentação técnica referente a Arquiteturas de APIs Avançadas (GraphQL vs REST vs gRPC) 🚀 deve conter:
(x) Requisitos, diagramas de fluxo, exemplos de uso e instruções de teste.
( ) Apenas o nome do autor do código.
( ) Lista de reprodução de músicas recomendadas.
( ) Histórico completo de conversas do suporte.

🧠 Quiz 18 – Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀

Qual o propósito principal de Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀?
( ) Reduzir o espaço em disco sem validação.
(x) Garantir estruturação, eficiência e robustez no processamento do sistema.
( ) Desativar os testes unitários automatizados.
( ) Substituir a documentação técnica por código legado.
Qual benefício direto é obtido ao aplicar os padrões de Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀?
(x) Maior manutenibilidade, legibilidade e desempenho.
( ) Aumento no tempo de resposta das chamadas à API.
( ) Incompatibilidade com compiladores modernos.
( ) Bloqueio da execução assíncrona.
Em relação à arquitetura de Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀, assinale a alternativa correta:
( ) O módulo opera de forma totalmente isolada sem interface de dados.
(x) O fluxo de dados segue validação de entrada, processamento e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de apresentação.
( ) Não há suporte para testes de integração.
Qual a melhor prática ao implementar Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀?
(x) Manter o código coeso, desacoplado e devidamente documentado.
( ) Utilizar variáveis globais sem controle de acesso.
( ) Omitir o tratamento de erros em produção.
( ) Desabilitar a checagem de tipos estáticos.
Como verificar se a implementação de Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀 atingiu os objetivos de qualidade?
( ) Observando o tamanho do arquivo fonte em bytes.
(x) Executando testes automatizados de cobertura e benchmarks de desempenho.
( ) Verificando a cor do tema do editor de código.
( ) Aguardando reclamações dos usuários finais em produção.
Ao lidar com exceções em Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀, deve-se:
(x) Capturar falhas específicas e fornecer mensagens informativas com rastreamento.
( ) Ignorar todos os erros com blocos vazios try-catch.
( ) Encerrar o sistema imediatamente sem log.
( ) Modificar o sistema operacional hospedeiro.
Qual o impacto do mau uso dos conceitos de Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀?
(x) Degradação de desempenho, vulnerabilidades de segurança e débito técnico.
( ) Redução automática no uso de memória RAM.
( ) Melhoria na taxa de transferência de dados da rede.
( ) Formatação automática de arquivos Markdown.
O princípio da responsabilidade única aplicado a Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀 determina que:
(x) Cada classe ou função deve ter apenas uma razão para mudar.
( ) Todas as funções do sistema devem residir no mesmo arquivo.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os comentários de código devem ser removidos antes da compilação.
Na integração de Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀 com outros componentes do ecossistema:
(x) Deve-se utilizar interfaces bem definidas e contratos claros (APIs/DTOs).
( ) Deve-se utilizar acesso direto às estruturas privadas de outros módulos.
( ) É proibido transmitir dados pela rede.
( ) Todos os dados devem ser trafegados em formato de texto bruto desformatado.
A documentação técnica referente a Autenticação Segura (OAuth2, OpenID Connect e JWT) 🚀 deve conter:
(x) Requisitos, diagramas de fluxo, exemplos de uso e instruções de teste.
( ) Apenas o nome do autor do código.
( ) Lista de reprodução de músicas recomendadas.
( ) Histórico completo de conversas do suporte.

🧠 Quiz 19 – Rate Limiting, Throttling e Proteção contra Ataques 🚀

Qual o propósito principal de Rate Limiting, Throttling e Proteção contra Ataques 🚀?
( ) Reduzir o espaço em disco sem validação.
(x) Garantir estruturação, eficiência e robustez no processamento do sistema.
( ) Desativar os testes unitários automatizados.
( ) Substituir a documentação técnica por código legado.
Qual benefício direto é obtido ao aplicar os padrões de Rate Limiting, Throttling e Proteção contra Ataques 🚀?
(x) Maior manutenibilidade, legibilidade e desempenho.
( ) Aumento no tempo de resposta das chamadas à API.
( ) Incompatibilidade com compiladores modernos.
( ) Bloqueio da execução assíncrona.
Em relação à arquitetura de Rate Limiting, Throttling e Proteção contra Ataques 🚀, assinale a alternativa correta:
( ) O módulo opera de forma totalmente isolada sem interface de dados.
(x) O fluxo de dados segue validação de entrada, processamento e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de apresentação.
( ) Não há suporte para testes de integração.
Qual a melhor prática ao implementar Rate Limiting, Throttling e Proteção contra Ataques 🚀?
(x) Manter o código coeso, desacoplado e devidamente documentado.
( ) Utilizar variáveis globais sem controle de acesso.
( ) Omitir o tratamento de erros em produção.
( ) Desabilitar a checagem de tipos estáticos.
Como verificar se a implementação de Rate Limiting, Throttling e Proteção contra Ataques 🚀 atingiu os objetivos de qualidade?
( ) Observando o tamanho do arquivo fonte em bytes.
(x) Executando testes automatizados de cobertura e benchmarks de desempenho.
( ) Verificando a cor do tema do editor de código.
( ) Aguardando reclamações dos usuários finais em produção.
Ao lidar com exceções em Rate Limiting, Throttling e Proteção contra Ataques 🚀, deve-se:
(x) Capturar falhas específicas e fornecer mensagens informativas com rastreamento.
( ) Ignorar todos os erros com blocos vazios try-catch.
( ) Encerrar o sistema imediatamente sem log.
( ) Modificar o sistema operacional hospedeiro.
Qual o impacto do mau uso dos conceitos de Rate Limiting, Throttling e Proteção contra Ataques 🚀?
(x) Degradação de desempenho, vulnerabilidades de segurança e débito técnico.
( ) Redução automática no uso de memória RAM.
( ) Melhoria na taxa de transferência de dados da rede.
( ) Formatação automática de arquivos Markdown.
O princípio da responsabilidade única aplicado a Rate Limiting, Throttling e Proteção contra Ataques 🚀 determina que:
(x) Cada classe ou função deve ter apenas uma razão para mudar.
( ) Todas as funções do sistema devem residir no mesmo arquivo.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os comentários de código devem ser removidos antes da compilação.
Na integração de Rate Limiting, Throttling e Proteção contra Ataques 🚀 com outros componentes do ecossistema:
(x) Deve-se utilizar interfaces bem definidas e contratos claros (APIs/DTOs).
( ) Deve-se utilizar acesso direto às estruturas privadas de outros módulos.
( ) É proibido transmitir dados pela rede.
( ) Todos os dados devem ser trafegados em formato de texto bruto desformatado.
A documentação técnica referente a Rate Limiting, Throttling e Proteção contra Ataques 🚀 deve conter:
(x) Requisitos, diagramas de fluxo, exemplos de uso e instruções de teste.
( ) Apenas o nome do autor do código.
( ) Lista de reprodução de músicas recomendadas.
( ) Histórico completo de conversas do suporte.

🧠 Quiz 20 – Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀

Qual o propósito principal de Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀?
( ) Reduzir o espaço em disco sem validação.
(x) Garantir estruturação, eficiência e robustez no processamento do sistema.
( ) Desativar os testes unitários automatizados.
( ) Substituir a documentação técnica por código legado.
Qual benefício direto é obtido ao aplicar os padrões de Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀?
(x) Maior manutenibilidade, legibilidade e desempenho.
( ) Aumento no tempo de resposta das chamadas à API.
( ) Incompatibilidade com compiladores modernos.
( ) Bloqueio da execução assíncrona.
Em relação à arquitetura de Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀, assinale a alternativa correta:
( ) O módulo opera de forma totalmente isolada sem interface de dados.
(x) O fluxo de dados segue validação de entrada, processamento e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de apresentação.
( ) Não há suporte para testes de integração.
Qual a melhor prática ao implementar Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀?
(x) Manter o código coeso, desacoplado e devidamente documentado.
( ) Utilizar variáveis globais sem controle de acesso.
( ) Omitir o tratamento de erros em produção.
( ) Desabilitar a checagem de tipos estáticos.
Como verificar se a implementação de Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀 atingiu os objetivos de qualidade?
( ) Observando o tamanho do arquivo fonte em bytes.
(x) Executando testes automatizados de cobertura e benchmarks de desempenho.
( ) Verificando a cor do tema do editor de código.
( ) Aguardando reclamações dos usuários finais em produção.
Ao lidar com exceções em Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀, deve-se:
(x) Capturar falhas específicas e fornecer mensagens informativas com rastreamento.
( ) Ignorar todos os erros com blocos vazios try-catch.
( ) Encerrar o sistema imediatamente sem log.
( ) Modificar o sistema operacional hospedeiro.
Qual o impacto do mau uso dos conceitos de Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀?
(x) Degradação de desempenho, vulnerabilidades de segurança e débito técnico.
( ) Redução automática no uso de memória RAM.
( ) Melhoria na taxa de transferência de dados da rede.
( ) Formatação automática de arquivos Markdown.
O princípio da responsabilidade única aplicado a Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀 determina que:
(x) Cada classe ou função deve ter apenas uma razão para mudar.
( ) Todas as funções do sistema devem residir no mesmo arquivo.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os comentários de código devem ser removidos antes da compilação.
Na integração de Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀 com outros componentes do ecossistema:
(x) Deve-se utilizar interfaces bem definidas e contratos claros (APIs/DTOs).
( ) Deve-se utilizar acesso direto às estruturas privadas de outros módulos.
( ) É proibido transmitir dados pela rede.
( ) Todos os dados devem ser trafegados em formato de texto bruto desformatado.
A documentação técnica referente a Projeto Capstone: Gateway de APIs Autônomo e Escalável 🚀 deve conter:
(x) Requisitos, diagramas de fluxo, exemplos de uso e instruções de teste.
( ) Apenas o nome do autor do código.
( ) Lista de reprodução de músicas recomendadas.
( ) Histórico completo de conversas do suporte.

Slides

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!

Sobre

ℹ️ Sobre o Curso

Bem-vindo à disciplina de Backend.

Materiais Complementares 📚

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

🏷️ Índice de Tags Didáticas

Navegue pelas aulas, exercícios e projetos do curso organizados por temas, tecnologias e conceitos fundamentais:

tags.md:145-167/name

Versão para Impressão

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

Engenharia de Backends e APIs Modernas 🚀

💡 Dicas de Sucesso

Plano de Ensino 🧭

🎯 1. Objetivos do Curso

📚 2. Cronograma de Aulas (Matriz de 20 Semanas)

🧠 3. Metodologia de Ensino

💼 4. Competências e Perfil Desenvolvido

📊 5. Critérios de Avaliação

Aulas

Aulas do Curso

📚 Módulos do Curso

🌐 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

🌐 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

🌐 Aula 09 - Infraestrutura Cloud Native

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

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

Analisando o Código fonte

🔗 Materiais da Aula

🌐 Aula 10 - Observabilidade e Monitoramento

1. Visão Geral Teórica 🧠

2. Arquitetura e Modelagem 📊

2.1 Comparativo de Tecnologias

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

Analisando o Código fonte

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` 💻