Hosting di ASP.NET Core in Linux con NginxHost ASP.NET Core on Linux with Nginx

Di Sourabh ShirhattiBy Sourabh Shirhatti

Questa guida descrive come configurare un ambiente ASP.NET Core pronto per la produzione in un server Ubuntu 16.04.This guide explains setting up a production-ready ASP.NET Core environment on an Ubuntu 16.04 server. Queste istruzioni si applicano probabilmente anche alle versioni più recenti di Ubuntu, sebbene non siano state testate con le versioni più recenti.These instructions likely work with newer versions of Ubuntu, but the instructions haven't been tested with newer versions.

Per informazioni su altre distribuzioni Linux supportate da ASP.NET Core, vedere Prerequisiti per .NET Core in Linux.For information on other Linux distributions supported by ASP.NET Core, see Prerequisites for .NET Core on Linux.

Nota

Per Ubuntu 14.04, è consigliabile supervisord come soluzione per il monitoraggio del processo Kestrel.For Ubuntu 14.04, supervisord is recommended as a solution for monitoring the Kestrel process. systemd non è disponibile in Ubuntu 14.04.systemd isn't available on Ubuntu 14.04. Per le istruzioni per Ubuntu 14.04, vedere la versione precedente di questo argomento.For Ubuntu 14.04 instructions, see the previous version of this topic.

In questa guida:This guide:

  • Posizionare un'app ASP.NET Core esistente dietro un server proxy inverso.Places an existing ASP.NET Core app behind a reverse proxy server.
  • Configurare il server proxy inverso per l'inoltro delle richieste al server Web Kestrel.Sets up the reverse proxy server to forward requests to the Kestrel web server.
  • Verificare che l'app Web venga eseguita all'avvio come daemon.Ensures the web app runs on startup as a daemon.
  • Configurare uno strumento di gestione del processo per consentire il riavvio dell'app Web.Configures a process management tool to help restart the web app.

PrerequisitesPrerequisites

  1. Accedere a un server Ubuntu 16.04 con un account utente standard con privilegio sudo.Access to an Ubuntu 16.04 server with a standard user account with sudo privilege.
  2. Installare il runtime .NET Core nel server.Install the .NET Core runtime on the server.
    1. Visitare la pagina di tutti i download per .NET Core.Visit the .NET Core All Downloads page.
    2. Selezionare il runtime non di anteprima più recente nell'elenco Runtime.Select the latest non-preview runtime from the list under Runtime.
    3. Selezionare e seguire le istruzioni per Ubuntu relative alla versione di Ubuntu del server.Select and follow the instructions for Ubuntu that match the Ubuntu version of the server.
  3. Un'app ASP.NET Core esistente.An existing ASP.NET Core app.

Pubblicare e copiare l'appPublish and copy over the app

Configurare l'app per una distribuzione dipendente dal framework.Configure the app for a framework-dependent deployment.

Se l'app viene eseguita in locale e non è configurata per connessioni sicure (HTTPS), adottare uno degli approcci seguenti:If the app is run locally and isn't configured to make secure connections (HTTPS), adopt either of the following approaches:

  • Configurare l'app per la gestione di connessioni locali sicure.Configure the app to handle secure local connections. Per altre informazioni, vedere la sezione Configurazione HTTPS.For more information, see the HTTPS configuration section.
  • Rimuovere https://localhost:5001 (se presente) dalla proprietà applicationUrl nel file Properties/launchSettings.json.Remove https://localhost:5001 (if present) from the applicationUrl property in the Properties/launchSettings.json file.

Eseguire dotnet publish dall'ambiente di sviluppo per creare il pacchetto di un'app in una directory (ad esempio, bin/Release/<target_framework_moniker>/publish) che può essere eseguita nel server:Run dotnet publish from the development environment to package an app into a directory (for example, bin/Release/<target_framework_moniker>/publish) that can run on the server:

dotnet publish --configuration Release

È anche possibile pubblicare l'app come distribuzione completa se si preferisce non mantenere il runtime .NET Core nel server.The app can also be published as a self-contained deployment if you prefer not to maintain the .NET Core runtime on the server.

Copiare l'app ASP.NET Core sul server usando uno strumento integrato nel flusso di lavoro dell'organizzazione, ad esempio SCP o FTP.Copy the ASP.NET Core app to the server using a tool that integrates into the organization's workflow (for example, SCP, SFTP). Le app Web si trovano in genere nella directory var, ad esempio, var/www/helloapp.It's common to locate web apps under the var directory (for example, var/www/helloapp).

