TOC

Bereitstellen einer ASP.NET-Kernanwendung mit MySQL Server unter Verwendung von Nginx unter Ubuntu 18.04

Der Autor hat die Open Source Initiative ausgewählt, um eine Spende als Teil der Write for DOnations zu erhalten. Programm.

Einführung

ASP.NET Core ist ein leistungsstarkes Open-Source-Framework zum Erstellen moderner Webanwendungen, das modularer gestaltet werden soll von Microsofts ASP.NET Framework. Es wurde 2016 veröffentlicht und kann auf verschiedenen Betriebssystemen wie Linux und macOS ausgeführt werden. Auf diese Weise können Entwickler ein bestimmtes Betriebssystem für die Entwicklung auswählen, basierend auf den Designanforderungen. Mit ASP.NET Core kann ein Entwickler jede Art von Webanwendung oder -dienst unabhängig von der Komplexität und Größe erstellen. Entwickler können auch Razor pages verwenden, um seitenorientiertes Design zu erstellen über das traditionelle Muster Model-View-Controller (MVC).

ASP.NET Core bietet die Flexibilität, in beliebige Front-End-Frameworks integriert zu werden, um clientseitige Logik zu verarbeiten oder einen Webdienst zu nutzen. Sie können beispielsweise eine RESTful-API mit ASP.NET Core erstellen und diese problemlos mit JavaScript-Frameworks wie Angular, React und Vue.js verwenden.

In diesem Tutorial richten Sie eine produktionsbereite ASP.NET Core-Anwendung mit einem MySQL-Server unter Ubuntu 18.04 unter Verwendung von Nginx ein und stellen sie bereit. Sie werden eine Demo-ASP.NET Core-Anwendung bereitstellen, die der Anwendung aus der Microsoft-Dokumentation ähnelt und auf https://github.com/aspnet/AspNetCore.Docs/tree/master/aspnetcore/tutorials/razor-pages/razor-pages- gehostet wird. start / 2.2-stage-samples [GitHub]. Nach der Bereitstellung können Sie mit der Demoanwendung eine Liste mit Filmen erstellen und in der Datenbank speichern. Sie können Datensätze in der Datenbank erstellen, lesen, aktualisieren und löschen. Sie können dieses Lernprogramm verwenden, um stattdessen Ihre eigene ASP.NET Core-Anwendung bereitzustellen. Möglicherweise müssen Sie zusätzliche Schritte implementieren, die das Generieren einer neuen Migrationsdatei für Ihre Datenbank umfassen.

Voraussetzungen

Für dieses Tutorial benötigen Sie Folgendes:

Schritt 1 - Installieren von .NET Core Runtime

Eine .NET Core-Laufzeit ist erforderlich, um eine .NET Core-Anwendung erfolgreich auszuführen. Sie müssen diese also zunächst auf Ihrem Computer installieren. Zunächst müssen Sie den Microsoft-Schlüssel und das Produkt-Repository registrieren. Danach installieren Sie die erforderlichen Abhängigkeiten.

Als erstes müssen Sie als neu erstellter Benutzer angemeldet sein und sicherstellen, dass Sie sich in Ihrem Stammverzeichnis befinden:

cd ~

Führen Sie als Nächstes den folgenden Befehl aus, um den Microsoft-Schlüssel und das Produkt-Repository zu registrieren:

wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb

Verwenden Sie + dpkg + mit dem + -i + Flag, um die angegebene Datei zu installieren:

sudo dpkg -i packages-microsoft-prod.deb

Um die Installation anderer für Ihre Anwendung erforderlicher Pakete zu erleichtern, installieren Sie das Repository + universe + mit dem folgenden Befehl:

sudo add-apt-repository universe

Installieren Sie als Nächstes das Paket "+ apt-transport", um die Verwendung von Repositorys zu ermöglichen, auf die über das HTTP Secure-Protokoll zugegriffen wird:

sudo apt install apt-transport-https

Führen Sie nun den folgenden Befehl aus, um die Paketliste aus den Repositorys herunterzuladen und zu aktualisieren, um Informationen zu den neuesten Versionen von Paketen und deren Abhängigkeiten abzurufen:

sudo apt update

Schließlich können Sie das .NET-Laufzeit-SDK installieren mit:

sudo apt install dotnet-sdk-2.2

Sie werden aufgefordert, die Details der Größe der zusätzlichen Dateien anzugeben, die installiert werden sollen. Geben Sie "+ A " ein und drücken Sie " ENTER", um fortzufahren.

