olafn/infoscreen

Fork 0

Files

RobbStarkAustria 1efe40a03b Initial commit - copied workspace after database cleanup

2025-10-10 15:20:14 +00:00

10 KiB

Raw Blame History

Infoscreen Deployment Guide

Komplette Anleitung für das Deployment des Infoscreen-Systems auf einem Ubuntu-Server mit GitHub Container Registry.

📋 Übersicht

Phase 0: Docker Installation (optional)
Phase 1: Images bauen und zur Registry pushen
Phase 2: Ubuntu-Server Installation
Phase 3: System-Konfiguration und Start

🐳 Phase 0: Docker Installation (optional)

Falls Docker noch nicht installiert ist, wählen Sie eine der folgenden Optionen:

Option A: Ubuntu Repository (schnell)

# Standard Ubuntu Docker-Pakete
sudo apt update
sudo apt install docker.io docker-compose-plugin -y
sudo systemctl enable docker
sudo systemctl start docker

Option B: Offizielle Docker-Installation (empfohlen)

# Alte Docker-Versionen entfernen
sudo apt remove docker docker-engine docker.io containerd runc -y

# Abhängigkeiten installieren
sudo apt update
sudo apt install ca-certificates curl gnupg lsb-release -y

# Docker GPG-Key hinzufügen
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Docker Repository hinzufügen
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Docker installieren (neueste Version)
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# Docker aktivieren und starten
sudo systemctl enable docker
sudo systemctl start docker

# User zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER

# Neuanmeldung für Gruppenänderung erforderlich
exit
# Neu einloggen via SSH

Docker-Installation testen

# Test-Container ausführen
docker run hello-world

# Docker-Version prüfen
docker --version
docker compose version

🏗️ Phase 1: Images bauen und pushen (Entwicklungsmaschine)

# GitHub Personal Access Token mit write:packages Berechtigung erstellen
echo $GITHUB_TOKEN | docker login ghcr.io -u robbstarkaustria --password-stdin

# Oder interaktiv:
docker login ghcr.io
# Username: robbstarkaustria
# Password: [GITHUB_TOKEN]

2. Images bauen und taggen

cd /workspace

# Server-Image bauen
docker build -f server/Dockerfile -t ghcr.io/robbstarkaustria/infoscreen-api:latest .

# Dashboard-Image bauen
docker build -f dashboard/Dockerfile -t ghcr.io/robbstarkaustria/infoscreen-dashboard:latest .

# Listener-Image bauen (falls vorhanden)
docker build -f listener/Dockerfile -t ghcr.io/robbstarkaustria/infoscreen-listener:latest .

# Scheduler-Image bauen (falls vorhanden)
docker build -f scheduler/Dockerfile -t ghcr.io/robbstarkaustria/infoscreen-scheduler:latest .

3. Images zur Registry pushen

# Alle Images pushen
docker push ghcr.io/robbstarkaustria/infoscreen-api:latest
docker push ghcr.io/robbstarkaustria/infoscreen-dashboard:latest
docker push ghcr.io/robbstarkaustria/infoscreen-listener:latest
docker push ghcr.io/robbstarkaustria/infoscreen-scheduler:latest

# Status prüfen
docker images | grep ghcr.io

🖥️ Phase 2: Ubuntu-Server Installation

4. Ubuntu Server vorbereiten

sudo apt update && sudo apt upgrade -y

# Grundlegende Tools installieren
sudo apt install git curl wget -y

# Docker installieren (siehe Phase 0)

5. Deployment-Dateien übertragen

# Deployment-Ordner erstellen
mkdir -p ~/infoscreen-deployment
cd ~/infoscreen-deployment

# Dateien vom Dev-System kopieren (über SCP)
scp user@dev-machine:/workspace/docker-compose.prod.yml .
scp user@dev-machine:/workspace/.env .
scp user@dev-machine:/workspace/nginx.conf .
scp -r user@dev-machine:/workspace/certs ./
scp -r user@dev-machine:/workspace/mosquitto ./

# Alternative: Deployment-Paket verwenden
# Auf Dev-Maschine (/workspace):
# tar -czf infoscreen-deployment.tar.gz docker-compose.prod.yml .env nginx.conf certs/ mosquitto/
# scp infoscreen-deployment.tar.gz user@server:~/
# Auf Server: tar -xzf infoscreen-deployment.tar.gz

6. Mosquitto-Konfiguration vorbereiten

# Falls mosquitto-Ordner noch nicht vollständig vorhanden:
mkdir -p mosquitto/{config,data,log}

# Mosquitto-Konfiguration erstellen (falls nicht übertragen)
cat > mosquitto/config/mosquitto.conf << 'EOF'
# -----------------------------
# Netzwerkkonfiguration
# -----------------------------
listener 1883
allow_anonymous true
# password_file /mosquitto/config/passwd

# WebSocket (optional)
listener 9001
protocol websockets

# -----------------------------
# Persistence & Pfade
# -----------------------------
persistence true
persistence_location /mosquitto/data/

log_dest file /mosquitto/log/mosquitto.log
EOF

# Berechtigungen für Mosquitto setzen
sudo chown -R 1883:1883 mosquitto/data mosquitto/log
chmod 755 mosquitto/config mosquitto/data mosquitto/log

7. Environment-Variablen anpassen

# .env für Produktionsumgebung anpassen
nano .env

# Wichtige Anpassungen:
# VITE_API_URL=https://YOUR_SERVER_HOST/api  # Für Dashboard-Build (Production)
# DB_HOST=db                                 # In Containern immer 'db'
# DB_CONN=mysql+pymysql://${DB_USER}:${DB_PASSWORD}@db/${DB_NAME}
# Alle Passwörter für Produktion ändern

