examen - github docker hub

¿Cómo puedo usar IdentityServer4 desde dentro y fuera de una máquina de conexión?

Question

Quiero poder autenticarme contra un servidor de identidad (STS) desde fuera y dentro de una máquina de conexión.

Estoy teniendo problemas para establecer la autoridad correcta que funcione tanto dentro como fuera del contenedor. Si configuro la autoridad en el nombre interno mcoidentityserver:5000 entonces la API puede autenticarse, pero el cliente no puede obtener un token ya que el cliente se encuentra fuera de la red de la ventana acoplable. Si configuro la autoridad en el nombre externo localhost:5000 entonces el cliente puede obtener un token pero la API no reconoce el nombre de la autoridad (porque localhost en este caso es la máquina host).

¿Qué debo establecer la Autoridad para? O tal vez necesito ajustar la red docker?

Diagrama

La flecha roja es la parte con la que estoy teniendo problemas.

Detalle

Estoy configurando un entorno de desarrollo docker de Windows 10 que utiliza una API de ASP.NET Core (en Linux), Identity Server 4 (ASP.NET Core en Linux) y una base de datos PostgreSQL. PostgreSQL no es un problema, incluido en el diagrama para completar. Se asigna a 9876 porque también tengo una instancia de PostgreSQL que se ejecuta en el host por ahora. mco es un nombre abreviado de nuestra empresa.

He estado siguiendo las instrucciones de Identity Server 4 para empezar a funcionar.

Código

No estoy incluyendo el docker-compose.debug.yml porque ha ejecutado los comandos pertinentes solo para ejecutarse en Visual Studio.

docker-compose.yml

version: ''2''

services:
mcodatabase:
    image: mcodatabase
    build:
    context: ./Data
    dockerfile: Dockerfile
    restart: always
    ports:
    - 9876:5432
    environment:
    POSTGRES_USER: mcodevuser
    POSTGRES_PASSWORD: password
    POSTGRES_DB: mcodev
    volumes:
    - postgresdata:/var/lib/postgresql/data
    networks:
    - mconetwork

mcoidentityserver:
    image: mcoidentityserver
    build:
    context: ./Mco.IdentityServer
    dockerfile: Dockerfile
    ports:
    - 5000:5000
    networks:
    - mconetwork

mcoapi:
    image: mcoapi
    build:
    context: ./Mco.Api
    dockerfile: Dockerfile
    ports:
    - 56107:80
    links:
    - mcodatabase
    depends_on:
    - "mcodatabase"
    - "mcoidentityserver"
    networks:
    - mconetwork

volumes:
postgresdata:

networks:
mconetwork:
    driver: bridge

docker-compose.override.yml

Esto es creado por el complemento de Visual Studio para inyectar valores extra.

version: ''2''

services:
mcoapi:
    environment:
    - ASPNETCORE_ENVIRONMENT=Development
    ports:
    - "80" 

mcoidentityserver:
    environment:
    - ASPNETCORE_ENVIRONMENT=Development
    ports:
    - "5000" 

API Dockerfile

FROM microsoft/aspnetcore:1.1
ARG source
WORKDIR /app
EXPOSE 80
COPY ${source:-obj/Docker/publish} .
ENTRYPOINT ["dotnet", "Mco.Api.dll"]

Identity Server Dockerfile

FROM microsoft/aspnetcore:1.1
ARG source
WORKDIR /app
COPY ${source:-obj/Docker/publish} .
EXPOSE 5000
ENV ASPNETCORE_URLS http://*:5000
ENTRYPOINT ["dotnet", "Mco.IdentityServer.dll"]

API Startup.cs

Donde le decimos a la API que use el servidor de identidad y establezca la autoridad.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

    app.UseIdentityServerAuthentication(new IdentityServerAuthenticationOptions
    {
        // This can''t work because we''re running in docker and it doesn''t understand what localhost:5000 is!
        Authority = "http://localhost:5000", 
        RequireHttpsMetadata = false,

        ApiName = "api1"
    });

    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}

Identity Server Startup.cs

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddIdentityServer()
            .AddTemporarySigningCredential()
            .AddInMemoryApiResources(Config.GetApiResources())
            .AddInMemoryClients(Config.GetClients());
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole();

        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseIdentityServer();

        app.Run(async (context) =>
        {
            await context.Response.WriteAsync("Hello World!");
        });
    }
}

Identity Server Config.cs

public class Config
{
    public static IEnumerable<ApiResource> GetApiResources()
    {
        return new List<ApiResource>
        {
            new ApiResource("api1", "My API")
        };
    }

    public static IEnumerable<Client> GetClients()
    {
        return new List<Client>
        {
            new Client
            {
                ClientId = "client",

                // no interactive user, use the clientid/secret for authentication
                AllowedGrantTypes = GrantTypes.ClientCredentials,

                // secret for authentication
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                // scopes that client has access to
                AllowedScopes = { "api1" }
            }
        };
    }
}

