web-dev-qa-db-fra.com

Comment accéder aux variables de serveur dans ASP.Net Core 2.x

J'utilise l'application web ASP.Net core 2.0 et elle est déployée sur Azure. Ce que je dois faire, c'est obtenir l'adresse IP du client. Pour cela, je fais des recherches partout sur Internet et j'ai constaté que les variables du serveur m'aident à ce sujet.

J'ai donc trouvé ce code depuis ici pour obtenir l'adresse IP du client en utilisant:

string IpAddress = this.Request.ServerVariables["REMOTE_ADDR"];

Mais lorsque j'essaie le code ci-dessus, il me montre une erreur "HttpRequest ne contient pas de définition pour les variables de serveur"

J'ai aussi essayé ce code:

var ip0 = HttpContext.Features.Get<IHttpConnectionFeature>()?.RemoteIpAddress;

Définition du code

RemoteIpAddress L'adresse IP du client effectuant la demande. Notez que cela peut être pour un proxy plutôt que pour l'utilisateur final.

Le code ci-dessus obtient l'adresse IP mais ce n'est pas un clientip et chaque fois que j'accède au code ci-dessus via le contrôleur, il rafraîchit l'IP. Il s'agit peut-être d'un proxy de service Web Azure qui fait à chaque fois une demande get.

Quelle est la bonne façon d'accéder aux variables de serveur dans ASP.Net Core 2.x?

c#asp.netasp.net-core
6
Ahmer Ali Ahsan

Vous pouvez utiliser HttpContext.Connection pour obtenir des informations sur la connexion (IP, etc.)

https://docs.Microsoft.com/en-us/dotnet/api/Microsoft.aspnetcore.http.httpcontext.connection?view=aspnetcore-2.1

https://docs.Microsoft.com/en-us/dotnet/api/Microsoft.aspnetcore.http.connectioninfo.remoteipaddress?view=aspnetcore-2.1#Microsoft_AspNetCore_Http_ConnectionInfo_RemoteIpAddress

2
davidfowl

J'ai trouvé le lien de référence Mark G très utile.

J'ai configuré le middleware avec ForwardedHeadersOptions pour transférer les en-têtes X-Forwarded-For et X-Forwarded-Proto dans Startup.ConfigureServices.

Voici mon fichier de code startup.cs :

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
           options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

    services.AddIdentityServer()
            .AddDeveloperSigningCredential()
            .AddInMemoryPersistedGrants()
            .AddInMemoryIdentityResources(Config.GetIdentityResources())
            .AddInMemoryApiResources(Config.GetApiResources())
            .AddInMemoryClients(Config.GetClients())
            .AddAspNetIdentity<ApplicationUser>();

    services.AddCors(options =>
    {
        options.AddPolicy("AllowClient",
                   builder => builder.WithOrigins("http://**.asyncsol.com", "http://*.asyncsol.com", "http://localhost:10761", "https://localhost:44335")
                                  .AllowAnyHeader()
                                  .AllowAnyMethod());
        });

        services.AddMvc();
        services.Configure<ForwardedHeadersOptions>(options =>
        {
            options.ForwardedHeaders =
                ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
        });

        services.AddAuthentication(options =>
        {
            options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        })
        .AddJwtBearer(options =>
        {
            // base-address of your identityserver
            //options.Authority = "http://server.asyncsol.com/";
            options.Authority = "http://localhost:52718/";

            // name of the API resource
            options.Audience = "api1";

            options.RequireHttpsMetadata = false;
        });
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        app.UseForwardedHeaders();
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseIdentityServer();
        app.UseAuthentication();
        app.UseCors("AllowAll");
        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "areas",
                template: "{area:exists}/{controller=Home}/{action=Index}/{id?}"
            );
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");
        });
    }

Maintenant, après cela, j'ai mis le code ci-dessous dans mon contrôleur:

public IEnumerable<string> Get()
{
    string ip = Response.HttpContext.Connection.RemoteIpAddress.ToString();

    //https://en.wikipedia.org/wiki/Localhost
    //127.0.0.1    localhost
    //::1          localhost
    if (ip == "::1")
    {
        ip = Dns.GetHostEntry(Dns.GetHostName()).AddressList[2].ToString();
    }

    return new string[] { ip.ToString() };
 }

Donc, si j'exécute sur mon environnement localhost, il affiche mon adresse IP du système IPv4 et si j'exécute mon serveur sur Azure, il affiche mon nom d'hôte/adresse IP.

Conclusion:

J'ai trouvé ma réponse dans le commentaire de Mark G Middleware d'en-têtes transférés

2
Ahmer Ali Ahsan