Display resource endpoints for Docker Compose deploy #13216

captainsafia · 2025-11-26T21:09:31Z

github-actions · 2025-11-26T21:09:40Z

🚀 Dogfood this PR with:

⚠️ WARNING: Do not do this without first carefully reviewing the code of this PR to satisfy yourself it is safe.

curl -fsSL https://raw.githubusercontent.com/dotnet/aspire/main/eng/scripts/get-aspire-cli-pr.sh | bash -s -- 13216

Or

Run remotely in PowerShell:

iex "& { $(irm https://raw.githubusercontent.com/dotnet/aspire/main/eng/scripts/get-aspire-cli-pr.ps1) } 13216"

Copilot

Pull request overview

This PR adds functionality to display resource endpoints after Docker Compose deployment, addressing issue #12820. The implementation uses pipeline steps to query running Docker Compose containers and reports their accessible endpoints to users.

Key changes:

Adds endpoint discovery and display functionality using docker compose ps --format json
Refactors Docker Compose argument building into a reusable method
Integrates endpoint printing into the deployment pipeline workflow

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 4 comments.

File	Description
src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs	Converts from primary constructor to explicit constructor; adds `PrintEndpointsAsync` method to query and display container endpoints after deployment; adds JSON deserialization classes for parsing docker compose output; registers pipeline step for endpoint printing
src/Aspire.Hosting.Docker/DockerComposeEnvironmentResource.cs	Extracts docker compose argument building logic into `GetDockerComposeArguments` helper method; changes `GetEnvFilePath` to static method; adds pipeline step dependency to ensure endpoint printing runs after docker-compose-up; adds `--project-name` argument to docker compose commands

Copilot · 2025-11-26T21:19:31Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+                            if (endpointMapping.IsExternal || scheme is "http" or "https")
+                            {
+                                var endpoint = $"{scheme}://localhost:{publisher.PublishedPort}";
+                                endpoints.Add(endpoint);
+                            }
+                        }
+                    }


The logic for determining which endpoints to display could be clearer. The condition endpointMapping.IsExternal || scheme is "http" or "https" is confusing because:

externalEndpointMappings on line 371 already filters to external endpoints

When FirstOrDefault returns no match (line 410), endpointMapping will be the default struct value where IsExternal = false

The fallback to checking scheme is "http" or "https" suggests the intent is to show all http/https ports even without explicit mapping

Consider adding a comment to clarify this logic, or restructuring to make the intent clearer:

// Show endpoint if: it matches an external endpoint mapping, OR it's an http/https port (published ports are external by default) var hasExplicitMapping = endpointMapping.Resource is not null; if (hasExplicitMapping || scheme is "http" or "https") { var endpoint = $"{scheme}://localhost:{publisher.PublishedPort}"; endpoints.Add(endpoint); }

Copilot · 2025-11-26T21:19:32Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+
+            return steps;
+        }));
+    }


Missing blank line before the XML documentation comment. According to the codebase formatting conventions, there should be a blank line between the closing brace of the constructor and the XML documentation comment for the next member.

Suggested change

}

}

Copilot · 2025-11-26T21:19:32Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+    private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)
+    {


The PrintEndpointsAsync method is missing XML documentation. According to the Aspire XML documentation guidelines, internal methods should have brief <summary> tags explaining what they do. Consider adding:

/// <summary> /// Prints the endpoints for the Docker Compose service after deployment. /// </summary>

Suggested change

private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)

{

/// <summary>

/// Prints the endpoints for the Docker Compose service after deployment.

/// </summary>

private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)