Nota

In uno scenario di distribuzione di produzione un flusso di lavoro di integrazione continua esegue le operazioni di pubblicazione dell'app e di copia degli asset nel server.Under a production deployment scenario, a continuous integration workflow does the work of publishing the app and copying the assets to the server.

Eseguire il test dell'app:Test the app:

  1. Dalla riga di comando, eseguire l'app: dotnet <app_assembly>.dll.From the command line, run the app: dotnet <app_assembly>.dll.
  2. In un browser passare a http://<serveraddress>:<port> per verificare se l'app funziona in Linux in locale.In a browser, navigate to http://<serveraddress>:<port> to verify the app works on Linux locally.

Configurare un server proxy inversoConfigure a reverse proxy server

Un proxy inverso è una configurazione comune per la gestione delle app Web dinamiche.A reverse proxy is a common setup for serving dynamic web apps. Un proxy inverso termina la richiesta HTTP e la inoltra all'app ASP.NET Core.A reverse proxy terminates the HTTP request and forwards it to the ASP.NET Core app.

Usare un server proxy inversoUse a reverse proxy server

Kestrel funziona perfettamente per la gestione del contenuto dinamico da ASP.NET Core.Kestrel is great for serving dynamic content from ASP.NET Core. Tuttavia, le funzionalità di gestione Web sono meno avanzate rispetto a quelle offerte da server come IIS, Apache o Nginx.However, the web serving capabilities aren't as feature rich as servers such as IIS, Apache, or Nginx. Un server proxy inverso è in grado di eseguire l'offload di attività come la gestione del contenuto statico, la memorizzazione nella cache delle richieste, la compressione delle richieste e la terminazione HTTPS dal server HTTP.A reverse proxy server can offload work such as serving static content, caching requests, compressing requests, and HTTPS termination from the HTTP server. Un server proxy inverso può risiedere in un computer dedicato o essere distribuito insieme a un server HTTP.A reverse proxy server may reside on a dedicated machine or may be deployed alongside an HTTP server.

Ai fini di questa guida viene usata una singola istanza di Nginx.For the purposes of this guide, a single instance of Nginx is used. Viene eseguito sullo stesso server, insieme al server HTTP.It runs on the same server, alongside the HTTP server. In base ai requisiti, è possibile scegliere una configurazione diversa.Based on requirements, a different setup may be chosen.

Poiché le richieste vengono inoltrate dal proxy inverso, usare il middleware delle intestazioni inoltrate dal pacchetto Microsoft.AspNetCore.HttpOverrides.Because requests are forwarded by reverse proxy, use the Forwarded Headers Middleware from the Microsoft.AspNetCore.HttpOverrides package. Il middleware aggiorna Request.Scheme usando l'intestazione X-Forwarded-Proto, in modo che gli URI di reindirizzamento e altri criteri di sicurezza funzionino correttamente.The middleware updates the Request.Scheme, using the X-Forwarded-Proto header, so that redirect URIs and other security policies work correctly.

Qualsiasi componente che dipende dallo schema, ad esempio l'autenticazione, la generazione di collegamenti, i reindirizzamenti e la georilevazione, deve essere inserito dopo aver richiamato il middleware delle intestazioni inoltrate.Any component that depends on the scheme, such as authentication, link generation, redirects, and geolocation, must be placed after invoking the Forwarded Headers Middleware. Come regola generale,il middleware delle intestazioni inoltrate deve essere eseguito prima degli altri middleware, ad eccezione del middleware di diagnostica e gestione degli errori.As a general rule, Forwarded Headers Middleware should run before other middleware except diagnostics and error handling middleware. Questo ordine garantisce che il middleware basato sulle intestazioni inoltrate possa usare i valori di intestazione per l'elaborazione.This ordering ensures that the middleware relying on forwarded headers information can consume the header values for processing.

Richiamare il metodo UseForwardedHeaders in Startup.Configure prima di chiamare UseAuthentication o un middleware con schema di autenticazione simile.Invoke the UseForwardedHeaders method in Startup.Configure before calling UseAuthentication or similar authentication scheme middleware. Configurare il middleware per l'inoltro delle intestazioni X-Forwarded-For e X-Forwarded-Proto:Configure the middleware to forward the X-Forwarded-For and X-Forwarded-Proto headers:

app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});

app.UseAuthentication();

