Kontroly stavu v ASP.NET Core

Od Glenn Condron a Juergen Gutsch

ASP.NET Core nabízí middleware pro kontroly stavu a knihovny pro hlášení stavu komponent infrastruktury aplikace.

Kontroly stavu jsou vystaveny aplikací jako koncové body HTTP. Koncové body kontroly stavu je možné nakonfigurovat pro různé scénáře monitorování v reálném čase:

• Sondy stavu můžou používat orchestrátory kontejnerů a vyrovnavače zatížení ke kontrole stavu aplikace. Orchestrátor kontejnerů může například reagovat na neúspěšnou kontrolu stavu zastavením postupného nasazení nebo restartováním kontejneru. Nástroj pro vyrovnávání zatížení může reagovat na aplikaci, která není v pořádku, směrováním provozu mimo instanci, která selhává, do instance, která je v pořádku.
• Použití paměti, disku a dalších prostředků fyzického serveru je možné monitorovat, aby byl stav v pořádku.
• Kontroly stavu můžou otestovat závislosti aplikace, jako jsou databáze a koncové body externí služby, a ověřit dostupnost a normální fungování.

Kontroly stavu se obvykle používají s externí službou monitorování nebo orchestrátorem kontejnerů ke kontrole stavu aplikace. Než do aplikace přidáte kontroly stavu, rozhodněte se, jaký monitorovací systém se má použít. Monitorovací systém stanoví, jaké typy testů stavu se mají vytvořit a jak nakonfigurovat jejich koncové body.

Základní sonda stavu

U mnoha aplikací stačí základní konfigurace sondy stavu, která hlásí dostupnost aplikace pro zpracování požadavků (živé aktivity) ke zjištění stavu aplikace.

Základní konfigurace registruje služby kontroly stavu a vyvolá middleware pro kontroly stavu, aby na koncovém bodu URL vracel odpověď o stavu. Ve výchozím nastavení nejsou žádné konkrétní kontroly stavu registrovány k testování žádné konkrétní závislosti nebo subsystému. Aplikace se považuje za zdravou, pokud může reagovat na adresu URL koncového bodu stavu. Výchozí zapisovač odpovědí zapíše HealthStatus jako odpověď prostého textu klientovi. Je HealthStatus, HealthStatus.Healthy, HealthStatus.Degraded, nebo HealthStatus.Unhealthy.

Zaregistrujte služby zdravotní kontroly v AddHealthChecks v Program.cs. Vytvořte koncový bod kontroly stavu voláním MapHealthChecks.

Následující příklad vytvoří koncový bod kontroly stavu na /healthzadrese:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHealthChecks();

var app = builder.Build();

app.MapHealthChecks("/healthz");

app.Run();

DockerHEALTHCHECK

Docker obsahuje integrovanou HEALTHCHECK direktivu, kterou můžete použít ke kontrole stavu aplikace, která používá základní konfiguraci kontroly stavu:

HEALTHCHECK CMD curl --fail http://localhost:5000/healthz || exit 1

Předchozí příklad používá curl k vytvoření požadavku HTTP na koncový bod kontroly stavu na /healthzadrese . curl není součástí imagí kontejneru .NET Linux, ale můžete ho přidat instalací požadovaného balíčku do souboru Dockerfile. Kontejnery, které používají obrázky založené na Alpine Linuxu, mohou použít wget namísto curl.

Vytvořit kontroly stavu

Vytvořte kontroly stavu prováděním rozhraní IHealthCheck. Metoda CheckHealthAsync vrátí HealthCheckResult hodnotu, která označuje stav jako Healthy, Degradednebo Unhealthy. Výsledek se zapíše jako odpověď ve formátu prostého textu s konfigurovatelným stavovým kódem. Viz část Možnosti kontroly stavu . HealthCheckResult může také vracet volitelné klíče a hodnoty.

Následující příklad ukazuje rozložení kontroly stavu:

public class SampleHealthCheck : IHealthCheck
{
    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        var isHealthy = true;

        // ...

        if (isHealthy)
        {
            return Task.FromResult(
                HealthCheckResult.Healthy("A healthy result."));
        }

        return Task.FromResult(
            new HealthCheckResult(
                context.Registration.FailureStatus, "An unhealthy result."));
    }
}

Logika kontroly stavu je umístěna v CheckHealthAsync metodě. Předchozí příklad nastaví fiktivní proměnnou , isHealthyna true. Pokud je hodnota isHealthy nastavena na false, HealthCheckRegistration.FailureStatus stav se vrátí.

Pokud CheckHealthAsync při kontrole vyvolá výjimku, vrátí se nový HealthReportEntry s nastaveným HealthReportEntry.Status na FailureStatus. Tento stav je definován AddCheck (viz část Registrace služeb kontroly stavu) a obsahuje vnitřní výjimku, která způsobila selhání kontroly. Description je nastaven na zprávu výjimky.

Registrace služeb kontroly stavu

Pokud chcete zaregistrovat službu kontroly stavu, zavolejte AddCheck do Program.cs:

builder.Services.AddHealthChecks()
    .AddCheck<SampleHealthCheck>("Sample");

AddCheck Přetížení zobrazené v následujícím příkladu nastaví stav selhání (HealthStatus), který má být hlášen, když kontrola stavu indikuje selhání. Pokud je stav selhání nastavený na null (výchozí), HealthStatus.Unhealthy je hlášeno. Toto přetížení je užitečný scénář pro autory knihoven, kde je stav selhání označený knihovnou prosazován aplikací, když dojde k selhání kontroly stavu, pokud implementace kontroly stavu respektuje toto nastavení.

Značky lze použít k filtrování kontrol stavu. Značky jsou popsány v části Kontroly stavu filtru.

builder.Services.AddHealthChecks()
    .AddCheck<SampleHealthCheck>(
        "Sample",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "sample" });

AddCheck může také spustit funkci lambda. V následujícím příkladu vrátí kontrola stavu vždy výsledek, který je v pořádku:

builder.Services.AddHealthChecks()
    .AddCheck("Sample", () => HealthCheckResult.Healthy("A healthy result."));

Volání funkce AddTypeActivatedCheck pro předání argumentů implementaci kontroly stavu V následujícím příkladu přijímá kontrola stavu aktivovaná pomocí typu celé číslo a řetězec ve svém konstruktoru.

public class SampleHealthCheckWithArgs : IHealthCheck
{
    private readonly int _arg1;
    private readonly string _arg2;

    public SampleHealthCheckWithArgs(int arg1, string arg2)
        => (_arg1, _arg2) = (arg1, arg2);

    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        // ...

        return Task.FromResult(HealthCheckResult.Healthy("A healthy result."));
    }
}

Pokud chcete zaregistrovat předchozí kontrolu stavu, zavolejte AddTypeActivatedCheck s celým číslem a řetězcem předanými jako argumenty.

builder.Services.AddHealthChecks()
    .AddTypeActivatedCheck<SampleHealthCheckWithArgs>(
        "Sample",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "sample" },
        args: new object[] { 1, "Arg" });

Použití kontrol stavu při směrování

V Program.cs zavolejte v MapHealthChecks na sestavení koncového bodu pomocí adresy URL koncového bodu nebo relativní cesty:

app.MapHealthChecks("/healthz");

Vyžadovat hostitele (server)

Použijte RequireHost k zadání jednoho nebo více povolených hostitelů pro koncový bod kontroly stavu. Místo punycode pro hostitele používejte Unicode a můžete zahrnout port. Pokud kolekci nezadáte, přijme se jakýkoli hostitel:

app.MapHealthChecks("/healthz")
    .RequireHost("www.contoso.com:5001");

