Číst v angličtině

Sdílet prostřednictvím

Přehled orchestrace .NET.NET Aspire

  • Článek

.NET .NET Aspire poskytuje rozhraní API pro vyjádření prostředků a závislostí v rámci distribuované aplikace. Kromě těchto rozhraní API existují nástroje, které umožňují několik zajímavých scénářů. Orchestrátor je určený pro místní vývoj účely a není podporován v produkčních prostředích.

Než budete pokračovat, zvažte určitou běžnou terminologii použitou v .NET.NET Aspire:

  • model aplikace: Kolekce prostředků, které tvoří vaši distribuovanou aplikaci (DistributedApplication), definovanou v rámci oboru názvů Aspire.Hosting.ApplicationModel. Formální definici najdete v tématu Definování modelu aplikace.
  • hostitele aplikace nebo projekt orchestratoru: Projekt .NET, který orchestruje aplikační models názvem *. Přípona AppHost (podle konvence).
  • zdroje: zdroj je závislou součástí aplikace, například projekt .NET, kontejner, spustitelný soubor, databáze, mezipaměť nebo cloudová služba. Představuje jakoukoli část aplikace, na kterou lze spravovat nebo na ni odkazovat.
  • Integrace: Integrace je balíček NuGet pro hostitele aplikace, sloužící k modelování prostředku, nebo balíček, který konfiguruje klienta pro použití ve spotřebitelské aplikaci. Další informace naleznete v tématu .NET.NET Aspire přehled integrací.
  • Referenční: Odkaz definuje propojení mezi prostředky vyjádřené závislostí pomocí rozhraní API WithReference. Další informace naleznete v tématu Referenční zdroje nebo Referenční existující zdroje.

Poznámka

orchestrace .NET.NET Aspireje navržená tak, aby zlepšila prostředí místních vývojových zjednodušením správy konfigurace a propojení nativní pro cloud. I když je to neocenitelný nástroj pro vývoj, není určen k tomu, aby nahradil systémy pro produkční prostředí, jako je Kubernetes, které jsou speciálně navržené tak, aby v tomto kontextu excelovaly.

Definování modelu aplikace

.NET .NET Aspire vám umožní bezproblémově sestavovat, zřizovat, nasazovat, konfigurovat, testovat, spouštět a sledovat distribuované aplikace. Všechny tyto funkce se dosahuje využitím modelu aplikace , který popisuje prostředky ve vašem řešení .NET.NET Aspire a jejich vztahy. Tyto prostředky zahrnují projekty, spustitelné soubory, kontejnery a externí služby a cloudové prostředky, na které vaše aplikace závisí. V každém .NET.NET Aspire řešení je určený projekt hostitele aplikace , kde je model aplikace přesně definován pomocí metod dostupných v IDistributedApplicationBuilder. Tento tvůrce je získán vyvoláním DistributedApplication.CreateBuilder.

C# 
// Create a new app model builder
var builder = DistributedApplication.CreateBuilder(args);

// TODO:
//   Add resources to the app model
//   Express dependencies between resources

builder.Build().Run();

Projekt hostitele aplikace

Projekt hostitele aplikace zpracovává spouštění všech projektů, které jsou součástí .NET.NET Aspire projektu. Jinými slovy, zodpovídá za orchestraci všech aplikací v modelu aplikace. Samotný projekt je spustitelný projekt, který odkazuje na . Hostování.AppHost balíčku NuGet, nastaví vlastnost na a odkazuje na SDK:

XML 
<Project Sdk="Microsoft.NET.Sdk">

    <Sdk Name="Aspire.AppHost.Sdk" Version="9.0.0" />
    
    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net9.0</TargetFramework>
        <IsAspireHost>true</IsAspireHost>
        <!-- Omitted for brevity -->
    </PropertyGroup>

    <ItemGroup>
        <PackageReference Include="Aspire.Hosting.AppHost" Version="9.0.0" />
    </ItemGroup>

    <!-- Omitted for brevity -->

</Project>

Následující kód popisuje hostitele aplikace Program se dvěma odkazy na projekt a mezipamětí Redis:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");

var apiservice = builder.AddProject<Projects.AspireApp_ApiService>("apiservice");

builder.AddProject<Projects.AspireApp_Web>("webfrontend")
       .WithExternalHttpEndpoints()
       .WithReference(cache)
       .WaitFor(cache)
       .WithReference(apiService)
       .WaitFor(apiService);

