Comment spécifier le port sur lequel une application ASP.NET Core est hébergée?

198

Lors de l'utilisation WebHostBuilderdans unMain point d'entrée, comment puis-je spécifier le port auquel il se lie?

Par défaut, il utilise 5000.

Notez que cette question est spécifique à la nouvelle API ASP.NET Core (actuellement en 1.0.0-RC2).

Drew Noakes
la source
10
examiner à launchSettings.jsonpartir du Propertiesdossier. Vous pouvez changer le port dans le launchUrl.
Oleg
@Oleg, il me restait quelques paramètres liés à IIS à partir du modèle de projet de RC1. Ils n'ont eu aucun effet.
Drew Noakes
On peut utiliser hosting.json(voir la réponse ), qui ont été utilisés par défaut dans RC1 et il suffit d'ajouter .AddJsonFile("hosting.json", optional: true)(voir ici )
Oleg
1
L'utilisation de la pile de configuration semble en effet bien meilleure que de s'appuyer sur un mécanisme purement spécifique à VS (launchSettings.json).
Chalet Kévin
@DrewNoakes: J'ai ajouté mon ancienne réponse avec la partie MISE À JOUR 2 . Il décrit une variante de la modification du port par défaut et de l'utilisation de hosting.jsonou de la ligne de commande pour configurer la liaison.
Oleg

Réponses:

247

Dans ASP.NET Core 3.1, il existe 4 façons principales de spécifier un port personnalisé:

  • À l'aide d'arguments de ligne de commande, en démarrant votre application .NET avec --urls=[url]:
dotnet run --urls=http://localhost:5001/
  • Utilisation appsettings.json, en ajoutant un Urlsnœud:
{
  "Urls": "http://localhost:5001"
}
  • Utilisation de variables d'environnement, avec ASPNETCORE_URLS=http://localhost:5001/.
  • En utilisant UseUrls(), si vous préférez le faire par programme:
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/");
            });
}

Ou, si vous utilisez toujours le générateur d'hôte Web au lieu du générateur d'hôte générique:

public class Program
{
    public static void Main(string[] args) =>
        new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseUrls("http://localhost:5001/")
            .Build()
            .Run();
}
Chalet Kévin
la source
40
L'utilisation d'URL fixes directement dans le code n'est pas à mon avis le meilleur choix.
Oleg
3
Testé cela et cela fonctionne bien, merci. @Oleg, pourriez-vous étoffer une réponse montrant de quelle configuration vous avez besoin? Il pourrait être bon de l'avoir dans un fichier de configuration.
Drew Noakes
4
@Oleg peut-être, mais utiliser UseUrlsest l'approche recommandée par l'équipe ASP.NET pour les scénarios d'auto-hébergement (la valeur elle-même n'a pas à être codée en dur, évidemment). Cela dit, j'ai mis à jour ma réponse pour mentionner comment vous pouvez le faire en utilisant le générateur de configuration.
Chalet Kévin
1
@Pinpoint: J'ai posté l'ancienne réponse , où l'on peut trouver comment changer le port en utilisant hosting.json. La seule chose à faire est de forcer la lecture des informations dans RC2 (voir l'annonce ).
Oleg
2
Vous aurez besoin du package suivant:using Microsoft.Extensions.Configuration.CommandLine;
Apprenant
89

Vous pouvez insérer la section Kestrel dans le fichier appsettings.json asp.net core 2.1+.

  "Kestrel": {
    "EndPoints": {
      "Http": {
        "Url": "http://0.0.0.0:5002"
      }
    }
  },
menxin
la source
3
Merci, juste ce dont j'avais besoin :-) Mieux que UseUrls (). Plus de détails: docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/…
KTCO
7
CECI fonctionne en fait avec les binaires générés via dotnet publish.
rsenna le
N'est-ce pas définir le port que Kestrel est lié à IIS (proxy) plutôt qu'au port sur lequel l'application est hébergée dans IIS?
user12345
@ user12345 Dans l'hébergement IIS, Kestrel utilise la liaison de port dynamique.
menxin le
1
fonctionne également avec netcore 3.0 exécutant l'api Web d'exe, brillant !!!
vidriduch
58

Réponse de suivi pour aider quiconque à faire cela avec l'intégration de VS docker. J'avais besoin de passer au port 8080 pour fonctionner en utilisant l'environnement «flexible» dans google appengine.

Vous aurez besoin des éléments suivants dans votre Dockerfile:

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

et vous devrez également modifier le port dans docker-compose.yml:

    ports:
      - "8080"
