Is there a way to bind project as multiple services?

[En3Tho]

I have a host project that actually hosts 2 services, "apiservice" and "apiservicev2" for example. How can I specify an additional service name for a project that I add to the DistributedApplicationBuilder?

Basically what I want to do is something like that:

var apiservice = builder.AddProject<Projects.ApiService>("apiservice", "apiservicev2"); // implements both at once and references get injected automatically when referenced
var apiservice2 = builder.AddProject<Projects.ApiService2>("apiservice2")
    .WithReference(apiservice); // knows about both "apiservice" and "apiservicev2"

or

var apiservice = builder.AddProject<Projects.ApiService>("apiservice"); // default name is apiservice
var apiservice2 = builder.AddProject<Projects.ApiService2>("apiservice2")
    .WithReference(apiservice)
    .WithReference(apiservice, name: "apiservicev2"); // explicit custom name

I've tried some things but they did not work. It is quite possible that I've missed something in the doc.

[davidfowl]

I have a host project that actually hosts 2 services, "apiservice" and "apiservicev2" for example.

Can you explain some more? Do you want to declare 2 services or just refer to the same service by a different name? If so can you explain why?

[En3Tho]

I want to refer to the same "host" by multiple different names ("services"). Basically my services are modules that expose both client registration and server registation and can be hosted both as part of modular monolith or as a dedicated microservice. The idea is that instead of using HttpClient or whatever client directly, I expose "IMyBlablaService" interface with assossiated contracts (dtos and such) and end code always knows only about that. It doesn't know where service is hosted or what protocol is used etc. I'm experimenting with Aspire as a unified dev host (which I'm loving so far, it's great!).

Imagine this:

ServiceA : IServiceA
  => exposes ServiceA.Contracts (shared lib with interface, dtos and stuff like that)
  => exposes ServiceA.Client ("http://serviceA")
    services.AddServiceAClient()
  => exposes ServiceA.Server
    services.AddServiceAServer()
    app.MapServiceA()

ServiceB : ... same as above but maybe a grpc and not http, the point is that only IServiceB interface is consumed in the end

Project1
   => hosts ServiceAServer
   => hosts ServiceBServer
Project2
  => consumes ServiceAClient
  => consumes ServiceBClient

So I might host "serviceA" and "serviceB" in the same host "Project1" and I need a way for "Project2" to be able to discover both "serviceA" and "serviceB".

I hope this clarifies things a bit.

[En3Tho]

I guess you can think of it as "alias" to the project in terms of Aspire

[davidfowl]

There's no first-class support for doing this today but I think you can implement it. This won't work for deployment though, I'll file an issue:

static class WithReferenceAlias
{
    public static IResourceBuilder<ProjectResource> WithReference(
        this IResourceBuilder<ProjectResource> destination,
        IResourceBuilder<ProjectResource> source,
        string[] aliases)
    {
        static bool ContainsAmbiguousEndpoints(IEnumerable<AllocatedEndpointAnnotation> endpoints)
        {
            // An ambiguous endpoint is where any scheme (
            return endpoints.GroupBy(e => e.UriScheme).Any(g => g.Count() > 1);
        }

        return destination.WithEnvironment(context =>
        {
            if (!source.Resource.TryGetAllocatedEndPoints(out var allocatedEndPoints))
            {
                return;
            }

            var containsAmbiguousEndpoints = ContainsAmbiguousEndpoints(allocatedEndPoints);

            aliases = [source.Resource.Name, .. aliases];

            foreach (var name in aliases.Distinct())
            {
                var i = 0;
                foreach (var allocatedEndPoint in allocatedEndPoints)
                {
                    var bindingNameQualifiedUriStringKey = $"services__{name}__{i++}";
                    context.EnvironmentVariables[bindingNameQualifiedUriStringKey] = allocatedEndPoint.BindingNameQualifiedUriString;

                    if (!containsAmbiguousEndpoints)
                    {
                        var uriStringKey = $"services__{name}__{i++}";
                        context.EnvironmentVariables[uriStringKey] = allocatedEndPoint.UriString;
                    }
                }
            }
        });
    }
}

You should be able to do this:

var apiservice = builder.AddProject<Projects.ApiService>("apiservice"); // default name is apiservice
var apiservice2 = builder.AddProject<Projects.ApiService2>("apiservice2")
    .WithReference(apiservice)
    .WithReference(apiservice, ["apiservicev2"]); 

[En3Tho]

Thank you. I've been looking at the same code too. What do you personally think about this kind of project structure?

[davidfowl]

The only issue you will have with this pattern is that you will need to do something to distinguish between those services when you call them (if they are on the same port). If you expose service A and B from apiservice, then you can't really refer to them as "http://a" and "http://b", they'll be on the same port and you'll need to handle the routing somehow.

[davidfowl]

How are you going to handle that?

[davidfowl]

To makes this work you might need to include the path in there:

// Logical names
serviceA
serviceB

// Modular monolith

http://services/A -> http://serviceA
http://services/B -> http://serviceB

// Microservice

http://serviceA
http://serviceB

@ReubenBond Can service discovery handle the path as input for http requests?