Olvasás angol nyelven

Megosztás a következőn keresztül:

A .NET.NET Aspire 9.0 újdonságai

  • Cikk

📢 .NET Aspire 9.0 a .NET Aspirekövetkező fő általános rendelkezésre állási (GA) kiadása; támogatja mindkét:

  • .NET 8.0 hosszú távú támogatás (LTS) vagy
  • .NET 9.0 Standard kifejezéstámogatás (STS).

Megjegyzés

A .NET Aspire 9.0 .NET 8 vagy .NET 9 használatával is használható!

Ez a kiadás a közösség által leggyakrabban kért funkciókkal és fájdalompontokkal foglalkozik. A legjobb funkciók a közösségvezéreltek! Ha csatlakozni szeretne a közösséghez, látogasson el Discord oldalunkra, hogy csevehessen a csapattagokkal, és működjön együtt velünk a GitHubprojekten.

A hivatalos .NET verzióval és .NET Aspire verziótámogatással kapcsolatos további információkért lásd:

Frissítés a .NET.NET Aspire 9-re

A .NET Aspire korábbi verzióiról a .NET Aspire 9-re való frissítéshez kövesse a hivatalos Frissítés .NET.NET Aspire 9-re útmutató utasításait. Az útmutató részletes útmutatást nyújt a meglévő .NET Aspire megoldások .NET Aspire 9-re való frissítéséhez. Függetlenül attól, hogy manuálisan vagy a Frissítési Asszisztens használatával végzi el, az útmutató egyszerűsíti a folyamatot.

Eszközhasználati fejlesztések

.NET Aspire 9 egyszerűbbé teszi a környezet konfigurálását .NET Aspire alkalmazások fejlesztésére. Már nincs szüksége „.NET” számítási feladatra. Ehelyett telepíti az új .NET.NET Aspire SDK--at a .NET.NET Aspire megoldások alkalmazás gazdaprojektjébe. További információ: .NET.NET Aspire beállítás és eszközhasználat.

A sablonok át lettek helyezve

.NET .NET Aspire 9 a számítási feladaton keresztül telepített tartalmat külön NuGet-csomagokba helyezi át. Ez magában foglalja az új .NET.NET Aspire projektek és megoldások létrehozásához szükséges sablonokat. Ezek a sablonok a dotnet new install parancshasználatával vannak telepítve. Ezek a következő parancs futtatásával telepíthetők:

.NET CLI 
dotnet new install Aspire.ProjectTemplates::9.0.0

Tipp.

Ha már telepítve van a .NET.NET Aspire számítási feladat, át kell adnia a --force jelzőt a meglévő sablonok felülírásához. Nyugodtan távolítsa el a .NET.NET Aspire munkaterhelést.

További információ: .NET.NET Aspire sablonok.

Az irányítópult felhasználói felületének fejlesztései és új interaktivitási funkciók

Az .NET.NET Aspire irányítópult folyamatosan fejlődik minden kiadással.

Erőforrás-életciklus kezelése

Az irányítópult leggyakrabban kért funkciója az összehangolt, elnevezett erőforrások életciklusainak kezelése. Pontosabban az erőforrások leállításának, elindításának és újraindításának lehetősége. Ez a funkció projektekhez, tárolókhoz és végrehajthatókhoz használható. Lehetővé teszi az egyes erőforrások újraindítását a teljes alkalmazásgazda újraindítása nélkül. Projekterőforrások esetén, amikor a hibakereső csatlakoztatva van, újra van kapcsolva újraindításkor. További információ: .NET.NET Aspire irányítópult: Erőforrás leállítása vagy indítása.

Mobil és rugalmas támogatás

A .NET Aspire irányítópult mostantól mobilbarát, rugalmasan alkalmazkodik a képernyőméretek széles köréhez, és lehetővé teszi az üzembe helyezett .NET Aspire alkalmazások helyszíni felügyeletét. Egyéb akadálymentességi fejlesztések is történtek, beleértve a beállítások megjelenítését és a tartalom túlcsordulását mobileszközökön.

Érzékeny tulajdonságok, volumek és állapotellenőrzések az erőforrások részleteinél