builder.Build().Run();

Předchozí kód:

  • Vytvoří nového tvůrce modelů aplikací pomocí metody CreateBuilder.
  • Přidá prostředek Rediscache s názvem "cache" pomocí metody AddRedis.
  • Přidá prostředek projektu s názvem "apiservice" pomocí metody AddProject.
  • Přidá zdroj projektu s názvem "webfrontend" pomocí metody AddProject.
  • Sestaví a spustí model aplikace pomocí Build a Run metod.

Ukázkový kód používá integrační hostování .NET AspireRedis.

Pokud chcete pomoct vizualizovat vztah mezi hostitelským projektem aplikace a prostředky, které popisuje, zvažte následující diagram:

Vztah mezi projekty v šabloně .NET.NET Aspire Starter Application.

Každý prostředek musí mít jedinečný název. Tento diagram znázorňuje jednotlivé prostředky a vztahy mezi nimi. Prostředek kontejneru má název "cache" a prostředky projektu mají název "apiservice" a "webfrontend". Webový front-endový projekt odkazuje na projekty služby mezipaměti a rozhraní API. Když tímto způsobem vyjadřujete odkazy, webový front-endový projekt říká, že závisí na těchto dvou prostředcích, "mezipaměti" a "apiservice".

Předdefinované typy prostředků

.NET .NET Aspire projekty se skládají ze sady zdrojů. Primární základní typy prostředků v balíčku NuGet 📦Aspire.Hosting.AppHost jsou popsány v následující tabulce.

Metoda Typ prostředku Popis
AddProject ProjectResource Projekt .NET, například webová aplikace ASP.NET Core.
AddContainer ContainerResource Image kontejneru, například Docker image.
AddExecutable ExecutableResource Spustitelný soubor, například aplikace Node.js.
AddParameter ParameterResource Parametrický prostředek, který lze použít k vyjádření externích parametrů.

Zdroje projektu představují .NET projekty, které jsou součástí modelu aplikace. Když přidáte odkaz na projekt hostitele aplikace, sada .NET.NET Aspire SDK vygeneruje typ v oboru názvů Projects pro každý odkazovaný projekt. Další informace naleznete v tématu .NET.NET Aspire SDK: Odkazy na projekty.

Pokud chcete do modelu aplikace přidat projekt, použijte metodu AddProject:

C# 
var builder = DistributedApplication.CreateBuilder(args);

// Adds the project "apiservice" of type "Projects.AspireApp_ApiService".
var apiservice = builder.AddProject<Projects.AspireApp_ApiService>("apiservice");

Projekty je možné replikovat a škálovat přidáním více instancí stejného projektu do modelu aplikace. Ke konfiguraci replik použijte metodu WithReplicas:

C# 
var builder = DistributedApplication.CreateBuilder(args);

// Adds the project "apiservice" of type "Projects.AspireApp_ApiService".
var apiservice = builder.AddProject<Projects.AspireApp_ApiService>("apiservice")
                        .WithReplicas(3);

Předchozí kód přidá do modelu aplikace tři repliky prostředku projektu "apiservice". Další informace viz .NET.NET Aspire ovládací panel: Repliky prostředků.

Referenční zdroje

Odkaz představuje závislost mezi prostředky. Můžete si například představit scénář, kdy webový front-end závisí na Redis mezipaměti. Zvažte následující ukázkový kód hostitele aplikace v C# s identifikátorem Program:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");

builder.AddProject<Projects.AspireApp_Web>("webfrontend")
       .WithReference(cache);

Zdroj projektu "webfrontend" používá WithReference k přidání závislosti na kontejnerový prostředek "cache". Tyto závislosti mohou představovat připojovací řetězce nebo informace o zjišťování služeb. V předchozím příkladu je proměnná prostředí vložena do prostředku „webfrontend“ s názvem ConnectionStrings__cache. Tato proměnná prostředí obsahuje připojovací řetězec, který webfrontend používá k připojení k Redis prostřednictvím integrace.NET AspireRedis, například ConnectionStrings__cache="localhost:62354".

Čekání na prostředky

V některých případech můžete chtít počkat, až bude prostředek připravený, než začnete s jiným prostředkem. Před spuštěním rozhraní API, které na něm závisí, můžete například chtít počkat, než bude databáze připravená. K vyjádření této závislosti použijte metodu WaitFor:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var postgres = builder.AddPostgres("postgres");
var postgresdb = postgres.AddDatabase("postgresdb");

