Add persistent executable and project lifetimes

playground/AzureAppService/AzureAppService.AppHost/AppHost.cs

@@ -13,7 +13,7 @@
 
 // Testing kv secret refs
 var cosmosDb = builder.AddAzureCosmosDB("account")
-                      .RunAsEmulator(c => c.WithLifetime(ContainerLifetime.Persistent));
+                      .RunAsEmulator(c => c.WithPersistentLifetime());
 
 cosmosDb.AddCosmosDatabase("db");
 
@@ -24,7 +24,7 @@
                          var storage = infra.GetProvisionableResources().OfType<StorageAccount>().Single();
                          storage.AllowBlobPublicAccess = false;
                      })
-                     .RunAsEmulator(c => c.WithLifetime(ContainerLifetime.Persistent));
+                     .RunAsEmulator(c => c.WithPersistentLifetime());
 var blobs = storage.AddBlobs("blobs");
 
 // Testing projects

playground/AzureContainerApps/AzureContainerApps.AppHost/AppHost.cs

@@ -18,19 +18,19 @@
 
 // Testing volumes
 var redis = builder.AddRedis("cache")
-    .WithLifetime(ContainerLifetime.Persistent)
+    .WithPersistentLifetime()
     .WithDataVolume();
 
 // Testing secret outputs
 var cosmosDb = builder.AddAzureCosmosDB("account")
                       .WithAccessKeyAuthentication()
-                      .RunAsEmulator(c => c.WithLifetime(ContainerLifetime.Persistent));
+                      .RunAsEmulator(c => c.WithPersistentLifetime());
 
 cosmosDb.AddCosmosDatabase("db");
 
 // Testing a connection string
 var storage = builder.AddAzureStorage("storage")
-                     .RunAsEmulator(c => c.WithLifetime(ContainerLifetime.Persistent));
+                     .RunAsEmulator(c => c.WithPersistentLifetime());
 var blobs = storage.AddBlobs("blobs");
 
 // Testing docker files

playground/AzureServiceBus/ServiceBus.AppHost/AppHost.cs

@@ -34,7 +34,7 @@
 serviceBus.RunAsEmulator(configure => configure.WithConfiguration(document =>
 {
     document["UserConfig"]!["Logging"] = new JsonObject { ["Type"] = "Console" };
-}).WithLifetime(ContainerLifetime.Persistent));
+}).WithPersistentLifetime());
 
 builder.AddProject<Projects.ServiceBusWorker>("worker")
     .WithReference(queue).WaitFor(queue)

playground/AzureVirtualNetworkEndToEnd/AzureVirtualNetworkEndToEnd.AppHost/AppHost.cs

@@ -49,7 +49,7 @@
 privateEndpointsSubnet.AddPrivateEndpoint(queues);
 
 var sqlServer = builder.AddAzureSqlServer("sql")
-    .RunAsContainer(c => c.WithLifetime(ContainerLifetime.Persistent));
+    .RunAsContainer(c => c.WithPersistentLifetime());
 privateEndpointsSubnet.AddPrivateEndpoint(sqlServer);
 
 var db = sqlServer.AddDatabase("sqldb");

playground/TestShop/TestShop.AppHost/AppHost.cs

@@ -69,7 +69,7 @@
 
 var messaging = builder.AddRabbitMQ("messaging")
                        .WithDataVolume()
-                       .WithLifetime(ContainerLifetime.Persistent)
+                       .WithPersistentLifetime()
                        .WithManagementPlugin()
                        .PublishAsContainer();
 

playground/TypeScriptAppHost/apphost.ts

