AzureStorage auto create blob containers

Resolves #5167

Author: RussKie

playground/AzureStorageEndToEnd/AzureStorageEndToEnd.ApiService/Program.cs

@@ -17,7 +17,6 @@
 app.MapGet("/", async (BlobServiceClient bsc, QueueServiceClient qsc) =>
 {
     var container = bsc.GetBlobContainerClient("mycontainer");
-    await container.CreateIfNotExistsAsync();
 
     var blobNameAndContent = Guid.NewGuid().ToString();
     await container.UploadBlobAsync(blobNameAndContent, new BinaryData(blobNameAndContent));

playground/AzureStorageEndToEnd/AzureStorageEndToEnd.AppHost/Program.cs

@@ -9,11 +9,14 @@
 });
 
 var blobs = storage.AddBlobs("blobs");
+var blobContainer = blobs.AddBlobContainer("mycontainer");
+
 var queues = storage.AddQueues("queues");
 
 builder.AddProject<Projects.AzureStorageEndToEnd_ApiService>("api")
        .WithExternalHttpEndpoints()
        .WithReference(blobs).WaitFor(blobs)
+       .WithReference(blobContainer).WaitFor(blobContainer)
        .WithReference(queues).WaitFor(queues);
 
 #if !SKIP_DASHBOARD_REFERENCE

src/Aspire.Hosting.Azure.Storage/AzureBlobStorageContainerResource.cs

@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Hosting.ApplicationModel;
+using Aspire.Hosting.Azure;
+using Azure.Provisioning;
+
+namespace Aspire.Hosting;
+
+/// <summary>
+/// A resource that represents an Azure Blob Storage container.
+/// </summary>
+/// <param name="name">The name of the resource.</param>
+/// <param name="blobStorage">The <see cref="AzureBlobStorageResource"/> that the resource is stored in.</param>
+public class AzureBlobStorageContainerResource(string name, AzureBlobStorageResource blobStorage) : Resource(name),
+    IResourceWithConnectionString,
+    IResourceWithParent<AzureBlobStorageResource>,
+    IResourceWithAzureFunctionsConfig
+{
+    /// <summary>
+    /// Gets the connection string template for the manifest for the Azure Blob Storage container resource.
+    /// </summary>
+    public ReferenceExpression ConnectionStringExpression => Parent.GetConnectionString(Name);
+
+    /// <summary>
+    /// Gets the parent <see cref="AzureBlobStorageResource"/> of this <see cref="AzureBlobStorageContainerResource"/>.
+    /// </summary>
+    public AzureBlobStorageResource Parent => blobStorage ?? throw new ArgumentNullException(nameof(blobStorage));
+
+    internal void ApplyAzureFunctionsConfiguration(IDictionary<string, object> target, string connectionName)
+        => Parent.ApplyAzureFunctionsConfiguration(target, connectionName, Name);
+
+    /// <summary>
+    /// Converts the current instance to a provisioning entity.
+    /// </summary>
+    /// <returns>A <see cref="global::Azure.Provisioning.Storage.BlobContainer"/> instance.</returns>
+    internal global::Azure.Provisioning.Storage.BlobContainer ToProvisioningEntity()
+    {
+        global::Azure.Provisioning.Storage.BlobContainer blobContainer = new(Infrastructure.NormalizeBicepIdentifier(Name));
+
+        if (Name is not null)
+        {
+            blobContainer.Name = Name;
+        }
+
+        return blobContainer;
+    }
+
+    void IResourceWithAzureFunctionsConfig.ApplyAzureFunctionsConfiguration(IDictionary<string, object> target, string connectionName)
+        => ApplyAzureFunctionsConfiguration(target, connectionName);
+}

src/Aspire.Hosting.Azure.Storage/AzureBlobStorageResource.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Aspire.Hosting.ApplicationModel;
+using Azure.Provisioning;
 
 namespace Aspire.Hosting.Azure;
 
