Linux

Stellen Sie RAMP auf einem Bare-Metal- oder VM-basierten Linux-Server mit systemd-Diensten und Nginx als Reverse-Proxy bereit. Diese Anleitung behandelt Debian 13, die Schritte gelten jedoch mit geringen Anpassungen für die meisten systemd-basierten Distributionen.

Architekturübersicht

Die Linux-Bereitstellung betreibt drei Dienste:

Dienst	Läuft als	Hört auf	Zweck
RAMP API	systemd (ramp.service)	localhost:5000	Backend-API + eingebettetes Frontend
Keycloak	systemd (keycloak.service)	localhost:8180	OIDC-Identitätsanbieter (optional)
Nginx	Systemdienst	Ports 80, 443, 8443	TLS-Terminierung und Reverse-Proxy

RAMP verwendet SQLite zur Datenspeicherung und lokalen Dateispeicher für Uploads. Keycloak ist optional — Sie können stattdessen die integrierte Authentifizierung von RAMP verwenden.

---

Voraussetzungen

• Debian 13 (oder Ubuntu 22.04+, RHEL 9+, andere systemd-basierte Distributionen)
• Root-Zugriff (oder sudo-Berechtigungen)
• 2 GB RAM mindestens (4 GB empfohlen mit Keycloak)
• 5 GB Speicherplatz mindestens
• Veröffentlichte RAMP-Build-Ausgabe (auf einem Entwicklungsrechner erstellt)
• SSL-Zertifikate (für HTTPS — für die Produktion empfohlen)

---

Schnellstart

Die Bereitstellung besteht aus vier Phasen, orchestriert durch das Skript deploy-all.sh:

1. VM-Setup — .NET Runtime, Java (für Keycloak) und Nginx installieren.
2. Keycloak-Installation — Keycloak herunterladen und als systemd-Dienst konfigurieren (optional).
3. RAMP-Bereitstellung — Anwendung bereitstellen und als systemd-Dienst registrieren.
4. Nginx-Konfiguration — Reverse-Proxy mit TLS-Terminierung konfigurieren.

# Alles auf einmal ausführen (als root)
sudo ./deploy-all.sh

Oder führen Sie jede Phase einzeln aus, wie unten beschrieben.

---

Phase 1: VM-Setup

Das Skript setup-vm.sh installiert alle Voraussetzungen und erstellt die erforderliche Verzeichnisstruktur.

Was installiert wird

• Wichtige Tools — curl, wget, gnupg, unzip, net-tools, htop
• ASP.NET Core 10 Runtime — aus dem Microsoft-Paketrepository
• Java 21 (OpenJDK) — erforderlich für Keycloak
• Nginx — Reverse-Proxy

Setup ausführen

sudo ./setup-vm.sh

Was erstellt wird

Pfad	Zweck
/opt/ramp/app/	RAMP-Anwendungsdateien
/var/ramp/data/	SQLite-Datenbank
/var/ramp/data/files/	Speicher für hochgeladene Dateien
/var/ramp/logs/	Anwendungsprotokolle
/opt/keycloak/	Keycloak-Installation

Das Skript erstellt außerdem einen ramp-Systembenutzer ohne Anmelde-Shell, unter dem der RAMP-Dienst ausgeführt wird.

Manuelle Installation

Falls Sie Voraussetzungen lieber manuell installieren möchten:

Debian / Ubuntu

# Microsoft-Repository hinzufügen
wget -q https://packages.microsoft.com/config/debian/13/packages-microsoft-prod.deb \
  -O /tmp/packages-microsoft-prod.deb
sudo dpkg -i /tmp/packages-microsoft-prod.deb

# Laufzeitumgebungen installieren
sudo apt-get update
sudo apt-get install -y aspnetcore-runtime-10.0 openjdk-21-jre-headless nginx

RHEL / Fedora

# Microsoft-Repository hinzufügen
sudo rpm -Uvh https://packages.microsoft.com/config/rhel/9/packages-microsoft-prod.rpm

# Laufzeitumgebungen installieren
sudo dnf install -y aspnetcore-runtime-10.0 java-21-openjdk-headless nginx

---

Phase 2: Keycloak-Installation (optional)

Hinweis