@@ -8,7 +8,6 @@ import {
     createBuilder,
     refExpr,
     EnvironmentCallbackContext,
-    ContainerLifetime,
     ExecuteCommandContext,
     InputsDialogValidationContext,
     InputType
@@ -50,7 +49,7 @@ console.log("Added Express API with reference to PostgreSQL database");
 
 // Redis
 const cache = await builder.addRedis("cache");
-await cache.withLifetime(ContainerLifetime.Persistent);
+await cache.withPersistentLifetime();
 await cache.withCommand(
     "set-prefix",
     "Set prefix",

playground/TypeScriptApps/RpsArena/apphost.ts

@@ -1,7 +1,7 @@
 // Rock Paper Scissors Arena — Aspire TypeScript AppHost
 // A polyglot game: C# Game Master, Python & Node.js players, React frontend, PostgreSQL
 
-import { createBuilder, ContainerLifetime, type ExecuteCommandContext, type ExecuteCommandResult } from './.modules/aspire.js';
+import { createBuilder, type ExecuteCommandContext, type ExecuteCommandResult } from './.modules/aspire.js';
 
 const builder = await createBuilder();
 
@@ -10,7 +10,7 @@ const builder = await createBuilder();
 // Persistent lifetime so data survives restarts during development.
 const postgres = await builder
     .addPostgres("postgres")
-    .withLifetime(ContainerLifetime.Persistent)
+    .withPersistentLifetime()
     .withPgAdmin()
     .withDataVolume();
 

src/Aspire.Hosting.Azure.EventHubs/AzureEventHubsExtensions.cs

@@ -273,22 +273,17 @@ public static IResourceBuilder<AzureEventHubsResource> RunAsEmulator(this IResou
                 .AddAzureStorage($"{builder.Resource.Name}-storage")
                 .WithParentRelationship(builder);
 
-        var lifetime = ContainerLifetime.Session;
-
-        // Copy the lifetime from the main resource to the storage resource
         var surrogate = new AzureEventHubsEmulatorResource(builder.Resource);
         var surrogateBuilder = builder.ApplicationBuilder.CreateResourceBuilder(surrogate);
         if (configureContainer != null)
         {
             configureContainer(surrogateBuilder);
-
-            if (surrogate.TryGetLastAnnotation<ContainerLifetimeAnnotation>(out var lifetimeAnnotation))
-            {
-                lifetime = lifetimeAnnotation.Lifetime;
-            }
+            storageResource = storageResource.RunAsEmulator(c => c.WithLifetimeOf(surrogateBuilder));
+        }
+        else
+        {
+            storageResource = storageResource.RunAsEmulator();
         }
-
-        storageResource = storageResource.RunAsEmulator(c => c.WithLifetime(lifetime));
 
         var storage = storageResource.Resource;
 

src/Aspire.Hosting.Azure.ServiceBus/AzureServiceBusExtensions.cs

@@ -433,23 +433,15 @@ public static IResourceBuilder<AzureServiceBusResource> RunAsEmulator(this IReso
             context.EnvironmentVariables["MSSQL_SA_PASSWORD"] = passwordParameter;
         }));
 
-        var lifetime = ContainerLifetime.Session;
-
         var surrogate = new AzureServiceBusEmulatorResource(builder.Resource);
         var surrogateBuilder = builder.ApplicationBuilder.CreateResourceBuilder(surrogate);
 
         if (configureContainer != null)
         {
             configureContainer(surrogateBuilder);
-
-            if (surrogate.TryGetLastAnnotation<ContainerLifetimeAnnotation>(out var lifetimeAnnotation))
-            {
-                lifetime = lifetimeAnnotation.Lifetime;
-            }
+            sqlServerResource = sqlServerResource.WithLifetimeOf(surrogateBuilder);
         }
 
-        sqlServerResource = sqlServerResource.WithLifetime(lifetime);
-
         // RunAsEmulator() can be followed by custom model configuration so we need to delay the creation of the Config.json file
         // until all resources are about to be prepared and annotations can't be updated anymore.
         surrogateBuilder.WithContainerFiles(

src/Aspire.Hosting.DevTunnels/DevTunnelHealthCheck.cs

@@ -34,11 +34,12 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
             // Check that expected ports are active
             foreach (var portResource in _tunnelResource.Ports)
             {
-                var portStatus = tunnelStatus.Ports?.FirstOrDefault(p => p.PortNumber == portResource.TargetEndpoint.Port);
+                var tunnelPort = await portResource.GetTunnelPortAsync(cancellationToken).ConfigureAwait(false);
+                var portStatus = tunnelStatus.Ports?.FirstOrDefault(p => p.PortNumber == tunnelPort);
                 portResource.LastKnownStatus = portStatus;
                 if (portStatus?.PortUri is null)
                 {
-                    return HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelUnhealthy_PortInactive, _tunnelResource.TunnelId, portResource.TargetEndpoint.Port));
+                    return HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelUnhealthy_PortInactive, _tunnelResource.TunnelId, tunnelPort));
                 }
             }
 
@@ -49,7 +50,8 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
             // Get access status for each port
             foreach (var portResource in _tunnelResource.Ports)
             {
-                var portAccessStatus = await _devTunnelClient.GetAccessAsync(_tunnelResource.TunnelId, portResource.TargetEndpoint.Port, logger, cancellationToken).ConfigureAwait(false);
+                var tunnelPort = await portResource.GetTunnelPortAsync(cancellationToken).ConfigureAwait(false);
+                var portAccessStatus = await _devTunnelClient.GetAccessAsync(_tunnelResource.TunnelId, tunnelPort, logger, cancellationToken).ConfigureAwait(false);
                 portResource.LastKnownAccessStatus = portAccessStatus;
             }
 

src/Aspire.Hosting.DevTunnels/DevTunnelPortHealthCheck.cs

@@ -6,40 +6,42 @@
 
 namespace Aspire.Hosting.DevTunnels;
 
