CDN

import crypto from "node:crypto";
import http from "node:http";

// Dado público: a CDN guarda por 5 minutos, o navegador por 1, e ambos aceitam
// a cópia vencida enquanto revalidam ou se a origem cair
const CACHE_PUBLICO =
  "public, max-age=60, s-maxage=300, stale-while-revalidate=60, stale-if-error=86400";

http.createServer((req, res) => {
  if (req.url === "/produtos/7") {
    const corpo = JSON.stringify({ id: 7, nome: "Tênis de corrida", preco: "19.90" });
    const etag = `"${crypto.createHash("sha256").update(corpo).digest("hex").slice(0, 16)}"`;
    res.setHeader("Cache-Control", CACHE_PUBLICO);
    res.setHeader("ETag", etag);
    if (req.headers["if-none-match"] === etag) {
      res.statusCode = 304; // a cópia de quem pediu continua valendo: sem corpo
      return res.end();
    }
    res.setHeader("Content-Type", "application/json");
    return res.end(corpo);
  }
  if (req.url === "/minha-conta") {
    // Dado de um usuário: nenhum cache compartilhado pode guardar
    res.setHeader("Cache-Control", "private, no-store");
    res.setHeader("Content-Type", "application/json");
    return res.end(JSON.stringify({ usuario: req.headers["x-usuario"] }));
  }
  res.statusCode = 404;
  res.end();
}).listen(3000);

import hashlib
import json

from fastapi import FastAPI, Header, Response

# Dado público: a CDN guarda por 5 minutos, o navegador por 1, e ambos aceitam
# a cópia vencida enquanto revalidam ou se a origem cair
CACHE_PUBLICO = "public, max-age=60, s-maxage=300, stale-while-revalidate=60, stale-if-error=86400"

app = FastAPI()


@app.get("/produtos/7")
def produto(if_none_match: str | None = Header(None)):
    corpo = json.dumps({"id": 7, "nome": "Tênis de corrida", "preco": "19.90"},
                       ensure_ascii=False, separators=(",", ":"))
    etag = '"' + hashlib.sha256(corpo.encode()).hexdigest()[:16] + '"'
    cabecalhos = {"Cache-Control": CACHE_PUBLICO, "ETag": etag}
    if if_none_match == etag:
        return Response(status_code=304, headers=cabecalhos)  # a cópia continua valendo
    return Response(corpo, media_type="application/json", headers=cabecalhos)


@app.get("/minha-conta")
def minha_conta(x_usuario: str | None = Header(None)):
    # Dado de um usuário: nenhum cache compartilhado pode guardar
    return Response(json.dumps({"usuario": x_usuario}), media_type="application/json",
                    headers={"Cache-Control": "private, no-store"})

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"net/http"
)

// Dado público: a CDN guarda por 5 minutos, o navegador por 1, e ambos aceitam
// a cópia vencida enquanto revalidam ou se a origem cair
const cachePublico = "public, max-age=60, s-maxage=300, " +
	"stale-while-revalidate=60, stale-if-error=86400"

func produto(w http.ResponseWriter, r *http.Request) {
	corpo, _ := json.Marshal(map[string]any{"id": 7, "nome": "Tênis de corrida", "preco": "19.90"})
	soma := sha256.Sum256(corpo)
	etag := `"` + hex.EncodeToString(soma[:])[:16] + `"`
	w.Header().Set("Cache-Control", cachePublico)
	w.Header().Set("ETag", etag)
	if r.Header.Get("If-None-Match") == etag {
		w.WriteHeader(http.StatusNotModified) // a cópia de quem pediu continua valendo
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.Write(corpo)
}

func minhaConta(w http.ResponseWriter, r *http.Request) {
	// Dado de um usuário: nenhum cache compartilhado pode guardar
	w.Header().Set("Cache-Control", "private, no-store")
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{"usuario": r.Header.Get("X-Usuario")})
}