Az erőforrás részleteinek megjelenítése számos fejlesztést tartalmaz:

  • A tulajdonságok jelölhetők bizalmasként, és automatikusan maszkolhatók az irányítópult felhasználói felületén. Ez a biztonsági funkció segít elkerülni a kulcsok vagy jelszavak véletlen felfedését az irányítópult másokkal való megosztásakor. A tárolóargumentumok például bizalmas információkat adhatnak át, ezért alapértelmezés szerint maszkoltak.

  • A konfigurált tárolókötetek az erőforrás részletei között szerepelnek.

  • .NET .NET Aspire 9 támogatja az állapot-ellenőrzéseket. Az ellenőrzésekkel kapcsolatos részletes információk mostantól megtekinthetők az erőforrás részletei panelen, amely bemutatja, hogy egy erőforrás miért lehet nem kifogástalan vagy csökkentett állapotúként megjelölve. További információ az állapot-ellenőrzésekről itt.

Színes konzolnapló

ANSI escape kódok a szöveg terminálokon belüli formázását végzik a színek (előtér és háttér) és a stílusok (például félkövér, aláhúzott és dőlt) szabályozásával. Korábban az irányítópult konzolnaplóinak lapja egyszerre csak egy ANSI-feloldókódot tudott megjeleníteni, amely több kód kombinálásakor meghiúsult. Például piros szöveget jeleníthet meg, de nem piros és félkövér szöveget.

Egy közösségi hozzájárulás a @mangeg részéről javította az ANSI vezérlőkódok támogatását, ezzel megszüntetve ezt a korlátozást.

Színes konzolnaplók

A konzolnaplók egy másik fejlesztése a nem támogatott feloldókódok elrejtése. A szöveg megjelenítéséhez nem kapcsolódó kódok, például a kurzor elhelyezése vagy az operációs rendszerrel való kommunikáció nem értelmezhetők ebben a felhasználói felületen, és rejtettek.

Telemetria felhasználóközpontú kiegészítései

telemetriai továbbra is a .NET.NET Aspirefontos eleme marad. A .NET.NET Aspire 9 frissítésben számos új funkciót vezettek be a telemetriai szolgáltatáshoz.

Továbbfejlesztett telemetriai szűrés

A nyomkövetések attribútumértékekkel szűrhetők. Ha például csak egy végpont nyomkövetéseit szeretné megtekinteni az alkalmazásban, a HTTP-kérelmek http.route attribútuma szűrhető egy megadott értékre.

A telemetriai szűrés a meglévő értékek automatikus kiegészítését is támogatja. A Szűrő hozzáadása párbeszédpanel egy kombinált mezőt biztosít az irányítópult által elérhető értékek közötti választáshoz. Ez a funkció sokkal egyszerűbbé teszi a valós adatokra való szűrést, és segít elkerülni az elírásokat egy érték beírásával.

További információért lásd: .NET.NET Aspire irányítópult: Nyomkövetések szűrése.

Telemetriai adatok kombinálása több erőforrásból

Ha egy erőforrás több replikával rendelkezik, mostantól szűrheti a telemetriát az összes példány adatainak egyszerre való megtekintéséhez. Válassza ki a szülőerőforrást, amely a "(application)" címkével van ellátva. További információkért lásd a .NET.NET Aspire irányítópultot: telemetria egyesítése több erőforrásból.

Böngésző telemetriai támogatása

Az irányítópult támogatja az OpenTelemetry Protokollt (OTLP) HTTP-n és forrásközi erőforrás-megosztáson (CORS) keresztül. Ezek a funkciók lehetővé teszi OpenTelemetry küldését a böngészőalkalmazásokból a .NET Aspire irányítópultra.

Egy böngészőalapú egyoldalas alkalmazás (SPA) például konfigurálhatja a JavaScript-OpenTelemetry SDK- a böngészőben létrehozott strukturált naplók, nyomkövetések és metrikák irányítópultra küldésére. A böngészőtelemetria a kiszolgáló telemetriai adatai mellett jelenik meg.

Nyomkövetési részletek oldala böngésző telemetriával

A böngésző telemetriájának konfigurálásáról további információt A böngésző telemetriájának engedélyezése dokumentációjában talál.

Alkalmazásgazda (vezénylés)

Az alkalmazásgazda az egyik legfontosabb funkciója. A .NET.NET Aspire 9-ben számos új funkció lett hozzáadva az alkalmazás hosztjához.

Várakozás a függőségekre

