HTTP, hosting et middleware

POST /api/commandes HTTP/1.1          ← verbe + chemin + version
Host: boutique.fr                      ← en-têtes : métadonnées
Content-Type: application/json
Authorization: Bearer eyJhbGciOi...
Accept-Language: fr-FR

{ "produitId": 42, "quantite": 2 }     ← corps (facultatif)

HTTP/1.1 201 Created                   ← code de statut
Location: /api/commandes/1024           ← en-têtes de réponse
Content-Type: application/json

{ "id": 1024, "statut": "creee" }       ← corps

var builder = WebApplication.CreateBuilder(args);
// … enregistrement des services (voir chapitre 11) …
var app = builder.Build();

// ---------- 1. Gestion des erreurs : le plus à l'extérieur possible ----------
if (app.Environment.IsDevelopment())
    app.UseDeveloperExceptionPage();
else
{
    app.UseExceptionHandler();
    app.UseHsts();
}

// ---------- 2. Réseau / transport ----------
app.UseHttpsRedirection();
app.UseResponseCompression();

// ---------- 3. Fichiers statiques (avant le routage : inutile de router un .css) ----------
app.MapStaticAssets();          // .NET 9+ : compression et empreintes à la compilation

// ---------- 4. Routage ----------
app.UseRouting();

// ---------- 5. CORS — après le routage, avant l'authentification ----------
app.UseCors("front");

// ---------- 6. Qui es-tu ? puis : as-tu le droit ? ----------
app.UseAuthentication();
app.UseAuthorization();         // ⚠️ TOUJOURS après UseAuthentication

// ---------- 7. Limitation de débit, sessions, antiforgerie ----------
app.UseRateLimiter();

// ---------- 8. Les points de terminaison ----------
app.MapGet("/sante", () => Results.Ok("ok"));
app.MapControllers();

app.Run();

// Version courte, pour un besoin simple
app.Use(async (ctx, suivant) =>
{
    var chrono = Stopwatch.StartNew();
    ctx.Response.Headers["X-Trace-Id"] = ctx.TraceIdentifier;

    await suivant(ctx);            // ← passe la main au maillon suivant

    // au RETOUR : la réponse existe déjà
    app.Logger.LogInformation("{Methode} {Chemin} → {Statut} en {Ms}ms",
        ctx.Request.Method, ctx.Request.Path, ctx.Response.StatusCode, chrono.ElapsedMilliseconds);
});

// Version en classe, testable et injectable
public class MiddlewareLocataire(RequestDelegate suivant)
{
    public async Task InvokeAsync(HttpContext ctx, IContexteLocataire contexte)  // ← DI possible ici
    {
        var id = ctx.Request.Headers["X-Locataire"].FirstOrDefault();
        if (string.IsNullOrEmpty(id))
        {
            ctx.Response.StatusCode = StatusCodes.Status400BadRequest;
            await ctx.Response.WriteAsJsonAsync(new { erreur = "En-tête X-Locataire manquant" });
            return;                 // ← court-circuit : le reste du pipeline n'est PAS exécuté
        }
        contexte.Definir(id);
        await suivant(ctx);
    }
}
app.UseMiddleware<MiddlewareLocataire>();

app.UseWhen(
    ctx => ctx.Request.Path.StartsWithSegments("/api"),
    branche => branche.UseMiddleware<MiddlewareQuotas>());

app.Map("/admin", admin => { admin.UseMiddleware<MiddlewareAudit>(); /* … */ });

var builder = WebApplication.CreateBuilder(args);
// Cette seule ligne met en place :
//  • la configuration (appsettings, environnement, arguments, user-secrets)
//  • la journalisation (console, débogueur)
//  • le conteneur d'injection de dépendances
//  • le serveur Kestrel
//  • la détection de l'environnement (ASPNETCORE_ENVIRONMENT)

// Configurer le serveur
builder.WebHost.ConfigureKestrel(o =>
{
    o.Limits.MaxRequestBodySize = 10 * 1024 * 1024;      // 10 Mo
    o.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
});

var app = builder.Build();
app.Run();          // bloque jusqu'à l'arrêt du processus

// Une tâche de fond qui respecte l'arrêt demandé
public class NettoyageNocturne(IServiceScopeFactory fabrique, ILogger<NettoyageNocturne> log)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken arret)
    {
        while (!arret.IsCancellationRequested)
        {
            using (var portee = fabrique.CreateScope())        // ← portée par cycle (chapitre 11)
            {
                var db = portee.ServiceProvider.GetRequiredService<AppDbContext>();
                var supprimes = await db.Sessions
                    .Where(s => s.Expiration < DateTime.UtcNow)
                    .ExecuteDeleteAsync(arret);
                log.LogInformation("{N} sessions expirées supprimées", supprimes);
            }
            await Task.Delay(TimeSpan.FromHours(1), arret);    // ← le jeton interrompt l'attente
        }
    }
}