Hook up Azure Deployer to BicepProvisioner

Aspire.slnx

@@ -161,6 +161,9 @@
     <Project Path="playground/DatabaseMigration/DatabaseMigration.AppHost/DatabaseMigration.AppHost.csproj" />
     <Project Path="playground/DatabaseMigration/DatabaseMigration.MigrationService/DatabaseMigration.MigrationService.csproj" />
   </Folder>
+  <Folder Name="/playground/deployers/">
+    <Project Path="playground/deployers/Deployers.AppHost/Deployers.AppHost.csproj" />
+  </Folder>
   <Folder Name="/playground/dockerfile/">
     <Project Path="playground/withdockerfile/WithDockerfile.AppHost/WithDockerfile.AppHost.csproj" />
   </Folder>

playground/deployers/Deployers.AppHost/AppHost.cs

@@ -0,0 +1,22 @@
+var builder = DistributedApplication.CreateBuilder(args);
+
+builder.AddAzureContainerAppEnvironment("env");
+
+var storage = builder.AddAzureStorage("storage");
+
+storage.AddBlobs("blobs");
+storage.AddBlobContainer("mycontainer1", blobContainerName: "test-container-1");
+storage.AddBlobContainer("mycontainer2", blobContainerName: "test-container-2");
+storage.AddQueue("myqueue", queueName: "my-queue");
+
+#if !SKIP_DASHBOARD_REFERENCE
+// This project is only added in playground projects to support development/debugging
+// of the dashboard. It is not required in end developer code. Comment out this code
+// or build with `/p:SkipDashboardReference=true`, to test end developer
+// dashboard launch experience, Refer to Directory.Build.props for the path to
+// the dashboard binary (defaults to the Aspire.Dashboard bin output in the
+// artifacts dir).
+builder.AddProject<Projects.Aspire_Dashboard>(KnownResourceNames.AspireDashboard);
+#endif
+
+builder.Build().Run();

playground/deployers/Deployers.AppHost/Deployers.AppHost.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>$(DefaultTargetFramework)</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsAspireHost>true</IsAspireHost>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\KnownResourceNames.cs" Link="KnownResourceNames.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AspireProjectOrPackageReference Include="Aspire.Hosting.Azure.AppContainers" />
+    <AspireProjectOrPackageReference Include="Aspire.Hosting.Azure" />
+    <AspireProjectOrPackageReference Include="Aspire.Hosting.Azure.Storage" />
+  </ItemGroup>
+
+</Project>

playground/deployers/Deployers.AppHost/Properties/launchSettings.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:17222;http://localhost:15020",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development",
+        "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "https://localhost:21267",
+        "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "https://localhost:22116"
+      }
+    },
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:15020",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development",
+        "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "http://localhost:19093",
+        "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:20094"
+      }
+    },
+    "deploy": {
+      "commandName": "Project",
+      "commandLineArgs": "--publisher default --deploy true --output-path deploy",
+    }
+  }
+}

playground/deployers/Deployers.AppHost/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

playground/deployers/Deployers.AppHost/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning",
+      "Aspire.Hosting.Dcp": "Warning"
+    }
+  }
+}

src/Aspire.Hosting.Azure/AzureBicepResource.cs

@@ -120,7 +120,8 @@ public virtual BicepTemplateFile GetBicepTemplateFile(string? directory = null,
             }
         }
 
-        return new(path, isTempFile && deleteTemporaryFileOnDispose);
+        var targetPath = directory is not null ? Path.Combine(directory, path) : path;
+        return new(targetPath, isTempFile && deleteTemporaryFileOnDispose);
     }
 
     /// <summary>

src/Aspire.Hosting.Azure/AzureDeployingContext.cs

@@ -4,17 +4,74 @@
 #pragma warning disable ASPIREAZURE001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
 #pragma warning disable ASPIREPUBLISHERS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
 
+using Aspire.Hosting.Azure.Provisioning;
 using Aspire.Hosting.Azure.Provisioning.Internal;