Se non vengono specificate opzioni ForwardedHeadersOptions per il middleware, le intestazioni predefinite per l'inoltro sono None.If no ForwardedHeadersOptions are specified to the middleware, the default headers to forward are None.

I proxy in esecuzione su indirizzi di loopback (127.0.0.0/8, [::1]), incluso l'indirizzo localhost standard (127.0.0.1), sono considerati attendibili per impostazione predefinita.Proxies running on loopback addresses (127.0.0.0/8, [::1]), including the standard localhost address (127.0.0.1), are trusted by default. Se le richieste tra Internet e il server Web vengono gestite anche da altri proxy o reti attendibili all'interno dell'organizzazione, aggiungerli all'elenco di KnownProxies o KnownNetworks con ForwardedHeadersOptions.If other trusted proxies or networks within the organization handle requests between the Internet and the web server, add them to the list of KnownProxies or KnownNetworks with ForwardedHeadersOptions. L'esempio seguente aggiunge un server proxy attendibile all'indirizzo IP 10.0.0.100 nel middleware delle intestazioni inoltrate KnownProxies in Startup.ConfigureServices:The following example adds a trusted proxy server at IP address 10.0.0.100 to the Forwarded Headers Middleware KnownProxies in Startup.ConfigureServices:

services.Configure<ForwardedHeadersOptions>(options =>
{
    options.KnownProxies.Add(IPAddress.Parse("10.0.0.100"));
});

Per ulteriori informazioni, vedere Configurare ASP.NET Core per l'uso di server proxy e servizi di bilanciamento del carico.For more information, see Configurare ASP.NET Core per l'uso di server proxy e servizi di bilanciamento del carico.

Installare NginxInstall Nginx

Usare apt-get per installare Nginx.Use apt-get to install Nginx. Il programma di installazione crea uno script di inizializzazione systemd che esegue Nginx come daemon all'avvio del sistema.The installer creates a systemd init script that runs Nginx as daemon on system startup. Seguire le istruzioni di installazione per Ubuntu riportate nell'articolo Nginx: Official Debian/Ubuntu packages (Nginx: pacchetti Debian/Ubuntu ufficiali).Follow the installation instructions for Ubuntu at Nginx: Official Debian/Ubuntu packages.

Nota

Se sono richiesti moduli Nginx facoltativi, potrebbe essere necessario compilare Nginx dall'origine.If optional Nginx modules are required, building Nginx from source might be required.

Poiché Nginx è stato installato per la prima volta, avviarlo in modo esplicito eseguendo:Since Nginx was installed for the first time, explicitly start it by running:

sudo service nginx start

Verificare che un browser visualizzi la pagina di destinazione predefinita per Nginx.Verify a browser displays the default landing page for Nginx. La pagina di destinazione è raggiungibile all'indirizzo http://<server_IP_address>/index.nginx-debian.html.The landing page is reachable at http://<server_IP_address>/index.nginx-debian.html.

Configurare NginxConfigure Nginx

Per configurare Nginx come proxy inverso per inoltrare le richieste all'app ASP.NET Core, modificare /etc/nginx/sites-available/default.To configure Nginx as a reverse proxy to forward requests to your ASP.NET Core app, modify /etc/nginx/sites-available/default. Aprirlo in un editor di testo e sostituire il contenuto con quanto segue:Open it in a text editor, and replace the contents with the following:

server {
    listen        80;
    server_name   example.com *.example.com;
    location / {
        proxy_pass         http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header   Upgrade $http_upgrade;
        proxy_set_header   Connection keep-alive;
        proxy_set_header   Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
    }
}

Se nessun server_name corrisponde, Nginx usa il server predefinito.When no server_name matches, Nginx uses the default server. Se non è definito alcun server predefinito, il primo server nel file di configurazione è il server predefinito.If no default server is defined, the first server in the configuration file is the default server. Come procedura consigliata, aggiungere un server predefinito specifico che restituisce un codice di stato 444 nel file di configurazione.As a best practice, add a specific default server which returns a status code of 444 in your configuration file. Un esempio di configurazione del server predefinito è il seguente:A default server configuration example is:

server {
    listen   80 default_server;
    # listen [::]:80 default_server deferred;
    return   444;
}