Ha már követte a .NET.NET Aspire, már tudja, hogy az alkalmazásgazdaprojekt az, ahol ön határozza meg az alkalmazásmodellt. Létrehozhat egy elosztott alkalmazáskészítőt, erőforrásokat vehet fel és konfigurálhat, és kifejezheti függőségeiket. Most megadhatja, hogy egy erőforrásnak várnia egy másik erőforrásra a kezdés előtt. Ez segít elkerülni a kapcsolati hibákat az indítás során, ha csak akkor indítja el az erőforrásokat, ha függőségeik "készen állnak".

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

var rabbit = builder.AddRabbitMQ("rabbit");

builder.AddProject<Projects.WebApplication1>("api")
       .WithReference(rabbit)
       .WaitFor(rabbit); // Don't start "api" until "rabbit" is ready...

builder.Build().Run();

Amikor az alkalmazásgazda elindul, megvárja, amíg a rabbit erőforrás készen áll a api erőforrás elindítása előtt.

Két módszer áll rendelkezésre az erőforrásra való várakozáshoz:

  • WaitFor: Várjon, amíg egy erőforrás készen áll egy másik erőforrás indítása előtt.
  • WaitForCompletion: Várjon, amíg egy erőforrás befejeződik, mielőtt elindít egy másik erőforrást.

További információ: .NET.NET Aspire alkalmazásgazda: Várakozás az erőforrásokra.

Erőforrásállapot-ellenőrzések

A WaitFor API szabványos .NET állapotellenőrzési segítségével állapítja meg, hogy egy erőforrás készen áll-e. De mit jelent az, hogy "egy erőforrás készen áll"? A legjobb az, hogy a felhasználó az alapértelmezett értékeken túl konfigurálhatja a beállításokat.

Ha egy erőforrás nem tesz közzé állapotellenőrzéseket (az alkalmazásban nincs állapotellenőrzés), az alkalmazás gazdagépe megvárja, hogy az erőforrás Running állapotban legyen a függő erőforrás elindítása előtt.

A HTTP-végpontokat elérhetővé tevő erőforrások esetében egyszerűen hozzáadhat egy állapotellenőrzést, amely lekérdezi a HTTP 200-válasz adott elérési útját.

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

var catalogApi = builder.AddContainer("catalog-api", "catalog-api")
                        .WithHttpEndpoint(targetPort: 8080)
                        .WithHttpHealthCheck("/health");

builder.AddProject<Projects.WebApplication1>("store")
       .WithReference(catalogApi.GetEndpoint("http"))
       .WaitFor(catalogApi);

builder.Build().Run();

Az előző példa egy állapot-ellenőrzést ad hozzá a catalog-api erőforráshoz. Az alkalmazásgazda megvárja, amíg az állapot-ellenőrzés egészséges állapotot jelez, mielőtt elindítaná a store erőforrást. Meghatározza, hogy az erőforrás készen áll-e, amikor a /health végpont EGY HTTP 200 állapotkódot ad vissza.

Miközben store arra vár, hogy catalog-api meggyógyuljon, az irányítópult erőforrásai így jelennek meg:

Nem kifogástalan erőforrásra vár a indítása előtt

Az alkalmazásgazda állapot-ellenőrzési mechanizmusa a IHealthChecksBuilder névtérből származó Microsoft.Extensions.Diagnostics.HealthChecks implementációra épül.

Állapotellenőrzési jelentésadatok, amelyek az irányítópulton jelennek meg:

Állapot-ellenőrzés részletei az irányítópult erőforrás-részletek nézetében

Az egyéni állapot-ellenőrzés létrehozása egyszerű. Először határozza meg az állapotellenőrzést, majd rendelje hozzá a nevét azokhoz az erőforrásokhoz, amelyekre vonatkozik.

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

var healthyAfter = DateTime.Now.AddSeconds(20);

builder.Services.AddHealthChecks().AddCheck(
    "delay20secs",
    () => DateTime.Now > healthyAfter 
        ? HealthCheckResult.Healthy() 
        : HealthCheckResult.Unhealthy()
    );

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

builder.AddProject<Projects.MyApp>("myapp")
       .WithReference(cache)
       .WaitFor(cache);

Az előző példa egy állapot-ellenőrzést ad hozzá a cache erőforráshoz, amely az alkalmazásgazda elindítása utáni első 20 másodpercben nem megfelelő állapotot jelez. Így a myapp erőforrás 20 másodpercig várakozik a kezdés előtt, biztosítva, hogy a cache erőforrás kifogástalan állapotban legyen.