builder.AddProject<Projects.AspireApp_ApiService>("apiservice")
       .WithReference(postgresdb)
       .WaitFor(postgresdb);

V předchozím kódu prostředek projektu "apiservice" čeká, až prostředek databáze postgresdb zadá KnownResourceStates.Running. Ukázkový kód ukazuje .NET AspirePostgreSQL integraci, ale stejný vzor lze použít u jiných prostředků.

Jiné případy mohou vyžadovat čekání na dokončení prostředku, a to buď KnownResourceStates.Exited, nebo KnownResourceStates.Finished, než začne závislý prostředek. Pokud chcete počkat na dokončení zdroje, použijte metodu WaitForCompletion.

C# 
var builder = DistributedApplication.CreateBuilder(args);

var postgres = builder.AddPostgres("postgres");
var postgresdb = postgres.AddDatabase("postgresdb");

var migration = builder.AddProject<Projects.AspireApp_Migration>("migration")
                       .WithReference(postgresdb)
                       .WaitFor(postgresdb);

builder.AddProject<Projects.AspireApp_ApiService>("apiservice")
       .WithReference(postgresdb)
       .WaitForCompletion(migration);

V předchozím kódu prostředek projektu "apiservice" čeká, až se prostředek projektu "migration" dokončí, než začne. Zdroj projektu „migrace“ čeká, až databázový prostředek „postgresdb“ vstoupí do fáze KnownResourceStates.Running. To může být užitečné ve scénářích, kdy chcete spustit migraci databáze před spuštěním služby API, například.

Rozhraní API pro přidávání a vyjádření zdrojů

.NET .NET Aspire integrace pro hostování a integrace klientů se doručují jako balíčky NuGet, ale slouží různým účelům. I když klientské integrace poskytují konfiguraci klientské knihovny pro použití aplikací mimo rozsah hostitele aplikace, integrace hostování poskytují rozhraní API pro vyjádření prostředků a závislostí v rámci hostitele aplikace. Další informace najdete v tématu přehled integrace .NET.NET Aspire: odpovědnosti za integraci.

Prostředky kontejneru Express

Pokud chcete vyjádřit ContainerResource, přidáte ho do instance IDistributedApplicationBuilder voláním metody AddContainer:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var ollama = builder.AddContainer("ollama", "ollama/ollama")
    .WithBindMount("ollama", "/root/.ollama")
    .WithBindMount("./ollamaconfig", "/usr/config")
    .WithHttpEndpoint(port: 11434, targetPort: 11434, name: "ollama")
    .WithEntrypoint("/usr/config/entrypoint.sh")
    .WithContainerRuntimeArgs("--gpus=all");

Další informace najdete v tématu podpora GPU v Docker Desktop.

Předchozí kód přidá kontejnerový zdroj s názvem "ollama" s image ollama/ollama. Prostředek kontejneru je nakonfigurován s několika připojeními vazby, pojmenovaným koncovým bodem HTTP, vstupním bodem, který odkazuje na shell skript Unix, a argumenty spuštění kontejneru pomocí metody WithContainerRuntimeArgs.

Přizpůsobte prostředky kontejneru

Všechny podtřídy ContainerResource je možné přizpůsobit tak, aby splňovaly vaše konkrétní požadavky. Toto může být užitečné při použití hostovací integraci, která modeluje prostředek kontejneru, ale vyžaduje úpravy. Pokud máte IResourceBuilder<ContainerResource>, můžete zřetězovat volání na libovolné z dostupných rozhraní API pro úpravu prostředku kontejneru. .NET .NET Aspire kontejnerové prostředky obvykle odkazují na připnuté značky, ale možná byste chtěli použít značku latest místo toho.

Abychom vám to pomohli, představte si scénář, ve kterém používáte integraci .NET AspireRedis. Pokud integrace Redis spoléhá na značku 7.4 a chcete místo toho použít značku latest, můžete zřetězit volání na rozhraní API WithImageTag.

C# 
var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
                   .WithImageTag("latest");

// Instead of using the "7.4" tag, the "cache" 
// container resource now uses the "latest" tag.

Další informace a další dostupná rozhraní API najdete v tématu ContainerResourceBuilderExtensions.

Životní cyklus kontejnerových zdrojů