Con il file di configurazione precedente e il server predefinito, Nginx accetta il traffico pubblico sulla porta 80 con l'intestazione host example.com o *.example.com.With the preceding configuration file and default server, Nginx accepts public traffic on port 80 with host header example.com or *.example.com. Le richieste che non corrispondono a questi host non verranno inoltrate a Kestrel.Requests not matching these hosts won't get forwarded to Kestrel. Nginx inoltra a Kestrel le richieste corrispondenti a http://localhost:5000.Nginx forwards the matching requests to Kestrel at http://localhost:5000. Per altre informazioni, vedere How nginx processes a request (Elaborazione di una richiesta in nginx).See How nginx processes a request for more information. Per cambiare porta/IP di Kestrel, vedere Kestrel: Configurazione dell'endpoint.To change Kestrel's IP/port, see Kestrel: Endpoint configuration.

Avviso

Se non si specifica una direttiva server_name corretta, l'app può risultare esposta a vulnerabilità di sicurezza.Failure to specify a proper server_name directive exposes your app to security vulnerabilities. L'associazione con caratteri jolly del sottodominio (ad esempio, *.example.com) non costituisce un rischio per la sicurezza se viene controllato l'intero dominio padre (a differenza di *.com, che è vulnerabile).Subdomain wildcard binding (for example, *.example.com) doesn't pose this security risk if you control the entire parent domain (as opposed to *.com, which is vulnerable). Vedere la sezione 5.4 di RFC7230 per altre informazioni.See rfc7230 section-5.4 for more information.

Una volta stabilita la configurazione di Nginx, eseguire sudo nginx -t per verificare la sintassi dei file di configurazione.Once the Nginx configuration is established, run sudo nginx -t to verify the syntax of the configuration files. Se il test dei file di configurazione ha esito positivo, è possibile forzare Nginx ad applicare le modifiche eseguendo sudo nginx -s reload.If the configuration file test is successful, force Nginx to pick up the changes by running sudo nginx -s reload.

Per eseguire direttamente l'app nel server:To directly run the app on the server:

  1. Passare alla directory dell'app.Navigate to the app's directory.
  2. Eseguire l'app: dotnet <app_assembly.dll>, dove app_assembly.dll è il nome di file di assembly dell'app.Run the app: dotnet <app_assembly.dll>, where app_assembly.dll is the assembly file name of the app.

Se l'app viene eseguita nel server ma non risponde tramite Internet, controllare il firewall del server e verificare che la porta 80 sia aperta.If the app runs on the server but fails to respond over the Internet, check the server's firewall and confirm that port 80 is open. Se si usa una macchina virtuale Ubuntu di Azure, aggiungere una regola del gruppo di sicurezza di rete (NSG) che abiliti il traffico in ingresso della porta 80.If using an Azure Ubuntu VM, add a Network Security Group (NSG) rule that enables inbound port 80 traffic. Non è necessario abilitare una regola per il traffico in uscita della porta 80, poiché il traffico in uscita viene autorizzato automaticamente quando viene abilitata la regola in ingresso.There's no need to enable an outbound port 80 rule, as the outbound traffic is automatically granted when the inbound rule is enabled.

Dopo aver eseguito il test dell'app, arrestare l'app con Ctrl+C al prompt dei comandi.When done testing the app, shut the app down with Ctrl+C at the command prompt.

Monitorare l'appMonitor the app

Il server è configurato in modo da inoltrare le richieste eseguite a http://<serveraddress>:80 all'app ASP.NET Core eseguita in Kestrel all'indirizzo http://127.0.0.1:5000.The server is setup to forward requests made to http://<serveraddress>:80 on to the ASP.NET Core app running on Kestrel at http://127.0.0.1:5000. Tuttavia, Nginx non è configurato per la gestione del processo Kestrel.However, Nginx isn't set up to manage the Kestrel process. È possibile usare systemd e creare un file del servizio per avviare e monitorare l'app Web sottostante.systemd can be used to create a service file to start and monitor the underlying web app. systemd è un sistema di inizializzazione che offre molte funzionalità potenti per l'avvio, l'arresto e la gestione dei processi.systemd is an init system that provides many powerful features for starting, stopping, and managing processes.

Creare il file del servizioCreate the service file

Creare il file di definizione del servizio:Create the service definition file:

sudo nano /etc/systemd/system/kestrel-helloapp.service

Di seguito è riportato un esempio di file del servizio per l'app:The following is an example service file for the app:

[Unit]
Description=Example .NET Web API App running on Ubuntu

[Service]
WorkingDirectory=/var/www/helloapp
ExecStart=/usr/bin/dotnet /var/www/helloapp/helloapp.dll
Restart=always
# Restart service after 10 seconds if the dotnet service crashes:
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-example
User=www-data
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