Chcete-li omezit koncový bod kontroly stavu tak, aby reagoval pouze na konkrétním portu, zadejte port v volání RequireHost. Obvykle tento přístup použijte v prostředí kontejneru k zveřejnění portu pro monitorovací služby:

app.MapHealthChecks("/healthz")
    .RequireHost("*:5001");

Warning

Rozhraní API, které závisí na Host header, jako například HttpRequest.Host a RequireHost, jsou náchylná k potenciálnímu falšování ze strany klientů.

Pokud chcete zabránit falšování identity hostitele a portu, použijte jeden z následujících přístupů:

• Použijte HttpContext.Connection (ConnectionInfo.LocalPort) v místech, kde se kontrolují porty.
• Používejte filtrování hostitelů.

Pokud chcete zabránit neoprávněným klientům v falšování identity portu, zavolejte RequireAuthorization:

app.MapHealthChecks("/healthz")
    .RequireHost("*:5001")
    .RequireAuthorization();

Další informace naleznete v tématu Porovnávání hostitelů v trasách s RequireHost.

Vyžadovat autorizaci

Zavolejte RequireAuthorization, aby se na koncovém bodu požadavků na kontrolu stavu spustil autorizační middleware. RequireAuthorization Přetížení přijímá jednu nebo více zásad autorizace. Pokud zásady nejsou zadané, použije se výchozí zásada autorizace:

app.MapHealthChecks("/healthz")
    .RequireAuthorization();

Povolení žádostí nepůvodního zdroje (CORS)

I když spouštění kontrol stavu ručně z prohlížeče není běžným scénářem, middleware CORS je možné povolit voláním RequireCors koncových bodů kontroly stavu. Přetížení RequireCors přijímá delegáta tvůrce zásad CORS (CorsPolicyBuilder) nebo název zásady. Další informace najdete v tématu Povolení žádostí mezi zdroji (CORS) v ASP.NET Core.

Možnosti kontroly stavu

HealthCheckOptions poskytnout příležitost přizpůsobit chování kontroly zdraví:

• Kontroly stavu filtrů
• Přizpůsobení stavového kódu HTTP
• Omezit hlavičky mezipaměti
• Přizpůsobení výstupu

Kontrola kondice filtrů

Ve výchozím nastavení middleware pro kontroly stavu spustí všechny registrované kontroly stavu. Pokud chcete spustit podmnožinu kontrol stavu, zadejte funkci, která ve volbě Predicate vrátí hodnotu typu Boolean.

Následující příklad filtruje kontroly stavu, aby se spustily pouze ty, které jsou označené sample .

app.MapHealthChecks("/healthz", new HealthCheckOptions
{
    Predicate = healthCheck => healthCheck.Tags.Contains("sample")
});

Přizpůsobení stavového kódu HTTP

Použijte ResultStatusCodes k úpravě mapování stavu zdraví na stavové kódy HTTP. Následující StatusCodes přiřazení jsou výchozí hodnoty používané middlewarem. Změňte hodnoty stavového kódu tak, aby splňovaly vaše požadavky:

app.MapHealthChecks("/healthz", new HealthCheckOptions
{
    ResultStatusCodes =
    {
        [HealthStatus.Healthy] = StatusCodes.Status200OK,
        [HealthStatus.Degraded] = StatusCodes.Status200OK,
        [HealthStatus.Unhealthy] = StatusCodes.Status503ServiceUnavailable
    }
});

Potlačení hlaviček mezipaměti

AllowCachingResponses určuje, jestli middleware kontroly stavu přidá hlavičky HTTP do odpovědi sondy, aby se zabránilo ukládání odpovědí do mezipaměti. Pokud je výchozí hodnota false, middleware nastaví nebo přepíše hlavičky Cache-Control, Expires a Pragma, aby se zabránilo ukládání odpovědí do mezipaměti. Pokud je hodnota true, middleware nezmění hlavičky mezipaměti odpovědi :

