Aula 11 — Plano de Ensino — Mergulhando nas Redes

Identificação

Disciplina

IN02 · Desenvolvimento Web

Módulo

2 — Ciclo Comum

Aula

11 de 11 (encerramento)

Carga horária do dia

6h (2h + 2h + 2h)

Modalidade

Presencial · Metodologia ativa

Pré-aula

Autoestudo guiado

Resumo

A aula 11 conecta a stack à internet real. Os alunos atravessam o modelo TCP/IP de 4 camadas, comparam TCP × UDP com 3-way handshake, percorrem o DNS registro por registro, entendem o TLS handshake conceitual, exploram HTTP/1.1 × 2 × 3, dominam cache HTTP (Cache-Control, ETag, 304), atravessam uma CDN (origem/edge/PoP) e fecham com padrões de tolerância a falhas (retry com backoff exponencial + jitter, timeout, idempotência, circuit breaker, fallback, health checks, observabilidade RED).

O encerramento amarra tudo no nosso stack TS + Express + EJS + SSR + pg — a infraestrutura de rede deixa de ser caixa-preta para virar superfície de design.

Objetivos de aprendizagem

OA-1Posicionar HTTP, TLS, TCP e IP nas camadas TCP/IP de 4 níveis.
OA-2Distinguir TCP de UDP e justificar a escolha conforme o caso de uso.
OA-3Resolver um nome via DNS passo a passo, identificando registros A / CNAME / MX / TXT.
OA-4Aplicar cache HTTP correto (Cache-Control, ETag, 304) por tipo de recurso.
OA-5Desenhar a interação navegador → CDN → origem com hit/miss explícitos.
OA-6Aplicar retry com backoff+jitter, timeout, idempotência e circuit breaker no nosso stack TS.

Pré-requisitos

Aulas 1–10 concluídas: o projeto já está em produção (ou pronto para deploy) com testes e CI verdes.
Domínio próprio do projeto acessível (mesmo que ainda em ambiente de staging).
Ambiente local com dig ou nslookup disponível e acesso ao DevTools do navegador.

Importante

Aqui a equipe blinda o projeto contra falhas reais de rede — não é teoria abstrata: cada conceito vira mudança de código no projeto integrador antes das 16h.

Cronograma do dia

📚 Bloco 1 · Autoestudo

08h00 — 10h00

Estudo individual orientado pelo material da aula 11.

Leitura completa do Material da Aula 11 (TCP/IP, DNS, TLS, HTTP, cache, CDN, resiliência).
Rodar dig (ou nslookup) no domínio do projeto e registrar os registros encontrados (A, CNAME, MX, NS, TTL).
Mapear quais respostas do back-end fazem sentido cachear e por quanto tempo (HTML SSR, estáticos, JSON dinâmico, JSON privado).
Caderno de bordo: anotar dúvidas sobre TLS handshake e diferenças HTTP/1.1 × 2 × 3.

🎓 Bloco 2 · Instrução PE — Aula em metodologia ativa

10h00 — 12h00

Encontro síncrono com o professor especialista. 15 minutos de daily seguidos de 1h45 de aula.

10h00 — 10h15 · Daily: registros DNS e plano de cache trazidos do autoestudo.
10h15 — 12h00 · TCP/IP, DNS, TLS, cache, retry/timeout, idempotência e circuit breaker.

🍴 Intervalo · Almoço

12h00 — 14h00

Janela livre.

🛠️ Bloco 3 · Desenvolvimento do projeto

14h00 — 16h00

Janela de trabalho da equipe sobre o projeto integrador.

Aplicar Cache-Control coerente nos endpoints (HTML SSR, estáticos, JSON público, JSON privado).
Configurar timeout via AbortController em todos os fetch internos.
Aplicar retry com backoff exponencial + jitter na chamada externa principal do projeto.
Documentar plano de tolerância a falhas em docs/redes/resiliencia.md (timeouts, retries, idempotência, circuit breaker, fallback).
Abrir Merge Request feat(net): cache + resiliência com evidência (DevTools mostrando 304 e logs de retry).

Detalhamento da instrução PE (10h00 — 12h00)

10h00
10h15

DailyDaily de abertura

Cada aluno apresenta, em 1 minuto, o resultado do dig no domínio do projeto e o item mais surpreendente que encontrou (TTL alto demais, CNAME inesperado, etc).

10h15
10h30

TalkPor que um dev backend precisa entender redes

Casos reais: timeout sem retry derrubando produção, cache mal configurado mostrando dado errado para outro usuário, falta de idempotência cobrando duas vezes. Rede não é problema do "ops", é design de API.

10h30
10h45

TalkTCP/IP 4 camadas + TCP × UDP + 3-way handshake

Apresentação do modelo de 4 camadas (Acesso, Internet, Transporte, Aplicação), diferença entre TCP (confiável, ordenado) e UDP (rápido, sem garantia), e desenho do 3-way handshake (SYN / SYN-ACK / ACK).

10h45
11h00

TalkDNS — registros + resolução + TTL

Caminho completo: stub resolver → recursivo → root → TLD → autoritativo. Tipos de registro (A, AAAA, CNAME, MX, TXT, NS) e o papel do TTL em cache de resolução.

11h00
11h15