Cliente

Ejecutando en una aplicación de consola.

var discovery = DiscoveryClient.GetAsync("localhost:5000").Result;
var tokenClient = new TokenClient(discovery.TokenEndpoint, "client", "secret");
var tokenResponse = tokenClient.RequestClientCredentialsAsync("api1").Result;

if (tokenResponse.IsError)
{
    Console.WriteLine(tokenResponse.Error);
    return 1;
}

var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);

var response = client.GetAsync("http://localhost:56107/test").Result;
if (!response.IsSuccessStatusCode)
{
    Console.WriteLine(response.StatusCode);
}
else
{
    var content = response.Content.ReadAsStringAsync().Result;
    Console.WriteLine(JArray.Parse(content));
}

Gracias por adelantado.

Answer 1

Asegúrese de que IssuerUri se establece en una constante explícita. Tuvimos problemas similares con el acceso a la instancia de Identity Server por el IP / nombre de host y lo resolvimos de esta manera:

services.AddIdentityServer(x =>
{
    x.IssuerUri = "my_auth";
})

PS ¿Por qué no unifica la URL de autoridad al hostname:5000 de hostname:5000 ? Sí, es posible que el Cliente y la API llamen al mismo URL hostname:5000 si:

• El puerto 5000 está expuesto (veo que está bien)
• DNS se resuelve dentro del contenedor docker.
• Tiene acceso al hostname:5000 de hostname:5000 (verifique firewalls, topología de red, etc.)

DNS es la parte más difícil. Si tiene algún problema con él, le recomiendo que intente llegar a Identity Server por su IP expuesta en lugar de resolver el hostname de hostname .

Answer 2

Para hacer que esto funcionara, necesitaba pasar dos variables de entorno en el docker-compose.yml y configurar CORS en la instancia del servidor de identidad para que la API pudiera llamarla. La configuración de CORS está fuera del alcance de esta pregunta; esta pregunta lo cubre bien.

Docker-Componer cambios

El servidor de identidad necesita IDENTITY_ISSUER , que es el nombre que el servidor de identidad se dará a sí mismo. En este caso, he utilizado la IP del IP de la ventana acoplable y el puerto del servidor de identidad.

  mcoidentityserver:
    image: mcoidentityserver
    build:
      context: ./Mco.IdentityServer
      dockerfile: Dockerfile
    environment:
      IDENTITY_ISSUER: "http://10.0.75.1:5000"
    ports:
       - 5000:5000
    networks:
     - mconetwork

La API necesita saber dónde está la autoridad. Podemos usar el nombre de la red de la ventana acoplable para la autoridad porque la llamada no necesita salir de la red de la ventana acoplable, la API solo está llamando al servidor de identidad para verificar el token.

  mcoapi:
    image: mcoapi
    build:
      context: ./Mco.Api
      dockerfile: Dockerfile
    environment:
      IDENTITY_AUTHORITY: "http://mcoidentityserver:5000"
    ports:
       - 56107:80
    links:
     - mcodatabase
     - mcoidentityserver
    depends_on:
     - "mcodatabase"
     - "mcoidentityserver"
    networks:
     - mconetwork

Usando estos valores en C #

Identity Server.cs

Establece el nombre del Emisor de Identidad en ConfigureServices :

    public void ConfigureServices(IServiceCollection services)
    {
        var sqlConnectionString = Configuration.GetConnectionString("DefaultConnection");

        services
            .AddSingleton(Configuration)
            .AddMcoCore(sqlConnectionString)
            .AddIdentityServer(x => x.IssuerUri = Configuration["IDENTITY_ISSUER"])
            .AddTemporarySigningCredential()
            .AddInMemoryApiResources(Config.GetApiResources())
            .AddInMemoryClients(Config.GetClients())
            .AddCorsPolicyService<InMemoryCorsPolicyService>()
            .AddAspNetIdentity<User>();
    }

API Startup.cs

Ahora podemos establecer la Autoridad a la variable de entorno.

app.UseIdentityServerAuthentication(new IdentityServerAuthenticationOptions
    {
        Authority = Configuration["IDENTITY_AUTHORITY"],
        RequireHttpsMetadata = false,
        ApiName = "api1"
    });

Inconvenientes

Como se muestra aquí, la compilación de la ventana acoplable no sería adecuada para la producción, ya que el emisor de identidad codificado es una IP local. En su lugar, necesitaría una entrada de DNS adecuada que se asignaría a la instancia de la ventana acoplable con el servidor de identidad ejecutándose en ella. Para hacer esto, crearía un archivo de reemplazo de compilación acoplable y compilaría la producción con el valor reemplazado.

Gracias a por su ayuda.

Editar

Además de esto, escribí el proceso completo de construcción de una ventana acoplable Linux + ASP.NET Core 2 + OAuth con Identity Server en mi blog.