Keycloak ist optional. Wenn Sie nur die integrierte Authentifizierung von RAMP benötigen, überspringen Sie diese Phase und entfernen Sie die Keycloak-IDP-Verbindung aus der Scaffold-Datei.

Das Skript install-keycloak.sh lädt Keycloak 24.0 herunter, richtet den Realm-Import ein und registriert es als systemd-Dienst.

sudo ./install-keycloak.sh

Was passiert

1. Keycloak 24.0 wird nach /opt/keycloak/keycloak-24.0.0/ heruntergeladen
2. Ein Symlink wird unter /opt/keycloak/current erstellt
3. Die Realm-Import-Datei (realm-export.json) wird für die automatische Realm-Bereitstellung kopiert
4. Der Dienst keycloak.service wird installiert und gestartet
5. Warten auf die Integritätsprüfung (bis zu 120 Sekunden)

Keycloak systemd-Dienst

[Unit]
Description=Keycloak Identity Provider
After=network.target

[Service]
Type=exec
User=root
Group=root

Environment=KEYCLOAK_ADMIN=admin
Environment=KEYCLOAK_ADMIN_PASSWORD=Passw0rd
Environment=KC_HEALTH_ENABLED=true
Environment=KC_HTTP_PORT=8180

ExecStart=/opt/keycloak/current/bin/kc.sh start-dev --import-realm --http-port=8180

Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Gefahr

Ändern Sie KEYCLOAK_ADMIN_PASSWORD vor dem Einsatz in der Produktion. Das Standardpasswort Passw0rd ist nur für die Entwicklung gedacht.

Auf Keycloak zugreifen

• Admin-Konsole: http://localhost:8180/admin
• Anmeldedaten: admin / Passw0rd
• RAMP-Realm: vorab importiert aus realm-export.json

Keycloak-Dienst verwalten

sudo systemctl status keycloak
sudo systemctl stop keycloak
sudo systemctl start keycloak
sudo journalctl -u keycloak -f

---

Phase 3: RAMP-Bereitstellung

RAMP auf Ihrem Entwicklungsrechner erstellen

Veröffentlichen Sie die RAMP-Anwendung vor der Bereitstellung:

# Backend
cd src/RAMP.API
dotnet publish -c Release -o ./publish

# Frontend (erstellt und in die API-Veröffentlichungsausgabe eingebettet)
cd src/RAMP.Web
npm ci && npm run build

Dateien auf den Server übertragen