func main() {
	http.HandleFunc("GET /produtos/7", produto)
	http.HandleFunc("GET /minha-conta", minhaConta)
	http.ListenAndServe(":3000", nil)
}

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;

public class Origem {
    // Dado público: a CDN guarda por 5 minutos, o navegador por 1, e ambos aceitam
    // a cópia vencida enquanto revalidam ou se a origem cair
    static final String CACHE_PUBLICO =
        "public, max-age=60, s-maxage=300, stale-while-revalidate=60, stale-if-error=86400";

    static void produto(HttpExchange ex) throws IOException {
        byte[] corpo = "{\"id\":7,\"nome\":\"Tênis de corrida\",\"preco\":\"19.90\"}"
            .getBytes(StandardCharsets.UTF_8);
        String etag;
        try {
            var soma = MessageDigest.getInstance("SHA-256").digest(corpo);
            etag = "\"" + HexFormat.of().formatHex(soma).substring(0, 16) + "\"";
        } catch (Exception e) {
            throw new IOException(e);
        }
        ex.getResponseHeaders().set("Cache-Control", CACHE_PUBLICO);
        ex.getResponseHeaders().set("ETag", etag);
        if (etag.equals(ex.getRequestHeaders().getFirst("If-None-Match"))) {
            ex.sendResponseHeaders(304, -1); // a cópia de quem pediu continua valendo
            return;
        }
        ex.getResponseHeaders().set("Content-Type", "application/json");
        ex.sendResponseHeaders(200, corpo.length);
        ex.getResponseBody().write(corpo);
    }

    static void minhaConta(HttpExchange ex) throws IOException {
        // Dado de um usuário: nenhum cache compartilhado pode guardar
        byte[] corpo = ("{\"usuario\":\"" + ex.getRequestHeaders().getFirst("X-Usuario") + "\"}")
            .getBytes(StandardCharsets.UTF_8);
        ex.getResponseHeaders().set("Cache-Control", "private, no-store");
        ex.getResponseHeaders().set("Content-Type", "application/json");
        ex.sendResponseHeaders(200, corpo.length);
        ex.getResponseBody().write(corpo);
    }

    public static void main(String[] args) throws IOException {
        var servidor = HttpServer.create(new InetSocketAddress(3000), 0);
        servidor.createContext("/produtos/7", ex -> { try (ex) { produto(ex); } });
        servidor.createContext("/minha-conta", ex -> { try (ex) { minhaConta(ex); } });
        servidor.start();
    }
}

using System.Security.Cryptography;
using System.Text;
using System.Text.Encodings.Web;
using System.Text.Json;

// Dado público: a CDN guarda por 5 minutos, o navegador por 1, e ambos aceitam
// a cópia vencida enquanto revalidam ou se a origem cair
const string CachePublico =
    "public, max-age=60, s-maxage=300, stale-while-revalidate=60, stale-if-error=86400";

var app = WebApplication.Create(args);

app.MapGet("/produtos/7", (HttpContext ctx) =>
{
    // Sem escapar acentos, para os mesmos bytes (e o mesmo ETag) das outras versões
    var opcoes = new JsonSerializerOptions { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
    var corpo = JsonSerializer.Serialize(new { id = 7, nome = "Tênis de corrida", preco = "19.90" }, opcoes);
    var hash = Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(corpo)));
    var etag = $"\"{hash[..16]}\"";
    ctx.Response.Headers.CacheControl = CachePublico;
    ctx.Response.Headers.ETag = etag;
    if (ctx.Request.Headers.IfNoneMatch == etag)
        return Results.StatusCode(304); // a cópia de quem pediu continua valendo
    return Results.Text(corpo, "application/json");
});

app.MapGet("/minha-conta", (HttpContext ctx) =>
{
    // Dado de um usuário: nenhum cache compartilhado pode guardar
    ctx.Response.Headers.CacheControl = "private, no-store";
    return Results.Json(new { usuario = ctx.Request.Headers["X-Usuario"].ToString() });
});

app.Run("http://0.0.0.0:3000");