web-dev-qa-db-fra.com

Comment faire en sorte que le serveur Web de Kestrel écoute les requêtes non locales?

J'ai déployé mon application c #, asp.net 5, mvc 6 sur un serveur Windows 2008. J'ai lancé dnx web et il écoute le port 5000 et fonctionne correctement lors de l'accès à partir d'un ordinateur local.

Comment puis-je l'obtenir pour écouter des demandes non locales?

P.S. Cette question n'est pas une copie de cela ... il fait référence à asp.net pre RC1 lorsque hosting.ini avait en fait un format .ini. Maintenant, il s’agit de JSON et je ne trouve aucune documentation sur ce qu’elle devrait contenir.

P.P.S. La vraie solution est dans le non-accepté réponse à la question liée, avec une mise en garde massive. Pas:

  1. Changez votre fichier project.json en fonction de la réponse liée.
  2. Publiez votre projet sur votre serveur.
  3. Sur le serveur, accédez au dossier ...\approot\src\YourProject et ouvrez une fenêtre de commande à cet emplacement.
  4. Exécutez dnx web - il échouera
  5. Exécuter dnu restore
  6. Exécutez 'dnu build`
  7. Exécutez 'dnx web` - le serveur Web devrait maintenant démarrer correctement
c#asp.netasp.net-corednxkestrel-http-server
69
AngryHacker

Le fichier de configuration par défaut utilisé par le serveur Kestrel est hosting.json. Le nom a été changé plusieurs fois dans différentes versions bêta. Si vous utilisez maintenant project.json avec la section suivante "command"

"commands": {
    "web": "Microsoft.AspNet.Server.Kestrel"
}

puis lors du démarrage du serveur à partir de la ligne de commande en

dnx web

le fichier hosting.json sera lu. Le fichier

{
    "server.urls": "http://0.0.0.0:5000"
}

va configurer le serveur pour écouter 5000 sur chaque adresse IP4. La configuration

{
    "server.urls": "http://::5000;http://0.0.0.0:5000"
}

informera d’écouter 5000 adresses IP4 et IP6.

On peut spécifier d'autres fichiers de configuration en utilisant la variable d'environnement ASPNET_ENV ou en utilisant --config myconfig1.json (ou config=myconfig1.json). Par exemple, vous pouvez utiliser

SET ASPNET_ENV=Development

et créer le fichier hosting.Development.json avec une configuration spécifique. Vous pouvez également utiliser project.json avec

"commands": {
    "web": "Microsoft.AspNet.Server.Kestrel"
    "webProd": "Microsoft.AspNet.Server.Kestrel --config prod.json"
}

et démarrez le serveur par usage

dnx webProd

Je dois également rappeler qu'il peut être nécessaire d'autoriser l'écoute et l'enregistrement (pour démarrer dnx web). Cela est nécessaire en raison du pare-feu et de la sécurité locale d'écoute des nouveaux ports TCP/HTTP. Quelque chose comme ci-dessous devrait rendre l'enregistrement et l'écoute locaux du port 5000 pour tout le monde (IPv4 et IPv6):

netsh http add iplisten ipaddress=0.0.0.0:5000
netsh http add iplisten ipaddress=::5000
netsh http add urlacl url=http://+:5000/ user=\Everyone

Pour plus de sécurité, vous pouvez ajuster la configuration ci-dessus afin d’accorder des droits minimaux.

MIS À JOUR: Merci @BlaneBunderson. On peut utiliser * à la place de l'adresse IP (comme http://*:5000) pour écouter toutes les adresses IP4 et IP6 à partir de n'importe quelle interface. Il faut être prudent et ne pas utiliser http://*:5000;http://::5000, http://::5000;http://*:5000, http://*:5000;http://0.0.0.0:5000 ou http://*:5000;http://0.0.0.0:5000 car il faudra enregistrer l'adresse IP6 :: ou l'adresse IP4 0.0.0.0 deux fois .

Correspond à l'annonce