-internal sealed class DevTunnelPortHealthCheck(DevTunnelResource tunnelResource, int port) : IHealthCheck
+internal sealed class DevTunnelPortHealthCheck(DevTunnelPortResource portResource) : IHealthCheck
 {
-    private readonly DevTunnelResource _tunnelResource = tunnelResource ?? throw new ArgumentNullException(nameof(tunnelResource));
+    private readonly DevTunnelPortResource _portResource = portResource ?? throw new ArgumentNullException(nameof(portResource));
 
-    private readonly int _port = port;
-
-    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
     {
         try
         {
+            var tunnelResource = _portResource.DevTunnel;
+            var port = await _portResource.GetTunnelPortAsync(cancellationToken).ConfigureAwait(false);
             var tunnelStatus = tunnelResource.LastKnownStatus;
             if (tunnelStatus is null)
             {
-                return Task.FromResult(HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelPortUnhealthy_StatusUnknown, _port, _tunnelResource.TunnelId)));
+                return HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelPortUnhealthy_StatusUnknown, port, tunnelResource.TunnelId));
             }
 
             if (tunnelStatus.HostConnections == 0)
             {
-                return Task.FromResult(HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelUnhealthy_NoActiveHostConnections, _tunnelResource.TunnelId)));
+                return HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelUnhealthy_NoActiveHostConnections, tunnelResource.TunnelId));
             }
 
-            var portStatus = tunnelStatus.Ports?.FirstOrDefault(p => p.PortNumber == _port);
+            var portStatus = tunnelStatus.Ports?.FirstOrDefault(p => p.PortNumber == port);
 
             // Check that port is active
             if (portStatus?.PortUri is null)
             {
-                return Task.FromResult(HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelUnhealthy_PortInactive, _tunnelResource.TunnelId, _port)));
+                return HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelUnhealthy_PortInactive, tunnelResource.TunnelId, port));
             }
 
-            return Task.FromResult(HealthCheckResult.Healthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelPortHealthy, _port, _tunnelResource.TunnelId)));
+            return HealthCheckResult.Healthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelPortHealthy, port, tunnelResource.TunnelId));
         }
         catch (Exception ex)
         {
-            return Task.FromResult(HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelPortUnhealthy_Error, _port, _tunnelResource.TunnelId, ex.Message), ex));
+            var tunnelResource = _portResource.DevTunnel;
+            var port = _portResource.TargetEndpoint.TargetPort?.ToString(CultureInfo.InvariantCulture) ?? "unknown";
+            return HealthCheckResult.Unhealthy(string.Format(CultureInfo.CurrentCulture, Resources.MessageStrings.DevTunnelPortUnhealthy_Error, port, tunnelResource.TunnelId, ex.Message), ex);
         }
     }
-}
+}

src/Aspire.Hosting.DevTunnels/DevTunnelResource.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.Globalization;
 using Aspire.Hosting.ApplicationModel;
 
 namespace Aspire.Hosting.DevTunnels;
@@ -85,4 +86,43 @@ public DevTunnelPortResource(
     internal EndpointReference TargetEndpoint { get; init; }
     internal DevTunnelPort? LastKnownStatus { get; set; }
     internal DevTunnelAccessStatus? LastKnownAccessStatus { get; set; }
+
+    internal async ValueTask<int> GetTunnelPortAsync(CancellationToken cancellationToken = default)
+    {
+        if (TargetEndpoint.Resource.IsContainer())
+        {
+            // Dev tunnel hosting runs on the host, so container endpoints must forward the host-reachable
+            // allocated port rather than the container-internal target port.
+            return await GetResolvedEndpointPortAsync(EndpointProperty.Port, cancellationToken).ConfigureAwait(false)
+                ?? TargetEndpoint.Port;
+        }
+
+        if (TargetEndpoint.TargetPort is int targetPort)
+        {
+            return targetPort;
+        }
+
+        return await GetResolvedEndpointPortAsync(EndpointProperty.TargetPort, cancellationToken).ConfigureAwait(false)
+            ?? TargetEndpoint.Port;
+    }
+
+    private async ValueTask<int?> GetResolvedEndpointPortAsync(EndpointProperty property, CancellationToken cancellationToken)
+    {
+        string? resolvedTargetPort = null;
+        try
+        {
+            resolvedTargetPort = await TargetEndpoint.Property(property).GetValueAsync(cancellationToken).ConfigureAwait(false);
+        }
+        catch (InvalidOperationException) when (property == EndpointProperty.TargetPort && TargetEndpoint.IsAllocated)
+        {
+            // Endpoint references can only resolve targetPort dynamically when DCP reports a target-port expression.
+        }
+
+        if (int.TryParse(resolvedTargetPort, NumberStyles.None, CultureInfo.InvariantCulture, out var port))
+        {
+            return port;
+        }
+
+        return null;
+    }
 }

