2025-03-12 12:33:05 +01:00

4.3 KiB

Executable File

Raw Blame History

Bereitstellungsdetails und Best Practices

In diesem Abschnitt erläutere ich, wie das MYP-Projekt auf einem Server bereitgestellt wird, sowie empfohlene Praktiken zur Verwaltung und Optimierung des Systems.

1. Bereitstellungsschritte

1.1. Voraussetzungen

Server: Raspberry Pi mit installiertem Raspbian Lite.
Docker: Docker und Docker Compose müssen vorab installiert sein.
Netzwerk: Der Server muss über eine statische IP-Adresse oder einen DNS-Namen erreichbar sein.

1.2. Vorbereitung

1.2.1. Docker-Images erstellen und speichern

Führen Sie die folgenden Schritte auf dem Entwicklungssystem aus:

Images erstellen:
```
bash docker/build.sh
```
Images exportieren und komprimieren:
```
bash docker/save.sh <image-name>
```
Dies speichert die Docker-Images im Verzeichnis docker/images/.

1.2.2. Übertragung auf den Server

Kopieren Sie die erzeugten .tar.xz-Dateien auf den Raspberry Pi:

scp docker/images/*.tar.xz <username>@<server-ip>:/path/to/destination/

1.3. Images auf dem Server laden

Loggen Sie sich auf dem Server ein und laden Sie die Docker-Images:

docker load -i /path/to/destination/<image-name>.tar.xz

1.4. Starten der Anwendung

Führen Sie das Bereitstellungsskript aus:

bash docker/deploy.sh

Dieses Skript:

Startet die Docker-Container mithilfe von docker compose.
Verbindet den Reverse Proxy (Caddy) mit der Anwendung.

Die Anwendung sollte unter http://<server-ip> oder der konfigurierten Domain erreichbar sein.

2. Best Practices

2.1. Sicherheit

Umgebungsvariablen schützen:
- Stellen Sie sicher, dass die Datei .env nicht versehentlich in ein öffentliches Repository hochgeladen wird.
- Verwenden Sie geeignete Zugriffsrechte:
```
chmod 600 .env
```
HTTPS aktivieren:
- Der Caddy-Webserver unterstützt automatisch HTTPS. Stellen Sie sicher, dass eine gültige Domain konfiguriert ist.
Zugriffsrechte beschränken:
- Verwenden Sie Benutzerrollen („admin“, „guest“), um den Zugriff auf kritische Funktionen zu steuern.

2.2. Performance

Docker-Container optimieren:
- Reduzieren Sie die Größe der Docker-Images, indem Sie unnötige Dateien in .dockerignore ausschließen.
Datenbankwartung:
- Führen Sie regelmäßige Backups der SQLite-Datenbank durch:
```
cp db/sqlite.db /path/to/backup/location/
```
- Optimieren Sie die Datenbank regelmäßig:
```
VACUUM;
```
Skalierung:
- Bei hoher Last kann die Anwendung mit Kubernetes oder einer Cloud-Lösung (z. B. AWS oder Azure) skaliert werden.

2.3. Fehlerbehebung

Logs überprüfen:
- Docker-Logs können wichtige Debug-Informationen liefern:
```
docker logs <container-name>
```
Health Checks:
- Integrieren Sie Health Checks in die Docker Compose-Datei, um sicherzustellen, dass die Dienste korrekt laufen.
Fehlerhafte Drucker deaktivieren:
- Deaktivieren Sie Drucker mit einer hohen Fehlerrate über das Admin-Dashboard, um die Benutzererfahrung zu verbessern.

2.4. Updates

Neue Funktionen hinzufügen:
- Aktualisieren Sie die Anwendung und erstellen Sie neue Docker-Images:
```
git pull origin main
bash docker/build.sh
```
- Stellen Sie die aktualisierten Images bereit:
```
bash docker/deploy.sh
```
Datenbankmigrationen:
- Führen Sie neue Migrationsskripte mit folgendem Befehl aus:
```
pnpm run db:migrate
```

3. Backup und Wiederherstellung

3.1. Backups erstellen

Sichern Sie wichtige Dateien und Datenbanken regelmäßig:

SQLite-Datenbank:

cp db/sqlite.db /backup/location/sqlite-$(date +%F).db

Docker-Images:

docker save myp-rp:latest | gzip > /backup/location/myp-rp-$(date +%F).tar.gz

3.2. Wiederherstellung

Datenbank wiederherstellen:

cp /backup/location/sqlite-<date>.db db/sqlite.db

Docker-Images importieren:

docker load < /backup/location/myp-rp-<date>.tar.gz

Nächster Schritt: => Admin-Dashboard

4.3 KiB Executable File Raw Blame History