Nachdem Sie das .NET Core-Laufzeit-SDK auf dem Server installiert haben, können Sie die Demo-Anwendung von GitHub herunterladen und die Bereitstellungskonfiguration einrichten. Zunächst erstellen Sie jedoch die Datenbank für die Anwendung.

Schritt 2 - Erstellen eines MySQL-Benutzers und einer MySQL-Datenbank

In diesem Abschnitt erstellen Sie einen MySQL-Server-Benutzer, erstellen eine Datenbank für die Anwendung und gewähren dem neuen Benutzer alle erforderlichen Berechtigungen, um von Ihrer Anwendung aus eine Verbindung zur Datenbank herzustellen.

Um zu beginnen, müssen Sie mit dem MySQL-Root-Konto auf den MySQL-Client zugreifen, wie hier gezeigt:

mysql -u root -p

Sie werden aufgefordert, das Kennwort für das Root-Konto einzugeben, das Sie während des vorausgesetzten Lernprogramms eingerichtet haben.

Als nächstes erstellen Sie eine MySQL-Datenbank für die Anwendung mit:

CREATE DATABASE ;

In der Konsole wird die folgende Ausgabe angezeigt:

OutputQuery OK, 1 row affected (0.03 sec)

Sie haben die Datenbank jetzt erfolgreich erstellt. Als Nächstes erstellen Sie einen neuen MySQL-Benutzer, ordnen ihn der neu erstellten Datenbank zu und gewähren ihm alle Berechtigungen.

Führen Sie den folgenden Befehl aus, um den MySQL-Benutzer und das Kennwort zu erstellen. Denken Sie daran, den Benutzernamen und das Passwort in etwas Sichereres zu ändern:

CREATE USER ''@'localhost' IDENTIFIED BY '';

Sie werden die folgende Ausgabe sehen:

OutputQuery OK, 0 rows affected (0.02 sec)

Um auf eine Datenbank zuzugreifen oder eine bestimmte Aktion auszuführen, benötigt ein MySQL-Benutzer die entsprechende Berechtigung. Derzeit verfügt * movie-admin * nicht über die entsprechenden Berechtigungen für die Anwendungsdatenbank.

Sie ändern dies, indem Sie den folgenden Befehl ausführen, um * movie-admin * unter ++ Zugriff zu gewähren:

GRANT ALL PRIVILEGES ON .* TO ''@'localhost';

Sie werden die folgende Ausgabe sehen:

OutputQuery OK, 0 rows affected (0.01 sec)

Jetzt können Sie die Grant-Tabellen erneut laden, indem Sie den folgenden Befehl ausführen, um die Änderungen zu übernehmen, die Sie gerade mit der Flush-Anweisung vorgenommen haben:

FLUSH PRIVILEGES;

Sie werden die folgende Ausgabe sehen:

OutputQuery OK, 0 rows affected (0.00 sec)

Sie haben nun einen neuen Benutzer erstellt und Berechtigungen erteilt. Um zu testen, ob Sie auf dem richtigen Weg sind, beenden Sie den MySQL-Client:

quit;

Melden Sie sich erneut mit den Anmeldeinformationen des gerade erstellten MySQL-Benutzers an und geben Sie das entsprechende Kennwort ein, wenn Sie dazu aufgefordert werden:

mysql -u  -p

Stellen Sie sicher, dass der Benutzer * movie-admin * auf die erstellte Datenbank zugreifen kann. Überprüfen Sie dies mit:

SHOW DATABASES;

Sie werden die ++ Tabelle in der Ausgabe sehen:

Output+--------------------+
| Database           |
+--------------------+
|          |
| information_schema |
+--------------------+
2 rows in set (0.01 sec)

Beenden Sie nun den MySQL-Client:

quit;

Sie haben eine Datenbank erstellt, einen neuen MySQL-Benutzer für die Demo-Anwendung erstellt und dem neu erstellten Benutzer die Berechtigung zum Zugriff auf die Datenbank erteilt. Im nächsten Abschnitt beginnen Sie mit dem Einrichten der Demo-Anwendung.

Schritt 3 - Einrichten der Demo-App und der Datenbankanmeldeinformationen

Wie bereits erwähnt, stellen Sie eine vorhandene ASP.NET Core-Anwendung bereit. Diese Anwendung wurde erstellt, um eine Filmliste zu erstellen, und verwendet das Model-View-Controller-Entwurfsmuster, um eine ordnungsgemäße Struktur und Trennung der Belange sicherzustellen. Um einen neuen Film zu erstellen oder der Liste hinzuzufügen, füllt der Benutzer die Formularfelder mit den entsprechenden Details und klickt auf die Schaltfläche * Erstellen *, um die Details an den Controller zu senden. Der Controller erhält zu diesem Zeitpunkt eine POST-HTTP-Anforderung mit den übermittelten Details und speichert die Daten in der Datenbank über das Modell.