Copilot · 2025-11-26T21:19:32Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+    private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)
+    {
+        var outputPath = PublishingContextUtils.GetEnvironmentOutputPath(context, environment);
+        var dockerComposeFilePath = Path.Combine(outputPath, "docker-compose.yaml");
+
+        if (!File.Exists(dockerComposeFilePath))
+        {
+            context.Logger.LogWarning("Docker Compose file not found at {Path}", dockerComposeFilePath);
+            return;
+        }
+
+        try
+        {
+            // Use docker compose ps to get the running containers and their port mappings
+            var arguments = DockerComposeEnvironmentResource.GetDockerComposeArguments(context, environment);
+            arguments += " ps --format json";
+
+            var outputLines = new List<string>();
+
+            var spec = new ProcessSpec("docker")
+            {
+                Arguments = arguments,
+                WorkingDirectory = outputPath,
+                ThrowOnNonZeroReturnCode = false,
+                InheritEnv = true,
+                OnOutputData = output =>
+                {
+                    if (!string.IsNullOrWhiteSpace(output))
+                    {
+                        outputLines.Add(output);
+                    }
+                },
+                OnErrorData = error =>
+                {
+                    if (!string.IsNullOrWhiteSpace(error))
+                    {
+                        context.Logger.LogDebug("docker compose ps (stderr): {Error}", error);
+                    }
+                }
+            };
+
+            var (pendingProcessResult, processDisposable) = ProcessUtil.Run(spec);
+
+            await using (processDisposable)
+            {
+                var processResult = await pendingProcessResult
+                    .WaitAsync(context.CancellationToken)
+                    .ConfigureAwait(false);
+
+                if (processResult.ExitCode != 0)
+                {
+                    context.Logger.LogWarning("Failed to query Docker Compose services for {ResourceName}. Exit code: {ExitCode}", TargetResource.Name, processResult.ExitCode);
+                    return;
+                }
+
+                // Parse the JSON output to find port mappings for this service
+                var serviceName = TargetResource.Name.ToLowerInvariant();
+                var endpoints = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+                // Get all external endpoint mappings for this resource
+                var externalEndpointMappings = EndpointMappings.Values.Where(m => m.IsExternal).ToList();
+
+                // If there are no external endpoints configured, we're done
+                if (externalEndpointMappings.Count == 0)
+                {
+                    context.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{TargetResource.Name}** to Docker Compose environment **{environment.Name}**. No public endpoints were configured.", enableMarkdown: true);
+                    return;
+                }
+
+                foreach (var line in outputLines)
+                {
+                    try
+                    {
+                        var serviceInfo = JsonSerializer.Deserialize(line, DockerComposeJsonContext.Default.DockerComposeServiceInfo);
+
+                        if (serviceInfo is null ||
+                            !string.Equals(serviceInfo.Service, serviceName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            continue;
+                        }
+
+                        if (serviceInfo.Publishers is not { Count: > 0 })
+                        {
+                            continue;
+                        }
+
+                        foreach (var publisher in serviceInfo.Publishers)
+                        {
+                            // Skip ports that aren't actually published (port 0 or null means not exposed)
+                            if (publisher.PublishedPort is not > 0)
+                            {
+                                continue;
+                            }
+
+                            // Try to find a matching external endpoint to get the scheme
+                            // Match by internal port (numeric) or by exposed port
+                            // InternalPort may be a placeholder like ${API_PORT} for projects, so also check ExposedPort
+                            var targetPortStr = publisher.TargetPort?.ToString(CultureInfo.InvariantCulture);
+                            var endpointMapping = externalEndpointMappings
+                                .FirstOrDefault(m => m.InternalPort == targetPortStr || m.ExposedPort == publisher.TargetPort);
+
+                            // If we found a matching endpoint, use its scheme; otherwise default to http for external ports
+                            var scheme = endpointMapping.Scheme ?? "http";
+
+                            // Only add if we found a matching external endpoint OR if scheme is http/https
+                            // (published ports are external by definition in docker compose)
+                            if (endpointMapping.IsExternal || scheme is "http" or "https")
+                            {
+                                var endpoint = $"{scheme}://localhost:{publisher.PublishedPort}";
+                                endpoints.Add(endpoint);
+                            }
+                        }
+                    }
+                    catch (JsonException ex)
+                    {
+                        context.Logger.LogDebug(ex, "Failed to parse docker compose ps output line: {Line}", line);
+                    }
+                }
+
+                // Display the endpoints
+                if (endpoints.Count > 0)
+                {
+                    var endpointList = string.Join(", ", endpoints.Select(e => $"[{e}]({e})"));
+                    context.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{TargetResource.Name}** to {endpointList}", enableMarkdown: true);
+                }
+                else
+                {
+                    context.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{TargetResource.Name}** to Docker Compose environment **{environment.Name}**. No public endpoints were configured.", enableMarkdown: true);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            context.Logger.LogWarning(ex, "Failed to retrieve endpoints for {ResourceName}", TargetResource.Name);
+        }
+    }
+
+    /// <summary>


The new endpoint printing functionality introduced in the PrintEndpointsAsync method and the pipeline step configuration lacks test coverage. Consider adding tests to verify:

Endpoint discovery and display when containers are running

Behavior when no external endpoints are configured

Handling of multiple endpoints with different schemes

Error handling when Docker Compose commands fail

The test file tests/Aspire.Hosting.Docker.Tests/DockerComposePublisherTests.cs has comprehensive test coverage for other Docker Compose functionality and would be an appropriate location for these tests.

captainsafia

@copilot Address this feedback.

captainsafia · 2025-11-26T21:41:19Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+            var printResourceSummary = new PipelineStep
+            {
+                Name = $"print-{resource.Name}-summary",
+                Action = async ctx => await PrintEndpointsAsync(ctx, composeEnvironmentResource).ConfigureAwait(false),


Suggested change

Action = async ctx => await PrintEndpointsAsync(ctx, composeEnvironmentResource).ConfigureAwait(false),

Action = async ctx => await PrintEndpointsAsync(ctx, _composeEnvironmentResource).ConfigureAwait(false),

captainsafia · 2025-11-26T21:41:47Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+
+            var printResourceSummary = new PipelineStep
+            {
+                Name = $"print-{resource.Name}-summary",


Suggested change

Name = $"print-{resource.Name}-summary",

Name = $"print-{_targetResource.Name}-summary",

captainsafia · 2025-11-26T21:42:14Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+        _composeEnvironmentResource = composeEnvironmentResource;
+
+        // Add pipeline step annotation to display endpoints after deployment
+        Annotations.Add(new PipelineStepAnnotation((factoryContext) =>


Suggested change

Annotations.Add(new PipelineStepAnnotation((factoryContext) =>

Annotations.Add(new PipelineStepAnnotation(_ =>

captainsafia · 2025-11-26T21:43:26Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+
+    private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)
+    {
+        var outputPath = PublishingContextUtils.GetEnvironmentOutputPath(context, environment);


Remove this declaration and check for dockerComposeFilePath since we do it in DockerComposeEnvironmentResource.GetDockerComposeArguments now.

Copilot · 2025-11-26T21:44:23Z

@captainsafia I've opened a new pull request, #13217, to work on those changes. Once the pull request is ready, I'll request review from you.

…3217) * Initial plan * Address review feedback on DockerComposeServiceResource Co-authored-by: captainsafia <[email protected]> --------- Co-authored-by: copilot-swe-agent[bot] <[email protected]> Co-authored-by: captainsafia <[email protected]>

davidfowl · 2025-11-27T07:09:13Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

+        try
+        {
+            // Use docker compose ps to get the running containers and their port mappings
+            var arguments = DockerComposeEnvironmentResource.GetDockerComposeArguments(context, environment);


@copilot add a comment that shows an example of the expected format being parsed here from docker compose.

Copilot · 2025-11-27T07:09:25Z

@davidfowl I've opened a new pull request, #13220, to work on those changes. Once the pull request is ready, I'll request review from you.

Copilot · 2025-11-27T07:32:37Z

@davidfowl I've opened a new pull request, #13222, to work on those changes. Once the pull request is ready, I'll request review from you.

davidfowl · 2025-11-27T07:49:41Z

It's not printing the dashboard url.

#:package Aspire.Hosting.Docker@13.1.0-pr.13216.g40a62e5e
#:sdk Aspire.AppHost.Sdk@13.1.0-pr.13216.g40a62e5e

var builder = DistributedApplication.CreateBuilder(args);

builder.AddDockerComposeEnvironment("env")
      .WithDashboard(db => db.WithHostPort(9090));

#pragma warning disable ASPIRECSHARPAPPS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
builder.AddCSharpApp("api3", "./api.cs")
       .WithHttpEndpoint(targetPort: 5000)
       .WithExternalHttpEndpoints();

builder.Build().Run();

davidfowl · 2025-11-27T07:55:24Z

src/Aspire.Hosting.Docker/DockerComposeServiceResource.cs

        }
    }
+
+    private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)


Doesn't this need to handle potential slow startup of services? What guaranteees that docker compose ps --format json will have the information by the time you call it?

captainsafia · 2025-12-01T17:04:16Z

It's not printing the dashboard url.

Yep, I haven't done anything around that in this PR. Although I wonder if printing the dashboard URL might be a better strategy since it launches deterministically and can be used at the gateway to discover service URIs.

davidfowl · 2025-12-01T17:36:56Z

If you have it enabled, we should show it. I was playing with this in my ssh docker deploy and we should make sure that it works well if containers don't start up immediately.

Copilot AI review requested due to automatic review settings November 26, 2025 21:09

Copilot started reviewing on behalf of captainsafia November 26, 2025 21:10 View session

Copilot finished reviewing on behalf of captainsafia November 26, 2025 21:12

Display resource endpoints for Docker Compose deploy

3c202d9

captainsafia force-pushed the safia/docker-compose-endpoints branch from 256820a to 3c202d9 Compare November 26, 2025 21:19

Copilot AI reviewed Nov 26, 2025

View reviewed changes

captainsafia commented Nov 26, 2025

View reviewed changes

Copilot AI mentioned this pull request Nov 26, 2025

[WIP] Update resource endpoints display for Docker Compose deploy #13217

Merged

4 tasks

davidfowl reviewed Nov 27, 2025

View reviewed changes

Copilot AI mentioned this pull request Nov 27, 2025

Add comment showing expected docker compose ps JSON format #13220

Closed

16 tasks

Copilot AI mentioned this pull request Nov 27, 2025

[WIP] Update Docker Compose resource endpoint examples #13222

Closed

davidfowl reviewed Nov 27, 2025

View reviewed changes

		private async Task PrintEndpointsAsync(PipelineStepContext context, DockerComposeEnvironmentResource environment)
		{

	Action = async ctx => await PrintEndpointsAsync(ctx, composeEnvironmentResource).ConfigureAwait(false),
	Action = async ctx => await PrintEndpointsAsync(ctx, _composeEnvironmentResource).ConfigureAwait(false),

	Name = $"print-{resource.Name}-summary",
	Name = $"print-{_targetResource.Name}-summary",

	Annotations.Add(new PipelineStepAnnotation((factoryContext) =>
	Annotations.Add(new PipelineStepAnnotation(_ =>

Display resource endpoints for Docker Compose deploy #13216

Are you sure you want to change the base?

Display resource endpoints for Docker Compose deploy #13216

Conversation

captainsafia commented Nov 26, 2025

Uh oh!

github-actions bot commented Nov 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

captainsafia left a comment

Choose a reason for hiding this comment

Uh oh!

captainsafia Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

captainsafia Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

captainsafia Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

captainsafia Nov 26, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI commented Nov 26, 2025

Uh oh!

davidfowl Nov 27, 2025

Choose a reason for hiding this comment

Uh oh!

davidfowl Nov 27, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI commented Nov 27, 2025

Uh oh!

Copilot AI commented Nov 27, 2025

Uh oh!

davidfowl commented Nov 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

davidfowl Nov 27, 2025

Choose a reason for hiding this comment

Uh oh!

captainsafia commented Dec 1, 2025

Uh oh!

davidfowl commented Dec 1, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

github-actions bot commented Nov 26, 2025 •

edited

Loading

davidfowl commented Nov 27, 2025 •

edited

Loading