A AddCheck és WithHealthCheck metódusok egyszerű mechanizmust biztosítanak az állapot-ellenőrzések létrehozásához és adott erőforrásokhoz való társításához.

Állandó tárolók

Az alkalmazásgazda mostantól támogatja állandó tárolókat. Az állandó tárolók eltérnek .NET.NET Aspire vezényelt alkalmazásoktipikus tároló életciklusától. Bár hoztak létre, és (ha még nem érhető el) a .NET Aspire vezénylője indította el őket, .NET Aspirenem semmisítik meg őket.

Ez akkor hasznos, ha a tárolót az alkalmazásgazda leállítása után is futtatni szeretné.

Fontos

A tárolók törléséhez manuálisan kell leállítania őket a tároló futtatókörnyezetével.

Állandó élettartamú IResourceBuilder<ContainerResource> definiálásához hívja meg a WithLifetime metódust, és adja meg a ContainerLifetime.Persistent:

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

var queue = builder.AddRabbitMQ("rabbit")
                   .WithLifetime(ContainerLifetime.Persistent);

builder.AddProject<Projects.WebApplication1>("api")
       .WithReference(queue)
       .WaitFor(queue);

builder.Build().Run();

Az irányítópulton a perzisztens konténerek láthatók egy gombostű ikonnal.

állandó tárolók

Az alkalmazásgazda leállítása után a tároló továbbra is fut:

Docker asztali számítógép mutatja RabbitMQ.

A tárolómegőrzési mechanizmus megpróbálja azonosítani, hogy mikor szeretné újra létrehozni a tárolót. Ha például megváltozik a tároló környezete, a tároló újraindul, így nem kell manuálisan leállítania a tárolót, ha az erőforrás bemeneti konfigurációja megváltozott.

Erőforrásparancsok

Az alkalmazásgazda támogatja az egyéni parancsok erőforrásokhoz való hozzáadását. Ez akkor hasznos, ha olyan egyéni funkciókat szeretne hozzáadni, amelyeket az alkalmazásgazda nem támogat natív módon. Valószínűleg sok lehetőség van arra, hogy az egyéni kiterjesztési módszereket az erőforrásokon elérhetővé tegyük. A .NET.NET Aspire Közösségi eszközkészlet jó hely lehet ezeknek a bővítményeknek a megosztására.

Egyéni parancsok definiálásakor az irányítópulton felhasználói felületi funkcióként érhető el.

Fontos

Ezek a .NET.NET Aspire irányítópult-parancsok csak az irányítópult helyi futtatásakor érhetők el. Amikor az irányítópultot a Azure Container Apps-ban futtatják, nem állnak rendelkezésre.

További információ az egyéni erőforrásparancsok létrehozásáról: Útmutató: Egyéni erőforrásparancsok létrehozása .NET.NET Aspire.

Konténerhálózat

Az alkalmazásgazda mostantól az összes tárolót hozzáadja egy default-aspire-networknevű közös hálózathoz. Ez akkor hasznos, ha a tárolók közötti kommunikációt a gazdahálózat megkerülésével szeretné elvégezni. Ez megkönnyíti a docker-összeállításból az alkalmazás gazdagépére való migrálást is, mivel a tárolók a tárolónév használatával kommunikálhatnak egymással.

Eseménymodell

Az eseménymodell lehetővé teszi a fejlesztők számára, hogy az alkalmazás és az erőforrások életciklusához csatlakoznak. Ez akkor hasznos, ha egyéni kódot futtat az alkalmazás életciklusának bizonyos pontjain. Az eseményekre különböző módokon lehet feliratkozni, beleértve a globális eseményeket és az erőforrásonkénti eseményeket.

globális események:

  • BeforeStartEvent: Az alkalmazás indítása előtt aktivált esemény. Ez az utolsó hely, ahol az alkalmazásmodell módosításai figyelhetők meg. Ez "Futtatás" és "Közzététel" módban is fut. Ez egy blokkoló esemény, ami azt jelenti, hogy az alkalmazás nem indul el, amíg az összes kezelő be nem fejeződik.
  • AfterResourcesCreatedEvent: Az erőforrások létrehozása után aktiválódott esemény. Ez csak run módban fut.
  • AfterEndpointsAllocatedEvent: Egy esemény, amely az összes erőforráshoz tartozó végpont kiosztása után kiváltódik. Ez csak run módban fut.