Sie werden Git verwenden, um den Quellcode dieser Demo-Anwendung von GitHub abzurufen und in zu speichern ein neues Verzeichnis. Sie können hier auch eine alternative Anwendung herunterladen, wenn Sie eine andere Anwendung bereitstellen.

Erstellen Sie zunächst mit dem folgenden Befehl ein neues Verzeichnis mit dem Namen "++" vom Terminal aus:

sudo mkdir -p /var/www/

Dies dient als Stammverzeichnis für Ihre Anwendung. Ändern Sie als Nächstes den Ordnereigner und die Gruppe, damit ein Nicht-Root-Benutzerkonto mit den Projektdateien arbeiten kann:

sudo chown : /var/www/

Ersetzen Sie * sammy * durch Ihren sudo-Benutzernamen ohne Rootberechtigung.

Jetzt können Sie in das übergeordnete Verzeichnis wechseln und die Anwendung auf GitHub klonen:

cd /var/www
git clone https://github.com/do-community/movie-app-list.git

Sie werden die folgende Ausgabe sehen:

OutputCloning into ''...
remote: Enumerating objects: 91, done.
remote: Counting objects: 100% (91/91), done.
remote: Compressing objects: 100% (73/73), done.
remote: Total 91 (delta 13), reused 91 (delta 13), pack-reused 0
Unpacking objects: 100% (91/91), done.

Sie haben die Demoanwendung von GitHub erfolgreich geklont. Der nächste Schritt besteht darin, eine erfolgreiche Verbindung zur Anwendungsdatenbank herzustellen. Sie tun dies, indem Sie die Eigenschaft "+ ConnectionString" in der Datei "+ appsettings.json" bearbeiten und die Details der Datenbank hinzufügen.

Wechseln Sie das Verzeichnis in die Anwendung:

cd

Öffnen Sie nun die Datei zum Bearbeiten:

sudo nano appsettings.json

Fügen Sie Ihre Datenbankanmeldeinformationen hinzu:

appsettings.json

{
 "Logging": {
   "LogLevel": {
     "Default": "Warning"
   }
 },
 "AllowedHosts": "*",
 "ConnectionStrings": {
   "MovieContext": "Server=localhost;User Id=;Password=;Database="
 }
}

Damit haben Sie erfolgreich eine Verbindung zu Ihrer Datenbank hergestellt. Drücken Sie nun "+ STRG + X ", um Ihre Änderungen an der Datei zu speichern, und geben Sie " Y " zur Bestätigung ein. Drücken Sie dann " ENTER", um die Seite zu verlassen.

ASP.NET Core-Anwendungen verwenden eine .NET-Standardbibliothek mit dem Namen Entity Framework (EF) Core, um die Interaktion mit der Datenbank zu verwalten. Entity Framework Core ist eine kompakte, plattformübergreifende Version der beliebten Entity Framework-Datenzugriffstechnologie. Es handelt sich um einen objektrelationalen Mapper (ORM), mit dem .NET-Entwickler mithilfe eines beliebigen Datenbankanbieters wie MySQL mit einer Datenbank arbeiten können.

Sie können jetzt Ihre Datenbank mit den Tabellen aus der geklonten Demo-Anwendung aktualisieren. Führen Sie dazu den folgenden Befehl aus:

dotnet ef database update

Dadurch wird ein Update auf die Datenbank angewendet und die entsprechenden Schemas erstellt.

Führen Sie nun den folgenden Befehl aus, um das Projekt und alle seine Abhängigkeiten zu erstellen:

dotnet build

Sie sehen eine Ausgabe ähnlich der folgenden:

OutputMicrosoft (R) Build Engine version 16.1.76+g14b0a930a7 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

 Restore completed in 95.09 ms for /var/www//MvcMovie.csproj.
 MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.dll
 MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.Views.dll

Build succeeded.
   0 Warning(s)
   0 Error(s)

Time Elapsed 00:00:01.91

Dadurch wird das Projekt erstellt und alle in der ++ - Datei aufgeführten Abhängigkeiten von Drittanbietern werden installiert, die Anwendung ist jedoch noch nicht produktionsbereit. Führen Sie den folgenden Befehl aus, um die Anwendung für die Bereitstellung vorzubereiten:

dotnet publish

Sie werden folgendes sehen:

OutputMicrosoft (R) Build Engine version 16.1.76+g14b0a930a7 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