Při spuštění hostitele aplikace se ContainerResource použije k určení image kontejneru, která se má vytvořit a spustit. V zákulisí spustí .NET Aspire kontejner pomocí definovaného obrazu kontejneru delegováním volání na odpovídající kontejnerový runtime podle standardu OCI, buď Docker, nebo Podman. Používají se následující příkazy:

Nejprve se kontejner vytvoří pomocí příkazu docker container create. Kontejner se pak spustí pomocí příkazu docker container start.

Tyto příkazy se používají místo docker run ke správě připojených sítí kontejnerů, svazků a portů. Volání těchto příkazů v tomto pořadí umožňuje, aby již při počátečním spuštění byla přítomna jakákoli IP adresa (konfigurace sítě).

Kromě základních typů prostředků poskytuje ProjectResource, ContainerResourcea ExecutableResource, .NET.NET Aspire rozšiřující metody pro přidání běžných prostředků do modelu aplikace. Další informace najdete v tématu Integrace hostování.

Životnost zdroje kontejneru

Ve výchozím nastavení prostředky kontejneru používají relaci životnosti kontejneru. To znamená, že při každém spuštění hostitelského procesu aplikace se kontejner vytvoří a spustí. Když se hostitel aplikace zastaví, kontejner se rovněž zastaví a následně odebere. Prostředky kontejneru se můžou zapojit do trvalé životnosti, kterou lze použít k zabránění zbytečným restartováním a uchování trvalého stavu kontejneru. Pokud toho chcete dosáhnout, zřetězte volání rozhraní API ContainerResourceBuilderExtensions.WithLifetime a předejte ContainerLifetime.Persistent:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var ollama = builder.AddContainer("ollama", "ollama/ollama")
    .WithLifetime(ContainerLifetime.Persistent);

Předchozí kód přidá kontejnerový zdroj s názvem "ollama" s imagí "ollama/ollama" a perzistentní životností.

Odkazy na připojovací řetězec a koncový bod

Je běžné vyjádřit závislosti mezi projektovými zdroji. Podívejte se na následující ukázkový kód:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");

var apiservice = builder.AddProject<Projects.AspireApp_ApiService>("apiservice");

builder.AddProject<Projects.AspireApp_Web>("webfrontend")
       .WithReference(cache)
       .WithReference(apiservice);

Odkazy mezi projekty se zpracovávají jinak než prostředky, které mají dobře definované připojovací řetězce. Místo toho, aby byl do prostředku "webfrontend" vložen připojovací řetězec, jsou vloženy proměnné prostředí pro podporu zjišťování služeb.

Metoda Proměnná prostředí
WithReference(cache) ConnectionStrings__cache="localhost:62354"
WithReference(apiservice) services__apiservice__http__0="http://localhost:5455"
services__apiservice__https__0="https://localhost:7356"

Přidání odkazu na projekt "apiservice" vede k přidání proměnných prostředí zjišťování služeb do front-endu. Důvodem je to, že obvykle dochází ke komunikaci mezi projekty přes HTTP/gRPC. Další informace naleznete v tématu .NET.NET Aspire zjišťování služby.

Pokud chcete získat konkrétní koncové body z ContainerResource nebo ExecutableResource, použijte jedno z následujících rozhraní API koncových bodů:

Potom zavolejte rozhraní API GetEndpoint a získejte koncový bod, který se dá použít k odkazu na koncový bod v metodě WithReference:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var customContainer = builder.AddContainer("myapp", "mycustomcontainer")
                             .WithHttpEndpoint(port: 9043, name: "endpoint");

var endpoint = customContainer.GetEndpoint("endpoint");

var apiservice = builder.AddProject<Projects.AspireApp_ApiService>("apiservice")
                        .WithReference(endpoint);
Metoda Proměnná prostředí
WithReference(endpoint) services__myapp__endpoint__0=https://localhost:9043

Parametr port je port, na který kontejner naslouchá. Další informace o portech kontejneru najdete v tématu Porty kontejneru. Další informace o zjišťování služby naleznete v tématu .NET.NET Aspire zjišťování služby.

Formát proměnné prostředí koncového bodu služby

V předchozí části se metoda WithReference používá k vyjádření závislostí mezi prostředky. Pokud koncové body služby vedou k injekci proměnných prostředí do závislého zdroje, formát nemusí být zřejmý. Tato část obsahuje podrobnosti o tomto formátu.