app.MapHealthChecks("/healthz", new HealthCheckOptions
{
    AllowCachingResponses = true
});

Přizpůsobení výstupu

Pokud chcete přizpůsobit výstup zprávy o kontrolách zdraví, nastavte HealthCheckOptions.ResponseWriter vlastnost na delegáta, který vykresluje odpověď:

app.MapHealthChecks("/healthz", new HealthCheckOptions
{
    ResponseWriter = WriteResponse
});

Výchozí delegát zapíše minimální odpověď prostého textu s řetězcovou hodnotou HealthReport.Status. Následující vlastní delegát vypíše vlastní odpověď JSON pomocí System.Text.Json:

private static Task WriteResponse(HttpContext context, HealthReport healthReport)
{
    context.Response.ContentType = "application/json; charset=utf-8";

    var options = new JsonWriterOptions { Indented = true };

    using var memoryStream = new MemoryStream();
    using (var jsonWriter = new Utf8JsonWriter(memoryStream, options))
    {
        jsonWriter.WriteStartObject();
        jsonWriter.WriteString("status", healthReport.Status.ToString());
        jsonWriter.WriteStartObject("results");

        foreach (var healthReportEntry in healthReport.Entries)
        {
            jsonWriter.WriteStartObject(healthReportEntry.Key);
            jsonWriter.WriteString("status",
                healthReportEntry.Value.Status.ToString());
            jsonWriter.WriteString("description",
                healthReportEntry.Value.Description);
            jsonWriter.WriteStartObject("data");

            foreach (var item in healthReportEntry.Value.Data)
            {
                jsonWriter.WritePropertyName(item.Key);

                JsonSerializer.Serialize(jsonWriter, item.Value,
                    item.Value?.GetType() ?? typeof(object));
            }

            jsonWriter.WriteEndObject();
            jsonWriter.WriteEndObject();
        }

        jsonWriter.WriteEndObject();
        jsonWriter.WriteEndObject();
    }

    return context.Response.WriteAsync(
        Encoding.UTF8.GetString(memoryStream.ToArray()));
}

Rozhraní API pro kontroly stavu neposkytuje integrovanou podporu složitých návratových formátů JSON, protože formát je specifický pro váš výběr monitorovacího systému. Podle potřeby upravte odpověď v předchozích příkladech. Další informace o serializaci JSON pomocí System.Text.Json, naleznete v tématu Jak serializovat a deserializovat JSON v .NET.

Test databáze

Kontrola stavu může zadat databázový dotaz, který se má spustit jako logický test, který indikuje, jestli databáze normálně reaguje.

AspNetCore.Diagnostics.HealthChecks– knihovna kontroly stavu pro aplikace ASP.NET Core obsahuje kontrolu stavu, která se spouští v databázi SQL Serveru. AspNetCore.Diagnostics.HealthChecks SELECT 1 spustí dotaz na databázi, aby potvrdil, že připojení k databázi je v pořádku.

Warning

Při kontrole připojení k databázi pomocí dotazu zvolte dotaz, který se rychle vrátí. Přístup k dotazům riskuje přetížení databáze a snížení výkonu. Ve většině případů není spuštění testovacího dotazu nutné. Stačí pouze úspěšné připojení k databázi. Pokud zjistíte, že je nutné spustit dotaz, zvolte jednoduchý dotaz SELECT, například SELECT 1.

Pokud chcete použít tuto kontrolu stavu SQL Serveru, uveďte odkaz na AspNetCore.HealthChecks.SqlServer balíček NuGet. Následující příklad zaregistruje kontrolu stavu SQL Serveru:

var conStr = builder.Configuration.GetConnectionString("DefaultConnection");
if (string.IsNullOrEmpty(conStr))
{
    throw new InvalidOperationException(
                       "Could not find a connection string named 'DefaultConnection'.");
}
builder.Services.AddHealthChecks()
    .AddSqlServer(conStr);

Note