Restore completed in 89.62 ms for /var/www/movie-app/MvcMovie.csproj.
MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.dll
MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.Views.dll
MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/publish/

Dadurch wird die Anwendung gepackt und kompiliert, die Abhängigkeiten werden gelesen, die resultierenden Dateien werden in einem Ordner für die Bereitstellung veröffentlicht und es wird eine plattformübergreifende DLL-Datei erstellt, die die installierte .NET Core-Laufzeit zum Ausführen der Anwendung verwendet.

Durch Installieren von Abhängigkeiten, Herstellen einer Verbindung zur Datenbank, Aktualisieren der Datenbank mit den erforderlichen Tabellen und Veröffentlichen für die Produktion haben Sie die Einrichtung für diese Demoanwendung abgeschlossen. Im nächsten Schritt konfigurieren Sie den Webserver so, dass die Anwendung in Ihrer Domain zugänglich und sicher ist.

Schritt 4 - Konfigurieren des Webservers

Nachdem Sie den How To Secure Nginx with Let’s gefolgt sind Lernprogramm zum Verschlüsseln haben Sie einen Serverblock für Ihre Domain unter "+ / etc / nginx / sites-available / ", wobei die "+" - Direktive bereits entsprechend eingestellt ist. In diesem Schritt bearbeiten Sie diesen Serverblock, um Nginx als Reverse-Proxy für Ihre Anwendung zu konfigurieren. Ein Reverse-Proxy ist ein Server, der sich vor den Webservern befindet und die Anforderungen jedes Webbrowsers an diese Webserver weiterleitet. Es empfängt alle Anfragen aus dem Netzwerk und leitet sie an einen anderen Webserver weiter.

Bei einer ASP.NET Core-Anwendung ist Kestrel der bevorzugte Webserver standardmäßig enthalten. Es eignet sich hervorragend zum Bereitstellen dynamischer Inhalte aus einer ASP.NET Core-Anwendung, da es eine bessere Leistung bei der Anforderungsverarbeitung bietet und ASP.NET so schnell wie möglich gestalten soll. Kestrel wird jedoch nicht als voll ausgestatteter Webserver angesehen, da er die Sicherheit nicht verwalten und keine statischen Dateien bereitstellen kann. Aus diesem Grund ist es ratsam, ihn immer hinter einem Webserver auszuführen.

Stellen Sie zunächst sicher, dass Sie sich im Stammverzeichnis Ihres Servers befinden:

cd ~

Öffnen Sie den Serverblock zum Bearbeiten mit:

sudo nano /etc/nginx/sites-available/

Wie in der https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-18-04#step-4-%E2%80 beschrieben % 94-Erhalt eines SSL-Zertifikats [Schritt 4] von https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu- 18-04 [So sichern Sie Nginx mit Let’s Encrypt] Wenn Sie Option 2 ausgewählt haben, konfiguriert Certbot diesen Serverblock automatisch, um den HTTP-Datenverkehr mit nur wenigen Änderungen an HTTPS umzuleiten.

Fahren Sie mit der Konfiguration fort, indem Sie die ersten beiden Blöcke in der Datei bearbeiten, um Folgendes wiederzugeben:

/ etc / nginx / sites-available / your-domain

server {

   server_name   www.;

  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;
   }

listen [::]:443 ssl ipv6only=on; # managed by Certbot
listen 443 ssl; # managed by Certbot
ssl_certificate /etc/letsencrypt/live//fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live//privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot


}
...

Die Konfiguration in diesem Serverblock weist Nginx an, den Port "+ 443 " abzuhören, der der Standardport für Websites ist, die SSL verwenden. Darüber hinaus akzeptiert Nginx öffentlichen Datenverkehr auf Port " 443 " und leitet jede übereinstimmende Anforderung an den integrierten Kestrel-Server unter " http: // localhost: 5000 +" weiter.

Stellen Sie nach dem Serverblock, den Sie gerade in der Datei bearbeitet haben, sicher, dass der zweite Serverblock folgendermaßen aussieht:

/ etc / nginx / sites-available / your-domain

...
server {
if ($host = www.) {
   return 301 https://$host$request_uri;
} # managed by Certbot


if ($host = ) {
   return 301 https://$host$request_uri;
} # managed by Certbot


   listen 80;
   listen [::]:80;

   server_name   www.;
return 404; # managed by Certbot
}

Dieser Serverblock leitet alle Anforderungen an "+ https: // " und " https: // www. +" An einen sicheren HTTPS-Zugriff um.