Casey
la source
3
Merci, nous pouvons définir les variables dans l'invite de commande Windows de la même manière: set ASPNETCORE_URLS = http: // *: 8080
Pavel Biryukov
1
cela ne fonctionne pas pour moi. êtes-vous sûr que c'est tout ce que vous avez modifié? Avez-vous eu besoin de faire quelque chose de spécial pour votre image postérieure ou quoi que ce soit avec docker?
Steve
Cela fait si longtemps que cela a peut-être changé, mais si je me souviens bien, c'était tout ce que j'avais à faire.
Casey
dans VS Code, vous pouvez ajouter que "ASPNETCORE_URLS": "http: // +: 8080" sur la section "env" de launch.json, pour remplacer d'autres paramètres.
gorlok
31

Une solution alternative consiste à utiliser un hosting.jsonà la racine du projet.

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

Et puis dans 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();
}
Dennis
la source
7
Cela n'a pas fonctionné pour moi. server.urls est maintenant des URL et assurez-vous d'ajouter l'entrée à project.json "publishOptions": {"include": ["appsettings.json", "web.config", "wwwroot", "accommodation.json"]},
Manish Jain
3
J'ai mis à jour sa réponse avec la bonne propriété urls- merci @ManishJain
TetraDev
30

Vous pouvez spécifier l'URL d'hébergement sans aucune modification de votre application.

Créez un Properties/launchSettings.jsonfichier dans le répertoire de votre projet et remplissez-le avec quelque chose comme ceci:

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

dotnet runLa commande devrait choisir votre launchSettings.jsonfichier et l'affichera dans la console:

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. 

Plus de détails: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Aléatoire
la source
1
Vous travaillez également dans appSettings.json?
Paulo
Non, il doit y en avoir [ProjectRoot]/Properties/launchSettings.json, mais la belle chose est que cela fonctionne sans accroc.
Chaim Eliyah
5
Ceci n'est utile que pendant le développement, ne fonctionne pas avec les binaires. pour pouvoir l'utiliser, dotnet runvous devez accéder au code source.
rsenna le
18

Si vous utilisez dotnet run

dotnet run --urls="http://localhost:5001"
jabu.hlong
la source
La réponse parfaite! Fonctionne dans docker. Remplacement de "localhost" uniquement par "0.0.0.0"
AndrewPt
17

Au-dessus de .net core 2.2, la méthode Main support args avec 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>();
}

Vous pouvez créer votre projet et binexécuter une commande comme celle-ci

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

ou avec multi-urls

dotnet <yours>.dll --urls="http://localhost:5001,https://localhost:5002"
oudi
la source
vous pouvez simplement utiliser 'dotnet run --urls = 0.0.0.0:5001 ' dans le répertoire du projet
oudi
12

Lorsqu'il est hébergé dans des conteneurs docker (version linux pour moi), vous pouvez recevoir un message «Connexion refusée». Dans ce cas, vous pouvez utiliser l'adresse IP 0.0.0.0 qui signifie "toutes les adresses IP sur cette machine" au lieu du bouclage localhost pour corriger la redirection de port.

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();
    }
}
R. van Diesen
la source
5

Vous pouvez également spécifier le port en exécutant l'application via la ligne de commande.

Exécutez simplement la commande:

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

Remarque: où 5001 est le port sur lequel vous souhaitez exécuter.

Mwiza
la source
5

Sur .Net Core 3.1, suivez simplement Microsoft Doc pour dire que c'est assez simple: kestrel-aspnetcore-3.1

Résumer:

  1. Ajoutez la section ConfigureServices ci-dessous à CreateDefaultBuilder sur 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. Ajoutez la configuration de base ci-dessous au appsettings.jsonfichier (plus d'options de configuration sur l'article Microsoft):

    "Kestrel": {
        "EndPoints": {
            "Http": {
                "Url": "http://0.0.0.0:5002"
            }
        }
    }
  3. Ouvrez CMD ou Console sur votre dossier de projet Publish / Debug / Release binaires et exécutez:

    dotnet YourProject.dll
  4. Profitez de l'exploration de votre site / API sur votre http: // localhost: 5002

Ernest
la source
3

Accédez à properties / launchSettings.json et recherchez votre nom d'application et sous celui-ci, recherchez applicationUrl. vous verrez, il exécute localhost: 5000, changez-le en ce que vous voulez. puis lancez dotnet run ...... hourra

Md. Rafee
la source
0

J'ai résolu le problème de port dans Net core 3.1 en utilisant ce qui suit

Dans le 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>(); });
}

Vous pouvez accéder à l'application en utilisant

http://localhost:4000

https://localhost:4001
Sukesh Chand
la source