@@ -15,6 +16,8 @@ public class AzureBlobStorageResource(string name, AzureStorageResource storage)
     IResourceWithParent<AzureStorageResource>,
     IResourceWithAzureFunctionsConfig
 {
+    internal List<AzureBlobStorageContainerResource> BlobContainers { get; } = [];
+
     /// <summary>
     /// Gets the parent AzureStorageResource of this AzureBlobStorageResource.
     /// </summary>
@@ -26,7 +29,25 @@ public class AzureBlobStorageResource(string name, AzureStorageResource storage)
     public ReferenceExpression ConnectionStringExpression =>
        Parent.GetBlobConnectionString();
 
-    void IResourceWithAzureFunctionsConfig.ApplyAzureFunctionsConfiguration(IDictionary<string, object> target, string connectionName)
+    internal ReferenceExpression GetConnectionString(string? blobContainerName)
+    {
+        if (string.IsNullOrEmpty(blobContainerName))
+        {
+            return ConnectionStringExpression;
+        }
+
+        var builder = new ReferenceExpressionBuilder();
+        builder.Append($"{ConnectionStringExpression}");
+
+        if (!string.IsNullOrEmpty(blobContainerName))
+        {
+            builder.Append($"/{blobContainerName}");
+        }
+
+        return builder.Build();
+    }
+
+    internal void ApplyAzureFunctionsConfiguration(IDictionary<string, object> target, string connectionName, string? blobContainerName = null)
     {
         if (Parent.IsEmulator)
         {
@@ -42,10 +63,29 @@ void IResourceWithAzureFunctionsConfig.ApplyAzureFunctionsConfiguration(IDiction
             // uses the queue service for its internal bookkeeping on blob triggers.
             target[$"{connectionName}__blobServiceUri"] = Parent.BlobEndpoint;
             target[$"{connectionName}__queueServiceUri"] = Parent.QueueEndpoint;
+
             // Injected to support Aspire client integration for Azure Storage.
             // We don't inject the queue resource here since we on;y want it to
             // be accessible by the Functions host.
             target[$"{AzureStorageResource.BlobsConnectionKeyPrefix}__{connectionName}__ServiceUri"] = Parent.BlobEndpoint;
+
+            if (blobContainerName is not null)
+            {
+                target[$"{AzureStorageResource.BlobsConnectionKeyPrefix}__{connectionName}__BlobContainerName"] = blobContainerName;
+            }
         }
     }
+
+    /// <summary>
+    /// Converts the current instance to a provisioning entity.
+    /// </summary>
+    /// <returns>A <see cref="global::Azure.Provisioning.Storage.BlobService"/> instance.</returns>
+    internal global::Azure.Provisioning.Storage.BlobService ToProvisioningEntity()
+    {
+        global::Azure.Provisioning.Storage.BlobService service = new(Infrastructure.NormalizeBicepIdentifier(Name));
+        return service;
+    }
+
+    void IResourceWithAzureFunctionsConfig.ApplyAzureFunctionsConfiguration(IDictionary<string, object> target, string connectionName)
+        => ApplyAzureFunctionsConfiguration(target, connectionName);
 }

src/Aspire.Hosting.Azure.Storage/AzureStorageEmulatorConnectionString.cs

@@ -12,7 +12,7 @@ internal static class AzureStorageEmulatorConnectionString
 
     private static void AppendEndpointExpression(ReferenceExpressionBuilder builder, string key, EndpointReference endpoint)
     {
-        builder.Append($"{key}=http://{endpoint.Property(EndpointProperty.IPV4Host)}:{endpoint.Property(EndpointProperty.Port)}/devstoreaccount1;");
+        builder.Append($"{key}=http://{endpoint.Property(EndpointProperty.IPV4Host)}:{endpoint.Property(EndpointProperty.Port)}/devstoreaccount1");
     }
 
     public static ReferenceExpression Create(EndpointReference? blobEndpoint = null, EndpointReference? queueEndpoint = null, EndpointReference? tableEndpoint = null)

src/Aspire.Hosting.Azure.Storage/AzureStorageExtensions.cs

@@ -81,6 +81,18 @@ public static IResourceBuilder<AzureStorageResource> AddAzureStorage(this IDistr
             infrastructure.Add(new ProvisioningOutput("queueEndpoint", typeof(string)) { Value = storageAccount.PrimaryEndpoints.QueueUri });
             infrastructure.Add(new ProvisioningOutput("tableEndpoint", typeof(string)) { Value = storageAccount.PrimaryEndpoints.TableUri });
 
+            var azureResource = (AzureStorageResource)infrastructure.AspireResource;
+
+            foreach (var blobStorageResources in azureResource.Blobs)
+            {
+                foreach (var blobContainer in blobStorageResources.BlobContainers)
+                {
+                    var cdkBlobContainer = blobContainer.ToProvisioningEntity();
+                    cdkBlobContainer.Parent = blobs;
+                    infrastructure.Add(cdkBlobContainer);
+                }
+            }
+
             // We need to output name to externalize role assignments.
             infrastructure.Add(new ProvisioningOutput("name", typeof(string)) { Value = storageAccount.Name });
         };
@@ -126,15 +138,36 @@ public static IResourceBuilder<AzureStorageResource> RunAsEmulator(this IResourc
         builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(builder.Resource, async (@event, ct) =>
         {
             var connectionString = await builder.Resource.GetBlobConnectionString().GetValueAsync(ct).ConfigureAwait(false);
-
-            if (connectionString == null)
+            if (connectionString is null)
             {
-                throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{builder.Resource.Name}' resource but the connection string was null.");
+                throw new DistributedApplicationException($"BeforeResourceStartedEvent was published for the '{builder.Resource.Name}' resource but the connection string was null.");
             }
 
             blobServiceClient = CreateBlobServiceClient(connectionString);
         });
 
+        builder.ApplicationBuilder.Eventing.Subscribe<ResourceReadyEvent>(builder.Resource, async (@event, ct) =>
+        {
+            var connectionString = await builder.Resource.GetBlobConnectionString().GetValueAsync(ct).ConfigureAwait(false);
+            if (connectionString is null)
+            {
+                throw new DistributedApplicationException($"ResourceReadyEvent was published for the '{builder.Resource.Name}' resource but the connection string was null.");
+            }
+
+            if (blobServiceClient is null)
+            {
+                throw new DistributedApplicationException($"BlobServiceClient was not created for the '{builder.Resource.Name}' resource.");
+            }
+
+            foreach (var blobStorageResources in builder.Resource.Blobs)
+            {
+                foreach (var blobContainer in blobStorageResources.BlobContainers)
+                {
+                    await blobServiceClient.GetBlobContainerClient(blobContainer.Name).CreateIfNotExistsAsync(cancellationToken: ct).ConfigureAwait(false);
+                }
+            }
+        });
+
         var healthCheckKey = $"{builder.Resource.Name}_check";
 
         builder.ApplicationBuilder.Services.AddHealthChecks().AddAzureBlobStorage(sp =>
@@ -281,6 +314,26 @@ public static IResourceBuilder<AzureBlobStorageResource> AddBlobs(this IResource
         ArgumentException.ThrowIfNullOrEmpty(name);
 
         var resource = new AzureBlobStorageResource(name, builder.Resource);
+        builder.Resource.Blobs.Add(resource);
+
+        return builder.ApplicationBuilder.AddResource(resource);
+    }
+
+    /// <summary>
+    /// Creates a builder for the <see cref="AzureBlobStorageContainerResource"/> which can be referenced to get the Azure Storage blob container endpoint for the storage account.
+    /// </summary>
+    /// <param name="builder">The <see cref="IResourceBuilder{T}"/> for <see cref="AzureBlobStorageResource"/>/</param>
+    /// <param name="name">The name of the resource.</param>
+    /// <returns>An <see cref="IResourceBuilder{T}"/> for the <see cref="AzureBlobStorageContainerResource"/>.</returns>
+    public static IResourceBuilder<AzureBlobStorageContainerResource> AddBlobContainer(this IResourceBuilder<AzureBlobStorageResource> builder, [ResourceName] string name)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentException.ThrowIfNullOrEmpty(name);
+
+        AzureBlobStorageContainerResource resource = new(name, builder.Resource);
+
+        builder.Resource.BlobContainers.Add(resource);
+
         return builder.ApplicationBuilder.AddResource(resource);
     }
 
@@ -314,6 +367,22 @@ public static IResourceBuilder<AzureQueueStorageResource> AddQueues(this IResour
         return builder.ApplicationBuilder.AddResource(resource);
     }
 
+    /// <summary>
+    /// Allows setting the properties of an Azure Blob Storage container resource.
+    /// </summary>
+    /// <param name="builder">The Azure Blob Storage container resource builder.</param>
+    /// <param name="configure">A method that can be used for customizing the <see cref="AzureBlobStorageContainerResource"/>.</param>
+    /// <returns>A reference to the <see cref="IResourceBuilder{T}"/>.</returns>
+    public static IResourceBuilder<AzureBlobStorageContainerResource> WithProperties(this IResourceBuilder<AzureBlobStorageContainerResource> builder, Action<AzureBlobStorageContainerResource> configure)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(configure);
+
+        configure(builder.Resource);
+
+        return builder;
+    }
+
     /// <summary>
     /// Assigns the specified roles to the given resource, granting it the necessary permissions
     /// on the target Azure Storage account. This replaces the default role assignments for the resource.

src/Aspire.Hosting.Azure.Storage/AzureStorageResource.cs

@@ -15,13 +15,15 @@ namespace Aspire.Hosting.Azure;
 public class AzureStorageResource(string name, Action<AzureResourceInfrastructure> configureInfrastructure)
     : AzureProvisioningResource(name, configureInfrastructure), IResourceWithEndpoints, IResourceWithAzureFunctionsConfig
 {
+    internal const string BlobsConnectionKeyPrefix = "Aspire__Azure__Storage__Blobs";
+    internal const string QueuesConnectionKeyPrefix = "Aspire__Azure__Storage__Queues";
+    internal const string TablesConnectionKeyPrefix = "Aspire__Azure__Data__Tables";
+
     private EndpointReference EmulatorBlobEndpoint => new(this, "blob");
     private EndpointReference EmulatorQueueEndpoint => new(this, "queue");
     private EndpointReference EmulatorTableEndpoint => new(this, "table");
 
-    internal const string BlobsConnectionKeyPrefix = "Aspire__Azure__Storage__Blobs";
-    internal const string QueuesConnectionKeyPrefix = "Aspire__Azure__Storage__Queues";
-    internal const string TablesConnectionKeyPrefix = "Aspire__Azure__Data__Tables";
+    internal List<AzureBlobStorageResource> Blobs { get; } = [];
 
     /// <summary>
     /// Gets the "blobEndpoint" output reference from the bicep template for the Azure Storage resource.

tests/Aspire.Hosting.Azure.Tests/AzureStorageEmulatorFunctionalTests.cs

@@ -88,4 +88,40 @@ public async Task VerifyAzureStorageEmulatorResource()
         var downloadResult = (await blobClient.DownloadContentAsync()).Value;
         Assert.Equal("testValue", downloadResult.Content.ToString());
     }
+
+    [Fact]
+    [RequiresDocker]
+    public async Task VerifyAzureStorageEmulatorBlobContainer()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create().WithTestAndResourceLogging(testOutputHelper);
+        var storage = builder.AddAzureStorage("storage").RunAsEmulator();
+        var blobs = storage.AddBlobs("BlobConnection");
+        var blobContainer = blobs.AddBlobContainer("testblobcontainer");
+
+        using var app = builder.Build();
+        await app.StartAsync();
+
+        var hb = Host.CreateApplicationBuilder();
+        hb.Configuration["ConnectionStrings:BlobConnection"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
+        hb.AddAzureBlobClient("BlobConnection");
+
+        using var host = hb.Build();
+        await host.StartAsync();
+
+        var rns = app.Services.GetRequiredService<ResourceNotificationService>();
+        await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, CancellationToken.None);
+
+        var serviceClient = host.Services.GetRequiredService<BlobServiceClient>();
+        var blobContainerClient = serviceClient.GetBlobContainerClient("testblobcontainer");
+
+        var exists = await blobContainerClient.ExistsAsync();
+
+        var blobNameAndContent = Guid.NewGuid().ToString();
+        var response = await blobContainerClient.UploadBlobAsync(blobNameAndContent, new BinaryData(blobNameAndContent));
+
+        var blobClient = blobContainerClient.GetBlobClient(blobNameAndContent);
+
+        var downloadResult = (await blobClient.DownloadContentAsync()).Value;
+        Assert.Equal(blobNameAndContent, downloadResult.Content.ToString());
+    }
 }

