Controlli sanitari in .NET.NET Aspire

Articolo
12/15/2024

Le verifiche dello stato di salute forniscono informazioni sulla disponibilità e sullo stato di un'app. Le verifiche di integrità vengono spesso esposte come endpoint HTTP, ma possono anche essere utilizzate internamente dall'app per generare log o eseguire altre attività in base all'integrità attuale. I controlli di integrità vengono generalmente utilizzati insieme a un servizio di monitoraggio esterno o a un orchestratore di contenitori per verificare lo stato di un'app. I dati riportati dai controlli della salute possono essere usati per diversi scenari.

Influenzare le decisioni prese da agenti di orchestrazione dei contenitori, servizi di bilanciamento del carico, gateway API e altri servizi di gestione. Ad esempio, se il controllo di integrità per un'applicazione containerizzata non riesce, potrebbe essere ignorato da un bilanciatore del carico che instrada il traffico.
Verificare che le dipendenze sottostanti siano disponibili, ad esempio un database o una cache, e restituire un messaggio di stato appropriato.
Attivare avvisi o notifiche quando un'app non risponde come previsto.

.NET .NET Aspire endpoint di controllo dell'integrità

.NET .NET Aspire espone due endpoint HTTP di controllo integrità predefiniti negli ambienti di sviluppo quando i metodi AddServiceDefaults e MapDefaultEndpoints vengono chiamati nel file Program.cs.

L'endpoint /health indica se l'app è in esecuzione normalmente ed è pronta per ricevere le richieste. Tutti i controlli sanitari devono essere superati perché l'app sia considerata pronta per accettare il traffico dopo l'avvio.
```
GET /health
```
L'endpoint /health restituisce un codice di stato HTTP 200 e un valore text/plain di Healthy quando l'app è in buone condizioni.
Il /alive indica se un'app è in esecuzione o si è arrestata in modo anomalo e deve essere riavviata. Solo i controlli di integrità contrassegnati con il tag live devono essere passati affinché l'app venga considerata attiva.
```
GET /alive
```
L'endpoint /alive restituisce un codice di stato HTTP 200 e un valore text/plain di Healthy quando l'app è attiva.

I metodi AddServiceDefaults e MapDefaultEndpoints applicano anche varie configurazioni all'app, oltre ai controlli di integrità, come le configurazioni di individuazione dei servizi OpenTelemetry e .

Ambienti non di sviluppo

Negli ambienti non di sviluppo, gli endpoint /health e /alive sono disabilitati per impostazione predefinita. Se è necessario abilitarli, è consigliabile proteggere questi endpoint con varie funzionalità di routing, ad esempio il filtro host e/o l'autorizzazione. Per ulteriori informazioni, vedere Controlli della salute in ASP.NET Core.

Inoltre, può essere vantaggioso configurare timeout delle richieste e caching dell'output per questi endpoint per evitare abusi o attacchi denial-of-service. Per fare ciò, considera il seguente metodo AddDefaultHealthChecks modificato:

public static IHostApplicationBuilder AddDefaultHealthChecks(this IHostApplicationBuilder builder)
{
    builder.Services.AddRequestTimeouts(
        configure: static timeouts =>
            timeouts.AddPolicy("HealthChecks", TimeSpan.FromSeconds(5)));

    builder.Services.AddOutputCache(
        configureOptions: static caching =>
            caching.AddPolicy("HealthChecks",
            build: static policy => policy.Expire(TimeSpan.FromSeconds(10))));

    builder.Services.AddHealthChecks()
        // Add a default liveness check to ensure app is responsive
        .AddCheck("self", () => HealthCheckResult.Healthy(), ["live"]);

    return builder;
}

Il codice precedente:

Aggiunge un timeout di 5 secondi alle richieste di verifica dello stato di integrità con un criterio denominato HealthChecks.
Aggiunge una cache di 10 secondi alle risposte dei controlli di integrità con un policy chiamata HealthChecks.

Ora consideriamo il metodo aggiornato MapDefaultEndpoints:

public static WebApplication MapDefaultEndpoints(this WebApplication app)
{
    var healthChecks = app.MapGroup("");

    healthChecks
        .CacheOutput("HealthChecks")
        .WithRequestTimeout("HealthChecks");

    // All health checks must pass for app to be
    // considered ready to accept traffic after starting
    healthChecks.MapHealthChecks("/health");

    // Only health checks tagged with the "live" tag
    // must pass for app to be considered alive
    healthChecks.MapHealthChecks("/alive", new()
    {
        Predicate = static r => r.Tags.Contains("live")
    });

    return app;
}

Il codice precedente:

Raggruppa gli endpoint del controllo dello stato di salute nel percorso /.
Memorizza nella cache l'output e specifica un'ora di richiesta con i criteri di HealthChecks corrispondenti.

Oltre ai metodi aggiornati AddDefaultHealthChecks e MapDefaultEndpoints, è necessario aggiungere anche i servizi corrispondenti per i timeout delle richieste e la cache dell'output.

Nel punto di ingresso dell'app di utilizzo appropriato (di solito il file Program.cs), aggiungere il codice seguente:

// Wherever your services are being registered.
// Before the call to Build().
builder.Services.AddRequestTimeouts();
builder.Services.AddOutputCache();

var app = builder.Build();

// Wherever your app has been built, before the call to Run().
app.UseRequestTimeouts();
app.UseOutputCache();

app.Run();

Per altre informazioni, vedere middleware request timeouts in ASP.NET Core e middleware di memorizzazione nella cache dell'output in ASP.NET Core.

Controlli di integrità dell'integrazione

Le integrazioni .NETe.NET Aspire possono anche registrare controlli della salute aggiuntivi per l'app. Queste verifiche dello stato di salute contribuiscono allo stato restituito degli endpoint /health e /alive. Ad esempio, l'integrazione .NET AspirePostgreSQL aggiunge automaticamente una verifica dello stato di salute per controllare le condizioni seguenti:

È possibile stabilire una connessione al database
È possibile eseguire correttamente una query di database

Se una di queste operazioni fallisce, anche il controllo dello stato di integrità corrispondente fallisce.

Configurare i controlli di integrità

È possibile disabilitare i controlli di integrità per una determinata integrazione usando una delle opzioni di configurazione disponibili. le integrazioni di supportano Microsoft.Extensions.Configurations per applicare le impostazioni tramite file di configurazione, ad esempio :

{
  "Aspire": {
    "Npgsql": {
      "DisableHealthChecks": true,
    }
  }
}

È anche possibile usare un delegato inline per configurare i controlli di integrità:

builder.AddNpgsqlDbContext<MyDbContext>(
    "postgresdb",
    static settings => settings.DisableHealthChecks  = true);

Vedere anche

controlli di integrità dell'app .NET in C#
controlli di integrità in ASP.NET Core

Condividi tramite