Pokud jeden prostředek závisí na jiném prostředku, hostitel aplikace vloží proměnné prostředí do závislého prostředku. Tyto proměnné prostředí konfigurují závislý prostředek pro připojení k prostředku, na který závisí. Formát proměnných prostředí je specifický pro .NET.NET Aspire a vyjadřuje koncové body služby způsobem, který je kompatibilní se službou Service Discovery.

Názvy proměnných prostředí koncového bodu služby mají předponu services__ (dvojité podtržítko), název služby, název koncového bodu a nakonec index. Index podporuje více koncových bodů pro jednu službu, počínaje 0 pro první koncový bod a postupně se zvyšující pro každý další koncový bod.

Představte si následující příklady proměnných prostředí:

Environment 
services__apiservice__http__0

Proměnná předchozího prostředí určuje první HTTP koncový bod pro službu apiservice. Hodnota proměnné prostředí je adresa URL koncového bodu služby. Pojmenovaný koncový bod může být vyjádřen takto:

Environment 
services__apiservice__myendpoint__0

V předchozím příkladu má služba apiservice pojmenovaný koncový bod s názvem myendpoint. Hodnota proměnné prostředí je adresa URL koncového bodu služby.

Odkaz na existující prostředky

Některé situace zaručují, že odkazujete na existující prostředek, třeba na ten, který je nasazený u poskytovatele cloudu. Můžete například chtít odkazovat na databázi Azure. V tomto případě byste se spoléhali na kontext spouštění , abyste dynamicky určili, jestli je hostitel aplikace spuštěný v režimu "spuštění" nebo "publikování". Pokud pracujete lokálně a chcete se spoléhat na cloudový zdroj, můžete použít vlastnost IsRunMode k podmíněnému přidání odkazu. Místo toho můžete prostředek vytvořit v režimu publikování. Některé hostovací integrace podporují přímé poskytování připojovacího řetězce, který lze použít k odkazování na existující prostředek.

Podobně mohou existovat případy použití, kdy chcete integrovat .NET.NET Aspire do stávajícího řešení. Jedním z běžných přístupů je přidání projektu hostitele aplikace .NET.NET Aspire do existujícího řešení. V rámci hostitele vaší aplikace vyjadřujete závislosti přidáním odkazů na projekt na hostitele aplikace a vytvářením modelu aplikace. Jeden projekt může například záviset na jiném projektu. Tyto závislosti jsou vyjádřeny pomocí metody WithReference. Další informace najdete v tématu Přidání .NET Aspire do existující aplikace .NET.

Životní cykly hostitele aplikace

Hostitel aplikace .NET.NET Aspire zveřejňuje několik životních cyklů, ke kterým se můžete připojit implementací IDistributedApplicationLifecycleHook rozhraní. K dispozici jsou následující metody životního cyklu:

Objednávka Metoda Popis
1 BeforeStartAsync Spustí se před spuštěním distribuované aplikace.
2 AfterEndpointsAllocatedAsync Spustí se poté, co orchestrátor přidělí koncové body pro prostředky v aplikačním modelu.
3 AfterResourcesCreatedAsync Spustí se po vytvoření prostředku orchestrátorem.

Hostitel aplikace sice poskytuje háky životního cyklu, ale můžete chtít zaregistrovat vlastní události. Další informace naleznete v části Eventing v .NET.NET Aspire.

Registrace háku životního cyklu

Pokud chcete zaregistrovat háček životního cyklu, implementujte rozhraní IDistributedApplicationLifecycleHook a zaregistrujte háček u hostitele aplikace pomocí rozhraní API AddLifecycleHook:

C# 
using Aspire.Hosting.Lifecycle;
using Microsoft.Extensions.Logging;

var builder = DistributedApplication.CreateBuilder(args);

builder.Services.AddLifecycleHook<LifecycleLogger>();

builder.Build().Run();

internal sealed class LifecycleLogger(ILogger<LifecycleLogger> logger)
    : IDistributedApplicationLifecycleHook
{
    public Task BeforeStartAsync(
        DistributedApplicationModel appModel, CancellationToken cancellationToken = default)
    {
        logger.LogInformation("BeforeStartAsync");
        return Task.CompletedTask;
    }

    public Task AfterEndpointsAllocatedAsync(
        DistributedApplicationModel appModel, CancellationToken cancellationToken = default)
    {
        logger.LogInformation("AfterEndpointsAllocatedAsync");
        return Task.CompletedTask;
    }

    public Task AfterResourcesCreatedAsync(
        DistributedApplicationModel appModel, CancellationToken cancellationToken = default)
    {
        logger.LogInformation("AfterResourcesCreatedAsync");
        return Task.CompletedTask;
    }
}