Se l'utente www-data non viene usato dalla configurazione, è necessario creare prima l'utente definito qui e assegnargli correttamente la proprietà dei file.If the user www-data isn't used by the configuration, the user defined here must be created first and given proper ownership for files.

Usare TimeoutStopSec per configurare il tempo di attesa prima che l'app si arresti dopo aver ricevuto il segnale di interrupt iniziale.Use TimeoutStopSec to configure the duration of time to wait for the app to shut down after it receives the initial interrupt signal. Se l'app non si arresta in questo periodo, viene emesso il comando SIGKILL per terminare l'app.If the app doesn't shut down in this period, SIGKILL is issued to terminate the app. Specificare il valore in secondi senza unità di misura (ad esempio, 150), un valore per l'intervallo di tempo (ad esempio, 2min 30s) o infinity per disabilitare il timeout.Provide the value as unitless seconds (for example, 150), a time span value (for example, 2min 30s), or infinity to disable the timeout. Per impostazione predefinita, il valore di TimeoutStopSec viene impostato sul valore di DefaultTimeoutStopSec nel file di configurazione del sistema di gestione (systemd-system.conf, system.conf.d, systemd-user.conf, user.conf.d).TimeoutStopSec defaults to the value of DefaultTimeoutStopSec in the manager configuration file (systemd-system.conf, system.conf.d, systemd-user.conf, user.conf.d). Il timeout predefinito per la maggior parte delle distribuzioni è di 90 secondi.The default timeout for most distributions is 90 seconds.

# The default value is 90 seconds for most distributions.
TimeoutStopSec=90

Linux dispone di un file system con distinzione tra maiuscole e minuscole.Linux has a case-sensitive file system. L'impostazione di ASPNETCORE_ENVIRONMENT su "Production" determina la ricerca del file di configurazione appsettings.Production.json, non di appsettings.production.json.Setting ASPNETCORE_ENVIRONMENT to "Production" results in searching for the configuration file appsettings.Production.json, not appsettings.production.json.

Per alcuni valori (ad esempio, le stringhe di connessione SQL) è necessario usare caratteri di escape, in modo da consentire ai provider di configurazione di leggere le variabili di ambiente.Some values (for example, SQL connection strings) must be escaped for the configuration providers to read the environment variables. Usare il comando seguente per generare un valore con caratteri di escape corretti per l'uso nel file di configurazione:Use the following command to generate a properly escaped value for use in the configuration file:

systemd-escape "<value-to-escape>"

I due punti (:) separatori non sono supportati nei nomi delle variabili di ambiente.Colon (:) separators aren't supported in environment variable names. Usare un doppio carattere di sottolineatura (__) al posto dei due punti.Use a double underscore (__) in place of a colon. Il provider di configurazione delle variabili di ambiente converte le doppie sottolineature in due punti quando le variabili di ambiente vengono lette nella configurazione.The Environment Variables configuration provider converts double-underscores into colons when environment variables are read into configuration. Nell'esempio seguente la chiave della stringa di connessione ConnectionStrings:DefaultConnection è impostata nel file di definizione del servizio come ConnectionStrings__DefaultConnection:In the following example, the connection string key ConnectionStrings:DefaultConnection is set into the service definition file as ConnectionStrings__DefaultConnection:

Environment=ConnectionStrings__DefaultConnection={Connection String}

Salvare il file e abilitare il servizio.Save the file and enable the service.

sudo systemctl enable kestrel-helloapp.service

Avviare il servizio e verificare che sia in esecuzione.Start the service and verify that it's running.

sudo systemctl start kestrel-helloapp.service
sudo systemctl status kestrel-helloapp.service

● kestrel-helloapp.service - Example .NET Web API App running on Ubuntu
    Loaded: loaded (/etc/systemd/system/kestrel-helloapp.service; enabled)
    Active: active (running) since Thu 2016-10-18 04:09:35 NZDT; 35s ago
Main PID: 9021 (dotnet)
    CGroup: /system.slice/kestrel-helloapp.service
            └─9021 /usr/local/bin/dotnet /var/www/helloapp/helloapp.dll