Microsoft neudržuje ani nepodporuje AspNetCore.Diagnostics.HealthChecks.

Entity Framework Core DbContext test

Kontrola DbContext potvrzuje, že aplikace může komunikovat s databází nakonfigurovanou pro aplikaci EF CoreDbContext. Aplikace, které podporují DbContext kontrolu:

• Použijte Entity Framework (EF) Core.
• Zahrňte odkaz na Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore balíček NuGet.

AddDbContextCheckzaregistruje kontrolu stavu pro DbContext DbContext je dodáno metodě jako TContext. Je dostupné přetížení funkce pro konfiguraci stavu selhání, značek a vlastního testovacího dotazu.

Ve výchozím nastavení:

• DbContextHealthCheck volá metodu EF Core objektu CanConnectAsync. Můžete přizpůsobit, jaká operace se spustí při kontrole stavu pomocí přetížení metody AddDbContextCheck.
• Název kontroly stavu je název TContext typu.

Následující příklad zaregistruje DbContext a spojený DbContextHealthCheck:

builder.Services.AddDbContext<SampleDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddHealthChecks()
    .AddDbContextCheck<SampleDbContext>();

Samostatné sondy připravenosti a živosti

V některých scénářích hostování použijte pár kontrol stavu k odlišení dvou stavů aplikace:

• Připravenost označuje, jestli aplikace běží normálně, ale není připravená přijímat žádosti.
• Liveness označuje, jestli aplikace spadla a musí se restartovat.

Představte si následující příklad: Aplikace musí stáhnout velký konfigurační soubor, než bude připraven zpracovávat požadavky. Pokud se počáteční stahování nezdaří, nechcete aplikaci restartovat, protože aplikace může několikrát zkusit stáhnout soubor znovu. Použijte sondu živé aktivity k popisu aktivity procesu, nespustí se žádné další kontroly. Chcete také zabránit tomu, aby se požadavky odesílaly do aplikace, než bude stahování konfiguračního souboru úspěšné. Pomocí testu připravenosti označte stav "není připravený", dokud stahování nebude úspěšné a aplikace bude připravená přijímat žádosti.

Následující úloha na pozadí simuluje proces spuštění, který trvá přibližně 15 sekund. Po dokončení nastaví úloha StartupHealthCheck.StartupCompleted vlastnost na true:

public class StartupBackgroundService : BackgroundService
{
    private readonly StartupHealthCheck _healthCheck;

    public StartupBackgroundService(StartupHealthCheck healthCheck)
        => _healthCheck = healthCheck;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Simulate the effect of a long-running task.
        await Task.Delay(TimeSpan.FromSeconds(15), stoppingToken);

        _healthCheck.StartupCompleted = true;
    }
}

StartupHealthCheck Hlásí dokončení dlouhotrvající spouštěcí úlohy a zveřejňuje StartupCompleted vlastnost, kterou služba na pozadí nastaví:

public class StartupHealthCheck : IHealthCheck
{
    private volatile bool _isReady;

    public bool StartupCompleted
    {
        get => _isReady;
        set => _isReady = value;
    }

    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        if (StartupCompleted)
        {
            return Task.FromResult(HealthCheckResult.Healthy("The startup task has completed."));
        }

        return Task.FromResult(HealthCheckResult.Unhealthy("That startup task is still running."));
    }
}

Zaregistrujte zdravotní kontrolu s AddCheck v Program.cs spolu s hostovanou službou. Vzhledem k tomu, že hostovaná služba nastaví vlastnost kontroly stavu, zaregistrujte také kontrolu stavu v kontejneru služby jako jednoton:

builder.Services.AddHostedService<StartupBackgroundService>();
builder.Services.AddSingleton<StartupHealthCheck>();

builder.Services.AddHealthChecks()
    .AddCheck<StartupHealthCheck>(
        "Startup",
        tags: new[] { "ready" });