A globális események hasonlóak az alkalmazásgazda életciklus-eseményeihez. További információ: Alkalmazásgazda életciklusai.

erőforrásonkénti események:

  • BeforeResourceStartedEvent: Egy erőforrás indítása előtt aktivált esemény. Ez csak run módban fut. Ez egy blokkoló esemény, ami azt jelenti, hogy az erőforrás nem indul el, amíg az összes kezelő be nem fejeződik.
  • ConnectionStringAvailableEvent: Olyan esemény, amely akkor aktiválódik, ha egy kapcsolati sztring elérhető egy erőforráshoz. Ez csak run módban fut.
  • ResourceReadyEvent: Olyan esemény, amely akkor aktiválódik, ha egy erőforrás használatra kész. Ez csak run módban fut.

További információért lásd: eseménynaptár a .NET.NET Aspire-ban.

Integrációk

.NET .NET Aspire továbbra is olyan integrációkat ad hozzá, amelyek megkönnyítik a kedvenc szolgáltatások és eszközök használatának megkezdését. További információ: .NET.NET Aspire integrációk áttekintése.

Redis Bepillantás

A Redis Insights támogatása Redis erőforráson érhető el:

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

builder.AddRedis("redis")
       .WithRedisInsight(); // Starts a Redis Insight container image
                            // that is pre-configured to work with the
                            // Redis instance.

A WithRedisInsight bővítménymetódus több Redis erőforrásra is alkalmazható, és mindegyik látható lesz az Redis Insight irányítópultján.

Redis Insight-vezérlőpult több Redis példány megjelenítésére

További információért lásd: Redis-hoz tartozó Redis erőforrás hozzáadása.

OpenAI (előzetes verzió)

A .NET Aspire 9-től kezdve további OpenAI integráció érhető el, amely lehetővé teszi a legújabb hivatalos OpenAI dotnet-kódtár közvetlen használatát. Az ügyfélintegráció az OpenAIClient szolgáltatást egyedüli szolgáltatásként regisztrálja a szolgáltatásgyűjteményben. Az ügyfél használható a OpenAIREST API-val való interakcióhoz.

Emellett a már elérhető .NET AspireAzureOpenAI integrációs továbbfejlesztettük, hogy rugalmasan konfiguráljon egy OpenAIClient egy Azure AI OpenAI szolgáltatáshoz vagy egy dedikált OpenAIREST API-hoz az új AddOpenAIClientFromConfiguration(IHostApplicationBuilder, String) builder metódussal. Az alábbi példa észleli, hogy a kapcsolati sztring egy AzureAzure AI OpenAI szolgáltatáshoz tartozik-e, és automatikusan regisztrálja a legmegfelelőbb OpenAIClient-példányt.

C# 
builder.AddOpenAIClientFromConfiguration("openai");

Ha például a openai kapcsolat úgy nézne ki, mint Endpoint=https://{account}.azure.com;Key={key}; azt feltételezné, hogy a tartománynév miatt regisztrálhat egy AzureAzure AI OpenAI ügyfelet. Ellenkező esetben egy közös OpenAIClient-t használnának.

További részletekért olvassa el a Azureplatformfüggetlen ügyfél feloldás.

MongoDB

A MongoDB felhasználónév és jelszó megadásának támogatása a AddMongoDB(IDistributedApplicationBuilder, String, Nullable<Int32>, IResourceBuilder<ParameterResource>, IResourceBuilder<ParameterResource>) bővítménymetódus használatakor. Ha nincs megadva, a rendszer létrehoz egy véletlenszerű felhasználónevet és jelszót, de manuálisan is megadható paramétererőforrásokkal.

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

var username = builder.AddParameter("mongousername");
var password = builder.AddParameter("mongopassword", secret: true);

var db = builder.AddMongo("db", username, password);

Fontos Azure fejlesztések

A következő szakaszok ismertetik a Azure 9-ben hozzáadott .NET Aspire fejlesztéseket. Az összes kompatibilitástörő változás teljes listáját .NET.NET Aspire kompatibilitástörő változásai című témakörben talál.

Azure erőforrás testreszabása