src/Aspire.Hosting.DevTunnels/DevTunnelResourceBuilderExtensions.cs

@@ -177,7 +177,7 @@ public static IResourceBuilder<DevTunnelResource> AddDevTunnel(
                 async Task DeleteUnmodeledPortsAsync()
                 {
                     var existingPorts = await devTunnelClient.GetPortListAsync(tunnelResource.TunnelId, logger, ct).ConfigureAwait(false);
-                    var modeledPortNumbers = tunnelResource.Ports.Select(p => p.TargetEndpoint.Port).ToHashSet();
+                    var modeledPortNumbers = (await Task.WhenAll(tunnelResource.Ports.Select(p => p.GetTunnelPortAsync(ct).AsTask())).ConfigureAwait(false)).ToHashSet();
                     var unmodeledPorts = existingPorts.Ports.Where(p => !modeledPortNumbers.Contains(p.PortNumber)).ToList();
                     if (unmodeledPorts.Count > 0)
                     {
@@ -189,6 +189,7 @@ async Task DeleteUnmodeledPortsAsync()
                 async Task StartPortAsync(DevTunnelPortResource portResource)
                 {
                     var portLogger = e.Services.GetRequiredService<ResourceLoggerService>().GetLogger(portResource);
+                    var tunnelPort = await portResource.GetTunnelPortAsync(ct).ConfigureAwait(false);
 
                     // Clear any prior port status
                     portLogger.LogInformation("Tunnel starting");
@@ -202,17 +203,17 @@ await notifications.PublishUpdateAsync(portResource, snapshot => snapshot with
                     {
                         _ = await devTunnelClient.CreatePortAsync(
                                 portResource.DevTunnel.TunnelId,
-                                portResource.TargetEndpoint.Port,
+                                tunnelPort,
                                 portResource.Options,
                                 portLogger,
                                 ct)
                             .ConfigureAwait(false);
 
-                        portLogger.LogInformation("Created dev tunnel port '{Port}' on tunnel '{Tunnel}' targeting endpoint '{Endpoint}' on resource '{TargetResource}'", portResource.TargetEndpoint.Port, portResource.DevTunnel.TunnelId, portResource.TargetEndpoint.EndpointName, portResource.TargetEndpoint.Resource.Name);
+                        portLogger.LogInformation("Created dev tunnel port '{Port}' on tunnel '{Tunnel}' targeting endpoint '{Endpoint}' on resource '{TargetResource}'", tunnelPort, portResource.DevTunnel.TunnelId, portResource.TargetEndpoint.EndpointName, portResource.TargetEndpoint.Resource.Name);
                     }
                     catch (Exception ex)
                     {
-                        portLogger.LogError(ex, "Error trying to create dev tunnel port '{Port}' on tunnel '{Tunnel}': {Error}", portResource.TargetEndpoint.Port, portResource.DevTunnel.TunnelId, ex.Message);
+                        portLogger.LogError(ex, "Error trying to create dev tunnel port '{Port}' on tunnel '{Tunnel}': {Error}", tunnelPort, portResource.DevTunnel.TunnelId, ex.Message);
 #pragma warning disable CS0618 // Type or member is obsolete
                         portResource.TunnelEndpointAnnotation.AllocatedEndpointSnapshot.SetException(ex);
 #pragma warning restore CS0618 // Type or member is obsolete
@@ -589,7 +590,7 @@ private static void AddDevTunnelPort(
         var healtCheckKey = $"{portName}-check";
         tunnelBuilder.ApplicationBuilder.Services.AddHealthChecks().Add(new HealthCheckRegistration(
             healtCheckKey,
-            services => new DevTunnelPortHealthCheck(tunnel, targetEndpoint.Port),
+            services => new DevTunnelPortHealthCheck(portResource),
             failureStatus: default,
             tags: default,
             timeout: default));

src/Aspire.Hosting.Foundry/HostedAgent/HostedAgentBuilderExtension.cs

@@ -111,7 +111,7 @@ public static IResourceBuilder<T> PublishAsHostedAgent<T>(
             var targetPort = existingHttpEndpoint?.TargetPort ?? 8088;
 
             builder
-                .WithHttpEndpoint(name: "http", env: "DEFAULT_AD_PORT", targetPort: targetPort)
+                .WithHttpEndpoint(name: "http", env: "DEFAULT_AD_PORT", targetPort: targetPort, isProxied: true)
                 .WithUrls((ctx) =>
                 {
                     var http = ctx.Urls.FirstOrDefault(u => u.Endpoint?.EndpointName == "http" || u.Endpoint?.EndpointName == "https");