Předchozí kód:

Při spuštění tohoto hostitele aplikace se pro každou událost spustí háček životního cyklu. Vygeneruje se následující výstup:

Output 
info: LifecycleLogger[0]
      BeforeStartAsync
info: Aspire.Hosting.DistributedApplication[0]
      Aspire version: 9.0.0
info: Aspire.Hosting.DistributedApplication[0]
      Distributed application starting.
info: Aspire.Hosting.DistributedApplication[0]
      Application host directory is: ..\AspireApp\AspireApp.AppHost
info: LifecycleLogger[0]
      AfterEndpointsAllocatedAsync
info: Aspire.Hosting.DistributedApplication[0]
      Now listening on: https://localhost:17043
info: Aspire.Hosting.DistributedApplication[0]
      Login to the dashboard at https://localhost:17043/login?t=d80f598bc8a64c7ee97328a1cbd55d72
info: LifecycleLogger[0]
      AfterResourcesCreatedAsync
info: Aspire.Hosting.DistributedApplication[0]
      Distributed application started. Press Ctrl+C to shut down.

Upřednostňovaným způsobem připojení k životnímu cyklu hostitele aplikace je použití rozhraní API pro události. Další informace naleznete v části Eventing v .NET.NET Aspire.

Kontext spuštění

IDistributedApplicationBuilder zveřejňuje kontext spuštění (DistributedApplicationExecutionContext), který poskytuje informace o aktuálním spuštění hostitele aplikace. Tento kontext lze použít k vyhodnocení, jestli hostitel aplikace běží v režimu 'run' nebo jako součást operace publikování. Vezměte v úvahu následující vlastnosti:

  • IsRunMode: Vrátí true, pokud je aktuální operace spuštěná.
  • IsPublishMode: Vrátí true, pokud je aktuální operace publikování.

Tyto informace můžou být užitečné, když chcete podmíněně spouštět kód na základě aktuální operace. Podívejte se na následující příklad, který ukazuje použití vlastnosti IsRunMode. V tomto případě se metoda rozšíření používá ke generování stabilního názvu uzlu pro RabbitMQ pro místní běhy vývoje.

C# 
private static IResourceBuilder<RabbitMQServerResource> RunWithStableNodeName(
    this IResourceBuilder<RabbitMQServerResource> builder)
{
    if (builder.ApplicationBuilder.ExecutionContext.IsRunMode)
    {
        builder.WithEnvironment(context =>
        {
            // Set a stable node name so queue storage is consistent between sessions
            var nodeName = $"{builder.Resource.Name}@localhost";
            context.EnvironmentVariables["RABBITMQ_NODENAME"] = nodeName;
        });
    }

    return builder;
}

Kontext spuštění se často používá k podmíněnému přidání prostředků nebo připojovacích řetězců, které odkazují na existující prostředky. Podívejte se na následující příklad, který ukazuje podmíněné přidání Redis nebo připojovacího řetězce na základě kontextu spuštění:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var redis = builder.ExecutionContext.IsRunMode
    ? builder.AddRedis("redis")
    : builder.AddConnectionString("redis");

builder.AddProject<Projects.WebApplication>("api")
       .WithReference(redis);

builder.Build().Run();

V předchozím kódu:

  • Pokud je hostitel aplikace spuštěný v režimu 'run', prostředek kontejneru Redis se přidá.
  • Pokud je hostitel aplikace spuštěný v režimu publikování, přidá se připojovací řetězec.

Tato logika se dá snadno převrátit pro připojení k existujícímu Redis prostředku, když běžíte lokálně, a vytvoření nového Redis prostředku, když publikujete.

Důležité

.NET .NET Aspire poskytuje běžná rozhraní API pro řízení způsobu vytváření prostředků, což umožňuje, aby se prostředky chovaly jinak v závislosti na režimu provádění. Rozhraní API fluent mají předponu RunAs* a PublishAs*. Rozhraní API RunAs* ovlivňují chování místního vývoje (nebo režimu spuštění), zatímco rozhraní API PublishAs* ovlivňují publikování zdroje.

Viz také