.NET Core auf CentOS 7 installieren und ausführen
.NET Core ist ein neu konzipiertes, quelloffenes Entwicklungsframework, das von Microsoft und der stetig wachsenden .NET-Community gepflegt wird. Es wurde für plattformübergreifende Entwicklung geschaffen und ermöglicht es Entwicklern, moderne, leistungsfähige Anwendungen für verschiedenste Systeme zu erstellen.
Diese Anleitung erklärt Schritt für Schritt, wie man .NET Core auf einem CentOS 7 Server einrichtet und eine vollständig funktionsfähige .NET Core-Webanwendung startet.
Voraussetzungen vor der Installation
- Ein aktueller CentOS 7 x64 Server – in diesem Beispiel hat der Server die IP-Adresse
203.0.113.1
. - Zugriff auf ein Benutzerkonto mit
sudo
-Rechten. - Der Server wurde bereits mit dem EPEL YUM-Repository auf den neuesten stabilen Stand gebracht.
Das .NET-Produkt-Repository integrieren
.NET Core stellt vorkompilierte Binärpakete für unterschiedliche Plattformen bereit. Unter CentOS 7 lässt sich das offiziell signierte Microsoft-YUM-Repository mit folgenden Befehlen einrichten:
sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
sudo sh -c 'echo -e "[packages-microsoft-com-prod]\nname=packages-microsoft-com-prod \nbaseurl= https://packages.microsoft.com/yumrepos/microsoft-rhel7.3-prod\nenabled=1\ngpgcheck=1\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/dotnetdev.repo'
Neueste .NET SDK-Version mit YUM installieren
Nachdem das Repository eingerichtet ist, kannst du das aktuelle .NET SDK inklusive .NET Core Runtime und weiterer Abhängigkeiten installieren. Verwende dazu folgende Befehle:
sudo yum update -y
sudo yum install libunwind libicu -y
sudo yum install dotnet-sdk-2.1.4 -y
Zur Überprüfung der Installation kannst du ein einfaches „Hello World“-Beispiel mit der .NET Core-Befehlszeile erstellen und ausführen:
cd
dotnet new console -o helloworldApp
cd helloworldApp
dotnet run
Der Befehl dotnet new console -o helloworldApp
erstellt im Home-Verzeichnis den Ordner helloworldApp
und legt darin die Beispielanwendung an.
Mit dotnet run
wird die Anwendung kompiliert und ausgeführt. Im Terminal erscheint dann die Ausgabe Hello World!.
Eine .NET Core Webanwendung mit Razor erstellen
Im nächsten Schritt kannst du eine Webanwendung auf Basis von Razor Pages erzeugen. Razor Pages ist ein Bestandteil von ASP.NET Core MVC, speziell für seitenbasierte Webanwendungen:
cd
dotnet new razor -o myfirstwebapp
cd myfirstwebapp
dotnet run
Der Befehl dotnet run
startet den integrierten Webserver von .NET Core, welcher standardmäßig unter http://localhost:5000
erreichbar ist.
Auch ohne grafische Benutzeroberfläche kannst du im Terminal prüfen, ob die Anwendung läuft. Öffne dazu ein neues Terminalfenster und gib ein:
curl http://localhost:5000
Damit wird der HTML-Quelltext der Startseite angezeigt. Um die Anwendung zu beenden, drücke Strg + C
.
Zur Weiterentwicklung der Anwendung kannst du die Projektdateien im erstellten Verzeichnis anpassen. Weitere Informationen findest du auf der offiziellen .NET-Dokumentationsseite.
Wenn die Anwendung fertig ist, kannst du sie mit den folgenden Befehlen veröffentlichen:
cd ~/myfirstwebapp
dotnet publish
Die veröffentlichte Anwendung findest du anschließend unter:
~/myfirstwebapp/bin/Debug/netcoreapp2.0
(Optional) Supervisor verwenden, um die .NET Core Webanwendung am Laufen zu halten
Anwendungen können gelegentlich abstürzen. Um sicherzustellen, dass deine .NET Core Webanwendung dauerhaft verfügbar bleibt, empfiehlt es sich, ein Prozessüberwachungstool wie Supervisor zu nutzen. Dieses sorgt dafür, dass deine Anwendung automatisch neu gestartet wird, falls sie unerwartet beendet wird.
Die Installation von Supervisor auf CentOS 7 erfolgt mit folgendem Befehl:
sudo yum install supervisor -y
Erstelle anschließend eine eigene Konfigurationsdatei für deine Anwendung:
cd /etc/supervisord.d
sudo vi myfirstwebapp.conf
Füge in die Konfigurationsdatei den folgenden Inhalt ein:
[program:myfirstwebapp]
command=dotnet myfirstwebapp.dll
directory=/home/sudouser/myfirstwebapp/bin/Debug/netcoreapp2.0/
environment=ASPNETCORE__ENVIRONMENT=Production
user=root
stopsignal=INT
autostart=true
autorestart=true
startsecs=1
stderr_logfile=/var/log/myfirstwebapp.err.log
stdout_logfile=/var/log/myfirstwebapp.out.log
Speichere und verlasse die Datei mit:
:wq!
Anschließend musst du die zentrale Supervisor-Konfigurationsdatei so anpassen, dass sie auch .conf
-Dateien einliest:
sudo cp /etc/supervisord.conf /etc/supervisord.conf.bak
sudo vi /etc/supervisord.conf
Am Ende der Datei findest du die Zeile:
files = supervisord.d/*.ini
Diese ersetzt du durch:
files = supervisord.d/*.conf
Speichern und beenden mit:
:wq!
Starte anschließend Supervisor und aktiviere den Dienst für den automatischen Systemstart:
sudo systemctl start supervisord.service
sudo systemctl enable supervisord.service
Lade die aktualisierte Supervisor-Konfiguration:
sudo supervisorctl reread
sudo supervisorctl update
Du kannst den aktuellen Status deiner Anwendung mit folgendem Befehl prüfen:
sudo supervisorctl status
Die Ausgabe wird in etwa so aussehen:
myfirstwebapp RUNNING pid 3925, uptime 0:08:45
Um einen Absturz zu simulieren, kannst du den Prozess manuell beenden – dazu nutze die PID:
sudo kill -s 9 3925
Warte kurz und prüfe den Status erneut:
sudo supervisorctl status
Die neue Ausgabe bestätigt, dass die Anwendung automatisch neu gestartet wurde:
myfirstwebapp RUNNING pid 3925, uptime 0:00:06
(Optional) Nginx als Reverse Proxy einrichten
Um den Zugriff für Benutzer zu vereinfachen, kannst du Nginx so konfigurieren, dass es als Reverse Proxy fungiert. Es leitet dabei eingehende Anfragen an deine .NET Core-Anwendung weiter, die auf Port 5000 läuft.
Installiere Nginx mit folgendem Befehl:
sudo yum install nginx -y
Bearbeite anschließend die Standardkonfigurationsdatei von Nginx:
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak
sudo vi /etc/nginx/nginx.conf
Suche innerhalb des Blocks http {}
nach dem Abschnitt location / {}
und ergänze ihn mit den folgenden sechs Zeilen:
location / {
proxy_pass http://127.0.0.1:5000;
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;
}
Speichere die Datei und beende den Editor mit:
:wq!
Starte nun den Nginx-Dienst und aktiviere ihn für den automatischen Start beim Systemstart:
sudo systemctl start nginx.service
sudo systemctl enable nginx.service
Firewall-Zugriff konfigurieren
Damit externe Anfragen über die Ports 80 (HTTP) und 443 (HTTPS) zugelassen werden, solltest du die Firewall-Regeln entsprechend anpassen:
sudo firewall-cmd --zone=public --permanent --add-service=http
sudo firewall-cmd --zone=public --permanent --add-service=https
sudo firewall-cmd --reload
Nach erfolgreicher Konfiguration ist deine .NET Core-Webanwendung nun unter http://203.0.113.1
erreichbar.
Fazit
Mit den in dieser Anleitung beschriebenen Schritten hast du eine vollständige .NET Core-Umgebung auf einem CentOS 7-Server eingerichtet. Vom Hinzufügen des offiziellen Microsoft-Repositories über die Installation des .NET SDKs und die Bereitstellung einer Razor-Webanwendung bis hin zur Prozessüberwachung mit Supervisor und der Einbindung von Nginx als Reverse Proxy – jedes Element trägt zu einer stabilen, produktionsreifen Infrastruktur bei.
Diese Konfiguration gewährleistet nicht nur eine zuverlässige Ausführung deiner Anwendung, sondern bietet auch Flexibilität und Wartbarkeit für zukünftige Entwicklungen. Mit dem öffentlichen Zugriff über die konfigurierte URL steht deiner robusten Webentwicklung unter Linux nichts mehr im Weg.