A .NET Aspire 8-ban a Azure-erőforrások testreszabása kísérletiként lett megjelölve, mivel a mögöttes Azure.Provisioning könyvtárak újak voltak, és visszajelzések gyűjtése után jelölhették volna őket stabilnak. A .NET.NET Aspire 9 API-k frissítése megtörtént és eltávolította a kísérleti attribútumot.

Azure erőforrás elnevezésének kompatibilitástörő módosítása

A Azure.Provisioning könyvtárak frissítésének részeként az Azure erőforrások alapértelmezett elnevezési sémája frissült, hogy jobban támogassa a különböző elnevezési szabályzatokat. Ez a frissítés azonban megváltoztatta az erőforrások elnevezését. Az új elnevezési szabályzat a meglévő Azure erőforrások elhagyását és új Azure erőforrások létrehozását eredményezheti, miután a .NET Aspire alkalmazást 8-ról 9-re frissítette. Ha folytatni szeretné a .NET.NET Aspire 8 azonos elnevezési szabályainak használatát, hozzáadhatja az alábbi kódot az AppHost Program.csfájlhoz.

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

builder.Services.Configure<AzureProvisioningOptions>(options =>
{
    options.ProvisioningBuildOptions.InfrastructureResolvers.Insert(0, new AspireV8ResourceNamePropertyResolver());
});

Azure SQL, PostgreSQLés Redis frissítés

Azure SQL, PostgreSQLés Redis erőforrások eltérnek a többi Azure erőforrástól, mivel ezekhez a technológiákhoz helyi tárolóerőforrások tartoznak. A(z) .NET Aspire elején, ahhoz, hogy létrehozza ezeket a Azure erőforrásokat, először egy helyi tárolóerőforrással kellett kezdenie, majd vagy "As", vagy "PublishAs" műveletet alkalmaznia ahhoz, hogy Azure erőforrást hozzon létre. Ez a kialakítás problémákat vezetett be, és nem felelt meg a többi API-nak.

Előfordulhat például, hogy ez a kód szerepel a .NET.NET Aspire 8-ban:

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

var sql = builder.AddSqlServer("sql")
                 .PublishAsAzureSqlDatabase();

var pgsql = builder.AddPostgres("pgsql")
                   .PublishAsAzurePostgresFlexibleServer();

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

A 9-es .NET.NET Aspire ezek az API-k elavultként lettek megjelölve, és egy új API-minta lett implementálva:

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

var sql = builder.AddAzureSqlServer("sql")
                 .RunAsContainer();

var pgsql = builder.AddAzurePostgresFlexibleServer("pgsql")
                   .RunAsContainer();

var cache = builder.AddAzureRedis("cache")
                   .RunAsContainer();
Microsoft Entra-azonosító alapértelmezés szerint

A .NET Aspire-alkalmazások biztonságosabbá tétele érdekében a AzurePostgreSQL- és Azure Cache for Redis-erőforrások adatbázisát alapértelmezés szerint a Microsoft Entra ID használatára frissítettük. Ehhez módosítani kell azokat az alkalmazásokat, amelyeknek csatlakozniuk kell ezekhez az erőforrásokhoz. Az alkalmazások Microsoft Entra-azonosítóval történő frissítéséhez tekintse meg az alábbi lépéseket az erőforrásokhoz való csatlakozáshoz:

Az alábbi példák bemutatják, hogyan konfigurálhatja az alkalmazást úgy, hogy a Microsoft Entra-azonosító használatával csatlakozzon az Azure erőforrásokhoz:

Ha jelszó- vagy hozzáférésikulcs-hitelesítést kell használnia (nem ajánlott), az alábbi kóddal is bejelentkezhet:

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

var pgsql = builder.AddAzurePostgresFlexibleServer("pgsql")
                   .WithPasswordAuthentication();

var cache = builder.AddAzureRedis("cache")
                   .WithAccessKeyAuthentication();

A Azure Functions (előzetes verzió) támogatása

A Azure Functions támogatása a .NET.NET Aspire problémakövető egyik legszélesebb körben igényelt funkciója, és örömmel jelentjük be, hogy ebben a kiadásban előzetes verziós támogatást nyújtunk. A támogatás bemutatásához használjuk a .NET.NET Aspire egy webhook létrehozásához és üzembe helyezéséhez.