# Die veröffentlichte Ausgabe per SCP auf den Server übertragen
scp -r src/RAMP.API/publish/* user@your-server:/opt/ramp/app/

Anwendung bereitstellen

sudo ./deploy-ramp.sh

Was passiert

1. Vorhandenen RAMP-Dienst stoppen (falls aktiv)
2. appsettings.Production.json und scaffold.yaml in das App-Verzeichnis kopieren
3. Dateibesitz auf den ramp-Systembenutzer setzen
4. Systemd-Dienstdatei installieren
5. RAMP starten und auf die Integritätsprüfung warten (bis zu 60 Sekunden)

RAMP systemd-Dienst

[Unit]
Description=RAMP Application
After=network.target
Wants=keycloak.service

[Service]
Type=exec
User=ramp
Group=ramp
WorkingDirectory=/opt/ramp/app

Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=ASPNETCORE_URLS=http://localhost:5000
Environment=DOTNET_ENVIRONMENT=Production

ExecStart=/usr/bin/dotnet /opt/ramp/app/RAMP.API.dll

Restart=on-failure
RestartSec=5

LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

RAMP-Dienst verwalten

sudo systemctl status ramp
sudo systemctl stop ramp
sudo systemctl start ramp
sudo systemctl restart ramp
sudo journalctl -u ramp -f

---

Phase 4: Nginx-Konfiguration

Nginx dient als TLS-terminierender Reverse-Proxy vor RAMP und Keycloak.

Konfiguration installieren

# Konfigurationsdatei kopieren
sudo cp nginx/ramp-linux.conf /etc/nginx/sites-available/ramp-linux.conf

# Website aktivieren
sudo ln -sfn /etc/nginx/sites-available/ramp-linux.conf /etc/nginx/sites-enabled/ramp-linux.conf

# Standard-Website entfernen
sudo rm -f /etc/nginx/sites-enabled/default

# Testen und neu laden
sudo nginx -t && sudo systemctl reload nginx

SSL-Zertifikate

Platzieren Sie Ihre SSL-Zertifikate unter diesen Pfaden (oder passen Sie die Nginx-Konfiguration an):

Datei	Pfad
Zertifikat	/etc/ssl/your-domain/cert.crt
Privater Schlüssel	/etc/ssl/your-domain/cert.key
CA-Bundle	/etc/ssl/your-domain/ca-bundle.crt

Aktualisieren Sie die Direktiven ssl_certificate, ssl_certificate_key und ssl_trusted_certificate in der Nginx-Konfiguration entsprechend Ihren Pfaden.

Nginx-Konfigurationsübersicht

Die Nginx-Konfiguration definiert drei Serverblöcke:

Serverblock	Hört auf	Zweck
HTTP-Weiterleitung	Port 80	Leitet gesamten HTTP-Datenverkehr auf HTTPS um
RAMP (HTTPS)	Port 443	Leitet an RAMP API auf localhost:5000 weiter
Keycloak (HTTPS)	Port 8443	Leitet an Keycloak auf localhost:8180 weiter

Wichtige Proxy-Standorte im RAMP-Serverblock:

Standort	Backend	Hinweise
/_api/	localhost:5000/_api/	Backend-API-Endpunkte
/_hubs/	localhost:5000/_hubs/	SignalR WebSocket mit Upgrade-Headern, 7-Tage-Timeout
/_swagger/	localhost:5000/_swagger/	Swagger-Oberfläche
/_health	localhost:5000/_health	Integritätsprüfung (Zugriffsprotokoll deaktiviert)
/	localhost:5000/	Frontend SPA (Catch-all mit Fallback auf index.html)
Statische Dateien	localhost:5000	1-Jahres-Cache, Cache-Control: public, immutable

Tipp

client_max_body_size ist auf 100M gesetzt, um Datei-Uploads zu unterstützen. Passen Sie diesen Wert nach Bedarf an.

---

Anwendungskonfiguration

appsettings.Production.json

Die Produktionskonfigurationsdatei steuert Datenbank-, Authentifizierungs- und Diensteinstellungen:

{
  "Database": {
    "Provider": "Sqlite",
    "ConnectionString": "Data Source=/var/ramp/data/ramp.db",
    "AutoMigrate": true
  },
  "Jwt": {
    "Secret": "CHANGE_THIS_IN_PRODUCTION_MIN_32_CHARS",
    "Issuer": "https://your-domain.com",
    "Audience": "https://your-domain.com",
    "AccessTokenExpirationMinutes": 480,
    "RefreshTokenExpirationDays": 30
  },
  "CORS": {
    "AllowedOrigins": ["https://your-domain.com"]
  },
  "Cache": {
    "Provider": "InMemory"
  },
  "FileStorage": {
    "Provider": "Local",
    "LocalFileStorage": {
      "BasePath": "/var/ramp/data/files"
    }
  },
  "SignalR": {
    "UseRedisBackplane": false
  },
  "ForwardedHeaders": {
    "Enabled": true,
    "ForwardedHeaders": "All",
    "KnownProxies": ["127.0.0.1", "::1"]
  }
}

Gefahr

Ändern Sie das JWT-Secret immer vor dem Einsatz in der Produktion. Verwenden Sie einen zufällig generierten Schlüssel mit mindestens 32 Zeichen.

Die vollständige Konfigurationsreferenz finden Sie unter Anwendungseinstellungen.

Scaffold-Datei

Die Scaffold-Datei (default.yaml) befüllt die Datenbank beim ersten Start mit Mandanten, Benutzern, IDP-Verbindungen und Rollenzuordnungen.

Wichtige Abschnitte des Scaffolds:

• Mandantendefinition mit RAMP Internal und Keycloak OIDC-Identitätsanbietern
• Admin-Benutzer mit den Rollen Administrator und TenantAdministrator
• Rollenzuordnungen von Keycloak-Realm-Rollen und -Gruppen zu RAMP-Rollen

Tipp

Bearbeiten Sie die Scaffold-Datei vor der ersten Bereitstellung entsprechend den Benutzern und Rollen Ihrer Organisation.

---

Standardanmeldedaten

Dienst	URL	Benutzername	Passwort
RAMP	https://your-domain.com	admin	Passw0rd
Keycloak	https://your-domain.com:8443/admin	admin	Passw0rd

Vorsicht

Ändern Sie alle Standardpasswörter unmittelbar nach der Bereitstellung.

---

Integritätsprüfungen

# RAMP-Integrität
curl -s http://localhost:5000/_health

# Keycloak-Integrität
curl -s http://localhost:8180/health/ready

# Nginx-Status
sudo systemctl status nginx

---

Fehlerbehebung

RAMP startet nicht

# Dienststatus prüfen
sudo systemctl status ramp

# Detaillierte Protokolle anzeigen
sudo journalctl -u ramp -f

# Anwendungsprotokolle prüfen
ls -la /var/ramp/logs/

Häufige Ursachen:

• Fehlende appsettings.Production.json
• Datenbankverzeichnisberechtigungen (muss dem Benutzer ramp gehören)
• .NET Runtime nicht installiert

Keycloak startet nicht

# Dienststatus prüfen
sudo systemctl status keycloak

# Protokolle anzeigen
sudo journalctl -u keycloak -f

Häufige Ursachen:

• Java 21 nicht installiert
• Port 8180 bereits belegt
• Unzureichender Arbeitsspeicher (Keycloak benötigt ~512 MB)

Nginx gibt 502 Bad Gateway zurück

Ursache: RAMP läuft nicht oder hört nicht auf localhost:5000.

# Prüfen ob RAMP lauscht
sudo ss -tlnp | grep 5000

# RAMP neu starten
sudo systemctl restart ramp

Berechtigungsfehler

# Besitz korrigieren
sudo chown -R ramp:ramp /opt/ramp
sudo chown -R ramp:ramp /var/ramp

SSL-Zertifikatsprobleme

# Nginx-Konfiguration testen
sudo nginx -t

# Zertifikatsablauf prüfen
openssl x509 -in /etc/ssl/your-domain/cert.crt -noout -dates

---

Sicherung und Wiederherstellung

Sicherung

# Datenbank
cp /var/ramp/data/ramp.db /backups/ramp_$(date +%Y%m%d).db

# Hochgeladene Dateien
tar czf /backups/ramp_files_$(date +%Y%m%d).tar.gz /var/ramp/data/files/

# Anwendungskonfiguration
cp /opt/ramp/app/appsettings.Production.json /backups/

Wiederherstellung

# RAMP stoppen
sudo systemctl stop ramp

# Datenbank wiederherstellen
cp /backups/ramp_20260301.db /var/ramp/data/ramp.db
chown ramp:ramp /var/ramp/data/ramp.db

# RAMP starten
sudo systemctl start ramp

---

RAMP aktualisieren

1. Erstellen Sie ein neues Release auf Ihrem Entwicklungsrechner.

2. Übertragen Sie die veröffentlichten Dateien auf den Server:

   scp -r src/RAMP.API/publish/* user@your-server:/opt/ramp/app/

3. Führen Sie das Bereitstellungsskript erneut aus:

   sudo ./deploy-ramp.sh

Das Bereitstellungsskript stoppt den Dienst, kopiert Konfigurationsdateien und startet mit der neuen Version neu.

---

Produktions-Checkliste

• Alle Standardpasswörter ändern (RAMP-Admin, Keycloak-Admin, JWT-Secret)
• Gültige SSL-Zertifikate installieren
• CORS so konfigurieren, dass nur Ihre Produktionsdomäne erlaubt ist
• Automatische Sicherungen für Datenbank und Dateispeicher einrichten
• Protokollrotation für /var/ramp/logs/ konfigurieren
• Überwachung der Integritätsendpunkte einrichten
• Für Produktionslasten zu SQL Server oder PostgreSQL wechseln
• Redis für Caching und SignalR-Backplane beim Skalieren in Betracht ziehen

---

Verwandte Themen

Windows (IIS)-Bereitstellung RAMP auf Windows Server mit IIS und Windows-integrierter Authentifizierung bereitstellen

Docker Full Einzelserver-Produktionsbereitstellung mit PostgreSQL, LDAP und Nginx

Referenz der Anwendungseinstellungen Vollständige Referenz für die appsettings.json-Konfiguration von RAMP