Con il proxy inverso configurato e Kestrel gestito tramite systemd, l'app Web è completamente configurata ed è possibile accedervi da un browser nel computer locale all'indirizzo http://localhost.With the reverse proxy configured and Kestrel managed through systemd, the web app is fully configured and can be accessed from a browser on the local machine at http://localhost. È anche possibile accedervi da un computer remoto, escludendo eventuali firewall che potrebbero impedirlo.It's also accessible from a remote machine, barring any firewall that might be blocking. Se si esaminano le intestazioni di risposta, l'intestazione Server indica che l'app ASP.NET Core è gestita da Kestrel.Inspecting the response headers, the Server header shows the ASP.NET Core app being served by Kestrel.

HTTP/1.1 200 OK
Date: Tue, 11 Oct 2016 16:22:23 GMT
Server: Kestrel
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive
Transfer-Encoding: chunked

Visualizzare i logView logs

Poiché l'app Web che usa Kestrel viene gestita con systemd, tutti gli eventi e i processi vengono registrati in un giornale di registrazione centralizzato.Since the web app using Kestrel is managed using systemd, all events and processes are logged to a centralized journal. Tuttavia, questo giornale include tutte le voci per tutti i servizi e i processi gestiti da systemd.However, this journal includes all entries for all services and processes managed by systemd. Per visualizzare le voci specifiche di kestrel-helloapp.service, usare il comando seguente:To view the kestrel-helloapp.service-specific items, use the following command:

sudo journalctl -fu kestrel-helloapp.service

Per filtrare ulteriormente, opzioni come --since today, --until 1 hour ago o una combinazione delle stesse consentono di ridurre la quantità di voci restituite.For further filtering, time options such as --since today, --until 1 hour ago or a combination of these can reduce the amount of entries returned.

sudo journalctl -fu kestrel-helloapp.service --since "2016-10-18" --until "2016-10-18 04:00"

Protezione dei datiData protection

Lo stack di protezione dei dati di ASP.NET Core è usato da diversi middleware di ASP.NET Core, tra cui i middleware di autenticazione (ad esempio il middleware per i cookie) e le protezioni CSRF (Cross-Site Request Forgery).The ASP.NET Core Data Protection stack is used by several ASP.NET Core middlewares, including authentication middleware (for example, cookie middleware) and cross-site request forgery (CSRF) protections. Anche se le DPAPI (Data Protection API) non vengono chiamate dal codice dell'utente, è consigliabile configurare la protezione dati per la creazione di un archivio di chiavi crittografiche permanente.Even if Data Protection APIs aren't called by user code, data protection should be configured to create a persistent cryptographic key store. Se non si configura la protezione dei dati, le chiavi vengono mantenute in memoria ed eliminate al riavvio dell'app.If data protection isn't configured, the keys are held in memory and discarded when the app restarts.

Se il gruppo di chiavi viene archiviato in memoria quando l'app viene riavviata:If the key ring is stored in memory when the app restarts:

  • Tutti i token di autenticazione basati su cookie vengono invalidati.All cookie-based authentication tokens are invalidated.
  • Gli utenti devono ripetere l'accesso alla richiesta successiva.Users are required to sign in again on their next request.
  • Tutti i dati protetti con il gruppo di chiavi non possono più essere decrittografati.Any data protected with the key ring can no longer be decrypted. Possono essere inclusi i token CSRF e i cookie TempData di ASP.NET Core MVC.This may include CSRF tokens and ASP.NET Core MVC TempData cookies.

Per configurare la protezione dei dati in modo da rendere persistente il gruppo di chiavi e crittografarlo, vedere:To configure data protection to persist and encrypt the key ring, see:

Campi di intestazione della richiesta di grandi dimensioniLong request header fields

Le impostazioni predefinite del server proxy limitano in genere i campi di intestazione della richiesta a 4 K o 8 K a seconda della piattaforma.Proxy server default settings typically limit request header fields to 4 K or 8 K depending on the platform. Un'app può richiedere campi più lunghi del valore predefinito, ad esempio le app che usano Azure Active Directory.An app may require fields longer than the default (for example, apps that use Azure Active Directory). Se sono necessari campi più lunghi, le impostazioni predefinite del server proxy richiedono la regolazione.If longer fields are required, the proxy server's default settings require adjustment. I valori da applicare dipendono dallo scenario.The values to apply depend on the scenario. Per altre informazioni, vedere la documentazione del server.For more information, see your server's documentation.

Avviso

Aumentare i valori predefiniti dei buffer proxy solo se necessario.Don't increase the default values of proxy buffers unless necessary. Se si aumentano questi valori, si aumenta il rischio di sovraccarico del buffer (overflow) e di attacchi Denial of Service (DoS) da parte di utenti malintenzionati.Increasing these values increases the risk of buffer overrun (overflow) and Denial of Service (DoS) attacks by malicious users.

