"feat: Refactor backend configuration files, remove test scripts"
This commit is contained in:
parent
80172951d7
commit
117f7a857f
@ -221,19 +221,3 @@ def create_simple_ssl_cert():
|
||||
except Exception as e:
|
||||
print(f"Fehler beim Erstellen der SSL-Zertifikate: {e}")
|
||||
return None
|
||||
|
||||
# Debug-Informationen für Pfad-Überprüfung
|
||||
if __name__ == "__main__":
|
||||
print("=== Pfad-Konfiguration ===")
|
||||
print(f"BASE_DIR: {BASE_DIR}")
|
||||
print(f"PROJECT_ROOT: {PROJECT_ROOT}")
|
||||
print(f"DATABASE_PATH: {DATABASE_PATH}")
|
||||
print(f"LOG_DIR: {LOG_DIR}")
|
||||
print(f"SSL_CERT_PATH: {SSL_CERT_PATH}")
|
||||
print(f"SSL_KEY_PATH: {SSL_KEY_PATH}")
|
||||
print()
|
||||
print("=== Pfad-Existenz ===")
|
||||
print(f"Datenbank existiert: {os.path.exists(DATABASE_PATH)}")
|
||||
print(f"Log-Verzeichnis existiert: {os.path.exists(LOG_DIR)}")
|
||||
print(f"SSL-Zertifikat existiert: {os.path.exists(SSL_CERT_PATH)}")
|
||||
print(f"SSL-Schlüssel existiert: {os.path.exists(SSL_KEY_PATH)}")
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Test-Skript für Pfad-Überprüfung"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
# Aktuelles Verzeichnis hinzufügen
|
||||
sys.path.append('.')
|
||||
|
||||
try:
|
||||
from config.settings import (
|
||||
BASE_DIR, PROJECT_ROOT, DATABASE_PATH,
|
||||
LOG_DIR, SSL_CERT_PATH, SSL_KEY_PATH
|
||||
)
|
||||
|
||||
print("=== Pfad-Konfiguration ===")
|
||||
print(f"BASE_DIR: {BASE_DIR}")
|
||||
print(f"PROJECT_ROOT: {PROJECT_ROOT}")
|
||||
print(f"DATABASE_PATH: {DATABASE_PATH}")
|
||||
print(f"LOG_DIR: {LOG_DIR}")
|
||||
print(f"SSL_CERT_PATH: {SSL_CERT_PATH}")
|
||||
print(f"SSL_KEY_PATH: {SSL_KEY_PATH}")
|
||||
print()
|
||||
|
||||
print("=== Pfad-Existenz ===")
|
||||
print(f"Datenbank existiert: {os.path.exists(DATABASE_PATH)}")
|
||||
print(f"Log-Verzeichnis existiert: {os.path.exists(LOG_DIR)}")
|
||||
print(f"SSL-Zertifikat existiert: {os.path.exists(SSL_CERT_PATH)}")
|
||||
print(f"SSL-Schlüssel existiert: {os.path.exists(SSL_KEY_PATH)}")
|
||||
print()
|
||||
|
||||
print("=== Absolute Pfade ===")
|
||||
print(f"DATABASE_PATH absolut: {os.path.abspath(DATABASE_PATH)}")
|
||||
print(f"LOG_DIR absolut: {os.path.abspath(LOG_DIR)}")
|
||||
print(f"SSL_CERT_PATH absolut: {os.path.abspath(SSL_CERT_PATH)}")
|
||||
|
||||
except ImportError as e:
|
||||
print(f"Import-Fehler: {e}")
|
||||
except Exception as e:
|
||||
print(f"Fehler: {e}")
|
||||
@ -1,245 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Raspberry Pi Bereinigungsskript für MYP-Projekt Frontend
|
||||
# Dieses Skript bereinigt alte Docker-Installationen und installiert alle erforderlichen Abhängigkeiten
|
||||
|
||||
# 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"
|
||||
}
|
||||
|
||||
error_log() {
|
||||
echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
|
||||
}
|
||||
|
||||
# Prüfen, ob das Skript mit Root-Rechten ausgeführt wird
|
||||
if [ "$EUID" -ne 0 ]; then
|
||||
error_log "Dieses Skript muss mit Root-Rechten ausgeführt werden (sudo)."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "${YELLOW}=== MYP Frontend Raspberry Pi Bereinigung und Setup ===${NC}"
|
||||
log "Dieses Skript wird alle alten Docker-Installationen entfernen und die erforderlichen Abhängigkeiten neu installieren."
|
||||
|
||||
# Sicherstellen, dass apt funktioniert
|
||||
log "Aktualisiere apt-Paketindex..."
|
||||
apt-get update || {
|
||||
error_log "Konnte apt-Paketindex nicht aktualisieren."
|
||||
exit 1
|
||||
}
|
||||
|
||||
# Installiere grundlegende Abhängigkeiten
|
||||
log "Installiere grundlegende Abhängigkeiten..."
|
||||
apt-get install -y \
|
||||
apt-transport-https \
|
||||
ca-certificates \
|
||||
curl \
|
||||
gnupg \
|
||||
lsb-release \
|
||||
wget \
|
||||
git \
|
||||
jq \
|
||||
|| {
|
||||
error_log "Konnte grundlegende Abhängigkeiten nicht installieren."
|
||||
exit 1
|
||||
}
|
||||
|
||||
# Stoppe alle laufenden Docker-Container
|
||||
log "${YELLOW}Stoppe alle laufenden Docker-Container...${NC}"
|
||||
if command -v docker &> /dev/null; then
|
||||
docker stop $(docker ps -aq) 2>/dev/null || true
|
||||
log "Alle Docker-Container gestoppt."
|
||||
else
|
||||
log "Docker ist nicht installiert, keine Container zu stoppen."
|
||||
fi
|
||||
|
||||
# Entferne alte Docker-Installation
|
||||
log "${YELLOW}Entferne alte Docker-Installation...${NC}"
|
||||
apt-get remove -y docker docker-engine docker.io containerd runc docker-ce docker-ce-cli containerd.io docker-compose-plugin docker-compose || true
|
||||
apt-get autoremove -y || true
|
||||
rm -rf /var/lib/docker /var/lib/containerd /var/run/docker.sock /etc/docker /usr/local/bin/docker-compose 2>/dev/null || true
|
||||
log "${GREEN}Alte Docker-Installation entfernt.${NC}"
|
||||
|
||||
# Entferne alte Projektcontainer und -Dateien
|
||||
log "${YELLOW}Entferne alte MYP-Projektcontainer und -Dateien...${NC}"
|
||||
if command -v docker &> /dev/null; then
|
||||
# Entferne Container
|
||||
docker rm -f myp-frontend myp-backend 2>/dev/null || true
|
||||
# Entferne Images
|
||||
docker rmi -f myp-frontend myp-backend 2>/dev/null || true
|
||||
# Entferne unbenutzte Volumes und Netzwerke
|
||||
docker system prune -af --volumes 2>/dev/null || true
|
||||
fi
|
||||
|
||||
# Erkennen der Raspberry Pi-Architektur
|
||||
log "Erkenne Systemarchitektur..."
|
||||
ARCH=$(dpkg --print-architecture)
|
||||
log "Erkannte Architektur: ${ARCH}"
|
||||
|
||||
# Installiere Docker mit dem offiziellen Convenience-Skript
|
||||
log "${YELLOW}Installiere Docker mit dem offiziellen Convenience-Skript...${NC}"
|
||||
curl -fsSL https://get.docker.com -o get-docker.sh
|
||||
sh get-docker.sh --channel stable
|
||||
|
||||
# Überprüfen, ob Docker erfolgreich installiert wurde
|
||||
if ! command -v docker &> /dev/null; then
|
||||
error_log "Docker-Installation fehlgeschlagen!"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "${GREEN}Docker erfolgreich installiert!${NC}"
|
||||
|
||||
# Füge den aktuellen Benutzer zur Docker-Gruppe hinzu
|
||||
if [ "$SUDO_USER" ]; then
|
||||
log "Füge Benutzer $SUDO_USER zur Docker-Gruppe hinzu..."
|
||||
usermod -aG docker $SUDO_USER
|
||||
log "${YELLOW}Hinweis: Eine Neuanmeldung ist erforderlich, damit die Gruppenänderung wirksam wird.${NC}"
|
||||
fi
|
||||
|
||||
# Konfiguriere Docker mit DNS-Servern für bessere Netzwerkkompatibilität
|
||||
log "Konfiguriere Docker mit Google DNS..."
|
||||
mkdir -p /etc/docker
|
||||
cat > /etc/docker/daemon.json << EOL
|
||||
{
|
||||
"dns": ["8.8.8.8", "8.8.4.4"]
|
||||
}
|
||||
EOL
|
||||
|
||||
# Starte Docker-Dienst neu
|
||||
log "Starte Docker-Dienst neu..."
|
||||
systemctl restart docker
|
||||
systemctl enable docker
|
||||
log "${GREEN}Docker-Dienst neu gestartet und für den Autostart aktiviert.${NC}"
|
||||
|
||||
# Installiere Docker Compose v2
|
||||
log "${YELLOW}Installiere Docker Compose...${NC}"
|
||||
|
||||
# Bestimme die passende Docker Compose-Version für die Architektur
|
||||
if [ "$ARCH" = "armhf" ]; then
|
||||
log "Installiere Docker Compose für armhf (32-bit)..."
|
||||
curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-armv7" -o /usr/local/bin/docker-compose
|
||||
elif [ "$ARCH" = "arm64" ]; then
|
||||
log "Installiere Docker Compose für arm64 (64-bit)..."
|
||||
curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-aarch64" -o /usr/local/bin/docker-compose
|
||||
else
|
||||
log "Unbekannte Architektur, verwende automatische Erkennung..."
|
||||
curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
|
||||
fi
|
||||
|
||||
chmod +x /usr/local/bin/docker-compose
|
||||
|
||||
# Überprüfe, ob Docker Compose installiert wurde
|
||||
if ! command -v docker-compose &> /dev/null; then
|
||||
error_log "Docker Compose-Installation fehlgeschlagen!"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Installiere Docker Compose Plugin (neuere Methode)
|
||||
log "Installiere Docker Compose Plugin..."
|
||||
apt-get update
|
||||
apt-get install -y docker-compose-plugin
|
||||
|
||||
log "${GREEN}Docker Compose erfolgreich installiert!${NC}"
|
||||
docker compose version || docker-compose --version
|
||||
|
||||
# Installiere zusätzliche Abhängigkeiten für das Frontend
|
||||
log "${YELLOW}Installiere zusätzliche Frontend-Abhängigkeiten...${NC}"
|
||||
apt-get install -y \
|
||||
nodejs \
|
||||
npm \
|
||||
|| {
|
||||
error_log "Konnte zusätzliche Frontend-Abhängigkeiten nicht installieren."
|
||||
exit 1
|
||||
}
|
||||
|
||||
# Installiere Node.js LTS-Version über NodeSource
|
||||
log "${YELLOW}Installiere aktuelle Node.js LTS-Version...${NC}"
|
||||
curl -fsSL https://deb.nodesource.com/setup_18.x | bash -
|
||||
apt-get install -y nodejs
|
||||
|
||||
# Überprüfe Node.js-Installation
|
||||
NODE_VERSION=$(node -v)
|
||||
log "${GREEN}Node.js $NODE_VERSION erfolgreich installiert!${NC}"
|
||||
|
||||
# Installiere pnpm
|
||||
log "${YELLOW}Installiere pnpm Paketmanager...${NC}"
|
||||
npm install -g pnpm
|
||||
log "${GREEN}pnpm $(pnpm --version) erfolgreich installiert!${NC}"
|
||||
|
||||
# Optimieren des Raspberry Pi für Docker-Workloads
|
||||
log "${YELLOW}Optimiere Raspberry Pi für Docker-Workloads...${NC}"
|
||||
|
||||
# Swap erhöhen für bessere Performance bei begrenztem RAM
|
||||
log "Konfiguriere Swap-Größe..."
|
||||
CURRENT_SWAP=$(grep "CONF_SWAPSIZE" /etc/dphys-swapfile | cut -d= -f2)
|
||||
log "Aktuelle Swap-Größe: ${CURRENT_SWAP}"
|
||||
|
||||
# Erhöhe Swap auf 2GB, wenn weniger
|
||||
if [ "$CURRENT_SWAP" -lt 2048 ]; then
|
||||
sed -i 's/^CONF_SWAPSIZE=.*/CONF_SWAPSIZE=2048/' /etc/dphys-swapfile
|
||||
log "Swap-Größe auf 2048MB erhöht, Neustart des Swap-Dienstes erforderlich."
|
||||
|
||||
# Neustart des Swap-Dienstes
|
||||
/etc/init.d/dphys-swapfile restart
|
||||
else
|
||||
log "Swap-Größe ist bereits ausreichend."
|
||||
fi
|
||||
|
||||
# Konfiguriere cgroup für Docker
|
||||
if ! grep -q "cgroup_enable=memory" /boot/cmdline.txt; then
|
||||
log "Konfiguriere cgroup für Docker..."
|
||||
CMDLINE=$(cat /boot/cmdline.txt)
|
||||
echo "$CMDLINE cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1" > /boot/cmdline.txt
|
||||
log "${YELLOW}WICHTIG: Ein Systemneustart ist erforderlich, damit die cgroup-Änderungen wirksam werden.${NC}"
|
||||
fi
|
||||
|
||||
# Erstelle Datenbankverzeichnis für Frontend
|
||||
log "Erstelle Datenbankverzeichnis für Frontend..."
|
||||
mkdir -p /srv/MYP-DB
|
||||
chmod 777 /srv/MYP-DB
|
||||
|
||||
# Erstelle Umgebungsvariablen-Verzeichnis
|
||||
log "Erstelle Umgebungsvariablen-Verzeichnis..."
|
||||
mkdir -p /srv/myp-env
|
||||
cat > /srv/myp-env/github.env << EOL
|
||||
# OAuth-Konfiguration für Frontend
|
||||
OAUTH_CLIENT_ID=client_id
|
||||
OAUTH_CLIENT_SECRET=client_secret
|
||||
NEXT_PUBLIC_API_URL=http://192.168.0.105:5000
|
||||
EOL
|
||||
chmod 600 /srv/myp-env/github.env
|
||||
|
||||
# Prüfe, ob Frontend-Installationsdateien vorhanden sind
|
||||
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
FRONTEND_DIR="$SCRIPT_DIR"
|
||||
|
||||
if [ -f "$FRONTEND_DIR/package.json" ]; then
|
||||
log "${GREEN}Frontend-Projektdateien gefunden in $FRONTEND_DIR${NC}"
|
||||
else
|
||||
log "${YELLOW}Warnung: Frontend-Projektdateien nicht gefunden in $FRONTEND_DIR${NC}"
|
||||
fi
|
||||
|
||||
# Abschlussmeldung
|
||||
log "${GREEN}=== Bereinigung und Setup abgeschlossen ===${NC}"
|
||||
log "${YELLOW}WICHTIGE HINWEISE:${NC}"
|
||||
log "1. Ein ${RED}SYSTEMNEUSTART${NC} ist ${RED}DRINGEND ERFORDERLICH${NC}, damit alle Änderungen wirksam werden."
|
||||
log "2. Nach dem Neustart können Sie das Frontend-Installationsskript ausführen:"
|
||||
log " cd $FRONTEND_DIR && ./install.sh"
|
||||
log "3. Bei Problemen mit Docker-Berechtigungen stellen Sie sicher, dass Sie sich neu angemeldet haben."
|
||||
log "4. Sie müssen noch die OAuth-Konfiguration in /srv/myp-env/github.env anpassen."
|
||||
|
||||
echo ""
|
||||
read -p "Möchten Sie das System jetzt neu starten? (j/n): " REBOOT_CHOICE
|
||||
if [[ "$REBOOT_CHOICE" == "j" ]]; then
|
||||
log "System wird neu gestartet..."
|
||||
reboot
|
||||
else
|
||||
log "Bitte starten Sie das System manuell neu, bevor Sie die Installationsskripte ausführen."
|
||||
fi
|
||||
@ -1,31 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Define image name
|
||||
MYP_RP_IMAGE_NAME="myp-rp"
|
||||
|
||||
# Function to build Docker image
|
||||
build_image() {
|
||||
local image_name=$1
|
||||
local dockerfile=$2
|
||||
local platform=$3
|
||||
|
||||
echo "Building $image_name Docker image for $platform..."
|
||||
|
||||
docker buildx build --platform $platform -t ${image_name}:latest -f $dockerfile --load .
|
||||
if [ $? -eq 0 ]; then
|
||||
echo "$image_name Docker image built successfully"
|
||||
else
|
||||
echo "Error occurred while building $image_name Docker image"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Create and use a builder instance (if not already created)
|
||||
BUILDER_NAME="myp-rp-arm64-builder"
|
||||
docker buildx create --name $BUILDER_NAME --use || docker buildx use $BUILDER_NAME
|
||||
|
||||
# Build myp-rp image
|
||||
build_image "$MYP_RP_IMAGE_NAME" "$PWD/Dockerfile" "linux/arm64"
|
||||
|
||||
# Remove the builder instance
|
||||
docker buildx rm $BUILDER_NAME
|
||||
@ -1,68 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Get image name as argument
|
||||
IMAGE_NAME=$1
|
||||
PLATFORM="linux/arm64"
|
||||
|
||||
# Define paths
|
||||
IMAGE_DIR="docker/images"
|
||||
IMAGE_FILE="${IMAGE_DIR}/${IMAGE_NAME//[:\/]/_}.tar"
|
||||
COMPRESSED_FILE="${IMAGE_FILE}.xz"
|
||||
|
||||
# Function to pull the image
|
||||
pull_image() {
|
||||
local image=$1
|
||||
if [[ $image == arm64v8/* ]]; then
|
||||
echo "Pulling image $image without platform specification..."
|
||||
docker pull $image
|
||||
else
|
||||
echo "Pulling image $image for platform $PLATFORM..."
|
||||
docker pull --platform $PLATFORM $image
|
||||
fi
|
||||
return $?
|
||||
}
|
||||
|
||||
# Pull the image if it is not available locally
|
||||
if ! docker image inspect ${IMAGE_NAME} &>/dev/null; then
|
||||
if pull_image ${IMAGE_NAME}; then
|
||||
echo "Image $IMAGE_NAME pulled successfully."
|
||||
else
|
||||
echo "Error occurred while pulling $IMAGE_NAME for platform $PLATFORM"
|
||||
echo "Trying to pull $IMAGE_NAME without platform specification..."
|
||||
|
||||
# Attempt to pull again without platform
|
||||
if pull_image ${IMAGE_NAME}; then
|
||||
echo "Image $IMAGE_NAME pulled successfully without platform."
|
||||
else
|
||||
echo "Error occurred while pulling $IMAGE_NAME without platform."
|
||||
echo "Trying to pull arm64v8/${IMAGE_NAME} instead..."
|
||||
|
||||
# Construct new image name
|
||||
NEW_IMAGE_NAME="arm64v8/${IMAGE_NAME}"
|
||||
if pull_image ${NEW_IMAGE_NAME}; then
|
||||
echo "Image $NEW_IMAGE_NAME pulled successfully."
|
||||
IMAGE_NAME=${NEW_IMAGE_NAME} # Update IMAGE_NAME to use the new one
|
||||
else
|
||||
echo "Error occurred while pulling $NEW_IMAGE_NAME"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
else
|
||||
echo "Image $IMAGE_NAME found locally. Skipping pull."
|
||||
fi
|
||||
|
||||
# Save the Docker image
|
||||
echo "Saving $IMAGE_NAME Docker image..."
|
||||
docker save ${IMAGE_NAME} > $IMAGE_FILE
|
||||
|
||||
# Compress the Docker image (overwriting if file exists)
|
||||
echo "Compressing $IMAGE_FILE..."
|
||||
xz -z --force $IMAGE_FILE
|
||||
|
||||
if [ $? -eq 0 ]; then
|
||||
echo "$IMAGE_NAME Docker image saved and compressed successfully as $COMPRESSED_FILE"
|
||||
else
|
||||
echo "Error occurred while compressing $IMAGE_NAME Docker image"
|
||||
exit 1
|
||||
fi
|
||||
@ -1,376 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# HTTPS-Setup-Skript für das MYP-Projekt
|
||||
# Konfiguriert einen Raspberry Pi mit einer dual-network-Konfiguration
|
||||
# - LAN (eth0): Firmennetzwerk mit Zugang zu Internet und unter https://m040tbaraspi001.de040.corpintra.net/ erreichbar
|
||||
# - WLAN (wlan0): Verbindung zum Offline-Netzwerk, wo der Backend-Host erreichbar ist
|
||||
|
||||
# Farbcodes für Ausgabe
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[0;33m'
|
||||
BLUE='\033[0;34m'
|
||||
CYAN='\033[0;36m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Funktion zur Ausgabe mit Zeitstempel
|
||||
log() {
|
||||
echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
|
||||
}
|
||||
|
||||
error_log() {
|
||||
echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
|
||||
}
|
||||
|
||||
success_log() {
|
||||
echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] ERFOLG:${NC} $1"
|
||||
}
|
||||
|
||||
header() {
|
||||
echo ""
|
||||
echo -e "${CYAN}===== $1 =====${NC}"
|
||||
echo ""
|
||||
}
|
||||
|
||||
# Prüfen, ob das Skript als Root ausgeführt wird
|
||||
if [ "$EUID" -ne 0 ]; then
|
||||
error_log "Dieses Skript muss als Root ausgeführt werden."
|
||||
error_log "Bitte führen Sie es mit 'sudo' aus."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Konfigurationswerte
|
||||
FIRMENNETZWERK_HOSTNAME="m040tbaraspi001.de040.corpintra.net"
|
||||
BACKEND_HOST="192.168.0.105" # Backend-IP im Offline-Netzwerk
|
||||
BACKEND_PORT="5000" # Backend-Port
|
||||
OFFLINE_NETWORK_SSID="MYP-Net"
|
||||
OFFLINE_NETWORK_PASSWORD="myp-password"
|
||||
CADDY_VERSION="2.7.6"
|
||||
|
||||
header "MYP-Netzwerk und HTTPS-Setup"
|
||||
log "Dieses Skript konfiguriert Ihren Raspberry Pi für:"
|
||||
log "1. Firmennetzwerk über LAN (eth0) mit Internet-Zugang"
|
||||
log "2. Offline-Netzwerk über WLAN (wlan0) für Backend-Kommunikation"
|
||||
log "3. HTTPS mit selbstsigniertem Zertifikat für ${FIRMENNETZWERK_HOSTNAME}"
|
||||
|
||||
# Netzwerkkonfiguration
|
||||
setup_network() {
|
||||
header "Netzwerkkonfiguration"
|
||||
|
||||
# Sichern der aktuellen Netzwerkkonfiguration
|
||||
log "Sichere aktuelle Netzwerkkonfiguration..."
|
||||
if [ -f /etc/dhcpcd.conf ]; then
|
||||
cp /etc/dhcpcd.conf /etc/dhcpcd.conf.bak
|
||||
success_log "Aktuelle Netzwerkkonfiguration gesichert in /etc/dhcpcd.conf.bak"
|
||||
fi
|
||||
|
||||
# Konfigurieren von dhcpcd.conf für statische Routing
|
||||
log "Konfiguriere Routing für duale Netzwerke..."
|
||||
cat > /etc/dhcpcd.conf << EOL
|
||||
# MYP Dual-Network Configuration
|
||||
# eth0: Firmennetzwerk mit Internet
|
||||
# wlan0: Offline-Netzwerk für Backend
|
||||
|
||||
# Allow dhcpcd to manage all interfaces
|
||||
allowinterfaces eth0 wlan0
|
||||
|
||||
# eth0 configuration (Firmennetzwerk)
|
||||
interface eth0
|
||||
# DHCP for eth0, all default routes go through eth0
|
||||
metric 100
|
||||
|
||||
# wlan0 configuration (Offline Network)
|
||||
interface wlan0
|
||||
# Static IP for wlan0
|
||||
metric 200
|
||||
# Add specific route to backend via wlan0
|
||||
EOL
|
||||
|
||||
# Konfigurieren von wpa_supplicant für WLAN-Verbindung
|
||||
log "Konfiguriere WLAN-Verbindung für Offline-Netzwerk..."
|
||||
cat > /etc/wpa_supplicant/wpa_supplicant.conf << EOL
|
||||
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
|
||||
update_config=1
|
||||
country=DE
|
||||
|
||||
network={
|
||||
ssid="${OFFLINE_NETWORK_SSID}"
|
||||
psk="${OFFLINE_NETWORK_PASSWORD}"
|
||||
priority=1
|
||||
}
|
||||
EOL
|
||||
|
||||
chmod 600 /etc/wpa_supplicant/wpa_supplicant.conf
|
||||
|
||||
# Routing-Tabelle konfigurieren
|
||||
log "Konfiguriere spezifisches Routing zum Backend..."
|
||||
if ! grep -q "${BACKEND_HOST}" /etc/iproute2/rt_tables; then
|
||||
echo "200 backend" >> /etc/iproute2/rt_tables
|
||||
fi
|
||||
|
||||
# Routing-Regeln in /etc/network/if-up.d/ hinzufügen
|
||||
cat > /etc/network/if-up.d/route-backend << EOL
|
||||
#!/bin/bash
|
||||
# Routing-Regeln für Backend-Host über WLAN
|
||||
|
||||
# Wenn wlan0 hochgefahren wird
|
||||
if [ "\$IFACE" = "wlan0" ]; then
|
||||
# Spezifische Route zum Backend über wlan0
|
||||
/sbin/ip route add ${BACKEND_HOST}/32 dev wlan0
|
||||
fi
|
||||
EOL
|
||||
|
||||
chmod +x /etc/network/if-up.d/route-backend
|
||||
|
||||
success_log "Netzwerkkonfiguration abgeschlossen"
|
||||
}
|
||||
|
||||
# Installation von Caddy als Reverse-Proxy
|
||||
install_caddy() {
|
||||
header "Installation von Caddy als Reverse-Proxy"
|
||||
|
||||
log "Überprüfe, ob Caddy bereits installiert ist..."
|
||||
if command -v caddy &> /dev/null; then
|
||||
success_log "Caddy ist bereits installiert"
|
||||
else
|
||||
log "Installiere Caddy ${CADDY_VERSION}..."
|
||||
|
||||
# Download und Installation von Caddy
|
||||
wget -O /tmp/caddy.tar.gz "https://github.com/caddyserver/caddy/releases/download/v${CADDY_VERSION}/caddy_${CADDY_VERSION}_linux_armv7.tar.gz"
|
||||
|
||||
if [ $? -ne 0 ]; then
|
||||
error_log "Fehler beim Herunterladen von Caddy"
|
||||
return 1
|
||||
fi
|
||||
|
||||
tar -xzf /tmp/caddy.tar.gz -C /tmp
|
||||
mv /tmp/caddy /usr/local/bin/
|
||||
chmod +x /usr/local/bin/caddy
|
||||
|
||||
# Benutzer und Gruppe für Caddy erstellen
|
||||
if ! id -u caddy &>/dev/null; then
|
||||
useradd --system --home /var/lib/caddy --shell /usr/sbin/nologin caddy
|
||||
fi
|
||||
|
||||
# Verzeichnisse für Caddy erstellen
|
||||
mkdir -p /etc/caddy /var/lib/caddy /var/log/caddy
|
||||
chown -R caddy:caddy /var/lib/caddy /var/log/caddy
|
||||
|
||||
# Systemd-Service für Caddy einrichten
|
||||
cat > /etc/systemd/system/caddy.service << EOL
|
||||
[Unit]
|
||||
Description=Caddy Web Server
|
||||
Documentation=https://caddyserver.com/docs/
|
||||
After=network.target network-online.target
|
||||
Requires=network-online.target
|
||||
|
||||
[Service]
|
||||
User=caddy
|
||||
Group=caddy
|
||||
ExecStart=/usr/local/bin/caddy run --config /etc/caddy/Caddyfile
|
||||
ExecReload=/usr/local/bin/caddy reload --config /etc/caddy/Caddyfile
|
||||
TimeoutStopSec=5s
|
||||
LimitNOFILE=1048576
|
||||
LimitNPROC=512
|
||||
PrivateTmp=true
|
||||
ProtectSystem=full
|
||||
AmbientCapabilities=CAP_NET_BIND_SERVICE
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
EOL
|
||||
|
||||
success_log "Caddy wurde installiert"
|
||||
fi
|
||||
|
||||
# Caddyfile für HTTPS mit selbstsigniertem Zertifikat konfigurieren
|
||||
log "Konfiguriere Caddy für HTTPS mit selbstsigniertem Zertifikat..."
|
||||
cat > /etc/caddy/Caddyfile << EOL
|
||||
{
|
||||
# Globale Optionen
|
||||
admin off
|
||||
auto_https disable_redirects
|
||||
|
||||
# Selbstsigniertes Zertifikat verwenden
|
||||
local_certs
|
||||
default_sni ${FIRMENNETZWERK_HOSTNAME}
|
||||
}
|
||||
|
||||
# HTTPS-Konfiguration für den Firmennetzwerk-Hostnamen
|
||||
${FIRMENNETZWERK_HOSTNAME} {
|
||||
# TLS mit selbstsigniertem Zertifikat
|
||||
tls internal {
|
||||
on_demand
|
||||
}
|
||||
|
||||
# Reverse-Proxy zum Next.js-Frontend
|
||||
reverse_proxy localhost:3000 {
|
||||
# Zeitüberschreitungen für langsame Raspberry Pi-Verbindungen erhöhen
|
||||
timeouts 5m
|
||||
}
|
||||
|
||||
# Logging
|
||||
log {
|
||||
output file /var/log/caddy/access.log
|
||||
format console
|
||||
}
|
||||
}
|
||||
|
||||
# HTTP-Konfiguration für lokalen Zugriff
|
||||
:80 {
|
||||
# Weiterleitung zu HTTPS
|
||||
redir https://${FIRMENNETZWERK_HOSTNAME}{uri} permanent
|
||||
}
|
||||
|
||||
# Zusätzlicher Server für Backend-Proxy (API-Anfragen weiterleiten)
|
||||
localhost:8000 {
|
||||
reverse_proxy ${BACKEND_HOST}:${BACKEND_PORT} {
|
||||
# Headers für CORS anpassen
|
||||
header_up Host ${BACKEND_HOST}:${BACKEND_PORT}
|
||||
header_up X-Forwarded-Host ${FIRMENNETZWERK_HOSTNAME}
|
||||
header_up X-Forwarded-Proto https
|
||||
|
||||
# Zeitüberschreitungen für API-Anfragen erhöhen
|
||||
timeouts 1m
|
||||
}
|
||||
|
||||
# Logging
|
||||
log {
|
||||
output file /var/log/caddy/backend-access.log
|
||||
format console
|
||||
}
|
||||
}
|
||||
EOL
|
||||
|
||||
# Caddy-Service neu laden und starten
|
||||
log "Starte Caddy-Service..."
|
||||
systemctl daemon-reload
|
||||
systemctl enable caddy
|
||||
systemctl restart caddy
|
||||
|
||||
# Überprüfen, ob Caddy läuft
|
||||
if systemctl is-active --quiet caddy; then
|
||||
success_log "Caddy-Service wurde gestartet und ist aktiv"
|
||||
else
|
||||
error_log "Fehler beim Starten des Caddy-Services"
|
||||
return 1
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Next.js Frontend-Konfiguration für HTTPS und Backend-Proxy
|
||||
configure_frontend() {
|
||||
header "Frontend-Konfiguration für HTTPS"
|
||||
|
||||
# Verzeichnis für das Frontend
|
||||
FRONTEND_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
|
||||
# Prüfen, ob das Frontend-Verzeichnis existiert
|
||||
if [ ! -d "$FRONTEND_DIR" ]; then
|
||||
error_log "Frontend-Verzeichnis nicht gefunden: $FRONTEND_DIR"
|
||||
return 1
|
||||
fi
|
||||
|
||||
log "Konfiguriere Frontend für HTTPS und Backend-Proxy..."
|
||||
|
||||
# .env.local-Datei für das Frontend erstellen
|
||||
cat > "$FRONTEND_DIR/.env.local" << EOL
|
||||
# Backend API Konfiguration (über lokalen Proxy zu Backend)
|
||||
NEXT_PUBLIC_API_URL=http://localhost:8000
|
||||
|
||||
# Frontend-URL für OAuth Callback (HTTPS)
|
||||
NEXT_PUBLIC_FRONTEND_URL=https://${FIRMENNETZWERK_HOSTNAME}
|
||||
|
||||
# Explizite OAuth Callback URL für GitHub
|
||||
NEXT_PUBLIC_OAUTH_CALLBACK_URL=https://${FIRMENNETZWERK_HOSTNAME}/auth/login/callback
|
||||
EOL
|
||||
|
||||
# Berechtigungen setzen
|
||||
chown -R $(stat -c '%U:%G' "$FRONTEND_DIR") "$FRONTEND_DIR/.env.local"
|
||||
chmod 600 "$FRONTEND_DIR/.env.local"
|
||||
|
||||
success_log "Frontend wurde für HTTPS und Backend-Proxy konfiguriert"
|
||||
|
||||
# Hinweis zur Installation und zum Start des Frontends
|
||||
log "${YELLOW}Hinweis: Führen Sie nun das Frontend-Installationsskript aus:${NC}"
|
||||
log "cd $FRONTEND_DIR && ./install.sh"
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Hostname setzen
|
||||
set_hostname() {
|
||||
header "Hostname konfigurieren"
|
||||
|
||||
log "Aktueller Hostname: $(hostname)"
|
||||
log "Setze Hostname auf ${FIRMENNETZWERK_HOSTNAME}..."
|
||||
|
||||
# Hostname in /etc/hostname setzen
|
||||
echo "${FIRMENNETZWERK_HOSTNAME}" > /etc/hostname
|
||||
|
||||
# Hostname in /etc/hosts aktualisieren
|
||||
if grep -q "$(hostname)" /etc/hosts; then
|
||||
sed -i "s/$(hostname)/${FIRMENNETZWERK_HOSTNAME}/g" /etc/hosts
|
||||
else
|
||||
echo "127.0.1.1 ${FIRMENNETZWERK_HOSTNAME}" >> /etc/hosts
|
||||
fi
|
||||
|
||||
# Aktualisieren des Hostnamens ohne Neustart
|
||||
hostname "${FIRMENNETZWERK_HOSTNAME}"
|
||||
|
||||
success_log "Hostname wurde auf ${FIRMENNETZWERK_HOSTNAME} gesetzt"
|
||||
log "${YELLOW}Hinweis: Ein Neustart wird empfohlen, um sicherzustellen, dass der neue Hostname vollständig übernommen wurde.${NC}"
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Hauptfunktion
|
||||
main() {
|
||||
# Begrüßung und Bestätigung
|
||||
header "MYP HTTPS und Dual-Network Setup"
|
||||
log "Dieses Skript richtet Ihren Raspberry Pi für das MYP-Projekt ein:"
|
||||
log "- Setzt den Hostname auf: ${FIRMENNETZWERK_HOSTNAME}"
|
||||
log "- Konfiguriert das duale Netzwerk (LAN für Internet, WLAN für Backend)"
|
||||
log "- Installiert Caddy als Reverse-Proxy mit selbstsigniertem HTTPS"
|
||||
log "- Konfiguriert das Frontend für die Kommunikation mit dem Backend"
|
||||
echo ""
|
||||
log "${YELLOW}WICHTIG: Diese Konfiguration kann bestehende Netzwerk- und HTTPS-Einstellungen überschreiben.${NC}"
|
||||
read -p "Möchten Sie fortfahren? (j/n): " confirm
|
||||
|
||||
if [[ "$confirm" != "j" ]]; then
|
||||
log "Setup abgebrochen."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Schritte ausführen
|
||||
set_hostname || { error_log "Fehler beim Setzen des Hostnamens"; exit 1; }
|
||||
setup_network || { error_log "Fehler bei der Netzwerkkonfiguration"; exit 1; }
|
||||
install_caddy || { error_log "Fehler bei der Caddy-Installation"; exit 1; }
|
||||
configure_frontend || { error_log "Fehler bei der Frontend-Konfiguration"; exit 1; }
|
||||
|
||||
# Abschlussmeldung
|
||||
header "Setup abgeschlossen"
|
||||
success_log "MYP HTTPS und Dual-Network Setup erfolgreich!"
|
||||
log "Ihr Raspberry Pi ist nun wie folgt konfiguriert:"
|
||||
log "- Hostname: ${FIRMENNETZWERK_HOSTNAME}"
|
||||
log "- HTTPS mit selbstsigniertem Zertifikat über Caddy"
|
||||
log "- Duale Netzwerkkonfiguration:"
|
||||
log " * eth0: Firmennetzwerk mit Internet-Zugang"
|
||||
log " * wlan0: Verbindung zum Offline-Netzwerk (${OFFLINE_NETWORK_SSID})"
|
||||
log "- Frontend-URL: https://${FIRMENNETZWERK_HOSTNAME}"
|
||||
log "- Backend-Kommunikation über lokalen Proxy: http://localhost:8000 -> ${BACKEND_HOST}:${BACKEND_PORT}"
|
||||
echo ""
|
||||
log "${YELLOW}Wichtige nächste Schritte:${NC}"
|
||||
log "1. Starten Sie das Frontend mit dem Installationsskript:"
|
||||
log " cd $FRONTEND_DIR && ./install.sh"
|
||||
log "2. Neustart des Raspberry Pi empfohlen:"
|
||||
log " sudo reboot"
|
||||
echo ""
|
||||
log "${YELLOW}Hinweis zum selbstsignierten Zertifikat:${NC}"
|
||||
log "Bei Zugriff auf https://${FIRMENNETZWERK_HOSTNAME} erhalten Sie eine Zertifikatswarnung im Browser."
|
||||
log "Dies ist normal für selbstsignierte Zertifikate. Sie können die Warnung in Ihrem Browser bestätigen."
|
||||
}
|
||||
|
||||
# Skript starten
|
||||
main
|
||||
@ -1,570 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# MYP Frontend Installations-Skript
|
||||
# Dieses Skript installiert das Frontend mit Docker und Host-Netzwerkanbindung
|
||||
|
||||
# Farbcodes für Ausgabe
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[0;33m'
|
||||
BLUE='\033[0;34m'
|
||||
CYAN='\033[0;36m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Funktion zur Ausgabe mit Zeitstempel
|
||||
log() {
|
||||
echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
|
||||
}
|
||||
|
||||
error_log() {
|
||||
echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
|
||||
}
|
||||
|
||||
success_log() {
|
||||
echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] ERFOLG:${NC} $1"
|
||||
}
|
||||
|
||||
header() {
|
||||
echo ""
|
||||
echo -e "${CYAN}===== $1 =====${NC}"
|
||||
echo ""
|
||||
}
|
||||
|
||||
# Variablen definieren
|
||||
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
FRONTEND_DIR="$SCRIPT_DIR"
|
||||
DOCKER_DIR="$FRONTEND_DIR/docker"
|
||||
DEFAULT_BACKEND_URL="http://192.168.0.105:5000"
|
||||
IMAGE_NAME="myp-rp:latest"
|
||||
CONTAINER_NAME="myp-rp"
|
||||
DB_VOLUME_DIR="/srv/MYP-DB"
|
||||
ENV_FILE_PATH="/srv/myp-env/github.env"
|
||||
|
||||
# Prüfen, ob wir im Frontend-Verzeichnis sind
|
||||
if [ ! -f "$FRONTEND_DIR/package.json" ]; then
|
||||
error_log "Dieses Skript muss im Frontend-Verzeichnis ausgeführt werden."
|
||||
error_log "Bitte wechseln Sie in das Frontend-Verzeichnis."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Prüfen, ob Docker installiert ist
|
||||
if ! command -v docker &> /dev/null; then
|
||||
error_log "Docker ist nicht installiert. Bitte installieren Sie Docker zuerst."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Prüfen, ob Docker läuft
|
||||
if ! docker info &> /dev/null; then
|
||||
error_log "Docker-Daemon läuft nicht. Bitte starten Sie Docker mit 'sudo systemctl start docker'."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Prüfen, ob der Benutzer in der Docker-Gruppe ist
|
||||
if ! groups | grep -q '\bdocker\b'; then
|
||||
error_log "Aktueller Benutzer hat keine Docker-Berechtigungen."
|
||||
error_log "Bitte führen Sie das Skript mit 'sudo' aus oder fügen Sie den Benutzer zur Docker-Gruppe hinzu:"
|
||||
error_log "sudo usermod -aG docker $USER && newgrp docker"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Erstelle Datenbank-Verzeichnis, falls nicht vorhanden
|
||||
if [ ! -d "$DB_VOLUME_DIR" ]; then
|
||||
log "Erstelle Datenbankverzeichnis: $DB_VOLUME_DIR"
|
||||
if ! mkdir -p "$DB_VOLUME_DIR"; then
|
||||
if ! sudo mkdir -p "$DB_VOLUME_DIR"; then
|
||||
error_log "Konnte Datenbankverzeichnis nicht erstellen. Bitte erstellen Sie es manuell:"
|
||||
error_log "sudo mkdir -p $DB_VOLUME_DIR && sudo chown $USER:$USER $DB_VOLUME_DIR"
|
||||
exit 1
|
||||
fi
|
||||
sudo chown $USER:$USER "$DB_VOLUME_DIR"
|
||||
fi
|
||||
else
|
||||
log "Datenbankverzeichnis existiert bereits: $DB_VOLUME_DIR"
|
||||
fi
|
||||
|
||||
# Funktion zum Laden der Umgebungsvariablen aus /srv/myp-env/github.env
|
||||
load_env_from_srv() {
|
||||
if [ -f "$ENV_FILE_PATH" ]; then
|
||||
log "Lade Umgebungsvariablen aus $ENV_FILE_PATH"
|
||||
|
||||
# Versuche, die Variablen aus der Datei zu laden
|
||||
OAUTH_CLIENT_ID=$(grep -oP 'OAUTH_CLIENT_ID=\K.*' "$ENV_FILE_PATH" 2>/dev/null || echo "client_id")
|
||||
OAUTH_CLIENT_SECRET=$(grep -oP 'OAUTH_CLIENT_SECRET=\K.*' "$ENV_FILE_PATH" 2>/dev/null || echo "client_secret")
|
||||
|
||||
# Prüfe, ob die Backend-URL in der Datei definiert ist
|
||||
BACKEND_URL_FROM_FILE=$(grep -oP 'NEXT_PUBLIC_API_URL=\K.*' "$ENV_FILE_PATH" 2>/dev/null)
|
||||
if [ -n "$BACKEND_URL_FROM_FILE" ]; then
|
||||
log "Backend-URL aus $ENV_FILE_PATH geladen: $BACKEND_URL_FROM_FILE"
|
||||
DEFAULT_BACKEND_URL="$BACKEND_URL_FROM_FILE"
|
||||
fi
|
||||
|
||||
success_log "OAuth-Konfiguration aus $ENV_FILE_PATH geladen."
|
||||
else
|
||||
log "${YELLOW}Warnung: $ENV_FILE_PATH nicht gefunden. Verwende Standard-Konfiguration.${NC}"
|
||||
OAUTH_CLIENT_ID="client_id"
|
||||
OAUTH_CLIENT_SECRET="client_secret"
|
||||
fi
|
||||
}
|
||||
|
||||
# Funktion zum Konfigurieren der Backend-URL
|
||||
configure_backend_url() {
|
||||
local backend_url="${1:-$DEFAULT_BACKEND_URL}"
|
||||
|
||||
header "Backend-URL konfigurieren"
|
||||
log "Konfiguriere Backend-URL für Frontend: $backend_url"
|
||||
|
||||
# Lade OAuth-Konfiguration aus /srv
|
||||
load_env_from_srv
|
||||
|
||||
# Prüfen, ob setup-backend-url.sh existiert
|
||||
if [ -f "$FRONTEND_DIR/setup-backend-url.sh" ]; then
|
||||
chmod +x "$FRONTEND_DIR/setup-backend-url.sh"
|
||||
if ! "$FRONTEND_DIR/setup-backend-url.sh" "$backend_url"; then
|
||||
error_log "Fehler beim Konfigurieren der Backend-URL."
|
||||
return 1
|
||||
fi
|
||||
else
|
||||
# Bestimme den Hostnamen für OAuth
|
||||
HOSTNAME=$(hostname)
|
||||
if [[ "$HOSTNAME" == *"m040tbaraspi001"* ]] || [[ "$HOSTNAME" == *"corpintra"* ]]; then
|
||||
FRONTEND_HOSTNAME="m040tbaraspi001.de040.corpintra.net"
|
||||
OAUTH_URL="http://m040tbaraspi001.de040.corpintra.net/auth/login/callback"
|
||||
log "Erkannt: Unternehmens-Hostname: $FRONTEND_HOSTNAME"
|
||||
else
|
||||
FRONTEND_HOSTNAME="$HOSTNAME"
|
||||
OAUTH_URL="http://$HOSTNAME:3000/auth/login/callback"
|
||||
log "Lokaler Hostname: $FRONTEND_HOSTNAME"
|
||||
fi
|
||||
|
||||
# Erstelle .env.local-Datei manuell
|
||||
log "Erstelle .env.local-Datei manuell..."
|
||||
cat > "$FRONTEND_DIR/.env.local" << EOL
|
||||
# Backend API Konfiguration
|
||||
NEXT_PUBLIC_API_URL=${backend_url}
|
||||
|
||||
# Frontend-URL für OAuth Callback
|
||||
NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME}
|
||||
|
||||
# Explizite OAuth Callback URL für GitHub
|
||||
NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL}
|
||||
|
||||
# OAuth Konfiguration aus /srv/myp-env/github.env
|
||||
OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID}
|
||||
OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET}
|
||||
EOL
|
||||
|
||||
if [ ! -f "$FRONTEND_DIR/.env.local" ]; then
|
||||
error_log "Konnte .env.local-Datei nicht erstellen."
|
||||
return 1
|
||||
fi
|
||||
|
||||
chmod 600 "$FRONTEND_DIR/.env.local"
|
||||
fi
|
||||
|
||||
success_log "Backend-URL erfolgreich konfiguriert: $backend_url"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion zum Bauen des Images
|
||||
build_image() {
|
||||
header "Docker-Image bauen"
|
||||
log "Baue Docker-Image: $IMAGE_NAME"
|
||||
|
||||
if [ ! -f "$FRONTEND_DIR/Dockerfile" ]; then
|
||||
error_log "Dockerfile nicht gefunden in $FRONTEND_DIR"
|
||||
return 1
|
||||
fi
|
||||
|
||||
cd "$FRONTEND_DIR" || return 1
|
||||
|
||||
# Vorhandenes Image entfernen, falls gewünscht
|
||||
if docker image inspect "$IMAGE_NAME" &>/dev/null; then
|
||||
log "Image $IMAGE_NAME existiert bereits."
|
||||
read -p "Möchten Sie das existierende Image überschreiben? (j/n): " rebuild_choice
|
||||
if [[ "$rebuild_choice" == "j" ]]; then
|
||||
log "Entferne existierendes Image..."
|
||||
docker rmi "$IMAGE_NAME" &>/dev/null || true
|
||||
else
|
||||
log "Behalte existierendes Image."
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
|
||||
# Baue das Image
|
||||
log "${YELLOW}Baue Docker-Image... (Dies kann auf einem Raspberry Pi mehrere Minuten dauern)${NC}"
|
||||
if ! docker build -t "$IMAGE_NAME" .; then
|
||||
error_log "Fehler beim Bauen des Docker-Images."
|
||||
return 1
|
||||
fi
|
||||
|
||||
success_log "Docker-Image erfolgreich gebaut: $IMAGE_NAME"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion zum Speichern des Images
|
||||
save_image() {
|
||||
header "Docker-Image speichern"
|
||||
local save_dir="${1:-$DOCKER_DIR/images}"
|
||||
local save_file="$save_dir/myp-frontend.tar"
|
||||
|
||||
# Prüfen, ob das Image existiert
|
||||
if ! docker image inspect "$IMAGE_NAME" &>/dev/null; then
|
||||
error_log "Image $IMAGE_NAME existiert nicht. Bitte bauen Sie es zuerst."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Verzeichnis erstellen, falls es nicht existiert
|
||||
mkdir -p "$save_dir"
|
||||
|
||||
log "Speichere Docker-Image in: $save_file"
|
||||
log "${YELLOW}Dies kann einige Minuten dauern...${NC}"
|
||||
|
||||
if ! docker save -o "$save_file" "$IMAGE_NAME"; then
|
||||
error_log "Fehler beim Speichern des Docker-Images."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Prüfe, ob die Datei erstellt wurde
|
||||
if [ ! -f "$save_file" ]; then
|
||||
error_log "Konnte Docker-Image nicht speichern."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Prüfe Dateigröße
|
||||
local filesize=$(stat -c%s "$save_file")
|
||||
if [ "$filesize" -lt 1000000 ]; then # Kleiner als 1MB ist verdächtig
|
||||
error_log "Gespeichertes Image ist ungewöhnlich klein ($filesize Bytes). Möglicherweise ist etwas schief gelaufen."
|
||||
return 1
|
||||
fi
|
||||
|
||||
success_log "Docker-Image erfolgreich gespeichert: $save_file (Größe: $(du -h "$save_file" | cut -f1))"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion zum Laden des Images
|
||||
load_image() {
|
||||
header "Docker-Image laden"
|
||||
local load_dir="${1:-$DOCKER_DIR/images}"
|
||||
local load_file="$load_dir/myp-frontend.tar"
|
||||
|
||||
# Prüfen, ob die Datei existiert
|
||||
if [ ! -f "$load_file" ]; then
|
||||
error_log "Image-Datei nicht gefunden: $load_file"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Prüfe Dateigröße
|
||||
local filesize=$(stat -c%s "$load_file")
|
||||
if [ "$filesize" -lt 1000000 ]; then # Kleiner als 1MB ist verdächtig
|
||||
error_log "Image-Datei ist ungewöhnlich klein ($filesize Bytes). Möglicherweise ist sie beschädigt."
|
||||
return 1
|
||||
fi
|
||||
|
||||
log "Lade Docker-Image aus: $load_file"
|
||||
log "${YELLOW}Dies kann einige Minuten dauern...${NC}"
|
||||
|
||||
if ! docker load -i "$load_file"; then
|
||||
error_log "Fehler beim Laden des Docker-Images. Die Datei könnte beschädigt sein."
|
||||
return 1
|
||||
fi
|
||||
|
||||
success_log "Docker-Image erfolgreich geladen."
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion zum Starten des Containers mit Docker Compose
|
||||
start_container_compose() {
|
||||
header "Container mit Docker Compose starten"
|
||||
|
||||
# Erstellen der vereinfachten docker-compose.yml-Datei
|
||||
local compose_file="$DOCKER_DIR/compose.simple.yml"
|
||||
|
||||
# Lade OAuth-Konfiguration aus /srv, falls noch nicht geschehen
|
||||
if [ -z "$OAUTH_CLIENT_ID" ]; then
|
||||
load_env_from_srv
|
||||
fi
|
||||
|
||||
# Docker-Verzeichnis erstellen, falls nicht vorhanden
|
||||
mkdir -p "$DOCKER_DIR"
|
||||
|
||||
log "Erstelle vereinfachte Docker-Compose-Datei: $compose_file"
|
||||
cat > "$compose_file" << EOL
|
||||
services:
|
||||
myp-rp:
|
||||
image: ${IMAGE_NAME}
|
||||
container_name: ${CONTAINER_NAME}
|
||||
environment:
|
||||
- NEXT_PUBLIC_API_URL=${BACKEND_URL}
|
||||
- NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME}
|
||||
- NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL}
|
||||
- OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID}
|
||||
- OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET}
|
||||
env_file: "${ENV_FILE_PATH}"
|
||||
ports:
|
||||
- "3000:3000"
|
||||
volumes:
|
||||
- ${DB_VOLUME_DIR}:/app/db
|
||||
restart: unless-stopped
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "--spider", "http://localhost:3000"]
|
||||
interval: 30s
|
||||
timeout: 10s
|
||||
retries: 3
|
||||
start_period: 40s
|
||||
EOL
|
||||
|
||||
# Prüfen, ob die Datei erstellt wurde
|
||||
if [ ! -f "$compose_file" ]; then
|
||||
error_log "Konnte Docker-Compose-Datei nicht erstellen."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Stoppen des vorhandenen Containers
|
||||
if docker ps -a | grep -q "$CONTAINER_NAME"; then
|
||||
log "Stoppe und entferne existierenden Container..."
|
||||
docker stop "$CONTAINER_NAME" &>/dev/null || true
|
||||
docker rm "$CONTAINER_NAME" &>/dev/null || true
|
||||
fi
|
||||
|
||||
# Container starten
|
||||
log "Starte Container..."
|
||||
cd "$DOCKER_DIR" || return 1
|
||||
|
||||
if ! docker compose -f "$(basename "$compose_file")" up -d; then
|
||||
# Versuche mit docker-compose, falls docker compose nicht funktioniert
|
||||
if ! docker-compose -f "$(basename "$compose_file")" up -d; then
|
||||
error_log "Fehler beim Starten des Containers."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
success_log "Container erfolgreich gestartet: $CONTAINER_NAME"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion zum Starten des Containers mit Docker Run
|
||||
start_container_run() {
|
||||
header "Container direkt starten"
|
||||
|
||||
# Stoppen des vorhandenen Containers
|
||||
if docker ps -a | grep -q "$CONTAINER_NAME"; then
|
||||
log "Stoppe und entferne existierenden Container..."
|
||||
docker stop "$CONTAINER_NAME" &>/dev/null || true
|
||||
docker rm "$CONTAINER_NAME" &>/dev/null || true
|
||||
fi
|
||||
|
||||
# Lade OAuth-Konfiguration aus /srv, falls noch nicht geschehen
|
||||
if [ -z "$OAUTH_CLIENT_ID" ]; then
|
||||
load_env_from_srv
|
||||
fi
|
||||
|
||||
# Container starten
|
||||
log "Starte Container mit 'docker run'..."
|
||||
|
||||
if ! docker run -d --name "$CONTAINER_NAME" \
|
||||
-p 3000:3000 \
|
||||
-e "NEXT_PUBLIC_API_URL=$BACKEND_URL" \
|
||||
-e "NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME}" \
|
||||
-e "NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL}" \
|
||||
-e "OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID}" \
|
||||
-e "OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET}" \
|
||||
--env-file "$ENV_FILE_PATH" \
|
||||
-v "$DB_VOLUME_DIR:/app/db" \
|
||||
--restart unless-stopped \
|
||||
"$IMAGE_NAME"; then
|
||||
error_log "Fehler beim Starten des Containers."
|
||||
return 1
|
||||
fi
|
||||
|
||||
success_log "Container erfolgreich gestartet: $CONTAINER_NAME"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion zum Starten der Anwendung ohne Docker
|
||||
start_without_docker() {
|
||||
header "Anwendung ohne Docker starten"
|
||||
|
||||
cd "$FRONTEND_DIR" || return 1
|
||||
|
||||
# Prüfen, ob Node.js und pnpm installiert sind
|
||||
if ! command -v node &> /dev/null; then
|
||||
error_log "Node.js ist nicht installiert. Bitte installieren Sie Node.js zuerst."
|
||||
return 1
|
||||
fi
|
||||
|
||||
if ! command -v pnpm &> /dev/null; then
|
||||
log "pnpm ist nicht installiert. Installiere pnpm..."
|
||||
npm install -g pnpm
|
||||
if [ $? -ne 0 ]; then
|
||||
error_log "Fehler beim Installieren von pnpm."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Installiere Abhängigkeiten
|
||||
log "Installiere Abhängigkeiten..."
|
||||
if ! pnpm install; then
|
||||
error_log "Fehler beim Installieren der Abhängigkeiten."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Lade OAuth-Konfiguration aus /srv und konfiguriere die Backend-URL
|
||||
load_env_from_srv
|
||||
if ! configure_backend_url "$BACKEND_URL"; then
|
||||
error_log "Fehler beim Konfigurieren der Backend-URL."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Baue und starte die Anwendung
|
||||
log "Baue und starte die Anwendung..."
|
||||
if ! pnpm build; then
|
||||
log "${YELLOW}Warnung: Build fehlgeschlagen. Versuche, im Dev-Modus zu starten...${NC}"
|
||||
fi
|
||||
|
||||
# Starte im Screen-Session, damit die Anwendung im Hintergrund läuft
|
||||
if command -v screen &> /dev/null; then
|
||||
log "Starte Anwendung in Screen-Session..."
|
||||
screen -dmS myp-frontend bash -c "cd $FRONTEND_DIR && \
|
||||
NEXT_PUBLIC_API_URL=$BACKEND_URL \
|
||||
NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME} \
|
||||
NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL} \
|
||||
OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID} \
|
||||
OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET} \
|
||||
pnpm start || \
|
||||
NEXT_PUBLIC_API_URL=$BACKEND_URL \
|
||||
NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME} \
|
||||
NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL} \
|
||||
OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID} \
|
||||
OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET} \
|
||||
pnpm dev"
|
||||
success_log "Anwendung im Hintergrund gestartet. Verbinden mit: screen -r myp-frontend"
|
||||
else
|
||||
log "${YELLOW}Screen ist nicht installiert. Starte Anwendung im Vordergrund...${NC}"
|
||||
log "${YELLOW}Beenden mit Strg+C. Die Anwendung wird dann beendet.${NC}"
|
||||
sleep 3
|
||||
export NEXT_PUBLIC_API_URL="$BACKEND_URL"
|
||||
export NEXT_PUBLIC_FRONTEND_URL="http://${FRONTEND_HOSTNAME}"
|
||||
export NEXT_PUBLIC_OAUTH_CALLBACK_URL="${OAUTH_URL}"
|
||||
export OAUTH_CLIENT_ID="${OAUTH_CLIENT_ID}"
|
||||
export OAUTH_CLIENT_SECRET="${OAUTH_CLIENT_SECRET}"
|
||||
pnpm start || pnpm dev
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Funktion für das Hauptmenü
|
||||
main_menu() {
|
||||
local choice
|
||||
header "MYP Frontend Deployment"
|
||||
echo "Bitte wählen Sie eine Option:"
|
||||
echo ""
|
||||
echo "1) Alles automatisch (Build, Deploy, Starten)"
|
||||
echo "2) Docker-Image bauen"
|
||||
echo "3) Docker-Image speichern"
|
||||
echo "4) Docker-Image laden"
|
||||
echo "5) Container mit Docker Compose starten"
|
||||
echo "6) Container direkt mit Docker Run starten"
|
||||
echo "7) Anwendung ohne Docker starten"
|
||||
echo "8) Nur Backend-URL konfigurieren"
|
||||
echo "9) Beenden"
|
||||
echo ""
|
||||
read -p "Ihre Wahl (1-9): " choice
|
||||
|
||||
case $choice in
|
||||
1) auto_deploy ;;
|
||||
2) build_image ;;
|
||||
3) save_image ;;
|
||||
4) load_image ;;
|
||||
5) configure_backend_url && start_container_compose ;;
|
||||
6) configure_backend_url && start_container_run ;;
|
||||
7) start_without_docker ;;
|
||||
8) configure_backend_url ;;
|
||||
9) log "Beende das Programm." && exit 0 ;;
|
||||
*) error_log "Ungültige Auswahl. Bitte versuchen Sie es erneut." && main_menu ;;
|
||||
esac
|
||||
|
||||
# Zurück zum Hauptmenü, es sei denn, der Benutzer hat das Programm beendet
|
||||
if [ $choice -ne 9 ]; then
|
||||
read -p "Drücken Sie Enter, um zum Hauptmenü zurückzukehren..."
|
||||
main_menu
|
||||
fi
|
||||
}
|
||||
|
||||
# Automatischer Deployment-Workflow
|
||||
auto_deploy() {
|
||||
header "Automatisches Deployment"
|
||||
log "Starte automatischen Deployment-Workflow..."
|
||||
|
||||
# Konfiguriere Backend-URL
|
||||
if ! configure_backend_url; then
|
||||
error_log "Fehler beim Konfigurieren der Backend-URL."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Versuche zunächst, das Image zu laden
|
||||
local load_dir="$DOCKER_DIR/images"
|
||||
local load_file="$load_dir/myp-frontend.tar"
|
||||
|
||||
if [ -f "$load_file" ]; then
|
||||
log "Image-Datei gefunden. Versuche zu laden..."
|
||||
if load_image; then
|
||||
log "Image erfolgreich geladen. Überspringe Bauen."
|
||||
else
|
||||
log "Konnte Image nicht laden. Versuche zu bauen..."
|
||||
if ! build_image; then
|
||||
error_log "Automatisches Deployment fehlgeschlagen beim Bauen des Images."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
else
|
||||
log "Keine Image-Datei gefunden. Baue neues Image..."
|
||||
if ! build_image; then
|
||||
error_log "Automatisches Deployment fehlgeschlagen beim Bauen des Images."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Speichere das Image für zukünftige Verwendung
|
||||
log "Speichere Image für zukünftige Verwendung..."
|
||||
save_image
|
||||
|
||||
# Starte den Container
|
||||
log "Starte Container..."
|
||||
if ! start_container_compose; then
|
||||
error_log "Konnte Container nicht mit Docker Compose starten. Versuche direkten Start..."
|
||||
if ! start_container_run; then
|
||||
error_log "Automatisches Deployment fehlgeschlagen beim Starten des Containers."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
success_log "Automatisches Deployment erfolgreich abgeschlossen!"
|
||||
log "Frontend ist unter http://localhost:3000 erreichbar"
|
||||
log "API-Kommunikation mit Backend: $BACKEND_URL"
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Hauptanwendung
|
||||
# Zuerst nach Backend-URL fragen
|
||||
header "Backend-URL Konfiguration"
|
||||
log "Standard-Backend-URL: $DEFAULT_BACKEND_URL"
|
||||
read -p "Möchten Sie eine andere Backend-URL verwenden? (j/n): " change_url_choice
|
||||
|
||||
if [[ "$change_url_choice" == "j" ]]; then
|
||||
read -p "Geben Sie die neue Backend-URL ein (z.B. http://192.168.0.105:5000): " custom_url
|
||||
if [ -n "$custom_url" ]; then
|
||||
BACKEND_URL="$custom_url"
|
||||
log "Verwende benutzerdefinierte Backend-URL: $BACKEND_URL"
|
||||
else
|
||||
BACKEND_URL="$DEFAULT_BACKEND_URL"
|
||||
log "Leere Eingabe. Verwende Standard-Backend-URL: $BACKEND_URL"
|
||||
fi
|
||||
else
|
||||
BACKEND_URL="$DEFAULT_BACKEND_URL"
|
||||
log "Verwende Standard-Backend-URL: $BACKEND_URL"
|
||||
fi
|
||||
|
||||
# Anzeigen des Hauptmenüs
|
||||
main_menu
|
||||
@ -1,55 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# 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"
|
||||
}
|
||||
|
||||
error_log() {
|
||||
echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
|
||||
}
|
||||
|
||||
# Pfad zum Debug-Server
|
||||
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
DEBUG_SERVER_DIR="$SCRIPT_DIR/debug-server"
|
||||
|
||||
# Prüfe, ob das Debug-Server-Verzeichnis existiert
|
||||
if [ ! -d "$DEBUG_SERVER_DIR" ]; then
|
||||
error_log "Debug-Server-Verzeichnis nicht gefunden: $DEBUG_SERVER_DIR"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Prüfe, ob Node.js installiert ist
|
||||
if ! command -v node &> /dev/null; then
|
||||
error_log "Node.js nicht gefunden. Bitte installieren Sie Node.js."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Prüfe, ob npm installiert ist
|
||||
if ! command -v npm &> /dev/null; then
|
||||
error_log "npm nicht gefunden. Bitte installieren Sie npm."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Wechsle ins Debug-Server-Verzeichnis
|
||||
cd "$DEBUG_SERVER_DIR" || exit 1
|
||||
|
||||
# Installiere Abhängigkeiten, falls nötig
|
||||
if [ -f "package.json" ]; then
|
||||
log "Installiere Abhängigkeiten..."
|
||||
npm install
|
||||
fi
|
||||
|
||||
# Erstelle benötigte Verzeichnisse, falls sie nicht existieren
|
||||
mkdir -p public/views
|
||||
|
||||
# Starte den Debug-Server
|
||||
log "Starte Frontend-Debug-Server..."
|
||||
node src/app.js
|
||||
@ -1,162 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# 🎨 MYP Frontend - Standalone Server Start
|
||||
# Startet den Frontend-Server vollständig unabhängig vom Backend
|
||||
|
||||
set -e
|
||||
|
||||
echo "🎨 MYP Frontend - Standalone Server wird gestartet..."
|
||||
|
||||
# Farben für Terminal-Ausgabe
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Funktionen
|
||||
log_info() {
|
||||
echo -e "${BLUE}[INFO]${NC} $1"
|
||||
}
|
||||
|
||||
log_success() {
|
||||
echo -e "${GREEN}[SUCCESS]${NC} $1"
|
||||
}
|
||||
|
||||
log_warning() {
|
||||
echo -e "${YELLOW}[WARNING]${NC} $1"
|
||||
}
|
||||
|
||||
log_error() {
|
||||
echo -e "${RED}[ERROR]${NC} $1"
|
||||
}
|
||||
|
||||
# Arbeitsverzeichnis setzen
|
||||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||||
cd "$SCRIPT_DIR"
|
||||
|
||||
log_info "Arbeitsverzeichnis: $SCRIPT_DIR"
|
||||
|
||||
# Umgebungsvariablen laden
|
||||
if [ -f ".env.frontend" ]; then
|
||||
log_info "Lade Frontend-Umgebungsvariablen..."
|
||||
export $(cat .env.frontend | grep -v '^#' | xargs)
|
||||
fi
|
||||
|
||||
# Prüfe Docker-Installation
|
||||
if ! command -v docker &> /dev/null; then
|
||||
log_error "Docker ist nicht installiert!"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if ! command -v docker-compose &> /dev/null; then
|
||||
log_error "Docker Compose ist nicht installiert!"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log_success "Docker-Installation verifiziert"
|
||||
|
||||
# Backend-Verfügbarkeit prüfen
|
||||
BACKEND_URL=${BACKEND_API_URL:-http://localhost:5000}
|
||||
log_info "Prüfe Backend-Verfügbarkeit: $BACKEND_URL"
|
||||
|
||||
if ! curl -f "$BACKEND_URL/health" >/dev/null 2>&1; then
|
||||
log_warning "Backend-Server ist nicht verfügbar!"
|
||||
log_warning "Stellen Sie sicher, dass der Backend-Server läuft:"
|
||||
log_warning "cd ../backend && ./start-backend-server.sh"
|
||||
|
||||
read -p "Möchten Sie trotzdem fortfahren? [y/N]: " -n 1 -r
|
||||
echo
|
||||
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
|
||||
log_info "Abgebrochen."
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Alte Container stoppen und entfernen
|
||||
log_info "Stoppe eventuell laufende Frontend-Container..."
|
||||
docker-compose -f docker-compose.frontend.yml down --remove-orphans 2>/dev/null || true
|
||||
|
||||
# Images aufräumen (optional)
|
||||
if [ "$1" = "--clean" ]; then
|
||||
log_info "Räume alte Frontend-Images auf..."
|
||||
docker-compose -f docker-compose.frontend.yml down --rmi all --volumes 2>/dev/null || true
|
||||
docker system prune -f
|
||||
fi
|
||||
|
||||
# Notwendige Verzeichnisse erstellen
|
||||
log_info "Erstelle notwendige Verzeichnisse..."
|
||||
mkdir -p .next public/uploads
|
||||
|
||||
# Node.js Dependencies prüfen
|
||||
if [ ! -d "node_modules" ] || [ ! -f "package-lock.json" ]; then
|
||||
log_info "Installiere Node.js Dependencies..."
|
||||
if command -v pnpm &> /dev/null; then
|
||||
pnpm install
|
||||
elif command -v npm &> /dev/null; then
|
||||
npm install
|
||||
else
|
||||
log_warning "Weder pnpm noch npm gefunden. Dependencies werden im Container installiert."
|
||||
fi
|
||||
fi
|
||||
|
||||
# Frontend-Container builden und starten
|
||||
log_info "Frontend-Container werden gebaut und gestartet..."
|
||||
docker-compose -f docker-compose.frontend.yml up --build -d
|
||||
|
||||
# Warten auf Frontend-Start
|
||||
log_info "Warte auf Frontend-Service..."
|
||||
timeout=120
|
||||
counter=0
|
||||
|
||||
while [ $counter -lt $timeout ]; do
|
||||
if curl -f http://localhost:3000/health >/dev/null 2>&1; then
|
||||
log_success "Frontend-Server ist bereit!"
|
||||
break
|
||||
fi
|
||||
|
||||
# Fallback: Prüfe, ob der Container läuft
|
||||
if [ $counter -gt 30 ] && curl -f http://localhost:3000 >/dev/null 2>&1; then
|
||||
log_success "Frontend-Server ist bereit!"
|
||||
break
|
||||
fi
|
||||
|
||||
if [ $((counter % 10)) -eq 0 ]; then
|
||||
log_info "Warte auf Frontend-Service... ($counter/$timeout Sekunden)"
|
||||
fi
|
||||
|
||||
sleep 1
|
||||
counter=$((counter + 1))
|
||||
done
|
||||
|
||||
if [ $counter -eq $timeout ]; then
|
||||
log_error "Frontend-Service konnte nicht gestartet werden!"
|
||||
log_info "Zeige Frontend-Logs:"
|
||||
docker-compose -f docker-compose.frontend.yml logs frontend
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Service-Status anzeigen
|
||||
log_info "Frontend-Service Status:"
|
||||
docker-compose -f docker-compose.frontend.yml ps
|
||||
|
||||
# URLs anzeigen
|
||||
echo ""
|
||||
log_success "🎉 Frontend-Server erfolgreich gestartet!"
|
||||
echo ""
|
||||
echo "🌐 Frontend-App: http://localhost:3000"
|
||||
echo "🔧 Frontend-Health: http://localhost:3000/health"
|
||||
echo "📦 CDN-Assets: http://localhost:8080"
|
||||
echo "⚡ Frontend-Cache: localhost:6380"
|
||||
echo ""
|
||||
echo "🔗 Verbindet sich mit Backend: ${BACKEND_API_URL:-http://localhost:5000}"
|
||||
echo ""
|
||||
|
||||
# Logs anzeigen (optional)
|
||||
if [ "$1" = "--logs" ] || [ "$2" = "--logs" ]; then
|
||||
log_info "Zeige Frontend-Logs (Strg+C zum Beenden):"
|
||||
docker-compose -f docker-compose.frontend.yml logs -f
|
||||
fi
|
||||
|
||||
log_info "Verwende 'docker-compose -f docker-compose.frontend.yml logs -f' um Logs zu verfolgen"
|
||||
log_info "Verwende 'docker-compose -f docker-compose.frontend.yml down' um den Server zu stoppen"
|
||||
334
myp_installer.sh
334
myp_installer.sh
@ -1,7 +1,7 @@
|
||||
#!/bin/bash
|
||||
# MYP Installer Control Center für Linux/Unix-Systeme
|
||||
# Konsolidiertes Installationsskript für die MYP-Plattform
|
||||
# Version 2.0
|
||||
# MYP Installer Control Center - Vollständige Linux/Unix-Installation
|
||||
# Zentrale Installationskonsole für die MYP-Plattform
|
||||
# Version 3.0 - Konsolidiert alle Setup-Funktionen
|
||||
|
||||
# Farbdefinitionen
|
||||
RED='\033[0;31m'
|
||||
@ -24,6 +24,7 @@ show_header() {
|
||||
clear
|
||||
echo -e "${CYAN}=============================================================${NC}"
|
||||
echo -e "${CYAN} MYP INSTALLER CONTROL CENTER ${NC}"
|
||||
echo -e "${CYAN} Version 3.0 ${NC}"
|
||||
echo -e "${CYAN}=============================================================${NC}"
|
||||
echo -e "${CYAN} $title${NC}"
|
||||
echo -e "${CYAN}=============================================================${NC}"
|
||||
@ -67,6 +68,8 @@ get_local_ip() {
|
||||
}
|
||||
|
||||
test_dependencies() {
|
||||
show_header "Systemvoraussetzungen prüfen"
|
||||
|
||||
echo -e "${BLUE}Prüfe Abhängigkeiten...${NC}"
|
||||
|
||||
local all_installed=1
|
||||
@ -74,8 +77,12 @@ test_dependencies() {
|
||||
# Python
|
||||
if check_command python3; then
|
||||
echo -e "${GREEN}✓ Python 3 gefunden${NC}"
|
||||
python_version=$(python3 --version 2>&1)
|
||||
echo -e "${WHITE} Version: $python_version${NC}"
|
||||
elif check_command python; then
|
||||
echo -e "${GREEN}✓ Python gefunden${NC}"
|
||||
python_version=$(python --version 2>&1)
|
||||
echo -e "${WHITE} Version: $python_version${NC}"
|
||||
else
|
||||
echo -e "${RED}✗ Python nicht gefunden${NC}"
|
||||
all_installed=0
|
||||
@ -94,6 +101,8 @@ test_dependencies() {
|
||||
# Docker
|
||||
if check_command docker; then
|
||||
echo -e "${GREEN}✓ Docker gefunden${NC}"
|
||||
docker_version=$(docker --version 2>&1)
|
||||
echo -e "${WHITE} Version: $docker_version${NC}"
|
||||
else
|
||||
echo -e "${RED}✗ Docker nicht gefunden${NC}"
|
||||
all_installed=0
|
||||
@ -110,6 +119,8 @@ test_dependencies() {
|
||||
# Node.js
|
||||
if check_command node; then
|
||||
echo -e "${GREEN}✓ Node.js gefunden${NC}"
|
||||
node_version=$(node --version 2>&1)
|
||||
echo -e "${WHITE} Version: $node_version${NC}"
|
||||
else
|
||||
echo -e "${RED}✗ Node.js nicht gefunden${NC}"
|
||||
all_installed=0
|
||||
@ -131,7 +142,23 @@ test_dependencies() {
|
||||
all_installed=0
|
||||
fi
|
||||
|
||||
return $all_installed
|
||||
# Git
|
||||
if check_command git; then
|
||||
echo -e "${GREEN}✓ Git gefunden${NC}"
|
||||
else
|
||||
echo -e "${RED}✗ Git nicht gefunden${NC}"
|
||||
all_installed=0
|
||||
fi
|
||||
|
||||
echo ""
|
||||
if [ $all_installed -eq 1 ]; then
|
||||
echo -e "${GREEN}✓ Alle Abhängigkeiten sind installiert!${NC}"
|
||||
else
|
||||
echo -e "${YELLOW}⚠ Einige Abhängigkeiten fehlen. Bitte installieren Sie diese vor der Verwendung.${NC}"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
}
|
||||
|
||||
setup_hosts() {
|
||||
@ -217,6 +244,10 @@ create_ssl_certificates() {
|
||||
backend_hostname="raspberrypi"
|
||||
frontend_hostname="m040tbaraspi001.de040.corpintra.net"
|
||||
;;
|
||||
*)
|
||||
backend_hostname="localhost"
|
||||
frontend_hostname="localhost"
|
||||
;;
|
||||
esac
|
||||
|
||||
echo -e "${BLUE}Backend-Hostname: $backend_hostname${NC}"
|
||||
@ -232,35 +263,52 @@ create_ssl_certificates() {
|
||||
# SSL-Zertifikate mit Python und cryptography erstellen
|
||||
echo -e "${BLUE}Erstelle SSL-Zertifikate mit Python...${NC}"
|
||||
|
||||
if check_command python3 || check_command python; then
|
||||
# Überprüfen, ob cryptography installiert ist
|
||||
# Überprüfen, ob Python verfügbar ist
|
||||
python_cmd=""
|
||||
if check_command python3; then
|
||||
python_cmd="python3"
|
||||
if ! check_command python3; then
|
||||
elif check_command python; then
|
||||
python_cmd="python"
|
||||
else
|
||||
echo -e "${RED}Python nicht gefunden. SSL-Zertifikate können nicht erstellt werden.${NC}"
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Überprüfen, ob cryptography installiert ist
|
||||
cryptography_installed=$($python_cmd -c "try: import cryptography; print('True'); except ImportError: print('False')" 2>/dev/null)
|
||||
|
||||
if [ "$cryptography_installed" != "True" ]; then
|
||||
echo -e "${YELLOW}Installiere Python-Abhängigkeit 'cryptography'...${NC}"
|
||||
if check_command pip3; then
|
||||
exec_command "pip3 install cryptography" "Installiere cryptography-Paket"
|
||||
else
|
||||
elif check_command pip; then
|
||||
exec_command "pip install cryptography" "Installiere cryptography-Paket"
|
||||
else
|
||||
echo -e "${RED}pip nicht gefunden. Kann cryptography nicht installieren.${NC}"
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Python-Skript zur Zertifikatserstellung
|
||||
cat > temp_cert_script.py << EOF
|
||||
# Python-Skript zur Zertifikatserstellung erstellen
|
||||
cat > temp_cert_script.py << EOL
|
||||
#!/usr/bin/env python3
|
||||
import os
|
||||
import datetime
|
||||
import sys
|
||||
from cryptography import x509
|
||||
from cryptography.x509.oid import NameOID
|
||||
from cryptography.hazmat.primitives import hashes
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||||
from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption
|
||||
|
||||
try:
|
||||
from cryptography import x509
|
||||
from cryptography.x509.oid import NameOID
|
||||
from cryptography.hazmat.primitives import hashes
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||||
from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption
|
||||
import ipaddress
|
||||
except ImportError as e:
|
||||
print(f"Fehler: Paket nicht gefunden: {e}")
|
||||
print("Bitte installieren Sie es mit: pip install cryptography")
|
||||
sys.exit(1)
|
||||
|
||||
def create_self_signed_cert(cert_path, key_path, hostname="localhost"):
|
||||
# Verzeichnis erstellen, falls es nicht existiert
|
||||
@ -312,7 +360,8 @@ def create_self_signed_cert(cert_path, key_path, hostname="localhost"):
|
||||
).add_extension(
|
||||
x509.SubjectAlternativeName([
|
||||
x509.DNSName(hostname),
|
||||
x509.DNSName("localhost")
|
||||
x509.DNSName("localhost"),
|
||||
x509.IPAddress(ipaddress.IPv4Address("127.0.0.1"))
|
||||
]),
|
||||
critical=False,
|
||||
).add_extension(
|
||||
@ -350,7 +399,7 @@ create_self_signed_cert('$backend_cert_file', '$backend_key_file', '$backend_hos
|
||||
|
||||
# Frontend-Zertifikat erstellen
|
||||
create_self_signed_cert('$frontend_cert_file', '$frontend_key_file', '$frontend_hostname')
|
||||
EOF
|
||||
EOL
|
||||
|
||||
# Python-Skript ausführbar machen und ausführen
|
||||
chmod +x temp_cert_script.py
|
||||
@ -362,10 +411,7 @@ EOF
|
||||
fi
|
||||
|
||||
# Temporäres Skript löschen
|
||||
rm temp_cert_script.py
|
||||
else
|
||||
echo -e "${RED}Python nicht gefunden. SSL-Zertifikate können nicht erstellt werden.${NC}"
|
||||
fi
|
||||
rm -f temp_cert_script.py
|
||||
|
||||
# Zertifikate im System installieren (optional)
|
||||
if [ $is_root -eq 1 ]; then
|
||||
@ -375,19 +421,28 @@ EOF
|
||||
if [ -f "$backend_cert_file" ]; then
|
||||
echo -e "${BLUE}Installiere Backend-Zertifikat im System...${NC}"
|
||||
|
||||
# Für verschiedene Linux-Distributionen
|
||||
if [ -d "/usr/local/share/ca-certificates" ]; then
|
||||
# Debian/Ubuntu/Raspberry Pi OS
|
||||
cp "$backend_cert_file" /usr/local/share/ca-certificates/myp.crt
|
||||
if [ -d "/usr/local/share/ca-certificates" ]; then
|
||||
cp "$backend_cert_file" /usr/local/share/ca-certificates/myp-backend.crt
|
||||
update-ca-certificates
|
||||
echo -e "${GREEN}Zertifikat installiert (Debian/Ubuntu)${NC}"
|
||||
elif [ -d "/etc/pki/ca-trust/source/anchors" ]; then
|
||||
# RHEL/CentOS/Fedora
|
||||
cp "$backend_cert_file" /etc/pki/ca-trust/source/anchors/myp.crt
|
||||
elif [ -d "/etc/pki/ca-trust/source/anchors" ]; then
|
||||
cp "$backend_cert_file" /etc/pki/ca-trust/source/anchors/myp-backend.crt
|
||||
update-ca-trust extract
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ -f "$frontend_cert_file" ]; then
|
||||
echo -e "${BLUE}Installiere Frontend-Zertifikat im System...${NC}"
|
||||
|
||||
# Debian/Ubuntu/Raspberry Pi OS
|
||||
if [ -d "/usr/local/share/ca-certificates" ]; then
|
||||
cp "$frontend_cert_file" /usr/local/share/ca-certificates/myp-frontend.crt
|
||||
update-ca-certificates
|
||||
# RHEL/CentOS/Fedora
|
||||
elif [ -d "/etc/pki/ca-trust/source/anchors" ]; then
|
||||
cp "$frontend_cert_file" /etc/pki/ca-trust/source/anchors/myp-frontend.crt
|
||||
update-ca-trust extract
|
||||
echo -e "${GREEN}Zertifikat installiert (RHEL/CentOS/Fedora)${NC}"
|
||||
else
|
||||
echo -e "${YELLOW}Unbekanntes System. Zertifikatinstallation übersprungen.${NC}"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
@ -404,50 +459,53 @@ EOF
|
||||
|
||||
# Kopiere Zertifikate ins Frontend-Verzeichnis
|
||||
frontend_ssl_dir="./frontend/ssl"
|
||||
if [ ! -d "$frontend_ssl_dir" ]; then
|
||||
mkdir -p "$frontend_ssl_dir"
|
||||
|
||||
if [ -f "$backend_cert_file" ]; then
|
||||
cp "$backend_cert_file" "$frontend_ssl_dir/myp.crt"
|
||||
fi
|
||||
|
||||
cp "$backend_cert_file" "$frontend_ssl_dir/myp.crt"
|
||||
if [ -f "$backend_key_file" ]; then
|
||||
cp "$backend_key_file" "$frontend_ssl_dir/myp.key"
|
||||
fi
|
||||
|
||||
echo -e "${GREEN}Zertifikate ins Frontend-Verzeichnis kopiert.${NC}"
|
||||
|
||||
# Prüfen, ob .env.local existiert und aktualisieren
|
||||
# .env.local aktualisieren
|
||||
env_local_path="./frontend/.env.local"
|
||||
|
||||
if [ -f "$env_local_path" ]; then
|
||||
# Datei existiert, mache Backup
|
||||
cp "$env_local_path" "${env_local_path}.bak"
|
||||
env_content=$(cat "$env_local_path")
|
||||
else
|
||||
# Datei erstellen
|
||||
echo "# MYP Frontend Umgebungsvariablen" > "$env_local_path"
|
||||
env_content="# MYP Frontend Umgebungsvariablen"
|
||||
fi
|
||||
|
||||
# SSL-Konfigurationen hinzufügen/aktualisieren
|
||||
declare -a ssl_configs=(
|
||||
# SSL-Konfigurationen
|
||||
ssl_configs=(
|
||||
"NODE_TLS_REJECT_UNAUTHORIZED=0"
|
||||
"HTTPS=true"
|
||||
"SSL_CRT_FILE=./ssl/myp.crt"
|
||||
"SSL_KEY_FILE=./ssl/myp.key"
|
||||
"NEXT_PUBLIC_API_URL=https://${backend_hostname}"
|
||||
"NEXT_PUBLIC_BACKEND_HOST=${backend_hostname}"
|
||||
"NEXT_PUBLIC_API_URL=https://$backend_hostname"
|
||||
"NEXT_PUBLIC_BACKEND_HOST=$backend_hostname"
|
||||
"NEXT_PUBLIC_BACKEND_PROTOCOL=https"
|
||||
)
|
||||
|
||||
# Existierende Konfigurationen aktualisieren
|
||||
for config in "${ssl_configs[@]}"; do
|
||||
key=$(echo "$config" | cut -d'=' -f1)
|
||||
|
||||
# Prüfen, ob die Konfiguration bereits existiert
|
||||
if grep -q "^${key}=" "$env_local_path"; then
|
||||
# Existierende Konfiguration aktualisieren
|
||||
sed -i "s|^${key}=.*|${config}|" "$env_local_path"
|
||||
if echo "$env_content" | grep -q "^$key="; then
|
||||
# Update existierende Konfiguration
|
||||
env_content=$(echo "$env_content" | sed "s/^$key=.*/$config/")
|
||||
else
|
||||
# Neue Konfiguration hinzufügen
|
||||
echo "$config" >> "$env_local_path"
|
||||
env_content="$env_content\n$config"
|
||||
fi
|
||||
done
|
||||
|
||||
# Speichern der aktualisierten Umgebungsvariablen
|
||||
echo -e "$env_content" > "$env_local_path"
|
||||
echo -e "${GREEN}.env.local Datei mit SSL-Konfigurationen aktualisiert.${NC}"
|
||||
fi
|
||||
|
||||
@ -464,28 +522,28 @@ setup_environment() {
|
||||
show_header "Umgebungs-Setup"
|
||||
|
||||
# Prüfen, ob Python und pip installiert sind
|
||||
python_cmd="python3"
|
||||
pip_cmd="pip3"
|
||||
python_cmd=""
|
||||
pip_cmd=""
|
||||
|
||||
if ! check_command python3; then
|
||||
if check_command python; then
|
||||
if check_command python3; then
|
||||
python_cmd="python3"
|
||||
elif check_command python; then
|
||||
python_cmd="python"
|
||||
else
|
||||
echo -e "${RED}Python ist nicht installiert.${NC}"
|
||||
echo -e "${RED}Python ist nicht installiert. Bitte installieren Sie Python 3.6+ und versuchen Sie es erneut.${NC}"
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
if ! check_command pip3; then
|
||||
if check_command pip; then
|
||||
if check_command pip3; then
|
||||
pip_cmd="pip3"
|
||||
elif check_command pip; then
|
||||
pip_cmd="pip"
|
||||
else
|
||||
echo -e "${RED}pip ist nicht installiert.${NC}"
|
||||
echo -e "${RED}pip ist nicht installiert. Bitte installieren Sie pip und versuchen Sie es erneut.${NC}"
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Python-Abhängigkeiten installieren
|
||||
echo -e "${BLUE}Installiere Backend-Abhängigkeiten...${NC}"
|
||||
@ -516,6 +574,12 @@ setup_environment() {
|
||||
fi
|
||||
fi
|
||||
|
||||
# Datenbank initialisieren
|
||||
echo -e "${BLUE}Initialisiere Datenbank...${NC}"
|
||||
if [ -f "backend/app/models.py" ]; then
|
||||
exec_command "cd backend && $python_cmd -c 'from app.models import init_db, create_initial_admin; init_db(); create_initial_admin()'" "Initialisiere Datenbank und Admin-Benutzer"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo -e "${GREEN}Umgebungs-Setup abgeschlossen!${NC}"
|
||||
|
||||
@ -529,54 +593,60 @@ start_application() {
|
||||
echo -e "${BLUE}Wie möchten Sie die Anwendung starten?${NC}"
|
||||
echo -e "${WHITE}1. Backend-Server starten (Python)${NC}"
|
||||
echo -e "${WHITE}2. Frontend-Server starten (Node.js)${NC}"
|
||||
echo -e "${WHITE}3. Beide Server starten${NC}"
|
||||
echo -e "${WHITE}3. Beide Server starten (in separaten Terminals)${NC}"
|
||||
echo -e "${WHITE}4. Mit Docker Compose starten${NC}"
|
||||
echo -e "${WHITE}5. Zurück zum Hauptmenü${NC}"
|
||||
echo -e "${WHITE}5. Vollständige Installation und Start${NC}"
|
||||
echo -e "${WHITE}6. Zurück zum Hauptmenü${NC}"
|
||||
|
||||
read -p "Wählen Sie eine Option (1-5): " choice
|
||||
read -p "Wählen Sie eine Option (1-6): " choice
|
||||
|
||||
case $choice in
|
||||
1)
|
||||
echo -e "${BLUE}Starte Backend-Server...${NC}"
|
||||
python_cmd=""
|
||||
if check_command python3; then
|
||||
python_cmd="python3"
|
||||
if ! check_command python3; then
|
||||
elif check_command python; then
|
||||
python_cmd="python"
|
||||
fi
|
||||
|
||||
if [ -n "$python_cmd" ]; then
|
||||
$python_cmd backend/app/app.py &
|
||||
echo -e "${GREEN}Backend-Server läuft jetzt im Hintergrund.${NC}"
|
||||
echo -e "${YELLOW}PID: $!${NC}"
|
||||
else
|
||||
echo -e "${RED}Python nicht gefunden.${NC}"
|
||||
fi
|
||||
;;
|
||||
2)
|
||||
echo -e "${BLUE}Starte Frontend-Server...${NC}"
|
||||
if check_command npm; then
|
||||
(cd frontend && npm run dev) &
|
||||
echo -e "${GREEN}Frontend-Server läuft jetzt im Hintergrund.${NC}"
|
||||
echo -e "${YELLOW}PID: $!${NC}"
|
||||
else
|
||||
echo -e "${RED}npm ist nicht installiert.${NC}"
|
||||
echo -e "${RED}npm nicht gefunden.${NC}"
|
||||
fi
|
||||
;;
|
||||
3)
|
||||
echo -e "${BLUE}Starte Backend-Server...${NC}"
|
||||
python_cmd=""
|
||||
if check_command python3; then
|
||||
python_cmd="python3"
|
||||
if ! check_command python3; then
|
||||
elif check_command python; then
|
||||
python_cmd="python"
|
||||
fi
|
||||
|
||||
if [ -n "$python_cmd" ]; then
|
||||
$python_cmd backend/app/app.py &
|
||||
backend_pid=$!
|
||||
echo -e "${GREEN}Backend-Server gestartet.${NC}"
|
||||
fi
|
||||
|
||||
echo -e "${BLUE}Starte Frontend-Server...${NC}"
|
||||
if check_command npm; then
|
||||
(cd frontend && npm run dev) &
|
||||
frontend_pid=$!
|
||||
echo -e "${GREEN}Frontend-Server gestartet.${NC}"
|
||||
fi
|
||||
|
||||
echo -e "${GREEN}Beide Server laufen jetzt im Hintergrund.${NC}"
|
||||
echo -e "${YELLOW}Backend PID: $backend_pid${NC}"
|
||||
echo -e "${YELLOW}Frontend PID: $frontend_pid${NC}"
|
||||
else
|
||||
echo -e "${RED}npm ist nicht installiert. Nur Backend wurde gestartet.${NC}"
|
||||
echo -e "${YELLOW}Backend PID: $backend_pid${NC}"
|
||||
fi
|
||||
;;
|
||||
4)
|
||||
if check_command docker && check_command docker-compose; then
|
||||
@ -588,6 +658,29 @@ start_application() {
|
||||
fi
|
||||
;;
|
||||
5)
|
||||
echo -e "${BLUE}Führe vollständige Installation durch...${NC}"
|
||||
setup_environment
|
||||
create_ssl_certificates
|
||||
echo -e "${BLUE}Starte Anwendung...${NC}"
|
||||
|
||||
python_cmd=""
|
||||
if check_command python3; then
|
||||
python_cmd="python3"
|
||||
elif check_command python; then
|
||||
python_cmd="python"
|
||||
fi
|
||||
|
||||
if [ -n "$python_cmd" ]; then
|
||||
$python_cmd backend/app/app.py &
|
||||
fi
|
||||
|
||||
if check_command npm; then
|
||||
(cd frontend && npm run dev) &
|
||||
fi
|
||||
|
||||
echo -e "${GREEN}Vollständige Installation und Start abgeschlossen!${NC}"
|
||||
;;
|
||||
6)
|
||||
return
|
||||
;;
|
||||
*)
|
||||
@ -599,45 +692,64 @@ start_application() {
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
}
|
||||
|
||||
clean_old_scripts() {
|
||||
show_header "Alte Skripte bereinigen"
|
||||
show_project_info() {
|
||||
show_header "Projekt-Informationen"
|
||||
|
||||
old_scripts=(
|
||||
"setup_ssl.sh"
|
||||
echo -e "${CYAN}MYP (Mercedes-Benz Yard Printing) Platform${NC}"
|
||||
echo -e "${BLUE}Version 3.0${NC}"
|
||||
echo ""
|
||||
echo -e "${BLUE}Beschreibung:${NC}"
|
||||
echo -e "${WHITE}Eine vollständige 3D-Drucker-Management-Plattform für Mercedes-Benz Werk 040 Berlin.${NC}"
|
||||
echo ""
|
||||
echo -e "${BLUE}Komponenten:${NC}"
|
||||
echo -e "${WHITE}- Backend: Flask-basierte REST API${NC}"
|
||||
echo -e "${WHITE}- Frontend: Next.js React-Anwendung${NC}"
|
||||
echo -e "${WHITE}- Datenbank: SQLite${NC}"
|
||||
echo -e "${WHITE}- Authentifizierung: GitHub OAuth + lokale Benutzer${NC}"
|
||||
echo -e "${WHITE}- SSL/TLS: Selbstsignierte Zertifikate${NC}"
|
||||
echo ""
|
||||
echo -e "${BLUE}Standard-Zugangsdaten:${NC}"
|
||||
echo -e "${WHITE}- Admin E-Mail: admin@mercedes-benz.com${NC}"
|
||||
echo -e "${WHITE}- Admin Passwort: 744563017196A${NC}"
|
||||
echo ""
|
||||
echo -e "${BLUE}URLs:${NC}"
|
||||
echo -e "${WHITE}- Backend: https://localhost:443 oder https://raspberrypi:443${NC}"
|
||||
echo -e "${WHITE}- Frontend: https://localhost:3000${NC}"
|
||||
echo ""
|
||||
echo -e "${YELLOW}Weitere Informationen finden Sie in der CREDENTIALS.md Datei.${NC}"
|
||||
|
||||
echo ""
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
}
|
||||
|
||||
clean_old_files() {
|
||||
show_header "Alte Dateien bereinigen"
|
||||
|
||||
read -p "Möchten Sie alte Skriptdateien und temporäre Dateien löschen? (j/n): " clean_files
|
||||
|
||||
if [ "$clean_files" = "j" ]; then
|
||||
files_to_delete=(
|
||||
"setup_hosts.sh"
|
||||
"setup_ssl.sh"
|
||||
"generate_ssl_certs.sh"
|
||||
"setup_ssl.ps1"
|
||||
"setup_hosts.ps1"
|
||||
"setup_hosts_copy.ps1"
|
||||
"generate_ssl_certs.ps1"
|
||||
"generate_ssl_certs_copy.ps1"
|
||||
"temp_cert_script.py"
|
||||
"frontend/cleanup.sh"
|
||||
"frontend/install.sh"
|
||||
"frontend/https-setup.sh"
|
||||
"frontend/start-debug-server.sh"
|
||||
"frontend/start-frontend-server.sh"
|
||||
)
|
||||
|
||||
echo -e "${BLUE}Folgende Skripte werden gelöscht:${NC}"
|
||||
for script in "${old_scripts[@]}"; do
|
||||
if [ -f "$script" ]; then
|
||||
echo -e "${WHITE} - $script${NC}"
|
||||
for file in "${files_to_delete[@]}"; do
|
||||
if [ -f "$file" ]; then
|
||||
rm -f "$file"
|
||||
echo -e "${GREEN}✓ Gelöscht: $file${NC}"
|
||||
fi
|
||||
done
|
||||
|
||||
echo ""
|
||||
read -p "Möchten Sie fortfahren? (j/n, Standard: j): " confirm
|
||||
|
||||
if [ "$confirm" != "n" ]; then
|
||||
for script in "${old_scripts[@]}"; do
|
||||
if [ -f "$script" ]; then
|
||||
if rm "$script"; then
|
||||
echo -e "${GREEN}✓ $script wurde gelöscht.${NC}"
|
||||
echo -e "${GREEN}Bereinigung abgeschlossen!${NC}"
|
||||
else
|
||||
echo -e "${RED}✗ Fehler beim Löschen von $script.${NC}"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
echo ""
|
||||
echo -e "${GREEN}Bereinigung abgeschlossen.${NC}"
|
||||
else
|
||||
echo -e "${YELLOW}Bereinigung abgebrochen.${NC}"
|
||||
echo -e "${BLUE}Bereinigung übersprungen.${NC}"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
@ -653,17 +765,16 @@ show_main_menu() {
|
||||
echo -e "${WHITE}3. SSL-Zertifikate erstellen${NC}"
|
||||
echo -e "${WHITE}4. Umgebung einrichten (Abhängigkeiten installieren)${NC}"
|
||||
echo -e "${WHITE}5. Anwendung starten${NC}"
|
||||
echo -e "${WHITE}6. Alte Skripte bereinigen${NC}"
|
||||
echo -e "${WHITE}Q. Beenden${NC}"
|
||||
echo -e "${WHITE}6. Projekt-Informationen anzeigen${NC}"
|
||||
echo -e "${WHITE}7. Alte Dateien bereinigen${NC}"
|
||||
echo -e "${WHITE}8. Beenden${NC}"
|
||||
echo ""
|
||||
|
||||
read -p "Wählen Sie eine Option (1-6, Q): " choice
|
||||
read -p "Wählen Sie eine Option (1-8): " choice
|
||||
|
||||
case $choice in
|
||||
1)
|
||||
test_dependencies
|
||||
echo ""
|
||||
read -p "Drücken Sie ENTER, um fortzufahren..."
|
||||
show_main_menu
|
||||
;;
|
||||
2)
|
||||
@ -683,10 +794,15 @@ show_main_menu() {
|
||||
show_main_menu
|
||||
;;
|
||||
6)
|
||||
clean_old_scripts
|
||||
show_project_info
|
||||
show_main_menu
|
||||
;;
|
||||
[Qq])
|
||||
7)
|
||||
clean_old_files
|
||||
show_main_menu
|
||||
;;
|
||||
8)
|
||||
echo -e "${GREEN}Auf Wiedersehen!${NC}"
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user