Techniquement, tout nom d'hôte qui n'est pas "localhost" ou une adresse IPv4 ou IPv6 valide entraînera la liaison de Kestrel à toutes les interfaces réseau.

Je pense que le comportement pourrait être changé à l'avenir. Ainsi, je recommanderais d'utiliser uniquement les formulaires *:5000, 0.0.0.0:5000 et ::5000 pour l'enregistrement de toute adresse informatique.

UPDATED 2: ASP.NET Core RC2 modifie (voir l'annonce ) le comportement du chargement des valeurs par défaut. Il faut modifier la variable Main pour charger les paramètres de hosting.json et les paramètres de la ligne de commande. Ci-dessous un exemple d'utilisation

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

    var Host = new WebHostBuilder()
        .UseUrls("http://*:1000", "https://*:1234", "http://0.0.0.0:5000")
        .UseEnvironment("Development")
        .UseConfiguration(config)
        .UseKestrel()
        .UseContentRoot(Directory.GetCurrentDirectory())
        .UseIISIntegration()
        .UseStartup<Startup>()
        .Build();

    Host.Run();
}

Le code ci-dessus utilise trois liaisons: "http://*:1000", "https://*:1234", "http://0.0.0.0:5000" par défaut au lieu d'utiliser le port par défaut 5000 par défaut (pour utiliser exactement http://localhost:5000). Les appels de .UseConfiguration(config) sont effectués après .UseUrls. Ainsi, la configuration chargée à partir de hosting.json ou la ligne de commande remplace les options par défaut. Si vous supprimez une ligne .SetBasePath(Directory.GetCurrentDirectory()), le hosting.json sera chargé à partir du même répertoire que celui où la DLL d'application sera compilée (par exemple bin\Debug\netcoreapp1.0).

On peut utiliser l'exécution comme

dotnet.exe run --server.urls=http://0.0.0.0:5000

pour écraser les paramètres par défaut (de UseUrls) et ceux de "server.urls", propriété de hosting.json s’il existe.

De la même manière, on pourrait écraser les paramètres ULR en définissant la variable d'environnement

set ASPNETCORE_SERVER.URLS=http://localhost:12541/

alors le démarrage par défaut de l'application utilisant dotnet.exe run utilisera http://localhost:12541/ pour la liaison.

Vous pouvez trouver ici un exemple d'utilisation de la liaison HTTPS.

98
Oleg

Dans RC2, la section des commandes de project.json n'est plus utilisée. Je n'ai pas encore demandé à Kestrel de prendre hosting.json, mais vous pouvez définir le port par programme dans le menu principal de l'application où le nouveau WebHostBuilder est créé et configuré. Ajoutez simplement la méthode .UseUrls () comme dans l'exemple ci-dessous

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

        Host.Run();
    }
30
Trygve

Si vous essayez de placer une application ASP.NET Core dans un conteneur Docker (ce qui était mon cas d'utilisation pour avoir besoin d'écouter des adresses non-hôte local), notez que ce cas d'utilisation a déjà été mis en place pour vous par Microsoft. Vous pouvez voir toute la gloire sur https://hub.docker.com/r/Microsoft/aspnetcore/

À la version actuelle (v1.0.1), la solution miracle pour résoudre ce problème est que le fichier Dockerfile source contient un paramètre de variable d'environnement url et que l'application ne tente pas de le remplacer. (En effet, une application conteneurisée doit en interne indiquer le moins possible l’environnement dans lequel elle sera exécutée.)

ENV ASPNETCORE_URLS http://+:80

Notez le signe plus plutôt que l'astérisque. En fait, je recommande de visiter le lien ci-dessus sur dockerhub plutôt que de lire ma réponse tant que le lien est bon. La version 1.1 est proche, et les choses pourraient changer à nouveau.

Lors de l'exécution du conteneur, veillez à exposer le port d'invité 80, conformément au paramètre de variable d'environnement. Par exemple:

docker run -d -p 8000:80 myapp
curl localhost:8000
6
GrandOpener

Si vous utilisez asp.net core 2.1 +, modifiez la section de configuration dans appsettings.json.

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

},

1
menxin