Proteggere l'appSecure the app

Abilitare AppArmorEnable AppArmor

Linux Security Modules (LSM) è un framework che fa parte del kernel Linux a partire da Linux 2.6.Linux Security Modules (LSM) is a framework that's part of the Linux kernel since Linux 2.6. LSM supporta diverse implementazioni di moduli di protezione.LSM supports different implementations of security modules. AppArmor è un modulo LSM che implementa un sistema di controllo di accesso obbligatorio che consente di circoscrivere il programma a un set limitato di risorse.AppArmor is a LSM that implements a Mandatory Access Control system which allows confining the program to a limited set of resources. Verificare che AppArmor sia abilitato e configurato correttamente.Ensure AppArmor is enabled and properly configured.

Configurare il firewallConfigure the firewall

Chiudere tutte le porte esterne che non sono in uso.Close off all external ports that are not in use. Il firewall UFW (Uncomplicated Firewall) offre un front-end per iptables attraverso un'interfaccia della riga di comando per la configurazione del firewall.Uncomplicated firewall (ufw) provides a front end for iptables by providing a command line interface for configuring the firewall.

Avviso

Se non è configurato correttamente, un firewall impedisce l'accesso all'intero sistema.A firewall will prevent access to the whole system if not configured correctly. Se non si specifica la porta SSH corretta, non sarà possibile accedere al sistema se si usa SSH per la connessione.Failure to specify the correct SSH port will effectively lock you out of the system if you are using SSH to connect to it. Il numero di porta predefinito è 22.The default port is 22. Per altre informazioni, vedere l'introduzione a ufw e il manuale.For more information, see the introduction to ufw and the manual.

Installare ufw e configurarlo per consentire il traffico su tutte le porte necessarie.Install ufw and configure it to allow traffic on any ports needed.

sudo apt-get install ufw

sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

sudo ufw enable

Proteggere NginxSecure Nginx

Modificare il nome di risposta NginxChange the Nginx response name

Modificare src/http/ngx_http_header_filter_module.c:Edit src/http/ngx_http_header_filter_module.c:

static char ngx_http_server_string[] = "Server: Web Server" CRLF;
static char ngx_http_server_full_string[] = "Server: Web Server" CRLF;

Configurare le opzioniConfigure options

Configurare il server con moduli aggiuntivi obbligatori.Configure the server with additional required modules. Può essere utile usare un firewall per app Web, ad esempio ModSecurity, per la protezione avanzata dell'app.Consider using a web app firewall, such as ModSecurity, to harden the app.

Configurazione HTTPSHTTPS configuration

Configurare l'app per connessioni locali sicure (HTTPS)Configure the app for secure (HTTPS) local connections

