Nyheter i .NET.NET Aspire 9.0
📢 .NET Aspire 9.0 är nästa Allmänt tillgänglig (GA)-version av .NET Aspire; Den stöder både:
- .NET 8.0 Long Term Support (LTS) eller
- .NET 9.0 Standardperiodstöd (STS).
Not
Du kan använda .NET Aspire 9.0 med antingen .NET 8 eller .NET 9!
Den här versionen tar upp några av de mest efterfrågade funktionerna och smärtpunkterna från communityn. De bästa funktionerna är communitydrivna! Om du vill delta i communityn besöker du oss på 
Discord för att chatta med teammedlemmar och samarbeta med oss på 
GitHub.
Mer information om den officiella .NET-versionen och .NET Aspire-versionens support finns i:.
- .NET stöder princip: Definitioner för LTS och STS.
- .NET .NET Aspire supportpolicy: Viktig information om produktens livscykel.
Uppgradera till .NET.NET Aspire 9
Om du vill uppgradera från tidigare versioner av .NET Aspire till .NET Aspire 9 följer du anvisningarna i den officiella Uppgradera till .NET.NET Aspire 9 guide. Guiden innehåller detaljerade instruktioner om hur du uppgraderar dina befintliga .NET Aspire lösningar till .NET Aspire 9. Oavsett om du gör det manuellt eller med hjälp av uppgraderingsassistenten gör guiden ett kort arbete med processen.
Verktygsförbättringar
.NET Aspire 9 gör det enklare att konfigurera din miljö för att utveckla .NET Aspire program. Du behöver inte längre en .NET arbetsbelastning. I stället installerar du den nya .NET.NET Aspire SDK i värdprojektet för appen för dina .NET.NET Aspire lösningar. För mer information, se .NET.NET Aspire installation och verktyg.
Mallar har flyttats
.NET
.NET Aspire 9 flyttar innehållet som tidigare installerades via arbetsbelastningen till separata NuGet-paket. Detta inkluderar mallarna för att skapa nya .NET.NET Aspire projekt och lösningar. Dessa mallar installeras med kommandot dotnet new install. Dessa kan installeras genom att köra följande kommando:
dotnet new install Aspire.ProjectTemplates::9.0.0
Tips
Om du redan har installerat arbetsbelastningen .NET.NET Aspire måste du använda flaggan --force för att skriva över befintliga mallar. Avinstallera gärna .NET.NET Aspire arbetsbelastningen.
Mer information finns i .NET.NET Aspire mallar.
Förbättringar av instrumentpanelens UX och nya interaktivitetsfunktioner
Instrumentpanelen .NET.NET Aspire fortsätter att förbättras för varje version.
Hantera resurslivscykel
Den mest efterfrågade funktionen för instrumentpanelen är att hantera livscykeln för dina orkestrerade namngivna resurser. Mer specifikt möjligheten att stoppa, starta och starta om resurser. Den här funktionen fungerar för projekt, containrar och körbara filer. Det gör det möjligt att starta om enskilda resurser utan att behöva starta om hela appvärden. För projektresurser, när felsökaren är ansluten, återansluts den vid omstart. Mer information finns på instrumentpanelen .NET.NET Aspire: Stoppa eller starta resursen.
Mobilt och dynamiskt stöd
Den .NET Aspire instrumentpanelen är nu mobilvänlig och anpassar sig dynamiskt till ett brett utbud av skärmstorlekar och möjliggör direkthantering av distribuerade .NET Aspire program. Andra åtkomlighetsförbättringar har gjorts, inklusive visning av inställningar och innehåll som svämmar över på mobilen.
Känsliga egenskaper, volymer och hälsokontroller i resursinformation
Visning av resursinformation innehåller flera förbättringar:
Egenskaper kan markeras som känsliga och maskeras automatiskt i instrumentpanelens användargränssnitt. Den här säkerhetsfunktionen hjälper till att undvika att oavsiktligt avslöja nycklar eller lösenord när du delar instrumentpanelen med andra. Containerargument kan till exempel skicka känslig information och maskeras därför som standard.
Konfigurerade containervolymer visas i resursinformation.
.NET .NET Aspire 9 lägger till stöd för hälsokontroller. Detaljerad information om dessa kontroller kan nu visas i resursinformationsfönstret, som visar varför en resurs kan markeras som felaktig eller degraderad. Läs mer om hälsokontroller här.
Färgglad konsollogg
ANSI-undantagskoder formatera text i terminaler genom att styra färger (förgrund och bakgrund) och format som fetstil, understrykning och kursiv stil. Tidigare kunde instrumentpanelens konsolloggsida bara återge en ANSI-escape-kod i taget, vilket misslyckades när flera koder kombinerades. Den kan till exempel visa röd text, men inte text som var både röd och fet.
Ett community-bidrag från @mangeg förbättrade stöd för ANSI escape-koder och tog bort den här begränsningen.
En annan förbättring av konsolloggar är att dölja undantagskoder som inte stöds. Koder som inte är relaterade till att visa text, till exempel att placera markören eller kommunicera med operativsystemet, är inte meningsfulla i det här användargränssnittet och är dolda.
Användarcentrerade tillägg för telemetri
Telemetri är fortfarande en viktig aspekt av .NET.NET Aspire. I .NET.NET Aspire 9 introducerades många nya funktioner i telemetritjänsten.
Förbättrad telemetrifiltrering
Spårningar kan filtreras med attributvärden. Om du till exempel bara vill visa spårningar för en slutpunkt i din app kan attributet http.route på HTTP-begäranden filtreras till ett angivet värde.
Telemetrifiltrering stöder också automatisk komplettering av befintliga värden. Dialogrutan Lägg till filter innehåller en kombinationsruta för att välja från värden som instrumentpanelen har tillgänglig. Den här funktionen gör det mycket enklare att filtrera efter verkliga data och hjälper till att undvika skrivfel genom att ange ett värde själv.
Mer information finns i .NET.NET Aspire instrumentpanel: Filtrera spårningar.
Kombinera telemetri från flera resurser
När en resurs har flera repliker kan du nu filtrera telemetri för att visa data från alla instanser samtidigt. Välj den överordnade resursen, märkt (application). För mer information, se .NET.NET Aspire instrumentpanel: Kombinera telemetri från flera resurser.
Stöd för webbläsartelemetri
Instrumentpanelen stöder OpenTelemetry Protocol (OTLP) via HTTP och resursdelning mellan ursprung (CORS). De här funktionerna låser upp möjligheten att skicka OpenTelemetry från webbläsarappar till .NET Aspire instrumentpanelen.
Till exempel kan en webbläsarbaserad ensidesapp (SPA) konfigurera JavaScript OpenTelemetry SDK för att skicka strukturerade loggar, spårningar och mått som skapats i webbläsaren till instrumentpanelen. Webbläsartelemetri visas tillsammans med server telemetri.
Mer information om hur du konfigurerar webbläsartelemetri finns i Aktivera webbläsartelemetri dokumentation.
Värd för appar (orkestrering)
.NET .NET Aspire appvärd är en av de viktigaste funktionerna i .NET.NET Aspire. I .NET.NET Aspire 9 har flera nya funktioner lagts till som är specifika för appvärden.
Väntar på beroenden
Om du har följt med .NET.NET Aspirevet du redan att ditt apphost-projekt är där du definierar din appmodell. Du skapar en distribuerad programbyggare, lägger till och konfigurerar resurser och uttrycker deras beroenden. Nu kan du ange att en resurs ska vänta på en annan resurs innan du startar. Detta kan hjälpa till att undvika anslutningsfel vid start genom att bara starta resurser när deras beroenden är "klara".
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();
När appvärden startar väntar den på att rabbit-resursen ska vara klar innan api-resursen startas.
Det finns två metoder för att vänta på en resurs:
- WaitFor: Vänta tills en resurs är klar innan du startar en annan resurs.
- WaitForCompletion: Vänta tills en resurs har slutförts innan du startar en annan resurs.
För mer information, se .NET.NET Aspire appvärd: Väntar på resurser.
Hälsokontroller för resurser
WaitFor-API:et använder standardhälskontroller .NET för att avgöra om en resurs är redo. Men vad betyder "en resurs som är redo"? Det bästa är att det kan konfigureras av konsumenten utöver deras standardvärden.
När en resurs inte exponerar några hälsokontroller (inga hälsokontroller registrerade i appen) väntar appvärden på att resursen ska vara i Running tillstånd innan den beroende resursen startas.
För resurser som exponerar HTTP-slutpunkter kan du enkelt lägga till en hälsokontroll som avsöker en specifik sökväg för ett HTTP 200-svar.
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();
Föregående exempel lägger till en hälsokontroll för den catalog-api resursen. Appvärden väntar på att hälsokontrollen ska returnera en felfri status innan den store-resursen startas. Den avgör att resursen är klar när /health slutpunkten returnerar en HTTP 200-statuskod.
Medan store väntar på att catalog-api ska bli felfri visas resurserna på instrumentpanelen som:
Appvärdens hälsokontrollsystem bygger på IHealthChecksBuilder-implementeringen från Microsoft.Extensions.Diagnostics.HealthChecks namnrymden.
Hälsokontroller rapporterar data, som visas i instrumentpanelen:
Det är enkelt att skapa en anpassad hälsokontroll. Börja med att definiera hälsokontrollen och associera dess namn med alla resurser som den gäller för.
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);
Föregående exempel lägger till en hälsokontroll för resurs cache, vilket rapporterar att det är ohälsosamt under de första 20 sekunderna efter att appvärden startar. Därför väntar den myapp resursen i 20 sekunder innan den startar, vilket säkerställer att den cache resursen är felfri.
Metoderna AddCheck och WithHealthCheck ger en enkel mekanism för att skapa hälsokontroller och associera dem med specifika resurser.
Beständiga behållare
App-hosten stöder nu beständiga containrar. Beständiga containrar avviker från den typiska containerlivscykeln för .NET.NET Aspire orkestrerade appar. De har skapats och startat (när de inte redan är tillgängliga) av .NET Aspire orchestrator, men de förstörs inte av .NET Aspire.
Det här är användbart när du vill att containern ska köras även efter att apphosten har stoppats.
Viktig
Om du vill ta bort dessa containrar måste du stoppa dem manuellt genom containerkörningsmiljön.
Om du vill definiera en IResourceBuilder<ContainerResource> med en beständig livslängd anropar du metoden WithLifetime och skickar in ContainerLifetime.Persistent:
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();
Instrumentpanelen visar persistenta containrar med en nål-ikon.
Efter att appvärden har stoppats kommer containern att fortsätta köra:
Mekanismen för behållarbeständighet försöker identifiera när du kanske vill återskapa containern. Om miljön för containern till exempel ändras startas containern om så att du inte behöver stoppa containern manuellt om indatakonfigurationen för resursen har ändrats.
Resurskommandon
Appvärden har stöd för att lägga till anpassade kommandon i resurser. Detta är användbart när du vill lägga till anpassade funktioner som inte stöds internt av appvärden. Det finns förmodligen många tillfällen där det kan vara användbart att exponera anpassade tilläggsmetoder på resurser. .NET .NET Aspire Community Toolkit kan vara ett bra ställe att dela dessa tillägg på.
När du definierar ett anpassat kommando är det tillgängligt på instrumentpanelen som en funktion för användarupplevelse.
Viktig
Dessa .NET.NET Aspire instrumentpanelskommandon är endast tillgängliga när du kör instrumentpanelen lokalt. De är inte tillgängliga när man kör instrumentpanelen i Azure Container Apps.
Mer information om hur du skapar anpassade resurskommandon finns i Instruktioner: Skapa anpassade resurskommandon i .NET.NET Aspire.
Containernätverk
Appvärden lägger nu till alla containrar i ett gemensamt nätverk med namnet default-aspire-network. Detta är användbart när du vill kommunicera mellan containrar utan att gå igenom värdnätverket. Detta gör det också enklare att migrera från docker compose till apphost, eftersom containrar kan kommunicera med varandra med hjälp av containernamnet.
Händelsemodell
Händelsemodellen gör det möjligt för utvecklare att ansluta sig till programmets och resursernas livscykel. Detta är användbart för att köra anpassad kod vid specifika tidpunkter i programmets livscykel. Det finns olika sätt att prenumerera på händelser, inklusive globala händelser och händelser per resurs.
Globala händelser:
- BeforeStartEvent: En händelse som utlöses innan programmet startar. Det här är den sista platsen där ändringar i appmodellen observeras. Detta körs i lägena "Kör" och "Publicera". Det här är en blockerande händelse, vilket innebär att programmet inte startar förrän alla hanterare har slutförts.
- AfterResourcesCreatedEvent: En händelse som utlöses när resurserna har skapats. Detta körs endast i körningsläge.
- AfterEndpointsAllocatedEvent: En händelse som utlöses efter att slutpunkterna har allokerats för alla resurser. Detta körs endast i körningsläge.
De globala händelserna är liknande de händelser som sker i applikationsvärdens livscykel. För mer information, se livscykler för appvärdar.
resursspecifika händelser:
- BeforeResourceStartedEvent: En händelse som utlöses innan en enskild resurs startar. Detta körs endast i körningsläge. Det här är en blockerande händelse, vilket innebär att resursen inte startar förrän alla hanterare har slutfört sina uppgifter.
- ConnectionStringAvailableEvent: En händelse som utlöses när en anslutningssträng är tillgänglig för en resurs. Detta körs endast i körningsläge.
- ResourceReadyEvent: En händelse som utlöses när en resurs är redo att användas. Detta körs endast i körningsläge.
Mer information finns i Eventing i .NET.NET Aspire.
Integrationer
.NET .NET Aspire fortsätter att lägga till integreringar som gör det enkelt att komma igång med dina favorittjänster och verktyg. Mer information finns i översikten över .NET.NET Aspire integreringar.
Redis Insikt
Stöd för Redis Insights finns på en Redis resurs:
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.
Tilläggsmetoden WithRedisInsight kan tillämpas på flera Redis resurser och varje kommer att visas på Redis Insight-instrumentpanelen.
För mer information, se Lägg till Redis resurs med Redis Insights.
OpenAI (förhandsversion)
Från och med .NET Aspire 9 finns ytterligare en OpenAI integrering som gör det möjligt att använda det senaste officiella OpenAI dotnet-biblioteket direkt. client-integreringen registrerar OpenAIClient- som en singletonservice i tjänstesamlingen. client kan användas för att interagera med api:et OpenAIREST.
Dessutom förbättrades den redan tillgängliga .NET AspireAzureOpenAI integreringen för att ge ett flexibelt sätt att konfigurera en OpenAIClient för antingen en Azure AI OpenAI-tjänst eller en dedikerad OpenAIREST API med den nya AddOpenAIClientFromConfiguration(IHostApplicationBuilder, String) builder-metoden. I följande exempel identifieras om anslutningssträngen är för en AzureAzure AI OpenAI-tjänst och registrerar den lämpligaste OpenAIClient instansen automatiskt.
builder.AddOpenAIClientFromConfiguration("openai");
Om openai anslutningen till exempel såg ut som Endpoint=https://{account}.azure.com;Key={key}; skulle den gissa att den kan registrera en Azure AI OpenAIclient på grund av domännamnet. Annars skulle en vanlig OpenAIClient användas.
Läs Azure-agnostisk client lösning för mer information.
MongoDB
Stöd har lagts till för att ange MongoDB användarnamn och lösenord när du använder AddMongoDB(IDistributedApplicationBuilder, String, Nullable<Int32>, IResourceBuilder<ParameterResource>, IResourceBuilder<ParameterResource>)-tilläggsmetoden. Om det inte anges genereras ett slumpmässigt användarnamn och lösenord men kan anges manuellt med hjälp av parameterresurser.
var builder = DistributedApplication.CreateBuilder(args);
var username = builder.AddParameter("mongousername");
var password = builder.AddParameter("mongopassword", secret: true);
var db = builder.AddMongo("db", username, password);
Viktiga Azure förbättringar
I följande avsnitt beskrivs Azure förbättringar som lagts till i .NET Aspire 9. För en komplett lista över alla genomgripande förändringar, se Genomgripande förändringar i .NET.NET Aspire 9.
Azure resursanpassning
I .NET Aspire 8 markerades anpassning av Azure resurser som experimentella eftersom de underliggande Azure.Provisioning biblioteken var nya och samlade in feedback innan de kunde markeras som stabila. I .NET.NET Aspire 9 uppdaterades dessa API:er och tog bort det experimentella attributet.
Azure Ändring i namngivning av resurser
Som en del av uppdateringen av Azure.Provisioning bibliotek uppdaterades standardnamnschemat för Azure resurser med bättre stöd för olika namngivningsprinciper. Den här uppdateringen resulterade dock i en ändring av hur resurser namnges. Den nya namngivningsprincipen kan leda till att befintliga Azure resurser överges och nya Azure resurser skapas efter att du har uppdaterat ditt .NET Aspire program från 8 till 9. Om du vill fortsätta att använda samma namngivningsprinciper från .NET.NET Aspire 8 kan du lägga till följande kod i Din AppHost-Program.cs:
var builder = DistributedApplication.CreateBuilder(args);
builder.Services.Configure<AzureProvisioningOptions>(options =>
{
options.ProvisioningBuildOptions.InfrastructureResolvers.Insert(0, new AspireV8ResourceNamePropertyResolver());
});
Azure SQL, PostgreSQLoch Redis Uppdatering
Azure SQL, PostgreSQLoch Redis resurser skiljer sig från andra Azure resurser eftersom det finns lokala containerresurser för dessa tekniker. I .NET Aspire 8, för att skapa dessa Azure-resurser, behövde du börja med en lokal containerresurs och sedan antingen "As" eller "PublishAs" det till en Azure-resurs. Den här designen introducerade problem och passade inte med andra API:er.
Du kan till exempel ha den här koden i .NET.NET Aspire 8:
var builder = DistributedApplication.CreateBuilder(args);
var sql = builder.AddSqlServer("sql")
.PublishAsAzureSqlDatabase();
var pgsql = builder.AddPostgres("pgsql")
.PublishAsAzurePostgresFlexibleServer();
var cache = builder.AddRedis("cache")
.PublishAsAzureSqlDatabase();
I .NET.NET Aspire 9 markerades dessa API:er som föråldrade och ett nytt API-mönster implementerades:
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-ID som standard
För att göra .NET Aspire program säkrare uppdaterades Azure Database for PostgreSQL och Azure Cache for Redis resurser för att använda Microsoft Entra-ID som standard. Detta kräver ändringar i program som behöver ansluta till dessa resurser. Se följande för att uppdatera program för att använda Microsoft Entra-ID för att ansluta till dessa resurser:
Följande exempel visar hur du konfigurerar ditt program för att ansluta till Azure resurser med hjälp av Microsoft Entra-ID:
Om du behöver använda lösenords- eller åtkomstnyckelautentisering (rekommenderas inte) kan du välja att använda följande kod:
var builder = DistributedApplication.CreateBuilder(args);
var pgsql = builder.AddAzurePostgresFlexibleServer("pgsql")
.WithPasswordAuthentication();
var cache = builder.AddAzureRedis("cache")
.WithAccessKeyAuthentication();
Stöd för Azure Functions (förhandsversion)
Stöd för Azure Functions är en av de mest efterfrågade funktionerna på .NET.NET Aspire problemspåraren och vi är glada över att kunna presentera förhandsversionsstöd för den i den här versionen. För att demonstrera det här stödet använder vi .NET.NET Aspire för att skapa och distribuera en webhook.
Kom igång genom att skapa ett nytt Azure Functions-projekt med hjälp av dialogrutan Visual Studio Nytt projekt. När du uppmanas till det markerar du kryssrutan Enlist i Aspire orkestrering när du skapar projektet.
Observera i appvärdprojektet att det finns en PackageReference till det nya 📦Aspire.Hosting.Azure.Functions NuGet-paket:
<ItemGroup>
<PackageReference Include="Aspire.Hosting.AppHost" Version="9.0.0" />
<PackageReference Include="Aspire.Hosting.Azure.Functions" Version="9.0.0" />
</ItemGroup>
Det här paketet innehåller ett AddAzureFunctionsProject<TProject>(IDistributedApplicationBuilder, String) API som kan anropas i appvärden för att konfigurera Azure Functions-projekt inom en .NET Aspire värd:
var builder = DistributedApplication.CreateBuilder(args);
builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp");
builder.Build().Run();
I det här exemplet ansvarar webhooken för att översätta en indatasträng till Pig Latin. Uppdatera innehållet i vår utlösare med följande kod:
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';
}
Ange en brytpunkt på den första logger.LogInformation raden i metoden Run och tryck på F5- för att starta Functions-värden. När .NET.NET Aspire-instrumentpanelen startas ser du följande:
.NET .NET Aspire har:
- Konfigurerade en emulerad Azure Storage-resurs som ska användas för bokföring av värden.
- Startade Functions-värden lokalt med målet när Functions-projektet registrerades.
- Anslöt porten som definierats i launchSettings.json av funktionsprojektet för att avlyssna.
Använd valfri HTTP-client för att skicka en begäran till utlösaren och observera indata som är bundna från begärandetexten i felsökningsprogrammet.
curl --request POST \
--url http://localhost:7282/api/Function1 \
--header 'Content-Type: application/json' \
--data '{
"value": "Welcome to Azure Functions"
}'
Nu är du redo att distribuera vårt program till Azure Container Apps (ACA). Distributionen beror för närvarande på förhandsversioner av Azure Functions Worker- och Worker SDK-paket. Om det behövs uppgraderar du de versioner som refereras till i Functions-projektet:
<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>
Du måste också exponera en offentlig slutpunkt för vårt Azure Functions-projekt så att begäranden kan skickas till vår HTTP-utlösare:
builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp")
.WithExternalHttpEndpoints();
Om du vill distribuera programmet med azd CLI-måste du hämta den senaste versionen först. Om du vill installera den senaste versionen visas en varning om din version är inaktuell. Följ anvisningarna för att uppdatera till den senaste versionen.
När den har installerats navigerar du till mappen som innehåller appvärdprojektet och kör azd init:
$ 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!
Distribuera sedan programmet genom att köra azd up:
$ 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}}
Testa slutligen ditt distribuerade Functions-program med hjälp av din favorit-HTTP-client:
curl --request POST \
--url {{endpoint-url}}/api/Function1 \
--header 'Content-Type: application/json' \
--data '{
"value": "Welcome to Azure Functions"
}'
Stöd för Azure Functions i .NET Aspire är fortfarande i förhandsversion med stöd för en begränsad uppsättning utlösare, inklusive:
- HTTP-utlösare
- Azure Lagringskö-utlösare
- Azure Storage Blob utlöser
- Azure Service Bus utlöser
- Azure Event Hubs utlöser
För mer information, se den officiella .NET AspireAzure-funktionens integrering (förhandsversion).
Anpassning av Azure Container Apps
En av de mest efterfrågade funktionerna är möjligheten att anpassa Azure Container Apps som appvärden skapar utan att röra Bicep. Detta är möjligt med hjälp av api:erna PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) och PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) i Aspire.Hosting.Azure.AppContainers namnområdet. De här metoderna anpassar definitionen Azure Container App som appvärden skapar.
Lägg till paketreferensen i projektfilen:
<ItemGroup>
<PackageReference Include="Aspire.Hosting.Azure.AppContainers"
Version="9.0.0" />
</ItemGroup>
I följande exempel visas hur du skalar en Azure Container App till noll (0) repliker:
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();
Kodexemplet ovan uppskjuter genereringen av Azure Container App-definitionen till appvärden. På så sätt kan du anpassa Azure Container App-definitionen utan att behöva köra azd infra synth och på ett osäkert sätt ändra de genererade bicep-filerna.
Se även
.NET Aspire