351 lines
9.8 KiB
Bash
351 lines
9.8 KiB
Bash
#!/bin/bash
|
|
|
|
# 🏭 MYP Backend - Installations-Skript
|
|
# Installiert das Backend für Produktionsbetrieb oder Entwicklung
|
|
|
|
set -e
|
|
|
|
# Farbcodes für Ausgabe
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[0;33m'
|
|
BLUE='\033[0;34m'
|
|
NC='\033[0m' # No Color
|
|
|
|
# Funktion zur Ausgabe mit Zeitstempel
|
|
log() {
|
|
echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
|
|
}
|
|
|
|
success_log() {
|
|
echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] SUCCESS:${NC} $1"
|
|
}
|
|
|
|
warning_log() {
|
|
echo -e "${YELLOW}[$(date +'%Y-%m-%d %H:%M:%S')] WARNING:${NC} $1"
|
|
}
|
|
|
|
error_log() {
|
|
echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
|
|
}
|
|
|
|
# Banner
|
|
echo "========================================"
|
|
echo "🏭 MYP Backend - Installation"
|
|
echo "========================================"
|
|
echo ""
|
|
|
|
# Arbeitsverzeichnis
|
|
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
|
cd "$SCRIPT_DIR"
|
|
|
|
log "Arbeitsverzeichnis: $SCRIPT_DIR"
|
|
|
|
# Installation-Modus bestimmen
|
|
INSTALL_MODE="development"
|
|
if [ "$1" = "--production" ]; then
|
|
INSTALL_MODE="production"
|
|
log "🚀 Produktions-Installation gewählt"
|
|
elif [ "$1" = "--development" ]; then
|
|
INSTALL_MODE="development"
|
|
log "🔧 Entwicklungs-Installation gewählt"
|
|
else
|
|
echo "Wählen Sie den Installationsmodus:"
|
|
echo "1) Entwicklung (empfohlen für lokale Tests)"
|
|
echo "2) Produktion (für Server-Deployment)"
|
|
read -p "Ihre Wahl (1/2): " choice
|
|
|
|
case $choice in
|
|
1) INSTALL_MODE="development" ;;
|
|
2) INSTALL_MODE="production" ;;
|
|
*) log "Verwende Standard-Entwicklungsmodus" && INSTALL_MODE="development" ;;
|
|
esac
|
|
fi
|
|
|
|
log "Installationsmodus: $INSTALL_MODE"
|
|
|
|
# Bereinige vorherige Installation
|
|
cleanup_existing_installation() {
|
|
log "🧹 Bereinige vorherige Installation..."
|
|
|
|
# Stoppe laufende Prozesse
|
|
if pgrep -f "flask run" > /dev/null; then
|
|
log "Stoppe laufende Flask-Prozesse..."
|
|
pkill -f "flask run" || true
|
|
fi
|
|
|
|
if pgrep -f "gunicorn" > /dev/null; then
|
|
log "Stoppe laufende Gunicorn-Prozesse..."
|
|
pkill -f "gunicorn.*wsgi:application" || true
|
|
fi
|
|
|
|
# Entferne alte virtuelle Umgebung
|
|
if [ -d "venv" ]; then
|
|
log "Entferne alte virtuelle Umgebung..."
|
|
rm -rf venv
|
|
fi
|
|
|
|
success_log "Bereinigung abgeschlossen"
|
|
}
|
|
|
|
# System-Dependencies prüfen und installieren
|
|
install_system_dependencies() {
|
|
log "🔧 Prüfe System-Dependencies..."
|
|
|
|
# Betriebssystem erkennen
|
|
if [ -f /etc/os-release ]; then
|
|
. /etc/os-release
|
|
OS=$NAME
|
|
VER=$VERSION_ID
|
|
elif type lsb_release >/dev/null 2>&1; then
|
|
OS=$(lsb_release -si)
|
|
VER=$(lsb_release -sr)
|
|
else
|
|
OS=$(uname -s)
|
|
VER=$(uname -r)
|
|
fi
|
|
|
|
log "Erkanntes System: $OS $VER"
|
|
|
|
# Python 3 prüfen
|
|
if ! command -v python3 &> /dev/null; then
|
|
error_log "Python 3 ist nicht installiert!"
|
|
log "Installationsanleitung:"
|
|
if [[ "$OS" == *"Ubuntu"* ]] || [[ "$OS" == *"Debian"* ]]; then
|
|
log "sudo apt update && sudo apt install python3 python3-pip python3-venv"
|
|
elif [[ "$OS" == *"CentOS"* ]] || [[ "$OS" == *"Red Hat"* ]]; then
|
|
log "sudo yum install python3 python3-pip"
|
|
elif [[ "$OS" == *"Alpine"* ]]; then
|
|
log "sudo apk add python3 py3-pip"
|
|
else
|
|
log "Bitte installieren Sie Python 3 manuell für Ihr System"
|
|
fi
|
|
exit 1
|
|
fi
|
|
|
|
# Python-Version prüfen
|
|
PYTHON_VERSION=$(python3 -c "import sys; print('.'.join(map(str, sys.version_info[:2])))")
|
|
log "Python-Version: $PYTHON_VERSION"
|
|
|
|
if python3 -c "import sys; exit(0 if sys.version_info >= (3, 8) else 1)"; then
|
|
success_log "Python-Version ist kompatibel (>= 3.8)"
|
|
else
|
|
error_log "Python-Version ist zu alt! Benötigt wird mindestens Python 3.8"
|
|
exit 1
|
|
fi
|
|
|
|
# pip prüfen
|
|
if ! command -v pip3 &> /dev/null; then
|
|
error_log "pip3 ist nicht installiert!"
|
|
log "Installiere pip3..."
|
|
if [[ "$OS" == *"Ubuntu"* ]] || [[ "$OS" == *"Debian"* ]]; then
|
|
sudo apt install python3-pip
|
|
else
|
|
error_log "Bitte installieren Sie pip3 manuell"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# Weitere notwendige System-Pakete prüfen
|
|
if [[ "$OS" == *"Ubuntu"* ]] || [[ "$OS" == *"Debian"* ]]; then
|
|
log "Prüfe System-Pakete für Ubuntu/Debian..."
|
|
|
|
# Prüfe ob build-essential installiert ist (für Compilation von Python-Paketen)
|
|
if ! dpkg -l | grep -q build-essential; then
|
|
log "Installiere build-essential..."
|
|
sudo apt update
|
|
sudo apt install -y build-essential python3-dev
|
|
fi
|
|
|
|
# Prüfe curl für Health-Checks
|
|
if ! command -v curl &> /dev/null; then
|
|
log "Installiere curl..."
|
|
sudo apt install -y curl
|
|
fi
|
|
fi
|
|
|
|
success_log "System-Dependencies sind verfügbar"
|
|
}
|
|
|
|
# Python virtuelle Umgebung erstellen
|
|
create_virtual_environment() {
|
|
log "🐍 Erstelle Python virtuelle Umgebung..."
|
|
|
|
# Erstelle virtuelle Umgebung
|
|
python3 -m venv venv
|
|
|
|
# Aktiviere virtuelle Umgebung
|
|
source venv/bin/activate
|
|
|
|
# Upgrade pip in virtueller Umgebung
|
|
log "Aktualisiere pip..."
|
|
pip install --upgrade pip
|
|
|
|
success_log "Virtuelle Umgebung erstellt und aktiviert"
|
|
}
|
|
|
|
# Python-Dependencies installieren
|
|
install_python_dependencies() {
|
|
log "📦 Installiere Python-Dependencies..."
|
|
|
|
# Aktiviere virtuelle Umgebung
|
|
source venv/bin/activate
|
|
|
|
# Installiere Requirements
|
|
if [ -f "requirements.txt" ]; then
|
|
log "Installiere aus requirements.txt..."
|
|
pip install -r requirements.txt
|
|
else
|
|
error_log "requirements.txt nicht gefunden!"
|
|
exit 1
|
|
fi
|
|
|
|
# Produktions-spezifische Dependencies
|
|
if [ "$INSTALL_MODE" = "production" ]; then
|
|
log "Installiere Produktions-Dependencies..."
|
|
pip install gunicorn supervisor
|
|
fi
|
|
|
|
success_log "Python-Dependencies installiert"
|
|
}
|
|
|
|
# Konfiguration vorbereiten
|
|
prepare_configuration() {
|
|
log "⚙️ Bereite Konfiguration vor..."
|
|
|
|
# Erstelle notwendige Verzeichnisse
|
|
mkdir -p instance logs migrations/versions
|
|
|
|
# Kopiere Beispiel-Umgebungsvariablen falls nicht vorhanden
|
|
if [ ! -f "env.backend" ]; then
|
|
if [ -f "env.example" ]; then
|
|
log "Erstelle env.backend aus Vorlage..."
|
|
cp env.example env.backend
|
|
else
|
|
log "Erstelle Standard env.backend..."
|
|
cat > env.backend << EOF
|
|
# MYP Backend Konfiguration
|
|
FLASK_ENV=$INSTALL_MODE
|
|
SECRET_KEY=$(python3 -c "import secrets; print(secrets.token_hex(32))")
|
|
DATABASE_PATH=instance/myp.db
|
|
LOG_LEVEL=INFO
|
|
JOB_CHECK_INTERVAL=60
|
|
PRINTERS={}
|
|
TAPO_USERNAME=
|
|
TAPO_PASSWORD=
|
|
EOF
|
|
fi
|
|
|
|
warning_log "env.backend wurde erstellt. Bitte anpassen!"
|
|
fi
|
|
|
|
success_log "Konfiguration vorbereitet"
|
|
}
|
|
|
|
# Datenbank initialisieren
|
|
initialize_database() {
|
|
log "🗄️ Initialisiere Datenbank..."
|
|
|
|
# Aktiviere virtuelle Umgebung
|
|
source venv/bin/activate
|
|
|
|
# Lade Umgebungsvariablen
|
|
if [ -f "env.backend" ]; then
|
|
export $(cat env.backend | grep -v '^#' | grep -v '^$' | xargs)
|
|
fi
|
|
|
|
# Setze Flask-App
|
|
export FLASK_APP=app.py
|
|
export FLASK_ENV=$INSTALL_MODE
|
|
|
|
# Initialisiere Datenbank
|
|
python3 -c "
|
|
from app import create_app, init_db
|
|
app = create_app('$INSTALL_MODE')
|
|
with app.app_context():
|
|
init_db()
|
|
print('✅ Datenbank initialisiert')
|
|
"
|
|
|
|
success_log "Datenbank initialisiert"
|
|
}
|
|
|
|
# Systemd-Service für Produktion erstellen
|
|
create_systemd_service() {
|
|
if [ "$INSTALL_MODE" = "production" ]; then
|
|
log "🔧 Erstelle systemd-Service für Produktion..."
|
|
|
|
SERVICE_FILE="/etc/systemd/system/myp-backend.service"
|
|
|
|
sudo tee $SERVICE_FILE > /dev/null << EOF
|
|
[Unit]
|
|
Description=MYP Backend Flask Application
|
|
After=network.target
|
|
|
|
[Service]
|
|
Type=exec
|
|
User=$USER
|
|
Group=$USER
|
|
WorkingDirectory=$SCRIPT_DIR
|
|
Environment=PATH=$SCRIPT_DIR/venv/bin
|
|
EnvironmentFile=$SCRIPT_DIR/env.backend
|
|
ExecStart=$SCRIPT_DIR/venv/bin/gunicorn --bind 0.0.0.0:5000 --workers 4 wsgi:application
|
|
ExecReload=/bin/kill -s HUP \$MAINPID
|
|
Restart=always
|
|
RestartSec=10
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
EOF
|
|
|
|
sudo systemctl daemon-reload
|
|
sudo systemctl enable myp-backend
|
|
|
|
success_log "Systemd-Service erstellt: myp-backend.service"
|
|
log "Starten mit: sudo systemctl start myp-backend"
|
|
log "Status prüfen mit: sudo systemctl status myp-backend"
|
|
fi
|
|
}
|
|
|
|
# Hauptinstallation
|
|
main() {
|
|
cleanup_existing_installation
|
|
install_system_dependencies
|
|
create_virtual_environment
|
|
install_python_dependencies
|
|
prepare_configuration
|
|
initialize_database
|
|
create_systemd_service
|
|
|
|
echo ""
|
|
echo "========================================"
|
|
success_log "🎉 Installation erfolgreich abgeschlossen!"
|
|
echo "========================================"
|
|
echo ""
|
|
|
|
log "Nächste Schritte:"
|
|
echo ""
|
|
|
|
if [ "$INSTALL_MODE" = "production" ]; then
|
|
echo "📋 Produktionsbetrieb:"
|
|
echo " 1. Konfiguration prüfen: nano env.backend"
|
|
echo " 2. Service starten: sudo systemctl start myp-backend"
|
|
echo " 3. Service prüfen: sudo systemctl status myp-backend"
|
|
echo " 4. Oder manuell: ./start-production.sh"
|
|
else
|
|
echo "🔧 Entwicklungsbetrieb:"
|
|
echo " 1. Konfiguration prüfen: nano env.backend"
|
|
echo " 2. Server starten: ./start-backend-server.sh"
|
|
echo " 3. Development-Server: ./start-backend-server.sh --development"
|
|
fi
|
|
|
|
echo ""
|
|
echo "📡 Backend wird verfügbar sein unter:"
|
|
echo " - API: http://localhost:5000"
|
|
echo " - Health-Check: http://localhost:5000/health"
|
|
echo " - Test: http://localhost:5000/api/test"
|
|
echo ""
|
|
}
|
|
|
|
# Installation starten
|
|
main "$@" |