Il comando dotnet run usa il file Properties/launchSettings.json dell'app, che configura l'app per l'ascolto negli URL specificati dalla proprietà applicationUrl , ad esempio https://localhost:5001; http://localhost:5000.The dotnet run command uses the app's Properties/launchSettings.json file, which configures the app to listen on the URLs provided by the applicationUrl property (for example, https://localhost:5001;http://localhost:5000).

Configurare l'app per l'uso di un certificato nello sviluppo per il comando dotnet run o l'ambiente di sviluppo (F5 o CTRL+F5 in Visual Studio Code) usando uno degli approcci seguenti:Configure the app to use a certificate in development for the dotnet run command or development environment (F5 or Ctrl+F5 in Visual Studio Code) using one of the following approaches:

Configurare il proxy inverso per connessioni client sicure (HTTPS)Configure the reverse proxy for secure (HTTPS) client connections

  • Configurare il server in modo che sia in ascolto del traffico HTTPS sulla porta 443 specificando un certificato valido emesso da un'autorità di certificazione attendibile.Configure the server to listen to HTTPS traffic on port 443 by specifying a valid certificate issued by a trusted Certificate Authority (CA).

  • Rafforzare la protezione adottando alcune delle procedure descritte nel file /etc/nginx/nginx.conf che segue.Harden the security by employing some of the practices depicted in the following /etc/nginx/nginx.conf file. Gli esempi includono la scelta di una crittografia più complessa e il reindirizzamento di tutto il traffico su HTTP a HTTPS.Examples include choosing a stronger cipher and redirecting all traffic over HTTP to HTTPS.

  • L'aggiunta di un'intestazione HTTP Strict-Transport-Security (HSTS) garantisce che tutte le richieste successive vengano effettuate dal client via HTTPS.Adding an HTTP Strict-Transport-Security (HSTS) header ensures all subsequent requests made by the client are over HTTPS.

  • Non aggiungere l'intestazione HSTS o scegliere un elemento max-age appropriato se si prevede di disabilitare HTTPS in futuro.Don't add the HSTS header or chose an appropriate max-age if HTTPS will be disabled in the future.

Aggiungere il file di configurazione /etc/nginx/proxy.conf:Add the /etc/nginx/proxy.conf configuration file:

proxy_redirect          off;
proxy_set_header        Host $host;
proxy_set_header        X-Real-IP $remote_addr;
proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header        X-Forwarded-Proto $scheme;
client_max_body_size    10m;
client_body_buffer_size 128k;
proxy_connect_timeout   90;
proxy_send_timeout      90;
proxy_read_timeout      90;
proxy_buffers           32 4k;

Aggiungere il file di configurazione /etc/nginx/proxy.conf.Edit the /etc/nginx/nginx.conf configuration file. L'esempio contiene entrambe le sezioni http e server in un unico file di configurazione.The example contains both http and server sections in one configuration file.

http {
    include        /etc/nginx/proxy.conf;
    limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;
    server_tokens  off;

    sendfile on;
    keepalive_timeout   29; # Adjust to the lowest possible value that makes sense for your use case.
    client_body_timeout 10; client_header_timeout 10; send_timeout 10;

    upstream hellomvc{
        server localhost:5000;
    }

    server {
        listen     *:80;
        add_header Strict-Transport-Security max-age=15768000;
        return     301 https://$host$request_uri;
    }

    server {
        listen                    *:443 ssl;
        server_name               example.com;
        ssl_certificate           /etc/ssl/certs/testCert.crt;
        ssl_certificate_key       /etc/ssl/certs/testCert.key;
        ssl_protocols             TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        ssl_ciphers               "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
        ssl_ecdh_curve            secp384r1;
        ssl_session_cache         shared:SSL:10m;
        ssl_session_tickets       off;
        ssl_stapling              on; #ensure your cert is capable
        ssl_stapling_verify       on; #ensure your cert is capable

        add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";
        add_header X-Frame-Options DENY;
        add_header X-Content-Type-Options nosniff;

        #Redirects all traffic
        location / {
            proxy_pass http://hellomvc;
            limit_req  zone=one burst=10 nodelay;
        }
    }
}

Proteggere Nginx dal clickjackingSecure Nginx from clickjacking

Il clickjacking, anche noto come attacco UI Redress, è un attacco dannoso in cui un visitatore di un sito Web viene indotto a fare clic su un collegamento o un pulsante in una pagina diversa da quella che sta attualmente visualizzando.Clickjacking, also known as a UI redress attack, is a malicious attack where a website visitor is tricked into clicking a link or button on a different page than they're currently visiting. Usare X-FRAME-OPTIONS per proteggere il sito.Use X-FRAME-OPTIONS to secure the site.

Per contrastare gli attacchi di clickjacking:To mitigate clickjacking attacks:

  1. Modificare il file nginx.conf:Edit the nginx.conf file:

    sudo nano /etc/nginx/nginx.conf
    

    Aggiungere la riga add_header X-Frame-Options "SAMEORIGIN";.Add the line add_header X-Frame-Options "SAMEORIGIN";.

  2. Salvare il file.Save the file.

  3. Riavviare Nginx.Restart Nginx.

Analisi del tipo MIMEMIME-type sniffing

Questa intestazione impedisce alla maggior parte dei browser di dedurre dall'analisi del tipo MIME un tipo di contenuto diverso da quello dichiarato, poiché l'intestazione indica al browser di non eseguire l'override del tipo di contenuto della risposta.This header prevents most browsers from MIME-sniffing a response away from the declared content type, as the header instructs the browser not to override the response content type. Con l'opzione nosniff, se il server indica che il contenuto è "text/html", il browser ne esegue il rendering come "text/html".With the nosniff option, if the server says the content is "text/html", the browser renders it as "text/html".

Modificare il file nginx.conf:Edit the nginx.conf file:

sudo nano /etc/nginx/nginx.conf

Aggiungere la riga add_header X-Content-Type-Options "nosniff"; e salvare il file, quindi riavviare Nginx.Add the line add_header X-Content-Type-Options "nosniff"; and save the file, then restart Nginx.

Risorse aggiuntiveAdditional resources