tests/Aspire.Hosting.Azure.Tests/AzureStorageExtensionsTests.ResourceNamesBicepValid.verified.bicep

@@ -0,0 +1,40 @@
+@description('The location for the resource(s) to be deployed.')
+param location string = resourceGroup().location
+
+resource storage 'Microsoft.Storage/storageAccounts@2024-01-01' = {
+  name: take('storage${uniqueString(resourceGroup().id)}', 24)
+  kind: 'StorageV2'
+  location: location
+  sku: {
+    name: 'Standard_GRS'
+  }
+  properties: {
+    accessTier: 'Hot'
+    allowSharedKeyAccess: false
+    minimumTlsVersion: 'TLS1_2'
+    networkAcls: {
+      defaultAction: 'Allow'
+    }
+  }
+  tags: {
+    'aspire-resource-name': 'storage'
+  }
+}
+
+resource blobs 'Microsoft.Storage/storageAccounts/blobServices@2024-01-01' = {
+  name: 'default'
+  parent: storage
+}
+
+resource my_blob_container 'Microsoft.Storage/storageAccounts/blobServices/containers@2024-01-01' = {
+  name: 'my-blob-container'
+  parent: blobs
+}
+
+output blobEndpoint string = storage.properties.primaryEndpoints.blob
+
+output queueEndpoint string = storage.properties.primaryEndpoints.queue
+
+output tableEndpoint string = storage.properties.primaryEndpoints.table
+
+output name string = storage.name

tests/Aspire.Hosting.Azure.Tests/AzureStorageExtensionsTests.cs

@@ -163,4 +163,20 @@ public async Task AddAzureStorage_RunAsEmulator_SetSkipApiVersionCheck()
 
         Assert.Contains("--skipApiVersionCheck", args);
     }
+
+    [Fact]
+    public async Task ResourceNamesBicepValid()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var storage = builder.AddAzureStorage("storage");
+
+        var blobs = storage.AddBlobs("myblobs");
+        var blob = blobs.AddBlobContainer("my-blob-container");
+        var queues = storage.AddQueues("myqueues");
+        var tables = storage.AddTables("mytables");
+
+        var manifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
+
+        await Verifier.Verify(manifest.BicepText, extension: "bicep");
+    }
 }