O que há de novo no .NET.NET Aspire 9.0
📢 .NET Aspire 9.0 é a próxima grande versão de disponibilidade geral (GA) do .NET Aspire; ele suporta ambos os:
- .NET 8.0 Suporte de longo prazo (LTS) ou
- .NET Suporte de Termo Padrão (STS) 9.0.
Observação
Você pode usar o .NET Aspire 9.0 com .NET 8 ou .NET 9!
Esta versão aborda alguns dos recursos e pontos problemáticos mais solicitados pela comunidade. As melhores funcionalidades são orientadas para a comunidade! Para participar da nossa comunidade, visite-nos no 
Discord para conversar com os membros da equipa e colabore conosco no 
GitHub.
Para obter mais informações sobre a versão oficial do .NET e o suporte à versão .NET Aspire, consulte:
- .NET política de suporte: Definições para LTS e STS.
- .NET .NET Aspire política de suporte: Detalhes importantes e exclusivos do ciclo de vida do produto.
Atualize para .NET.NET Aspire 9
Para atualizar de versões anteriores do .NET Aspire para o .NET Aspire 9, siga as instruções no guia oficial de atualização para o .NET.NET Aspire 9. O guia fornece instruções detalhadas sobre como atualizar suas soluções de .NET Aspire existentes para o .NET Aspire 9. Independentemente de estar a fazê-lo manualmente ou a utilizar o Assistente de Atualização, o guia torna o processo rápido e fácil.
Melhorias nas ferramentas
O .NET Aspire 9 simplifica a configuração do ambiente para desenvolver .NET Aspire aplicativos. Você não precisa mais de uma .NET carga de trabalho. Em vez disso, instala o novo SDK .NET.NET Aspire no projeto de host do aplicativo das suas soluções .NET.NET Aspire. Para obter mais informações, consulte .NET.NET Aspire configuração e ferramentas.
Os modelos foram movidos
.NET
.NET Aspire 9 está movendo o conteúdo que costumava ser instalado por meio da carga de trabalho em pacotes NuGet separados. Isso inclui os modelos para criar novos projetos e soluções .NET.NET Aspire. Esses modelos são instalados usando o comando dotnet new install. Eles podem ser instalados executando o seguinte comando:
dotnet new install Aspire.ProjectTemplates::9.0.0
Dica
Se já tiver a carga de trabalho .NET.NET Aspire instalada, precisa passar o indicador --force para substituir os modelos existentes. Sinta-se à vontade para desinstalar a carga de trabalho .NET.NET Aspire.
Para obter mais informações, consulte .NET.NET Aspire modelos.
Aprimoramentos de UX do painel e novos recursos de interatividade
O painel .NET.NET Aspire continua a melhorar a cada versão.
Gerenciar o ciclo de vida dos recursos
O recurso mais solicitado para o painel é gerenciar os ciclos de vida de seus recursos nomeados orquestrados. Especificamente, a capacidade de parar, iniciar e reiniciar recursos. Esse recurso funciona para projetos, contêineres e executáveis. Ele permite reiniciar recursos individuais sem ter que reiniciar todo o host do aplicativo. Para recursos do projeto, quando o depurador é anexado, ele é reanexado na reinicialização. Para obter mais informações, consulte o painel de controlo .NET.NET Aspire: Parar ou Começar um recurso.
Suporte móvel e responsivo
O painel .NET Aspire agora é compatível com dispositivos móveis, adaptando-se responsivamente a uma ampla gama de tamanhos de tela e permitindo o gerenciamento em movimento de aplicativos .NET Aspire implantados. Outras melhorias de acessibilidade foram feitas, incluindo a exibição de configurações e transbordo de conteúdo em dispositivos móveis.
Propriedades sensíveis, volumes e verificações de integridade nos detalhes do recurso
A exibição de detalhes do recurso contém várias melhorias:
As propriedades podem ser marcadas como confidenciais, mascarando-as automaticamente na interface do usuário do painel. Este recurso de segurança ajuda a evitar a divulgação acidental de chaves ou senhas ao compartilhar a tela do painel com outras pessoas. Por exemplo, argumentos de contêiner podem passar informações confidenciais e, portanto, são mascarados por padrão.
Os volumes de contêiner configurados são listados em detalhes do recurso.
.NET .NET Aspire 9 adiciona suporte para verificações de saúde. Informações detalhadas sobre essas verificações agora podem ser exibidas no painel de detalhes do recurso, mostrando por que um recurso pode ser marcado como não íntegro ou degradado. Saiba mais sobre os exames de saúde aqui.
Registro colorido do console
códigos de escape ANSI formatam texto nos terminais controlando cores (frente e plano de fundo) e estilos como negrito, sublinhado e itálico. Anteriormente, a página de logs do console do painel só conseguia processar um código de escape ANSI de cada vez, falhando quando vários códigos eram combinados. Por exemplo, ele poderia exibir texto vermelho, mas não texto que fosse vermelho e negrito.
Uma contribuição da comunidade de @mangeg melhorou o suporte para códigos de escape ANSI e removeu essa limitação.
Outra melhoria nos logs do console é ocultar códigos de escape não suportados. Os códigos que não estão relacionados à exibição de texto, como posicionar o cursor ou se comunicar com o sistema operacional, não fazem sentido nessa interface do usuário e ficam ocultos.
Adições de telemetria centradas no usuário
Telemetria continua a ser um aspeto vital da .NET.NET Aspire. No .NET.NET Aspire 9, muitos novos recursos foram introduzidos no serviço de Telemetria.
Filtragem de telemetria melhorada
Os rastreamentos podem ser filtrados com valores de atributos. Por exemplo, se você quiser exibir apenas rastreamentos para um ponto de extremidade em seu aplicativo, o atributo http.route em solicitações HTTP poderá ser filtrado para um valor especificado.
A filtragem por telemetria também oferece suporte ao preenchimento automático de valores existentes. A caixa de diálogo Adicionar filtro fornece uma caixa de combinação para selecionar entre os valores que o painel tem disponíveis. Esse recurso facilita muito a filtragem de dados reais e ajuda a evitar erros de digitação inserindo um valor você mesmo.
Para obter mais informações, consulte o painel .NET.NET Aspire: Filtrar registos.
Combine telemetria a partir de vários recursos
Quando um recurso tem várias réplicas, agora você pode filtrar a telemetria para exibir dados de todas as instâncias de uma só vez. Selecione o recurso pai, rotulado (application). Para obter mais informações, consulte .NET.NET Aspire Painel: Combinar telemetria de vários recursos.
Suporte de telemetria do navegador
O painel de controlo suporta OpenTelemetry Protocol (OTLP) sobre HTTP e partilha de recursos entre origens (CORS). Esses recursos desbloqueiam a capacidade de enviar OpenTelemetry de aplicações de navegador para o dashboard .NET Aspire.
Por exemplo, um aplicativo de página única (SPA) baseado em navegador pode configurar o JavaScript OpenTelemetry SDK para enviar logs, rastreamentos e métricas estruturados criados no navegador para o painel. A telemetria do navegador é exibida ao lado da telemetria server.
Para mais informações sobre como configurar a telemetria do navegador, consulte a documentação em Ativar a telemetria do navegador.
Host do aplicativo (orquestração)
Os hosts de aplicação .NET.NET Aspire são um dos recursos mais importantes de do .NET.NET Aspire. No .NET.NET Aspire 9, vários novos recursos foram adicionados específicos para o host do aplicativo.
À espera de dependências
Se você tem acompanhado .NET.NET Aspire, já sabe que seu projeto de host de aplicativo é onde você define seu modelo de aplicativo. Você cria um construtor de aplicativos distribuído, adiciona e configura recursos e expressa suas dependências. Agora, você pode especificar que um recurso deve aguardar por outro recurso antes de iniciar. Isso pode ajudar a evitar erros de conexão durante a inicialização, iniciando recursos apenas quando suas dependências estiverem "prontas".
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();
Quando o host do aplicativo é iniciado, ele aguarda que o recurso rabbit esteja pronto antes de iniciar o recurso api.
Existem dois métodos disponíveis para aguardar um recurso:
- WaitFor: Aguarde até que um recurso esteja pronto antes de iniciar outro recurso.
- WaitForCompletion: Aguarde a conclusão de um recurso antes de iniciar outro recurso.
Para obter mais informações, consulte .NET.NET Aspire host do aplicativo: aguardando recursos.
Verificações de integridade de recursos
A API WaitFor usa verificações de saúde padrão de .NET para determinar se um recurso está pronto. Mas o que significa "um recurso estar pronto"? A melhor parte é que isso é configurável pelo consumidor além de seus valores padrão.
Quando um recurso não expõe nenhuma verificação de integridade (nenhuma verificação de integridade registrada no aplicativo), o host do aplicativo aguarda que o recurso esteja no estado Running antes de iniciar o recurso dependente.
Para recursos que expõem endpoints HTTP, pode-se facilmente adicionar uma verificação de saúde que sonda um caminho específico para uma resposta HTTP 200.
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();
O exemplo anterior adiciona uma verificação de integridade ao recurso catalog-api. O anfitrião da aplicação aguarda que a verificação de integridade retorne um estado saudável antes de iniciar o recurso store. Determina-se que o recurso está pronto quando o endpoint /health retorna um código de status HTTP 200.
Enquanto store aguarda que catalog-api fique estável, os recursos no painel aparecem como:
O mecanismo de verificação de saúde do host da aplicação baseia-se na implementação IHealthChecksBuilder do namespace Microsoft.Extensions.Diagnostics.HealthChecks.
Dados do relatório de verificações de saúde, que são exibidos no painel de controlo:
Criar uma verificação de saúde personalizada é simples. Comece por definir a verificação de saúde e, em seguida, associe o nome da verificação aos recursos a que se aplica.
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);
O exemplo anterior adiciona uma verificação de saúde ao recurso cache, que o relata como não saudável nos primeiros 20 segundos após o início do host da aplicação. Assim, o recurso myapp aguarda por 20 segundos antes de iniciar, garantindo que o recurso cache esteja íntegro.
Os métodos AddCheck e WithHealthCheck fornecem um mecanismo simples para criar verificações de integridade e associá-las a recursos específicos.
Contentores persistentes
O host da aplicação agora suporta contentores persistentes. Os contêineres persistentes se desviam do ciclo de vida de contêiner típico de aplicativos orquestrados .NET.NET Aspire. Embora eles sejam criados e iniciados (quando ainda não estão disponíveis) pelo orquestrador .NET Aspire, eles não são destruídos por .NET Aspire.
Isso é útil quando você deseja manter o contêiner em execução mesmo depois que o host do aplicativo for interrompido.
Importante
Para excluir esses contêineres, você deve pará-los manualmente usando o tempo de execução do contêiner.
Para definir um IResourceBuilder<ContainerResource> com um tempo de vida persistente, chame o método WithLifetime e passe 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();
O painel mostra contêineres persistentes com um ícone de pino:
Depois que o host do aplicativo for interrompido, o contêiner continuará a ser executado:
O mecanismo de persistência do contêiner tenta identificar quando você pode querer recriar o contêiner. Por exemplo, se o ambiente do contêiner mudar, o contêiner será reiniciado para que você não precise parar manualmente o contêiner se a configuração de entrada do recurso tiver sido alterada.
Comandos de recursos
O host do aplicativo oferece suporte à adição de comandos personalizados aos recursos. Isso é útil quando você deseja adicionar funcionalidade personalizada que não é suportada nativamente pelo host do aplicativo. É provável que haja muitas oportunidades em que a exposição de métodos de extensão personalizados em recursos será útil. O Kit de Ferramentas da Comunidade .NET.NET Aspire pode ser um bom lugar para compartilhar essas extensões.
Quando você define um comando personalizado, ele fica disponível no painel como um recurso de experiência do usuário.
Importante
Os comandos do painel .NET.NET Aspire só estão disponíveis ao executar o painel localmente. Eles não estão disponíveis ao executar o painel no Azure Container Apps.
Para obter mais informações sobre como criar comandos de recursos personalizados, consulte Instruções: Criar comandos de recursos personalizados no .NET.NET Aspire.
Rede de contêineres
O host do aplicativo agora adiciona todos os contêineres a uma rede comum chamada default-aspire-network. Isso é útil quando você deseja se comunicar entre contêineres sem passar pela rede host. Isso também facilita a migração de docker Compose para o host da aplicação, já que os contêineres podem se comunicar usando o nome do contêiner.
Modelo de eventos
O modelo de eventos permite que os desenvolvedores se conectem ao ciclo de vida do aplicativo e dos recursos. Isso é útil para executar código personalizado em pontos específicos do ciclo de vida do aplicativo. Existem várias formas de subscrever eventos, incluindo eventos globais e eventos por recurso.
Eventos globais:
- BeforeStartEvent: Um evento que é acionado antes do aplicativo ser iniciado. Este é o último lugar em que as alterações no modelo de aplicativo são observadas. Isso é executado nos modos "Executar" e "Publicar". Este é um evento de bloqueio, o que significa que a aplicação não é iniciada até que todos os manipuladores tenham sido finalizados.
- AfterResourcesCreatedEvent: Um evento que é acionado depois que os recursos são criados. Isso só funciona no modo Run.
- AfterEndpointsAllocatedEvent: Um evento que é acionado depois que os endpoints são atribuídos para todos os recursos. Isto só é executado no modo Run.
Os eventos globais são análogos aos eventos do ciclo de vida do host do aplicativo. Para obter mais informações, consulte Ciclos de vida do host da aplicação.
Eventos por recurso:
- BeforeResourceStartedEvent: Um evento que é acionado antes do início de um único recurso. Isso é executado somente no modo de execução. Este é um evento de bloqueio, o que significa que o recurso não é iniciado até que todos os manipuladores sejam concluídos.
- ConnectionStringAvailableEvent: Um evento que é acionado quando uma cadeia de conexão está disponível para um recurso. Isso é executado somente no modo de execução.
- ResourceReadyEvent: Um evento que é acionado quando um recurso está pronto para ser usado. Isso só corre no modo de execução.
Para obter mais informações, consulte Eventos em .NET.NET Aspire.
Integrações
.NET .NET Aspire continua a adicionar integrações que facilitam o início com seus serviços e ferramentas favoritos. Para obter mais informações, consulte .NET.NET Aspire visão geral das integrações.
Visão Redis
O suporte para Redis Insights está disponível em um recurso Redis:
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.
O método de extensão WithRedisInsight pode ser aplicado a vários recursos de Redis e cada um deles ficará visível no painel do Redis Insight.
Painel de controlo Insight 
Para mais informações, veja Adicionar Redis recurso com o Redis Insights.
OpenAI (Pré-visualização)
A partir do .NET Aspire 9, uma integração OpenAI adicional está disponível que permite usar a mais recente biblioteca oficial OpenAI dotnet diretamente. A implementação client regista o OpenAIClient como um serviço singleton (instância única) na coleção de serviços. O client pode ser usado para interagir com a API OpenAIREST.
Além disso, o de integração de OpenAIClient mais apropriada automaticamente.
builder.AddOpenAIClientFromConfiguration("openai");
Por exemplo, se a conexão openai parecia Endpoint=https://{account}.azure.com;Key={key}; ele adivinharia que pode registrar um Azure AI OpenAIclient por causa do nome de domínio. Caso contrário, seria utilizada uma OpenAIClient comum.
Leia Azureresolução agnóstica de client para obter mais detalhes.
MongoDB
Adicionado suporte para especificar o nome de usuário e a senha MongoDB ao usar o método de extensão AddMongoDB(IDistributedApplicationBuilder, String, Nullable<Int32>, IResourceBuilder<ParameterResource>, IResourceBuilder<ParameterResource>). Se não for especificado, um nome de usuário e senha aleatórios são gerados, mas podem ser especificados manualmente usando recursos de parâmetro.
var builder = DistributedApplication.CreateBuilder(args);
var username = builder.AddParameter("mongousername");
var password = builder.AddParameter("mongopassword", secret: true);
var db = builder.AddMongo("db", username, password);
Melhorias Azure importantes
As seções a seguir descrevem as melhorias Azure introduzidas no .NET Aspire 9. Para obter uma lista completa de todas as alterações significativas, consulte Mudanças Disruptivas no .NET.NET Aspire 9.
Azure personalização de recursos
No .NET Aspire 8, a personalização de recursos Azure foi marcada como experimental porque as bibliotecas de Azure.Provisioning subjacentes eram novas e coletavam feedback antes que pudessem ser marcadas como estáveis. No .NET.NET Aspire 9, essas APIs foram atualizadas e removeram o atributo experimental.
Azure Mudança disruptiva na nomenclatura de recursos
Como parte da atualização para as bibliotecas Azure.Provisioning, o esquema de nomenclatura padrão para recursos Azure foi atualizado com melhor suporte para várias políticas de nomenclatura. No entanto, essa atualização resultou em uma alteração na forma como os recursos são nomeados. A nova política de nomenclatura pode resultar no abandono dos recursos Azure existentes e na criação de novos recursos Azure, após a atualização do aplicativo .NET Aspire de 8 para 9. Para continuar usando as mesmas políticas de nomenclatura do .NET.NET Aspire 8, você pode adicionar o seguinte código ao seu AppHost Program.cs:
var builder = DistributedApplication.CreateBuilder(args);
builder.Services.Configure<AzureProvisioningOptions>(options =>
{
options.ProvisioningBuildOptions.InfrastructureResolvers.Insert(0, new AspireV8ResourceNamePropertyResolver());
});
Azure SQL, PostgreSQLe Redis Atualização
Os recursos SQL Azure, PostgreSQLe Redis são diferentes de outros recursos Azure porque há recursos de contentores locais para essas tecnologias. No .NET Aspire 8, para criar esses recursos de Azure, era necessário começar com um recurso de contentor local e, em seguida, aplicar 'As' ou 'PublicarComo' a um recurso Azure. Esse design introduziu problemas e não se encaixou com outras APIs.
Por exemplo, você pode ter esse código no .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();
No .NET.NET Aspire 9, essas APIs foram marcadas como obsoletas e um novo padrão de API foi implementado:
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 por padrão
Para tornar as aplicações .NET Aspire mais seguras, o banco de dados Azure para os recursos PostgreSQL e Azure Cache for Redis foi atualizado para utilizar Microsoft Entra ID por padrão. Isso requer alterações nos aplicativos que precisam se conectar a esses recursos. Consulte o seguinte para atualizar aplicativos para usar o Microsoft Entra ID para se conectar a esses recursos:
Os exemplos a seguir demonstram como configurar seu aplicativo para se conectar aos recursos do Azure usando o Microsoft Entra ID:
- .NET Aspire: AzurePostgreSQL integração de hospedagem.
- .NET Aspire: AzureRedis integração de hospedagem.
Se você precisar usar a autenticação por senha ou chave de acesso (não recomendada), você pode optar por participar com o seguinte código:
var builder = DistributedApplication.CreateBuilder(args);
var pgsql = builder.AddAzurePostgresFlexibleServer("pgsql")
.WithPasswordAuthentication();
var cache = builder.AddAzureRedis("cache")
.WithAccessKeyAuthentication();
Suporte para funções Azure (pré-visualização)
O suporte para FunctionsAzure é um dos recursos mais solicitados no rastreador de problemas .NET.NET Aspire, e temos o prazer de introduzir o suporte em pré-visualização para ele nesta versão. Para demonstrar esse suporte, vamos usar .NET.NET Aspire para criar e implantar um webhook.
Para começar, crie um novo projeto do Azure Functions usando a caixa de diálogo Novo Projeto Visual Studio. Quando solicitado, marque a caixa de seleção Inscrever-se em Aspire orquestração ao criar o projeto.
No projeto de host do aplicativo, observe que há uma PackageReference para o novo 📦Aspire. Hospedagem.Azure. Funções pacote NuGet:
<ItemGroup>
<PackageReference Include="Aspire.Hosting.AppHost" Version="9.0.0" />
<PackageReference Include="Aspire.Hosting.Azure.Functions" Version="9.0.0" />
</ItemGroup>
Este pacote fornece uma API AddAzureFunctionsProject<TProject>(IDistributedApplicationBuilder, String) que pode ser invocada no host do aplicativo para configurar projetos do Azure Functions em um host .NET Aspire:
var builder = DistributedApplication.CreateBuilder(args);
builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp");
builder.Build().Run();
Neste exemplo, o webhook é responsável por traduzir uma string de entrada para Pig Latin. Atualize o conteúdo do nosso gatilho com o seguinte código:
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';
}
Defina um ponto de interrupção na primeira linha logger.LogInformation do método Run e pressione F5 para iniciar o host Functions. Depois que o painel .NET.NET Aspire for iniciado, observa-se o seguinte:
.NET .NET Aspire tem:
- Configurado um recurso emulado de armazenamento Azure para ser usado para contabilidade pelo host.
- Lançou o host Functions localmente com o destino como o projeto Functions registrado.
- Conectada a porta definida em launchSettings.json do projeto de funções para ouvir.
Use o seu HTTP client favorito para enviar uma solicitação ao gatilho e observe os dados vinculados do corpo da solicitação no depurador.
curl --request POST \
--url http://localhost:7282/api/Function1 \
--header 'Content-Type: application/json' \
--data '{
"value": "Welcome to Azure Functions"
}'
Agora você está pronto para implantar nosso aplicativo no Azure Container Apps (ACA). Atualmente, a implantação depende de compilações de visualização dos pacotes SDK do Azure Functions Worker e do Worker. Se necessário, atualize as versões referenciadas no projeto Functions:
<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>
Você também precisa expor um ponto de extremidade público para o nosso projeto Azure Functions para que as solicitações possam ser enviadas para o nosso disparador HTTP.
builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp")
.WithExternalHttpEndpoints();
Para implementar a aplicação com azd a CLI, primeiro precisa obter a versão mais recente. Para instalar a versão mais recente, você verá um aviso se sua versão estiver desatualizada. Siga as instruções para atualizar para a versão mais recente.
Depois de instalado, navegue até a pasta que contém o projeto de host do aplicativo e execute 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!
Em seguida, implante o aplicativo executando 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}}
Finalmente, teste seu aplicativo Functions implantado usando seu clientHTTP favorito:
curl --request POST \
--url {{endpoint-url}}/api/Function1 \
--header 'Content-Type: application/json' \
--data '{
"value": "Welcome to Azure Functions"
}'
O suporte para Azure Functions no .NET Aspire ainda está em pré-visualização com suporte para um conjunto limitado de gatilhos, incluindo:
- Gatilhos HTTP
- Azure Gatilhos de Fila de Armazenamento
- Azure Blob de armazenamento aciona
- Azure Service Bus desencadeia
- Azure Event Hubs desencadeia
Para mais informações, consulte a integração oficial das funções .NET AspireAzure (Preview).
Personalização de Azure Container Apps
Um dos recursos mais solicitados é a capacidade de personalizar o Azure Container Apps que o host do aplicativo cria sem tocar no Bicep. Isso é possível usando as APIs PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) e PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) no namespace Aspire.Hosting.Azure.AppContainers. Este método customiza a definição da aplicação de contêiner Azure que o hospedeiro da aplicação cria.
Adicione a referência do pacote ao seu arquivo de projeto:
<ItemGroup>
<PackageReference Include="Aspire.Hosting.Azure.AppContainers"
Version="9.0.0" />
</ItemGroup>
O exemplo a seguir demonstra como dimensionar um Azure Container App para zero (0) réplicas:
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();
O exemplo de código anterior adia a geração da definição de Azure Container App para o host do aplicativo. Isso permite personalizar a definição do Azure Container App sem ter que executar azd infra synth e modificar de forma insegura os arquivos bicep gerados.