Hinweise:

Eine Vorlage .env.example liegt im Repo. Kopiere sie als Ausgangspunkt: cp .env.example .env.
Für lokale Entwicklung lädt server/database.py die .env, wenn ENV=development gesetzt ist.
In Produktion verwaltet Compose/Container die Variablen; kein automatisches .env-Load im Code nötig.

🚀 Phase 3: System-Start und Konfiguration

8. Images von Registry pullen

# GitHub Container Registry Login (falls private Repository)
echo $GITHUB_TOKEN | docker login ghcr.io -u robbstarkaustria --password-stdin

# Images pullen
docker compose -f docker-compose.prod.yml pull

9. System starten

# Container starten
docker compose -f docker-compose.prod.yml up -d

# Status prüfen
docker compose ps
docker compose logs -f

10. Firewall konfigurieren

sudo ufw enable
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 1883/tcp  # MQTT
sudo ufw allow 9001/tcp  # MQTT WebSocket
sudo ufw status

11. Installation validieren

# Health-Checks
curl http://localhost/api/health
curl https://localhost -k  # -k für selbstsignierte Zertifikate

# Container-Status
docker compose ps

# Logs bei Problemen anzeigen
docker compose logs server
docker compose logs dashboard
docker compose logs mqtt

🧪 Quickstart (Entwicklung)

Schneller Start der Entwicklungsumgebung mit automatischen Proxys und Hot-Reload.

# Im Repository-Root
# 1) .env aus Vorlage erzeugen (lokal, falls noch nicht vorhanden)
cp -n .env.example .env

# 2) Dev-Stack starten (verwendet docker-compose.yml + docker-compose.override.yml)
docker compose up -d --build

# 3) Status & Logs
docker compose ps
docker compose logs -f server
docker compose logs -f dashboard
docker compose logs -f mqtt

# 4) Stack stoppen
docker compose down

Erreichbarkeit (Dev):

Dashboard (Vite): http://localhost:5173
API (Flask Dev): http://localhost:8000/api
API Health: http://localhost:8000/health
Screenshots: http://localhost:8000/screenshots/.jpg
MQTT: localhost:1883 (WebSocket: localhost:9001)

Hinweise:

ENV=development lädt .env automatisch in server/database.py.
Vite proxy routet /api und /screenshots in Dev direkt auf die API (siehe dashboard/vite.config.ts).

12. Automatischer Start (optional)

# Systemd-Service erstellen
sudo tee /etc/systemd/system/infoscreen.service > /dev/null << 'EOF'
[Unit]
Description=Infoscreen Application
Requires=docker.service
After=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/home/$USER/infoscreen-deployment
ExecStart=/usr/bin/docker compose -f docker-compose.prod.yml up -d
ExecStop=/usr/bin/docker compose -f docker-compose.prod.yml down
TimeoutStartSec=300

[Install]
WantedBy=multi-user.target
EOF

# Service aktivieren
sudo systemctl enable infoscreen.service
sudo systemctl start infoscreen.service

🌐 Zugriff auf die Anwendung

Nach erfolgreichem Deployment ist die Anwendung unter folgenden URLs erreichbar:

HTTPS Dashboard: https://YOUR_SERVER_IP
HTTP Dashboard: http://YOUR_SERVER_IP (Redirect zu HTTPS)
API: http://YOUR_SERVER_IP/api/
MQTT: YOUR_SERVER_IP:1883
MQTT WebSocket: YOUR_SERVER_IP:9001

🔧 Troubleshooting

Container-Status prüfen

# Alle Container anzeigen
docker compose ps

# Spezifische Logs anzeigen
docker compose logs -f [service-name]

# Container einzeln neustarten
docker compose restart [service-name]

System neustarten

# Komplett neu starten
docker compose down
docker compose up -d

# Images neu pullen
docker compose pull
docker compose up -d

Häufige Probleme

Problem	Lösung
Container startet nicht	`docker compose logs [service]` prüfen
Ports bereits belegt	`sudo netstat -tulpn \| grep :80` prüfen
Keine Berechtigung	User zu docker-Gruppe hinzufügen
DB-Verbindung fehlschlägt	Environment-Variablen in `.env` prüfen
Mosquitto startet nicht	Ordner-Berechtigungen für `1883:1883` setzen

📊 Docker-Version Vergleich

Aspekt	Ubuntu Repository	Offizielle Installation
Installation	✅ Schnell (1 Befehl)	⚠️ Mehrere Schritte
Version	⚠️ Oft älter	✅ Neueste Version
Updates	✅ Via apt	✅ Via apt (nach Setup)
Stabilität	✅ Getestet	✅ Aktuell
Features	⚠️ Möglicherweise eingeschränkt	✅ Alle Features

Empfehlung: Für Produktion die offizielle Docker-Installation verwenden.

📝 Wartung

Regelmäßige Updates

# Images aktualisieren
docker compose pull
docker compose up -d

# System-Updates
sudo apt update && sudo apt upgrade -y

Backup

# Container-Daten sichern
docker compose down
sudo tar -czf infoscreen-backup-$(date +%Y%m%d).tar.gz mosquitto/data/ certs/

# Backup wiederherstellen
sudo tar -xzf infoscreen-backup-YYYYMMDD.tar.gz
docker compose up -d

**Das Infoscreen-System ist jetzt vollständig über GitHub

10 KiB Raw Blame History