SignalR .NetCore Api not working when ran with docker-compose

I have a .NetCore API with a signalR Hub. My app is deployed on DigitalOcean, on Ubuntu 18.04.3 (LTS) x64.

• When running dotnet run in the cmd, the program starts and is accessible via the IP address. Both the API endpoints and the signalR hub respond as expected. ( this happens on HTTP ) I do however get this in the console :

• When running

  docker-compose build docker-compose up

the application starts (on HTTPS), the API words as expected, but SignalR gives the following error:

I also get this in the console

this is my docker-compose file:

#docker-compose

version: '2'

services:
  app:
    build:
      context:  ./
      dockerfile: Dockerfile
  https-portal:
    image: steveltn/https-portal:1
    ports:
      - '80:80'
      - '443:443'
    links:
      - app
    restart: always
    environment:
      DOMAINS: 'ns2.we*******.*** -> http://app:80'
      STAGE: 'production'

this is my Docker file

FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/core/sdk:3.1-buster AS build
WORKDIR /src
COPY ["iCoose.API/iChoose.API.csproj", "iCoose.API/"]
COPY ["iChoose.Business.Entities/iChoose.Business.Entities.csproj", "iChoose.Business.Entities/"]
COPY ["iChoose.Business.Services/iChoose.Business.Services.csproj", "iChoose.Business.Services/"]
COPY ["iChoose.Common.Core/iChoose.Common.Core.csproj", "iChoose.Common.Core/"]
COPY ["iChoose.DataAccess.Data/iChoose.DataAccess.Data.csproj", "iChoose.DataAccess.Data/"]
RUN dotnet restore "iCoose.API/iChoose.API.csproj"
COPY . .
WORKDIR "/src/iCoose.API"
RUN dotnet build "iChoose.API.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "iChoose.API.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "iChoose.API.dll"]

my Program.cs

public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
                webBuilder.UseUrls("http://*:80");
            });
}

This is my Startup :

 public class Startup
{
    const string CorsAllowAnyOriginPolicyName = "AllowAnyOrigin";

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }


    public void ConfigureServices(IServiceCollection services)
    {
        ConfigureCORS(services);
        services.AddControllers(config => 
          {}).SetCompatibilityVersion(CompatibilityVersion.Latest);

        services.AddEntityFrameworkNpgsql().AddDbContext<AppDbContext>(opt =>
        {
            opt.UseNpgsql(Configuration["ConnectionStrings:AppEntities"]);
        });

        services.AddRazorPages();
        services.AddSignalR();
        services.AddHttpClient();

        services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
        services.AddSingleton<VotingHub>();

        #region JWT authentication
        ....
        #endregion
    }


    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();
        app.UseCors(CorsAllowAnyOriginPolicyName);

        app.UseAuthentication();
        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
            endpoints.MapControllers();
            endpoints.MapHub<VotingHub>("/voteHub");
        });
    }


    private void ConfigureCORS(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(CorsAllowAnyOriginPolicyName, policy =>
            {
                policy.AllowAnyOrigin();
                policy.AllowAnyMethod();
                policy.AllowAnyHeader();
            });
        });

    }
 }