Una piccola macchina virtuale Linux su Azure costa circa $ 13 al mese. Puoi ottenere piccole macchine Linux dappertutto per $ 10-15 al mese. Su Linode costano circa $ 10 al mese, quindi ho pensato che sarebbe stato interessante configurare un sito Web ASP.NET Core in esecuzione su .NET Core. Come forse saprai, .NET Core è gratuito, open source, multipiattaforma e funziona praticamente ovunque.
Fase 0:procurati un host economico
Sono andato su Linode (o ovunque) e ho preso la macchina Linux più economica che offrivano. In questo caso si tratta di un profilo LTS Ubuntu 14.04, 64 bit, kernel 4.6.5.
Dato che sono su Windows ma voglio SSH in questa macchina Linux, avrò bisogno di un client SSH. Ci sono un sacco di opzioni.
- Se hai l'ultima versione di Windows 10 puoi solo usa la shell Bash/Ubuntu incorporata in Windows stesso
. Questo è quello che ho fatto. Ho eseguito bash, poi ssh. - Puoi scaricare OpenSSH per Windows. Questo è quello che il team di Windows/PowerShell sta portando in Windows. È un port Win32 di OpenSSH.
- SmarTTY - Più bello di Putty, questo è un client SSH multischeda gratuito che supporta anche la copia di file
- Putty o Bitvise:entrambi gratuiti ed entrambi funzionano bene
Fase 0.5:imposta un utente che non è root
È sempre una buona idea evitare di essere root. Dopo aver effettuato l'accesso al sistema come root, ho creato un nuovo utente e gli ho dato sudo (super user do):
adduser scott
usermod -aG sudo scott
Quindi mi disconnetterò e tornerò come scott.
Passaggio 1:ottieni .NET Core sulla tua macchina Linux
Vai su http://dot.net per ottenere .NET Core e segui le istruzioni. Ci sono almeno 8 Linux supportati in 6 versioni, quindi non dovresti avere problemi. Ho seguito le istruzioni di Ubuntu.
Per assicurarti che funzioni dopo averlo configurato, crea un'app per console rapida come questa ed eseguila.
mkdir testapp
cd testapp
dotnet new
dotnet restore
dotnet run
Se funziona, hai installato .NET Core e puoi passare alla creazione di un'app Web e alla sua esposizione a Internet.
NOTA: Se il "ripristino dotnet" non riesce a causa di un errore di segmentazione, è possibile che si verifichi questo problema con alcuni kernel Linux a 64 bit. Ecco i comandi per risolverlo che hanno funzionato per me su Ubuntu 14.04 quando ho colpito questo. La correzione è stata rilasciata come NuGet ora, ma sarà inclusa nella prossima versione minore di .NET Core, ma se hai bisogno di aggiornare manualmente CoreCLR puoi farlo.
Passaggio 2:crea un sito Web ASP.NET Core
È possibile creare un sito Web ASP.NET Core molto semplice e molto vuoto e va bene. Puoi anche ottenere Yeoman e utilizzare i generatori basati su yeoman ASP.NET per ottenere più scelte. C'è anche il grande progetto ASP.NET MVC Boilerplate per Visual Studio.
Oppure puoi semplicemente iniziare con:
dotnet new -t web
Oggi, questo sito predefinito utilizza npm, gulp e bower per gestire le dipendenze JavaScript e CSS. In futuro ci saranno opzioni che non richiedono molte cose extra ma per ora, per ripristinare dotnet questo sito avrò bisogno di npm e cosa no, quindi lo farò per ottenere node, npm, ecc.
sudo apt-get install npm
sudo npm install gulp
sudo npm install bower
Ora posso ripristinare facilmente dotnet ed eseguire la mia app Web per testare. Si avvierà solitamente su localhost:5000.
$ dotnet restore
$ dotnet run
scott@ubuntu:~/dotnettest$ dotnet run
Project dotnettest (.NETCoreApp,Version=v1.0) was previously compiled. Skipping compilation.
info: Microsoft.Extensions.DependencyInjection.DataProtectionServices[0]
User profile is available. Using '/home/scott/.aspnet/DataProtection-Keys' as key repository; keys will not be encrypted at rest.
Hosting environment: Production
Content root path: /home/scott/dotnettest
Now listening on: http://localhost:5000
Ovviamente, avere qualcosa che si avvia su localhost:5000 non mi aiuta dato che sono qui a casa, quindi non posso testare un sito Web locale come questo. Voglio esporre questo sito (tramite una porta) al mondo esterno. Voglio qualcosa come http://mysupermachine -> inside my machine -> localhost:5000.
Passaggio 3 - Esponi la tua app web all'esterno.
potrei dì a Kestrel - questo è il server Web .NET - di esporsi alla porta 80, anche se di solito voglio avere un altro processo tra te e il mondo esterno.
Puoi farlo in alcuni modi . Puoi aprire Program.cs con un editor come "pico" e aggiungere una chiamata .UseUrls() al WebHostBuilder in questo modo.
var host = new WebHostBuilder()
.UseKestrel()
.UseUrls("http://*:80")
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup<Startup>()
.Build();
Qui * si lega a tutte le schede di rete e rimane in ascolto sulla porta 80. Anche l'inserimento di http://0.0.0.0:80 funziona.
Potresti avere problemi di autorizzazione e dover elevare il processo dotnet e il server web, che è anche un problema, quindi teniamolo su una porta interna alta e proxy inverso il traffico con qualcosa come Nginx o Apache. Estrarremo la porta hardcoded dal codice e cambieremo Program.cs per utilizzare un file di configurazione .json.
public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("hosting.json", optional: true)
.Build();
var host = new WebHostBuilder()
.UseKestrel()
.UseConfiguration(config)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup<Startup>()
.Build();
host.Run();
}
Il file hosting.json è proprio questo:
{
"server.urls": "http://localhost:5123"
}
Possiamo anche usare "AddCommandLine(args) invece di "AddJsonFile()" e passare --server.urls=http://*:5123 sulla riga di comando. Dipende da te. Puoi anche usare la variabile di ambiente ASPNETCORE_URLS .
NOTA:sto facendo questo lavoro in una cartella nella mia cartella home ~ o ora. In seguito compilerò e "pubblicherò" questo sito Web in qualcosa di simile a /var/dotnetst quando voglio che venga visualizzato.
Fase 4:imposta un proxy inverso come Nginx
Sto seguendo le istruzioni dettagliate sul sito ASP.NET Core Docs chiamato "Pubblica in un ambiente di produzione Linux". (Anche tutti i documenti sono su GitHub)
Porterò Nginx e lo avvierò.
sudo apt-get install nginx
sudo service nginx start
Modificherò il sito Nginx predefinito in modo che punti alla mia (futura) app Web ASP.NET Core in esecuzione. Aprirò e modificherò /etc/nginx/sites-available/default e lo farò assomigliare a questo. Prendere nota del numero di porta. Nginx è MOLTO più complesso di così e ha molte sfumature, quindi quando sei pronto per entrare nella produzione super ufficiale, assicurati di esplorare l'aspetto del file di configurazione Nginx perfetto e modificarlo in base alle tue esigenze.
server {
listen 80;
location / {
proxy_pass http://localhost:5123;
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;
}
}
Quindi lo controlleremo e ricarichiamo la configurazione.
sudo nginx -t
sudo nginx -s reload
Passaggio 5:mantieni il tuo sito web funzionante
Il sito Web non è ancora attivo e funzionante su localhost:5123 (a meno che tu non lo abbia eseguito tu stesso e lo abbia mantenuto in esecuzione!), quindi avremo bisogno di un'app o di un monitor per eseguirlo e mantenerlo in esecuzione. C'è un'app chiamata Supervisor che è brava in questo, quindi la aggiungerò.
sudo apt-get install supervisor
Qui è dove tu/noi/io/sbagliamo abbiamo bisogno di ottenere i percorsi e i nomi corretti, quindi fai attenzione. Sono finito in ~/testapp o qualcosa del genere. Devo pubblicare il mio sito in una posizione finale, quindi eseguirò la pubblicazione dotnet, quindi copierò i risultati in /var/dotnettest dove vivrà.
dotnet publish
publish: Published to /home/scott/dotnettest/bin/Debug/netcoreapp1.0/publish
sudo cp -a /home/scott/dotnettest/bin/Debug/netcoreapp1.0/publish /var/dotnettest
Ora creerò un file (di nuovo, uso pico perché non sono fantastico come emacs o vim) chiamato /src/supervisor/conf.d/dotnettest.conf per avviare la mia app e mantenerla in esecuzione:
[program:dotnettest]
command=/usr/bin/dotnet /var/dotnettest/dotnettest.dll --server.urls:http://*:5123
directory=/var/dotnettest/
autostart=true
autorestart=true
stderr_logfile=/var/log/dotnettest.err.log
stdout_logfile=/var/log/dotnettest.out.log
environment=ASPNETCORE_ENVIRONMENT=Production
user=www-data
stopsignal=INT
Ora avviamo e interrompiamo Supervisor e controlliamo/seguiamo i suoi registri per vedere l'avvio della nostra app!
sudo service supervisor stop
sudo service supervisor start
sudo tail -f /var/log/supervisor/supervisord.log
#and the application logs if you like
sudo tail -f /var/log/dotnettest.out.log
Se tutto ha funzionato (se non ha funzionato, sarà un nome o un percorso, quindi continua a provare!) vedrai il registro del supervisore con dotnet all'avvio, che esegue la tua app.
Ricorda le relazioni.
- Dotnet:gestisce il tuo sito web
- Nginx o Apache:ascolta sulla porta 80 e inoltra le chiamate HTTP al tuo sito web
- Supervisore:mantiene la tua app in funzione
Successivamente, potrei voler configurare una build di integrazione continua o SCP/SFTP per gestire la distribuzione della mia app. In questo modo posso sviluppare localmente ed eseguire il push up sulla mia macchina Linux.
Naturalmente, ci sono una dozzina di altri modi per pubblicare un sito ASP.NET Core, per non parlare di Docker. Pubblicherò su Docker un'altra volta, ma per ora sono stato in grado di pubblicare il mio sito Web ASP.NET Core su un host economico da $ 10 in meno di un'ora. Puoi utilizzare gli stessi strumenti per gestire un sito .NET Core che utilizzi per gestire qualsiasi sito, sia esso PHP, nodejs, Ruby o qualsiasi cosa ti renda felice.
Sponsor: Aspose crea API di programmazione per lavorare con file, come:DOC, XLS, PPT, PDF e innumerevoli altri. Gli sviluppatori possono utilizzare i loro prodotti per creare, convertire, modificare o gestire file in quasi tutti i modi. Aspose è una buona azienda e offre prodotti solidi. Dai un'occhiata e scarica una valutazione gratuita.