Pokud chcete vytvořit dva různé koncové body kontroly stavu, volejte MapHealthChecks dvakrát:

app.MapHealthChecks("/healthz/ready", new HealthCheckOptions
{
    Predicate = healthCheck => healthCheck.Tags.Contains("ready")
});

app.MapHealthChecks("/healthz/live", new HealthCheckOptions
{
    Predicate = _ => false
});

Předchozí příklad vytvoří následující koncové body kontroly stavu:

• /healthz/ready pro kontrolu připravenosti. Kontrola připravenosti filtruje kontroly stavu na ty, které jsou označené ready.
• /healthz/live pro kontrolu živosti. Kontrola živosti filtruje všechny zdravotní kontroly vrácením false v delegátu HealthCheckOptions.Predicate. Další informace o filtrování kontrol stavu naleznete v části Filtrování kontrol stavu v tomto článku.

Před dokončením spouštěcí úlohy /healthz/ready koncový bod hlásí stav Unhealthy. Po dokončení spouštěcí úlohy tento koncový bod hlásí Healthy stav. Koncový /healthz/live bod vyloučí všechny kontroly a hlásí Healthy stav všech volání.

Příklad Kubernetes

Použití samostatných kontrol připravenosti a aktivity je užitečné v prostředí, jako Kubernetes. V Kubernetes může aplikace potřebovat spustit časově náročnou spouštěcí práci, aby mohla přijímat požadavky, jako je například test dostupnosti podkladové databáze. Pomocí samostatných kontrol může orchestrátor zjistit, jestli aplikace funguje, ale ještě není připravená nebo jestli se aplikaci nepodařilo spustit. Další informace o testech připravenosti a aktivity v Kubernetes najdete v dokumentaci ke konfiguraci testů živé aktivity a připravenosti v Kubernetes.

Následující příklad ukazuje konfiguraci sondy připravenosti Kubernetes:

spec:
  template:
  spec:
    readinessProbe:
      # an http probe
      httpGet:
        path: /healthz/ready
        port: 80
      # length of time to wait for a pod to initialize
      # after pod startup, before applying health checking
      initialDelaySeconds: 30
      timeoutSeconds: 1
    ports:
      - containerPort: 80

Distribuce knihovny zdravotní kontroly

Pro distribuci kontroly stavu jako knihovny:

1. Napište kontrolu stavu, která implementuje IHealthCheck rozhraní jako samostatnou třídu. Třída se může spoléhat na injektáž závislostí (DI), aktivaci typu a pojmenované možnosti pro přístup ke konfiguračním datům.

2. Napište metodu rozšíření s parametry, které spotřebová aplikace volá ve své Program.cs metodě. Podívejte se na následující příklad kontroly stavu, který přijímá arg1 a arg2 jako parametry konstruktoru.

   public SampleHealthCheckWithArgs(int arg1, string arg2)
       => (_arg1, _arg2) = (arg1, arg2);
   

   Předchozí podpis označuje, že kontrola stavu vyžaduje vlastní data ke zpracování logiky sondy kontroly stavu. Data jsou poskytována delegátu použitému k vytvoření instance kontroly stavu, když je kontrola stavu registrována pomocí rozšiřující metody. V následujícím příkladu volající určuje:

   • arg1: Celočíselná datová hodnota pro kontrolu stavu.
   • arg2: Řetězcový argument pro kontrolu stavu.
   • name: Volitelný název zdravotní kontroly. Pokud nullse použije výchozí hodnota.
   • failureStatus: Nepovinný prvek HealthStatus, který se hlásí pro stav selhání. Pokud se použije null, použije se HealthStatus.Unhealthy.
   • tags: Volitelná IEnumerable<string> kolekce značek.

   public static class SampleHealthCheckBuilderExtensions
   {
       private const string DefaultName = "Sample";
   
       public static IHealthChecksBuilder AddSampleHealthCheck(
           this IHealthChecksBuilder healthChecksBuilder,
           int arg1,
           string arg2,
           string? name = null,
           HealthStatus? failureStatus = null,
           IEnumerable<string>? tags = default)
       {
           return healthChecksBuilder.Add(
               new HealthCheckRegistration(
                   name ?? DefaultName,
                   _ => new SampleHealthCheckWithArgs(arg1, arg2),
                   failureStatus,
                   tags));
       }
   }
   