TalkTLS handshake conceitual + Let's Encrypt

Visão conceitual do handshake TLS (ClientHello → ServerHello → certificado → key exchange → Finished). Como o Let's Encrypt emite certificados via ACME e por que renovação automática é mandatória.

11h15
11h30

CodingCache-Control + ETag + 304

Demo ao vivo: aplicar Cache-Control: public, max-age=... em estáticos, no-store em JSON privado, e ETag + revalidação 304 em endpoint dinâmico. DevTools com Disable cache ON/OFF para ver a diferença.

11h30
11h45

CodingTimeout + retry com backoff exponencial + jitter (TS)

Em pares: implementar wrapper TS com AbortController para timeout e função de retry com backoff exponencial (2^n) + jitter aleatório. Discussão sobre quando retry é seguro (idempotente) e quando é catastrófico.

11h45
11h55

TalkIdempotência + circuit breaker

Por que PUT e DELETE são idempotentes por design e POST precisa de Idempotency-Key. Conceito de circuit breaker (closed → open → half-open) e quando ele protege a origem de cascata de falhas.

11h55
12h00

AtivaEncerramento do módulo + entrega da tarde

Retrospectiva relâmpago das 11 aulas (1 frase por aluno: "o módulo me ensinou que..."). O professor anuncia a entrega da tarde: cache + timeout + retry + docs/redes/resiliencia.md no MR feat(net): cache + resiliência.

Estratégias de metodologia ativa

Simulação de falha — o professor "mata" um endpoint da CDN ou da origem; cada equipe diagnostica pelo comportamento (status, headers, latência) qual camada falhou.
Competição de cache — em rodadas rápidas, qual time acerta o Cache-Control ideal para cada rota (HTML SSR, estáticos, JSON público, JSON privado, redirect)?
Debate retry seguro × perigoso — turma classifica chamadas reais do projeto em "pode dar retry" vs "nunca dar retry sem Idempotency-Key", justificando.

Recursos e ferramentas

Categoria	Recurso	Uso
Slides	`slides/slide-lesson-11.html`	Exposição na instrução PE
Material	`materials/lesson-11-material.html`	Autoestudo
DNS	`dig` / `nslookup`	Inspeção de registros (A, CNAME, MX, TXT, NS)
HTTP	DevTools Network	Disable cache, Throttling, inspeção de headers
Timeout	`AbortController` (TS)	Cancelar fetch interno antes do limite
Retry	Backoff exponencial + jitter	Wrapper TS para chamada externa principal
Documentação	`docs/redes/resiliencia.md`	Plano de tolerância a falhas do projeto

Verificação de aprendizagem

CR-1Cache-Control coerente aplicado por tipo de recurso (HTML SSR, estáticos, JSON público, JSON privado).
CR-2ETag e revalidação 304 funcionando em pelo menos 1 endpoint do projeto.
CR-3Timeout via AbortController aplicado em todos os fetch internos.
CR-4Retry com backoff exponencial + jitter na chamada externa principal do projeto.
CR-5docs/redes/resiliencia.md com plano de tolerância a falhas + MR feat(net): cache + resiliência aberto até as 16h.

Critério mínimo

Aluno que sair às 16h sem Cache-Control coerente, timeout em todos os fetch e retry com jitter na chamada externa principal está em débito técnico — o projeto não pode ser entregue ao avaliador final sem rede de proteção contra falhas reais de rede.

Encerramento do módulo

A aula 11 fecha o Módulo 2. Em vez de uma "próxima aula", esta seção amarra a trajetória: o módulo começou em HTML/CSS/JS, passou por banco de dados relacional e SQL, construiu um back-end TypeScript com Express + EJS em SSR sobre arquitetura MVC de 6 camadas, cobriu o sistema com testes e CI e agora blindou contra falhas de rede.

Retrospectiva das 11 aulas

Aulas 1–4 · Front estático e fundação relacional: HTML/CSS/JS, modelagem, SQL, JOINs.
Aulas 5–8 · Back-end MVC: Node.js + Express, controllers, services, repositories, helpers e EJS+SSR.
Aulas 9–10 · Qualidade: tipagem TS estrita, testes por camada, Husky e CI verde.
Aula 11 · Infraestrutura de rede: cache, CDN, TLS, resiliência e idempotência.

Ponte para os próximos módulos

O Módulo 3 (e os módulos seguintes do ciclo) parte deste projeto integrador como base — o stack TS + Express + EJS + SSR + pg permanece, e os próximos módulos vão adicionar autenticação, observabilidade, deploy avançado e arquiteturas distribuídas.

Checklist final para entrega do projeto integrador

DER + minimundo + dicionário de dados publicados em docs/banco/.
CRUD funcional em todas as entidades principais via Express + EJS (SSR).
Camadas MVC respeitadas (controllers / services / repositories / helpers / views).
Cobertura de testes mínima por camada + workflow GitHub Actions verde.
Cache + timeout + retry aplicados; docs/redes/resiliencia.md presente.
README com instruções claras de execução local + deploy.

Encerramento

Você sai do Módulo 2 sabendo construir um sistema web inteiro — do banco até o cache da CDN — com qualidade testável e tolerância a falhas. É a fundação sobre a qual todo o resto do ciclo será construído.