Első lépésként hozzon létre egy új Azure Functions-projektet az Visual Studio Új projekt párbeszédpanelen. Amikor a rendszer kéri, jelölje be a Enlist Aspire orchestration jelölőnégyzetet a projekt létrehozásakor.

Új .NET AspireAzure Functions-projekt létrehozása.

Az alkalmazáshoz tartozó projektben vegye észre, hogy az új PackageReference📦Aspire .Hosting.Azure.Függvények NuGet-csomag:

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

Ez a csomag egy AddAzureFunctionsProject<TProject>(IDistributedApplicationBuilder, String) API-t biztosít, amely az alkalmazás gazdagépén meghívható, hogy a Azure Functions-projekteket egy .NET Aspire gazdagépen konfigurálja.

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

builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp");

builder.Build().Run();

Ebben a példában a webhook felelős egy bemeneti karakterlánc pig latinra való fordításáért. Frissítse az eseményindító tartalmát a következő kóddal:

C# 
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using System.Text;
using FromBodyAttribute = Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute;

namespace PigLatinApp;

public class Function1(ILogger<Function1> logger)
{
    public record InputText(string Value);
    public record PigLatinText(string Value);

    [Function("Function1")]
    public IActionResult Run(
        [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,
        [FromBody] InputText inputText)
    {
        logger.LogInformation("C# HTTP trigger function processed a request.");

        var result = TranslateToPigLatin(inputText.Value);

        return new OkObjectResult(new PigLatinText(result));
    }

    private static string TranslateToPigLatin(string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return input;
        }

        var words = input.Split(' ');
        StringBuilder pigLatin = new();

        foreach (string word in words)
        {
            if (IsVowel(word[0]))
            {
                pigLatin.Append(word + "yay ");
            }
            else
            {
                int vowelIndex = FindFirstVowelIndex(word);
                if (vowelIndex is -1)
                {
                    pigLatin.Append(word + "ay ");
                }
                else
                {
                    pigLatin.Append(
                        word.Substring(vowelIndex) + word.Substring(0, vowelIndex) + "ay ");
                }
            }
        }

        return pigLatin.ToString().Trim();
    }

    private static int FindFirstVowelIndex(string word)
    {
        for (var i = 0; i < word.Length; i++)
        {
            if (IsVowel(word[i]))
            {
                return i;
            }
        }
        return -1;
    }

    private static bool IsVowel(char c) =>
        char.ToLower(c) is 'a' or 'e' or 'i' or 'o' or 'u';
}

Állítson be egy töréspontot a logger.LogInformation metódus első Run sorára, és nyomja le F5 a Functions-gazdagép elindításához. Az .NET.NET Aspire irányítópult elindítása után a következőket kell megfigyelni:

A .NET Aspire függvényalkalmazással futó Azure képernyőképe.

.NET .NET Aspire a következőket:

  • Konfigurálták az emulált Azure tár-erőforrást, amelyet a gazdagép nyilvántartás céljából használ.
  • Helyileg indította el a Funkciók-gazdagépet a regisztrált célként megadott Funkciók-projekttel.
  • A függvényprojekt launchSettings.json-ben meghatározott portot összekapcsolták a hallgatásra.

A választott kedvenc HTTP-ügyfél használatával küldjön egy kérést az eseményindítónak, és figyelje meg a hibakeresőben lévő kérés törzséből érkező bemeneteket.

Bash 
curl --request POST \
  --url http://localhost:7282/api/Function1 \
  --header 'Content-Type: application/json' \
  --data '{
  "value": "Welcome to Azure Functions"
}'

.NET Aspire irányítópult képernyőképe: Azure függvényalkalmazás hibakeresése.

Most már készen áll az alkalmazás Azure Container Apps (ACA) üzembe helyezésére. Az üzembe helyezés jelenleg Azure Functions Worker és Worker SDK-csomagok előzetes buildjeitől függ. Szükség esetén frissítse a Functions-projektben hivatkozott verziókat:

XML 
<ItemGroup>
    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="2.0.0-preview2" />
    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="2.0.0-preview2" />
</ItemGroup>

Közzé kell tennie egy nyilvános végpontot is a Azure Functions-projekthez, hogy a kérések elküldhetők legyenek a HTTP-eseményindítónknak:

C# 
builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp")
       .WithExternalHttpEndpoints();