Kontrola stavu – Vydavatel

Po přidání IHealthCheckPublisher do kontejneru služby systém kontroly stavu pravidelně provádí kontroly stavu a volá funkci PublishAsync s výsledkem. Tento proces je užitečný ve scénáři systému monitorování stavu založeného na nabízených oznámeních, který očekává, že každý proces bude pravidelně volat monitorovací systém, aby zjistil stav.

HealthCheckPublisherOptions umožňuje nastavit:

• Delay: Počáteční prodleva po spuštění aplikace před spuštěním IHealthCheckPublisher instancí. Zpoždění nastane při spuštění jednou a nevztahuje se na pozdější iterace. Výchozí hodnota je pět sekund.
• Period: Doba výkonu IHealthCheckPublisher. Výchozí hodnota je 30 sekund.
• Predicate: Pokud Predicate je null (výchozí), služba publikování zdravotních kontrol spustí všechny registrované zdravotní kontroly. Pokud chcete spustit podmnožinu kontrol stavu, zadejte funkci, která filtruje sadu kontrol. Predikát se vyhodnocuje každé období.
• Timeout: Časový limit pro provádění kontrol stavu pro všechny IHealthCheckPublisher instance. Použijte InfiniteTimeSpan ke spuštění bez časového limitu. Výchozí hodnota je 30 sekund.

Následující příklad ukazuje uspořádání zdravotnického vydavatele:

public class SampleHealthCheckPublisher : IHealthCheckPublisher
{
    public Task PublishAsync(HealthReport report, CancellationToken cancellationToken)
    {
        if (report.Status == HealthStatus.Healthy)
        {
            // ...
        }
        else
        {
            // ...
        }

        return Task.CompletedTask;
    }
}

Třída HealthCheckPublisherOptions poskytuje vlastnosti pro konfiguraci chování vydavatele zdravotních kontrol.

Následující příklad registruje publikátora zdravotní kontroly jako singleton a konfiguruje HealthCheckPublisherOptions.

builder.Services.Configure<HealthCheckPublisherOptions>(options =>
{
    options.Delay = TimeSpan.FromSeconds(2);
    options.Predicate = healthCheck => healthCheck.Tags.Contains("sample");
});

builder.Services.AddSingleton<IHealthCheckPublisher, SampleHealthCheckPublisher>();

AspNetCore.Diagnostics.HealthChecks:

• Zahrnuje vydavatele pro několik systémů, včetně Application Insights.
• Není udržováno nebo podporováno společností Microsoft.

Jednotlivé kontroly stavu

Můžete nastavit Delay a Period na každém HealthCheckRegistration jednotlivě. Tyto hodnoty nastavte, pokud chcete spustit některé kontroly stavu jinou rychlostí, než je doba nastavená v HealthCheckPublisherOptions.

Následující kód nastaví Delay a Period pro SampleHealthCheck1:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHealthChecks()
   .Add(new HealthCheckRegistration(
       name: "SampleHealthCheck1",
       instance: new SampleHealthCheck(),
       failureStatus: null,
       tags: null,
       timeout: default)
   {
       Delay = TimeSpan.FromSeconds(40),
       Period = TimeSpan.FromSeconds(30)
   });

var app = builder.Build();

app.MapHealthChecks("/healthz");

app.Run();

Injektáž závislostí a kontroly stavu

