¿Cómo especificar el puerto en el que está alojada una aplicación ASP.NET Core?

Cuando se usa WebHostBuilderen un Mainpunto de entrada, ¿cómo puedo especificar el puerto al que se une?

Por defecto usa 5000.

Tenga en cuenta que esta pregunta es específica de la nueva API ASP.NET Core (actualmente en 1.0.0-RC2).

En ASP.NET Core 3.1, hay 4 formas principales de especificar un puerto personalizado:

• Usando argumentos de línea de comando, iniciando su aplicación .NET con --urls=[url]:

dotnet run --urls=http://localhost:5001/

• Usando appsettings.json, agregando un Urlsnodo:

{
  "Urls": "http://localhost:5001"
}

• Utilizando variables de entorno, con ASPNETCORE_URLS=http://localhost:5001/.
• Usando UseUrls(), si prefieres hacerlo programáticamente:

public static class Program
{
    public static void Main(string[] args) =>
        CreateHostBuilder(args).Build().Run();

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

O, si todavía está utilizando el generador de host web en lugar del generador de host genérico:

public class Program
{
    public static void Main(string[] args) =>
        new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseUrls("http://localhost:5001/")
            .Build()
            .Run();
}

Puede insertar la sección Kestrel en el archivo asp.net core 2.1+ appsettings.json.

  "Kestrel": {
    "EndPoints": {
      "Http": {
        "Url": "http://0.0.0.0:5002"
      }
    }
  },

Respuesta de seguimiento para ayudar a cualquiera que haga esto con la integración de VS Docker. Necesitaba cambiar al puerto 8080 para ejecutar usando el entorno "flexible" en google appengine.

Necesitará lo siguiente en su Dockerfile:

ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080

y también necesitarás modificar el puerto en docker-compose.yml:

    ports:
      - "8080"

La solución alternativa es usar a hosting.jsonen la raíz del proyecto.

{
  "urls": "http://localhost:60000"
}

Y luego en Program.cs

public static void Main(string[] args)
{
    var config = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("hosting.json", true)
        .Build();

    var host = new WebHostBuilder()
        .UseKestrel(options => options.AddServerHeader = false)
        .UseConfiguration(config)
        .UseContentRoot(Directory.GetCurrentDirectory())
        .UseIISIntegration()
        .UseStartup<Startup>()
        .Build();

    host.Run();
}

Puede especificar la URL de alojamiento sin ningún cambio en su aplicación.

Cree un Properties/launchSettings.jsonarchivo en el directorio de su proyecto y complételo con algo como esto:

{
  "profiles": {
    "MyApp1-Dev": {
        "commandName": "Project",
        "environmentVariables": {
            "ASPNETCORE_ENVIRONMENT": "Development"
        },
        "applicationUrl": "http://localhost:5001/"
    }
  }
}

dotnet runEl comando debe elegir su launchSettings.jsonarchivo y lo mostrará en la consola:

C:\ProjectPath [master ≡]
λ  dotnet run
Using launch settings from C:\ProjectPath\Properties\launchSettings.json...
Hosting environment: Development
Content root path: C:\ProjectPath
Now listening on: http://localhost:5001
Application started. Press Ctrl+C to shut down. 

Más detalles: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Si usa dotnet run

dotnet run --urls="http://localhost:5001"

Por encima de .net core 2.2, el método Main support args with WebHost.CreateDefaultBuilder (args)

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

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>();
}

Puedes construir tu proyecto e ir a binejecutar comandos como este

dotnet <yours>.dll --urls=http://localhost:5001

o con múltiples URL

dotnet <yours>.dll --urls="http://localhost:5001,https://localhost:5002"

Cuando se aloja en contenedores de Docker (versión de Linux para mí), es posible que reciba un mensaje de "Conexión rechazada". En ese caso, puede usar la dirección IP 0.0.0.0 que significa "todas las direcciones IP en esta máquina" en lugar del bucle de retorno localhost para arreglar el reenvío de puertos.

public class Program
{
    public static void Main(string[] args)
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseUrls("http://0.0.0.0:5000/")
            .Build();

        host.Run();
    }
}

Alternativamente, puede especificar el puerto ejecutando la aplicación a través de la línea de comandos.

Simplemente ejecute el comando:

dotnet run --server.urls http://localhost:5001

Nota: Donde 5001 es el puerto en el que desea ejecutar.

En .Net Core 3.1 simplemente siga a Microsoft Doc que es bastante simple: kestrel-aspnetcore-3.1

Para resumir:

1. Agregue la siguiente sección ConfigureServices a CreateDefaultBuilder en Program.cs:

   // using Microsoft.Extensions.DependencyInjection;
   
   public static IHostBuilder CreateHostBuilder(string[] args) =>
       Host.CreateDefaultBuilder(args)
           .ConfigureServices((context, services) =>
           {
               services.Configure<KestrelServerOptions>(
                   context.Configuration.GetSection("Kestrel"));
           })
           .ConfigureWebHostDefaults(webBuilder =>
           {
               webBuilder.UseStartup<Startup>();
           });

2. Agregue la siguiente configuración básica al appsettings.jsonarchivo (más opciones de configuración en el artículo de Microsoft):

   "Kestrel": {
       "EndPoints": {
           "Http": {
               "Url": "http://0.0.0.0:5002"
           }
       }
   }

3. Abra CMD o la consola en la carpeta de binarios de publicación / depuración / publicación de su proyecto y ejecute:

   dotnet YourProject.dll

4. Disfrute explorando su sitio / api en su http: // localhost: 5002

Vaya a properties / launchSettings.json y encuentre su nombre de aplicación y debajo de esto, encuentre applicationUrl. verá que está ejecutando localhost: 5000, cámbielo a lo que quiera. y luego ejecuta dotnet run ...... hurra

Solucioné el problema del puerto en Net core 3.1 usando lo siguiente

En el Program.cs

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

    public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args)
        .ConfigureWebHost(x => x.UseUrls("https://localhost:4000", "http://localhost:4001"))
        .ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup<Startup>(); });
}

Puede acceder a la aplicación usando

http://localhost:4000

https://localhost:4001