+using Aspire.Hosting.Publishing;
 
 namespace Aspire.Hosting.Azure;
 
 internal sealed class AzureDeployingContext(
     IProvisioningContextProvider provisioningContextProvider,
-    IUserSecretsManager userSecretsManager)
+    IUserSecretsManager userSecretsManager,
+    IBicepProvisioner bicepProvisioner,
+    IPublishingActivityReporter activityReporter)
 {
-    public async Task DeployModelAsync(CancellationToken cancellationToken = default)
+    public async Task DeployModelAsync(AzureEnvironmentResource resource, CancellationToken cancellationToken = default)
     {
         var userSecrets = await userSecretsManager.LoadUserSecretsAsync(cancellationToken).ConfigureAwait(false);
-        await provisioningContextProvider.CreateProvisioningContextAsync(userSecrets, cancellationToken).ConfigureAwait(false);
+        var provisioningContext = await provisioningContextProvider.CreateProvisioningContextAsync(userSecrets, cancellationToken).ConfigureAwait(false);
+
+        if (resource.PublishingContext is null)
+        {
+            throw new InvalidOperationException($"Publishing context is not initialized. Please ensure that the {nameof(AzurePublishingContext)} has been initialized before deploying.");
+        }
+
+        var deployingStep = await activityReporter.CreateStepAsync("Deploying to Azure", cancellationToken).ConfigureAwait(false);
+        await using (deployingStep.ConfigureAwait(false))
+        {
+            // Map parameters from the AzurePublishingContext
+            foreach (var (parameterResource, provisioningParameter) in resource.PublishingContext.ParameterLookup)
+            {
+                if (parameterResource == resource.Location)
+                {
+                    resource.Parameters[provisioningParameter.BicepIdentifier] = provisioningContext.Location.Name;
+                }
+                else if (parameterResource == resource.ResourceGroupName)
+                {
+                    resource.Parameters[provisioningParameter.BicepIdentifier] = provisioningContext.ResourceGroup.Name;
+                }
+                else if (parameterResource == resource.PrincipalId)
+                {
+                    resource.Parameters[provisioningParameter.BicepIdentifier] = provisioningContext.Principal.Id.ToString();
+                }
+                else
+                {
+                    // TODO: Prompt here.
+                    await deployingStep.FailAsync("Deployment contains unresolvable parameters.", cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            try
+            {
+                var azureTask = await deployingStep.CreateTaskAsync("Provisioning Azure environment", cancellationToken).ConfigureAwait(false);
+                await using (azureTask.ConfigureAwait(false))
+                {
+                    try
+                    {
+                        await bicepProvisioner.GetOrCreateResourceAsync(resource, provisioningContext, cancellationToken).ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        await azureTask.FailAsync($"Provisioning failed: {ex.Message}", cancellationToken).ConfigureAwait(false);
+                        throw;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                await deployingStep.FailAsync($"Deployment failed: {ex.Message}", cancellationToken).ConfigureAwait(false);
+                throw;
+            }
+        }
     }
 }

src/Aspire.Hosting.Azure/AzureEnvironmentResource.cs

@@ -6,7 +6,9 @@
 
 using System.Diagnostics.CodeAnalysis;
 using Aspire.Hosting.ApplicationModel;
+using Aspire.Hosting.Azure.Provisioning;
 using Aspire.Hosting.Azure.Provisioning.Internal;
+using Aspire.Hosting.Publishing;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 
@@ -17,7 +19,7 @@ namespace Aspire.Hosting.Azure;
 /// Emits a <c>main.bicep</c> that aggregates all provisionable resources.
 /// </summary>
 [Experimental("ASPIREAZURE001", UrlFormat = "https://aka.ms/dotnet/aspire/diagnostics#{0}")]
-public sealed class AzureEnvironmentResource : Resource
+public sealed class AzureEnvironmentResource : AzureBicepResource
 {
     /// <summary>
     /// Gets or sets the Azure location that the resources will be deployed to.
@@ -34,6 +36,8 @@ public sealed class AzureEnvironmentResource : Resource
     /// </summary>
     public ParameterResource PrincipalId { get; set; }
 
+    internal AzurePublishingContext? PublishingContext { get; set; }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="AzureEnvironmentResource"/> class.
     /// </summary>
@@ -43,10 +47,11 @@ public sealed class AzureEnvironmentResource : Resource
     /// <param name="principalId">The Azure principal ID that will be used to deploy the resources.</param>
     /// <exception cref="ArgumentNullException">Thrown when the name is null or empty.</exception>
     /// <exception cref="ArgumentException">Thrown when the name is invalid.</exception>
-    public AzureEnvironmentResource(string name, ParameterResource location, ParameterResource resourceGroupName, ParameterResource principalId) : base(name)
+    public AzureEnvironmentResource(string name, ParameterResource location, ParameterResource resourceGroupName, ParameterResource principalId) : base(name, templateFile: "main.bicep")
     {
         Annotations.Add(new PublishingCallbackAnnotation(PublishAsync));
         Annotations.Add(new DeployingCallbackAnnotation(DeployAsync));
+        Annotations.Add(ManifestPublishingCallbackAnnotation.Ignore);
 
         Location = location;
         ResourceGroupName = resourceGroupName;
@@ -57,24 +62,28 @@ private Task PublishAsync(PublishingContext context)
     {
         var azureProvisioningOptions = context.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>();
 
-        var azureCtx = new AzurePublishingContext(
+        PublishingContext = new AzurePublishingContext(
             context.OutputPath,
             azureProvisioningOptions.Value,
             context.Logger,
             context.ActivityReporter);
 
-        return azureCtx.WriteModelAsync(context.Model, this);
+        return PublishingContext.WriteModelAsync(context.Model, this);
     }
 
     private Task DeployAsync(DeployingContext context)
     {
         var provisioningContextProvider = context.Services.GetRequiredService<IProvisioningContextProvider>();
         var userSecretsManager = context.Services.GetRequiredService<IUserSecretsManager>();
+        var bicepProvisioner = context.Services.GetRequiredService<IBicepProvisioner>();
+        var activityPublisher = context.Services.GetRequiredService<IPublishingActivityReporter>();
 
         var azureCtx = new AzureDeployingContext(
             provisioningContextProvider,
-            userSecretsManager);
+            userSecretsManager,
+            bicepProvisioner,
+            activityPublisher);
 
-        return azureCtx.DeployModelAsync(context.CancellationToken);
+        return azureCtx.DeployModelAsync(this, context.CancellationToken);
     }
 }

src/Aspire.Hosting.Azure/Provisioning/AzureProvisionerExtensions.cs

@@ -36,8 +36,8 @@ public static IDistributedApplicationBuilder AddAzureProvisioning(this IDistribu
 
         builder.Services.AddSingleton<ITokenCredentialProvider, DefaultTokenCredentialProvider>();
 
-        // Register BicepProvisioner directly
-        builder.Services.AddSingleton<BicepProvisioner>();
+        // Register BicepProvisioner via interface
+        builder.Services.AddSingleton<IBicepProvisioner, BicepProvisioner>();
 
         // Register the new internal services for testability
         builder.Services.AddSingleton<IArmClientProvider, DefaultArmClientProvider>();

src/Aspire.Hosting.Azure/Provisioning/Internal/DefaultArmDeploymentCollection.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Azure;
+using Azure.ResourceManager;
+using Azure.ResourceManager.Resources;
+using Azure.ResourceManager.Resources.Models;
+
+namespace Aspire.Hosting.Azure.Provisioning.Internal;
+
+internal sealed class DefaultArmDeploymentCollection(ArmDeploymentCollection armDeploymentCollection) : IArmDeploymentCollection
+{
+    public Task<ArmOperation<ArmDeploymentResource>> CreateOrUpdateAsync(
+        WaitUntil waitUntil,
+        string deploymentName,
+        ArmDeploymentContent content,
+        CancellationToken cancellationToken = default)
+    {
+        return armDeploymentCollection.CreateOrUpdateAsync(waitUntil, deploymentName, content, cancellationToken);
+    }
+}

src/Aspire.Hosting.Azure/Provisioning/Internal/DefaultProvisioningContextProvider.cs

@@ -8,6 +8,7 @@
 using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
 using Aspire.Hosting.Azure.Utils;
+using Aspire.Hosting.Publishing;
 using Azure;
 using Azure.Core;
 using Azure.ResourceManager.Resources;
@@ -28,9 +29,11 @@ internal sealed partial class DefaultProvisioningContextProvider(
     IArmClientProvider armClientProvider,
     IUserPrincipalProvider userPrincipalProvider,
     ITokenCredentialProvider tokenCredentialProvider,
-    DistributedApplicationExecutionContext distributedApplicationExecutionContext) : IProvisioningContextProvider
+    DistributedApplicationExecutionContext distributedApplicationExecutionContext,
+    IOptions<PublishingOptions> publishingOptions) : IProvisioningContextProvider
 {
     private readonly AzureProvisionerOptions _options = options.Value;
+    private readonly PublishingOptions _publishingOptions = publishingOptions.Value;
 
     private readonly TaskCompletionSource _provisioningOptionsAvailable = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
@@ -259,6 +262,7 @@ public async Task<ProvisioningContext> CreateProvisioningContextAsync(JsonObject
         }
 
         var principal = await userPrincipalProvider.GetUserPrincipalAsync(cancellationToken).ConfigureAwait(false);
+        var outputPath = _publishingOptions.OutputPath is { } outputPathValue ? Path.GetFullPath(outputPathValue) : null;
 
         return new ProvisioningContext(
                     credential,
@@ -268,7 +272,9 @@ public async Task<ProvisioningContext> CreateProvisioningContextAsync(JsonObject
                     tenantResource,
                     location,
                     principal,
-                    userSecrets);
+                    userSecrets,
+                    distributedApplicationExecutionContext,
+                    outputPath);
     }
 
     private string GetDefaultResourceGroupName()

src/Aspire.Hosting.Azure/Provisioning/Internal/DefaultResourceGroupResource.cs

@@ -1,11 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Azure;
 using Azure.Core;
-using Azure.ResourceManager;
 using Azure.ResourceManager.Resources;
-using Azure.ResourceManager.Resources.Models;
 
 namespace Aspire.Hosting.Azure.Provisioning.Internal;
 
@@ -21,16 +18,4 @@ public IArmDeploymentCollection GetArmDeployments()
     {
         return new DefaultArmDeploymentCollection(resourceGroupResource.GetArmDeployments());
     }
-
-    private sealed class DefaultArmDeploymentCollection(ArmDeploymentCollection armDeploymentCollection) : IArmDeploymentCollection
-    {
-        public Task<ArmOperation<ArmDeploymentResource>> CreateOrUpdateAsync(
-            WaitUntil waitUntil,
-            string deploymentName,
-            ArmDeploymentContent content,
-            CancellationToken cancellationToken = default)
-        {
-            return armDeploymentCollection.CreateOrUpdateAsync(waitUntil, deploymentName, content, cancellationToken);
-        }
-    }
 }

src/Aspire.Hosting.Azure/Provisioning/Internal/DefaultSubscriptionResource.cs

@@ -17,6 +17,11 @@ internal sealed class DefaultSubscriptionResource(SubscriptionResource subscript
     public string? DisplayName => subscriptionResource.Data.DisplayName;
     public Guid? TenantId => subscriptionResource.Data.TenantId;
 
+    public IArmDeploymentCollection GetArmDeployments()
+    {
+        return new DefaultArmDeploymentCollection(subscriptionResource.GetArmDeployments());
+    }
+
     public IResourceGroupCollection GetResourceGroups()
     {
         return new DefaultResourceGroupCollection(subscriptionResource.GetResourceGroups());

src/Aspire.Hosting.Azure/Provisioning/Internal/IProvisioningServices.cs

@@ -106,6 +106,11 @@ internal interface ISubscriptionResource
     /// Gets resource groups collection.
     /// </summary>
     IResourceGroupCollection GetResourceGroups();
+
+    /// <summary>
+    /// Gets ARM deployments collection.
+    /// </summary>
+    IArmDeploymentCollection GetArmDeployments();
 }
 
 /// <summary>