Injektáž závislostí je možné použít ke spotřebování instance konkrétní Type instance uvnitř třídy kontroly stavu. Injektáž závislostí může být užitečná pro vložení možností nebo globální konfigurace do kontroly stavu. Použití dependency injection není ne běžným scénářem konfigurace kontrol stavu. Každá kontrola stavu je obvykle velmi specifická pro daný test a je nakonfigurována pomocí rozšiřujících metod IHealthChecksBuilder.

Následující příklad ukazuje ukázkovou kontrolu stavu, která načte objekt konfigurace prostřednictvím injektáže závislostí:

public class SampleHealthCheckWithDI : IHealthCheck
{
    private readonly SampleHealthCheckWithDiConfig _config;

    public SampleHealthCheckWithDI(SampleHealthCheckWithDiConfig config)
        => _config = config;

    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        var isHealthy = true;

        // use _config ...

        if (isHealthy)
        {
            return Task.FromResult(
                HealthCheckResult.Healthy("A healthy result."));
        }

        return Task.FromResult(
            new HealthCheckResult(
                context.Registration.FailureStatus, "An unhealthy result."));
    }
}

Do kontejneru služby je potřeba přidat SampleHealthCheckWithDiConfig a kontrolu stavu.

builder.Services.AddSingleton<SampleHealthCheckWithDiConfig>(new SampleHealthCheckWithDiConfig
{
    BaseUriToCheck = new Uri("https://sample.contoso.com/api/")
});
builder.Services.AddHealthChecks()
    .AddCheck<SampleHealthCheckWithDI>(
        "With Dependency Injection",
        tags: new[] { "inject" });

UseHealthChecks vs. MapHealthChecks

Kontroly stavu můžete zpřístupnit volajícím dvěma způsoby:

• UseHealthChecks registruje middleware pro zpracování požadavků na kontroly zdraví v řetězci middlewaru.
• MapHealthChecks zaregistruje koncový bod zdravotních kontrol. Koncový bod je identifikován a spuštěn stejně jako další koncové body v aplikaci.

Místo MapHealthChecks můžete použít UseHealthChecks, což umožňuje používat middleware s podporou koncových bodů, jako je autorizace, a získat jemnější kontrolu nad politikou sladění. Použitím UseHealthChecks místo MapHealthChecks, řídíte přesně to, kde se zdravotní kontroly spouští v kanálu middlewaru.

UseHealthChecks:

• Ukončí pipeline, když požadavek odpovídá koncovému bodu kontroly stavu. Krátké spojení je často žádoucí, protože zabraňuje zbytečné práci, jako je protokolování a další middleware.
• Používá se především ke konfiguraci middlewaru kontroly stavu v pipeline.
• Může odpovídat jakékoli cestě na portu s null nebo prázdným PathString. Umožňuje provést health check u každého požadavku na zadaném portu.
• Zdrojový kód

MapHealthChecks umožňuje:

• Ukončení kanálu, když požadavek odpovídá koncovému bodu kontroly stavu voláním ShortCircuit. Například app.MapHealthChecks("/healthz").ShortCircuit();. Další informace najdete v tématu Middleware se zkratem po směrování.
• Mapování konkrétních tras nebo koncových bodů pro kontroly stavu
• Přizpůsobení adresy URL nebo cesty, kde je koncový bod kontroly stavu přístupný.
• Mapování několika koncových bodů kontroly stavu s různými trasami nebo konfiguracemi Podpora více koncových bodů:
  • Umožňuje samostatné koncové body pro různé typy kontrol stavu nebo součástí.
  • Používá se k rozlišení různých aspektů stavu aplikace nebo použití konkrétních konfigurací na podmnožinu kontrol stavu.
• Zdrojový kód

Dodatečné zdroje

• Zobrazení nebo stažení ukázkového kódu (postup stažení)

Note

Tento článek byl částečně vytvořen pomocí umělé inteligence. Před zveřejněním autor obsah zkontroloval a podle potřeby upravil. Viz Naše zásady pro používání obsahu generovaného AI v Microsoft Learn.