Erzwingen Sie als Nächstes, dass Nginx die Änderungen aufnimmt, die Sie am Serverblock vorgenommen haben, indem Sie Folgendes ausführen:

sudo nginx -s reload

Wenn die Nginx-Konfiguration erfolgreich abgeschlossen wurde, ist der Server vollständig eingerichtet, um alle HTTPS-Anforderungen an die ASP.NET Core-App weiterzuleiten, die auf Kestrel unter http: // localhost: 5000+ ausgeführt wird `. Nginx ist jedoch nicht für die Verwaltung des Kestrel-Serverprozesses eingerichtet. Um dies zu handhaben und sicherzustellen, dass der Kestrel-Prozess weiterhin im Hintergrund ausgeführt wird, verwenden Sie die Funktionen "+ systemd +".

Mit den Systemd -Dateien können Sie einen Prozess verwalten, indem Sie nach dem Erstellen Start-, Stopp-, Neustart- und Protokollfunktionen bereitstellen Ein Arbeitsprozess, der Einheit genannt wird.

Gehe in das + systemd + Verzeichnis:

cd /etc/systemd/systems

Erstellen Sie eine neue Datei zum Bearbeiten:

sudo nano

Fügen Sie den folgenden Inhalt hinzu:

Film.Service

[Unit]
Description=

[Service]
WorkingDirectory=/var/www/
ExecStart=/usr/bin/dotnet /var/www//bin/Debug/netcoreapp2.2/publish/MvcMovie.dll
Restart=always
RestartSec=10
SyslogIdentifier=
User=
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

Die Konfigurationsdatei gibt den Speicherort des Projektordners mit "+ WorkingDirectory " und den Befehl an, der zu Beginn des Prozesses in " ExecStart " ausgeführt werden soll. Außerdem haben Sie mit der Direktive " RestartSec " angegeben, wann der Dienst " systemd +" neu gestartet werden soll, wenn der .NET-Laufzeitdienst abstürzt.

Speichern Sie nun die Datei und aktivieren Sie den neuen Filmdienst, der erstellt wurde mit:

sudo systemctl enable

Starten Sie anschließend den Dienst und überprüfen Sie, ob er ausgeführt wird, indem Sie den Dienst starten:

sudo systemctl start

Dann überprüfe seinen Status:

sudo systemctl status

Sie werden die folgende Ausgabe sehen:

Output -
  Loaded: loaded (/etc/systemd/system/; enabled; vendor preset: enabled)
  Active: active (running) since Sun 2019-06-23 04:51:28 UTC; 11s ago
Main PID: 6038 (dotnet)
   Tasks: 16 (limit: 1152)
  CGroup: /system.slice/
          └─6038 /usr/bin/dotnet /var/www//bin/Debug/netcoreapp2.2/publish/MvcMovie.dll

Diese Ausgabe gibt Ihnen einen Überblick über den aktuellen Status des "++", das erstellt wurde, um Ihre App am Laufen zu halten. Es zeigt an, dass der Dienst aktiviert und derzeit aktiv ist.

Navigieren Sie in Ihrem Browser zu "+ https: // +", um die Anwendung auszuführen und zu testen.

Sie sehen die Startseite der Demoanwendung - * Movie List Application *.

image: https: //i.imgur.com/VI7KTaU.png [Filmlistenanwendung]

Wenn der Reverse-Proxy konfiguriert und Kestrel über systemd verwaltet wird, ist die Web-App vollständig konfiguriert und kann über einen Browser aufgerufen werden.

Fazit

In diesem Lernprogramm haben Sie eine ASP.NET Core-Anwendung auf einem Ubuntu-Server bereitgestellt. Um Daten zu erhalten und zu verwalten, haben Sie den MySQL-Server installiert und verwendet und den Nginx-Webserver als Reverse-Proxy für Ihre Anwendung verwendet.

Wenn Sie über dieses Lernprogramm hinaus eine interaktive Webanwendung mit C # anstelle von Javascript erstellen möchten, können Sie ein Web-UI-Framework von Microsoft mit dem Namen https://dotnet.microsoft.com/apps/aspnet/web-apps/client [ausprobieren. Blazor]. Es ist eine ereignisgesteuerte komponentenbasierte Web-Benutzeroberfläche zum Implementieren von Logik auf der Clientseite einer ASP.NET Core-Anwendung.

Wenn Sie Ihre eigene Anwendung bereitstellen möchten, müssen Sie andere erforderliche Verfahren berücksichtigen, um Ihre App bereitzustellen. Den vollständigen Quellcode für diese Demo-Anwendung finden Sie unter here on GitHub.

Related