Az alkalmazás a azd CLIhasználatával történő üzembe helyezéséhez először a legújabb verziót kell beszereznie. A legújabb verzió telepítéséhez figyelmeztetés jelenik meg, ha a verzió elavult. Kövesse az utasításokat a legújabb verzióra való frissítéshez.

A telepítés után keresse meg az alkalmazásgazdaprojektet tartalmazó mappát, és futtassa a azd init:

Azure Developer CLI 
$ azd init

Initializing an app to run on Azure (azd init)

? How do you want to initialize your app? Use code in the current directory

  (✓) Done: Scanning app code in current directory

Detected services:

  .NET (Aspire)
  Detected in: ./PigLatinApp/PigLatinApp.AppHost/PigLatinApp.AppHost.csproj

azd will generate the files necessary to host your app on Azure using Azure Container Apps.

? Select an option Confirm and continue initializing my app
? Enter a new environment name: azfunc-piglatin

Generating files to run your app on Azure:

  (✓) Done: Generating ./azure.yaml
  (✓) Done: Generating ./next-steps.md

SUCCESS: Your app is ready for the cloud!

Ezután telepítse az alkalmazást a azd upfuttatásával:

Azure Developer CLI 
$ azd up 
? Select an Azure Subscription to use: 130. [redacted]
? Select an Azure location to use: 50. (US) West US 2 (westus2)

Packaging services (azd package)


Provisioning Azure resources (azd provision)
Provisioning Azure resources can take some time.

Subscription: [redacted]
Location: West US 2

  You can view detailed progress in the Azure Portal:
  [redacted]

  (✓) Done: Resource group: rg-azfunc-piglatin (967ms)
  (✓) Done: Container Registry: [redacted] (13.316s)
  (✓) Done: Log Analytics workspace: [redacted] (16.467s)
  (✓) Done: Container Apps Environment: [redacted] (1m35.531s)
  (✓) Done: Storage account: [redacted] (21.37s)

Deploying services (azd deploy)

  (✓) Done: Deploying service piglatinapp
  - Endpoint: {{endpoint-url}}

  Aspire Dashboard: {{dashboard-url}}

Végül tesztelje az üzembe helyezett Functions-alkalmazást a kedvenc HTTP-ügyféllel:

Bash 
curl --request POST \
  --url {{endpoint-url}}/api/Function1 \
  --header 'Content-Type: application/json' \
  --data '{
  "value": "Welcome to Azure Functions"
}'

A(z) Azure függvények támogatása a .NET Aspire-ben továbbra is előzetes verzióban érhető el, és korlátozott számú eseményindítót támogat, például:

További információkért lásd a hivatalos .NET AspireAzure Functions-integrációt (előzetes verzió).

A Azure Container Apps testreszabása

Az egyik leggyakrabban kért funkció az alkalmazáshost által létrehozott Azure Container Apps testreszabása anélkül, hogy a Bicep-hez kellene nyúlni. Ez a PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) névtérben található PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) és Aspire.Hosting.Azure.AppContainers API-k használatával lehetséges. Ezek a metódusok testre szabják az alkalmazásgazda által létrehozott Azure tárolóalkalmazás-definíciót.

Adja hozzá a csomaghivatkozást a projektfájlhoz:

XML 
<ItemGroup>
  <PackageReference Include="Aspire.Hosting.Azure.AppContainers"
                    Version="9.0.0" />
</ItemGroup>

Az alábbi példa bemutatja, hogyan méretezhet egy Azure tárolóalkalmazást nullára (0) replikákra:

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

var db = builder.AddAzurePostgresFlexibleServer("pg")
                .RunAsContainer()
                .AddDatabase("db");

// Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
#pragma warning disable AZPROVISION001

builder.AddProject<Projects.WebApplication1>("api")
       .WithReference(db)
       .PublishAsAzureContainerApp((module, containerApp) =>
       {
           // Scale to 0
           containerApp.Template.Value!.Scale.Value!.MinReplicas = 0;
       });

#pragma warning restore AZPROVISION001

builder.Build().Run();

Az előző példakód a Azure tárolóalkalmazás definíciójának létrehozását az alkalmazás gazdagépére hárítja. Ez lehetővé teszi a Azure tárolóalkalmazás definíciójának testreszabását anélkül, hogy futtatnia kellene a azd infra synth-et vagy veszélyesen módosítania kellene a létrehozott bicep-fájlokat.

Lásd még: