Escalabilidade

import http from "node:http";

let encerrando = false;

const servidor = http.createServer(async (req, res) => {
  if (req.url === "/saude/vivo") return res.end("ok");
  if (req.url === "/saude/pronto") {
    res.statusCode = encerrando ? 503 : 200;
    return res.end(encerrando ? "encerrando" : "pronto");
  }
  // ... rotas da aplicação
});

servidor.listen(3000);

// Tempo para o balanceador perceber a saída; ajuste ao intervalo da verificação
const ESPERA_MS = Number(process.env.ESPERA_MS ?? 5000);

process.on("SIGTERM", async () => {
  encerrando = true;
  await new Promise((r) => setTimeout(r, ESPERA_MS));

  servidor.close(async () => {
    // feche aqui o pool do banco, o cliente do Redis etc.
    process.exit(0);
  });
  servidor.closeIdleConnections();
  setTimeout(() => process.exit(1), 25_000).unref(); // limite de segurança
});

from contextlib import asynccontextmanager

import uvicorn
from fastapi import FastAPI, Response


@asynccontextmanager
async def ciclo_de_vida(app: FastAPI):
    # abra aqui o pool do banco
    yield
    # Roda depois que o Uvicorn parou de aceitar conexões e terminou
    # os pedidos em andamento: feche o pool, o cliente do Redis etc.


app = FastAPI(lifespan=ciclo_de_vida)


@app.get("/saude/vivo")
def vivo():
    return {"status": "ok"}


@app.get("/saude/pronto")
async def pronto(resposta: Response):
    if not await banco_responde():
        resposta.status_code = 503
        return {"status": "indisponível"}
    return {"status": "pronto"}


if __name__ == "__main__":
    # No SIGTERM, o Uvicorn para de aceitar conexões e espera os pedidos
    # em andamento por até 20 s. A espera pelo balanceador fica no
    # orquestrador (preStop), porque o Uvicorn fecha a porta na hora.
    uvicorn.run(app, host="0.0.0.0", port=3000, timeout_graceful_shutdown=20)

package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"sync/atomic"
	"syscall"
	"time"
)

func main() {
	var encerrando atomic.Bool

	mux := http.NewServeMux()
	mux.HandleFunc("GET /saude/vivo", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok"))
	})
	mux.HandleFunc("GET /saude/pronto", func(w http.ResponseWriter, r *http.Request) {
		if encerrando.Load() {
			http.Error(w, "encerrando", http.StatusServiceUnavailable)
			return
		}
		w.Write([]byte("pronto"))
	})

	servidor := &http.Server{Addr: ":3000", Handler: mux}
	go func() {
		if err := servidor.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Fatal(err)
		}
	}()

	ctx, parar := signal.NotifyContext(context.Background(), syscall.SIGTERM, os.Interrupt)
	defer parar()
	<-ctx.Done()

	encerrando.Store(true)
	time.Sleep(5 * time.Second) // tempo para o balanceador perceber

	limite, cancelar := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancelar()
	// Para de aceitar conexões e espera os pedidos em andamento
	if err := servidor.Shutdown(limite); err != nil {
		log.Println("encerramento incompleto:", err)
	}
	// feche aqui o pool do banco
}

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;

public class Servidor {
    private static final AtomicBoolean ENCERRANDO = new AtomicBoolean(false);

    public static void main(String[] args) throws IOException {
        var servidor = HttpServer.create(new InetSocketAddress(3000), 0);
        servidor.setExecutor(Executors.newVirtualThreadPerTaskExecutor());

        servidor.createContext("/saude/vivo", ex -> responder(ex, 200, "ok"));
        servidor.createContext("/saude/pronto", ex -> {
            if (ENCERRANDO.get()) responder(ex, 503, "encerrando");
            else responder(ex, 200, "pronto");
        });
        servidor.start();

        // A JVM executa os ganchos de desligamento ao receber SIGTERM
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            ENCERRANDO.set(true);
            try {
                Thread.sleep(5_000); // tempo para o balanceador perceber
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // Fecha a porta e espera até 20 s pelos pedidos em andamento
            servidor.stop(20);
            // feche aqui o pool do banco
        }));
    }

    static void responder(HttpExchange ex, int status, String corpo) throws IOException {
        var dados = corpo.getBytes();
        ex.sendResponseHeaders(status, dados.length);
        try (var saida = ex.getResponseBody()) {
            saida.write(dados);
        }
    }
}

var builder = WebApplication.CreateBuilder(args);

// Tempo máximo para terminar os pedidos em andamento depois do SIGTERM
builder.Services.Configure<HostOptions>(o => o.ShutdownTimeout = TimeSpan.FromSeconds(25));

var app = builder.Build();
var encerrando = false;

app.MapGet("/saude/vivo", () => Results.Ok("ok"));
app.MapGet("/saude/pronto", () =>
    encerrando ? Results.StatusCode(503) : Results.Ok("pronto"));

// Executado no SIGTERM, antes de o servidor parar de aceitar conexões
app.Lifetime.ApplicationStopping.Register(() =>
{
    encerrando = true;
    Thread.Sleep(TimeSpan.FromSeconds(5)); // tempo para o balanceador perceber
});

app.Run();