"Add SSL configuration scripts (feat)"
This commit is contained in:
537
setup_ssl.sh
Normal file
537
setup_ssl.sh
Normal file
@@ -0,0 +1,537 @@
|
||||
#!/bin/bash
|
||||
|
||||
# SSL-Konfiguration für MYP-Plattform (Linux/Raspberry Pi)
|
||||
|
||||
# Farbdefinitionen
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[0;33m'
|
||||
CYAN='\033[0;36m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Titel anzeigen
|
||||
echo -e "${CYAN}===================================================="
|
||||
echo -e " SSL-Konfiguration für MYP-Plattform"
|
||||
echo -e "====================================================${NC}"
|
||||
echo ""
|
||||
|
||||
# Prüfen, ob das Skript mit Root-Rechten ausgeführt wird
|
||||
if [ "$EUID" -ne 0 ]; then
|
||||
echo -e "${YELLOW}WARNUNG: Dieses Skript sollte mit Root-Rechten ausgeführt werden, um Zertifikate im System zu installieren.${NC}"
|
||||
echo -e "${YELLOW}Einige Funktionen sind möglicherweise eingeschränkt.${NC}"
|
||||
echo ""
|
||||
|
||||
read -p "Möchten Sie trotzdem fortfahren? (j/n): " continue_anyway
|
||||
if [ "$continue_anyway" != "j" ]; then
|
||||
echo -e "${RED}Installation abgebrochen.${NC}"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Funktion zum Ausführen von Befehlen mit Ausgabe
|
||||
exec_command() {
|
||||
command="$1"
|
||||
description="$2"
|
||||
|
||||
echo -e "${YELLOW}> $description...${NC}"
|
||||
eval $command
|
||||
|
||||
if [ $? -eq 0 ]; then
|
||||
echo -e "${GREEN}✓ Erfolgreich abgeschlossen!${NC}"
|
||||
return 0
|
||||
else
|
||||
echo -e "${RED}✗ Fehler beim Ausführen des Befehls. Exit-Code: $?${NC}"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Prüfen, ob Python und pip installiert sind
|
||||
if ! command -v python3 &> /dev/null; then
|
||||
echo -e "${RED}✗ Python 3 ist nicht installiert. Bitte installieren Sie Python 3.6 oder höher.${NC}"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if ! command -v pip3 &> /dev/null; then
|
||||
echo -e "${RED}✗ pip3 ist nicht installiert. Bitte installieren Sie pip3.${NC}"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# 1. Prüfen, ob die notwendigen Abhängigkeiten installiert sind
|
||||
echo -e "${CYAN}1. Prüfe Abhängigkeiten...${NC}"
|
||||
|
||||
# Python-Abhängigkeiten prüfen
|
||||
cryptography_installed=$(python3 -c "try: import cryptography; print('True'); except ImportError: print('False')" 2>/dev/null)
|
||||
if [ "$cryptography_installed" != "True" ]; then
|
||||
echo "Installiere Python-Abhängigkeit 'cryptography'..."
|
||||
exec_command "pip3 install cryptography" "Installiere cryptography-Paket"
|
||||
fi
|
||||
|
||||
# 2. SSL-Zertifikat generieren
|
||||
echo ""
|
||||
echo -e "${CYAN}2. Generiere SSL-Zertifikat...${NC}"
|
||||
|
||||
# SSL-Verzeichnisse erstellen
|
||||
mkdir -p backend/app/instance/ssl
|
||||
mkdir -p frontend/ssl
|
||||
|
||||
# Python-Skript erstellen, falls nicht vorhanden
|
||||
if [ ! -f backend/generate_ssl_cert.py ]; then
|
||||
echo "SSL-Zertifikatsgenerator nicht gefunden. Erstelle..."
|
||||
|
||||
cat > backend/generate_ssl_cert.py << 'EOF'
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import os
|
||||
import datetime
|
||||
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
|
||||
|
||||
def generate_ssl_certificate():
|
||||
"""
|
||||
Generiert ein verbessertes SSL-Zertifikat für die MYP-Anwendung
|
||||
mit korrekten Metadaten und alternativen Namen.
|
||||
"""
|
||||
print("Generiere verbessertes SSL-Zertifikat für die MYP-Anwendung...")
|
||||
|
||||
# Verzeichnispfade definieren
|
||||
ssl_dir = "app/instance/ssl"
|
||||
ssl_cert_path = os.path.join(ssl_dir, "myp.crt")
|
||||
ssl_key_path = os.path.join(ssl_dir, "myp.key")
|
||||
|
||||
# Verzeichnis erstellen, falls es nicht existiert
|
||||
os.makedirs(ssl_dir, exist_ok=True)
|
||||
|
||||
try:
|
||||
# Privaten Schlüssel mit 4096 Bit generieren (sicherer)
|
||||
private_key = rsa.generate_private_key(
|
||||
public_exponent=65537,
|
||||
key_size=4096,
|
||||
)
|
||||
|
||||
# Aktuelles Datum und Ablaufdatum (1 Jahr gültig)
|
||||
now = datetime.datetime.now()
|
||||
valid_until = now + datetime.timedelta(days=365)
|
||||
|
||||
# Liste aller möglichen Hostnamen/IPs
|
||||
hostnames = [
|
||||
"localhost",
|
||||
"raspberrypi",
|
||||
"m040tbaraspi001",
|
||||
"m040tbaraspi001.de040.corpintra.net"
|
||||
]
|
||||
|
||||
# IP-Adressen (als String, werden später konvertiert)
|
||||
ip_addresses = [
|
||||
"127.0.0.1",
|
||||
"192.168.0.105"
|
||||
]
|
||||
|
||||
# Erweiterte Zertifikatsattribute
|
||||
subject = issuer = x509.Name([
|
||||
x509.NameAttribute(NameOID.COMMON_NAME, "raspberrypi"),
|
||||
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mercedes-Benz AG"),
|
||||
x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, "Werk 040 Berlin"),
|
||||
x509.NameAttribute(NameOID.COUNTRY_NAME, "DE"),
|
||||
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Berlin"),
|
||||
x509.NameAttribute(NameOID.LOCALITY_NAME, "Berlin")
|
||||
])
|
||||
|
||||
# Subject Alternative Names (SAN) erstellen
|
||||
san_list = []
|
||||
for hostname in hostnames:
|
||||
san_list.append(x509.DNSName(hostname))
|
||||
|
||||
# IP-Adressen hinzufügen
|
||||
import socket
|
||||
for ip in ip_addresses:
|
||||
san_list.append(x509.IPAddress(socket.inet_aton(ip)))
|
||||
|
||||
# Zertifikat erstellen
|
||||
cert = x509.CertificateBuilder().subject_name(
|
||||
subject
|
||||
).issuer_name(
|
||||
issuer
|
||||
).public_key(
|
||||
private_key.public_key()
|
||||
).serial_number(
|
||||
x509.random_serial_number()
|
||||
).not_valid_before(
|
||||
now
|
||||
).not_valid_after(
|
||||
valid_until
|
||||
).add_extension(
|
||||
x509.SubjectAlternativeName(san_list),
|
||||
critical=False,
|
||||
).add_extension(
|
||||
x509.BasicConstraints(ca=True, path_length=None), critical=True
|
||||
).add_extension(
|
||||
x509.KeyUsage(
|
||||
digital_signature=True,
|
||||
content_commitment=False,
|
||||
key_encipherment=True,
|
||||
data_encipherment=False,
|
||||
key_agreement=False,
|
||||
key_cert_sign=True,
|
||||
crl_sign=True,
|
||||
encipher_only=False,
|
||||
decipher_only=False
|
||||
), critical=True
|
||||
).add_extension(
|
||||
x509.ExtendedKeyUsage([
|
||||
x509.oid.ExtendedKeyUsageOID.SERVER_AUTH,
|
||||
x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH
|
||||
]), critical=False
|
||||
).sign(private_key, hashes.SHA256())
|
||||
|
||||
# Zertifikat und Schlüssel speichern
|
||||
with open(ssl_key_path, "wb") as f:
|
||||
f.write(private_key.private_bytes(
|
||||
encoding=Encoding.PEM,
|
||||
format=PrivateFormat.TraditionalOpenSSL,
|
||||
encryption_algorithm=NoEncryption()
|
||||
))
|
||||
|
||||
with open(ssl_cert_path, "wb") as f:
|
||||
f.write(cert.public_bytes(Encoding.PEM))
|
||||
|
||||
# Kopieren des Zertifikats in das Frontend-Verzeichnis
|
||||
frontend_ssl_dir = "../frontend/ssl"
|
||||
os.makedirs(frontend_ssl_dir, exist_ok=True)
|
||||
|
||||
import shutil
|
||||
shutil.copy2(ssl_cert_path, os.path.join(frontend_ssl_dir, "myp.crt"))
|
||||
shutil.copy2(ssl_key_path, os.path.join(frontend_ssl_dir, "myp.key"))
|
||||
|
||||
print(f"SSL-Zertifikat wurde erstellt:")
|
||||
print(f"- Zertifikat: {ssl_cert_path}")
|
||||
print(f"- Schlüssel: {ssl_key_path}")
|
||||
print(f"- Kopiert nach: {frontend_ssl_dir}")
|
||||
print(f"- Gültig bis: {valid_until.strftime('%d.%m.%Y')}")
|
||||
print(f"- Hostnamen: {', '.join(hostnames)}")
|
||||
print(f"- IP-Adressen: {', '.join(ip_addresses)}")
|
||||
|
||||
return True
|
||||
except Exception as e:
|
||||
print(f"Fehler beim Erstellen des SSL-Zertifikats: {e}")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
generate_ssl_certificate()
|
||||
EOF
|
||||
|
||||
# Ausführbar machen
|
||||
chmod +x backend/generate_ssl_cert.py
|
||||
fi
|
||||
|
||||
# Zertifikat generieren
|
||||
cert_gen_success=$(exec_command "cd backend && python3 generate_ssl_cert.py" "Generiere SSL-Zertifikat")
|
||||
|
||||
if [ $? -ne 0 ]; then
|
||||
echo -e "${RED}✗ Fehler bei der Zertifikatsgenerierung. Abbruch.${NC}"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# 3. Zertifikat im System installieren
|
||||
echo ""
|
||||
echo -e "${CYAN}3. Installiere Zertifikat im System...${NC}"
|
||||
|
||||
if [ "$EUID" -eq 0 ]; then
|
||||
# Als Root ausgeführt
|
||||
cert_path=$(readlink -f backend/app/instance/ssl/myp.crt)
|
||||
|
||||
# Zielverzeichnis für System-Zertifikate
|
||||
if [ -d "/usr/local/share/ca-certificates" ]; then
|
||||
# Debian/Ubuntu/Raspberry Pi OS
|
||||
cert_dir="/usr/local/share/ca-certificates"
|
||||
exec_command "cp $cert_path $cert_dir/myp.crt" "Kopiere Zertifikat in System-Verzeichnis"
|
||||
exec_command "update-ca-certificates" "Aktualisiere System-Zertifikate"
|
||||
elif [ -d "/etc/pki/ca-trust/source/anchors" ]; then
|
||||
# RHEL/CentOS/Fedora
|
||||
cert_dir="/etc/pki/ca-trust/source/anchors"
|
||||
exec_command "cp $cert_path $cert_dir/myp.crt" "Kopiere Zertifikat in System-Verzeichnis"
|
||||
exec_command "update-ca-trust extract" "Aktualisiere System-Zertifikate"
|
||||
else
|
||||
echo -e "${YELLOW}Unbekanntes System. Versuche direkte Installation...${NC}"
|
||||
if command -v certutil &> /dev/null; then
|
||||
exec_command "certutil -A -n 'MYP SSL Certificate' -t 'C,,' -i $cert_path -d sql:$HOME/.pki/nssdb" "Installiere mit certutil"
|
||||
fi
|
||||
fi
|
||||
else
|
||||
echo -e "${YELLOW}Überspringen der System-Installation, da das Skript nicht als Root ausgeführt wird.${NC}"
|
||||
echo -e "${YELLOW}Sie können das Zertifikat später manuell installieren durch:${NC}"
|
||||
echo -e "${NC}sudo cp backend/app/instance/ssl/myp.crt /usr/local/share/ca-certificates/ && sudo update-ca-certificates${NC}"
|
||||
fi
|
||||
|
||||
# 4. Frontend konfigurieren
|
||||
echo ""
|
||||
echo -e "${CYAN}4. Konfiguriere Frontend...${NC}"
|
||||
|
||||
# Erstelle Frontend-Konfigurationsskript
|
||||
cat > frontend/configure_ssl.js << 'EOF'
|
||||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Dieses Skript konfiguriert das Next.js-Frontend, um das selbstsignierte SSL-Zertifikat zu akzeptieren
|
||||
* und die richtigen SSL-Einstellungen im Frontend zu setzen.
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
// Pfade definieren
|
||||
const ENV_LOCAL_PATH = path.join(__dirname, '.env.local');
|
||||
const ENV_FRONTEND_PATH = path.join(__dirname, 'env.frontend');
|
||||
const SSL_DIR = path.join(__dirname, 'ssl');
|
||||
const NEXT_CONFIG_PATH = path.join(__dirname, 'next.config.js');
|
||||
|
||||
console.log('=== Frontend-SSL-Konfiguration ===');
|
||||
|
||||
// Prüfen, ob SSL-Verzeichnis und Zertifikate existieren
|
||||
if (!fs.existsSync(SSL_DIR) ||
|
||||
!fs.existsSync(path.join(SSL_DIR, 'myp.crt')) ||
|
||||
!fs.existsSync(path.join(SSL_DIR, 'myp.key'))) {
|
||||
console.error('SSL-Zertifikate nicht gefunden. Bitte zuerst das Backend-Skript ausführen.');
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
console.log('SSL-Zertifikate gefunden. Konfiguriere Frontend...');
|
||||
|
||||
// Umgebungsvariablen konfigurieren
|
||||
function updateEnvFile() {
|
||||
try {
|
||||
let envContent;
|
||||
|
||||
// .env.local erstellen oder aktualisieren
|
||||
if (fs.existsSync(ENV_LOCAL_PATH)) {
|
||||
envContent = fs.readFileSync(ENV_LOCAL_PATH, 'utf8');
|
||||
} else if (fs.existsSync(ENV_FRONTEND_PATH)) {
|
||||
envContent = fs.readFileSync(ENV_FRONTEND_PATH, 'utf8');
|
||||
} else {
|
||||
envContent = `# MYP Frontend Umgebungsvariablen\n`;
|
||||
}
|
||||
|
||||
// SSL-Konfigurationen
|
||||
const sslConfigs = [
|
||||
'NODE_TLS_REJECT_UNAUTHORIZED=0',
|
||||
'HTTPS=true',
|
||||
'SSL_CRT_FILE=./ssl/myp.crt',
|
||||
'SSL_KEY_FILE=./ssl/myp.key',
|
||||
'NEXT_PUBLIC_API_URL=https://raspberrypi:443',
|
||||
'NEXT_PUBLIC_BACKEND_HOST=raspberrypi:443',
|
||||
'NEXT_PUBLIC_BACKEND_PROTOCOL=https'
|
||||
];
|
||||
|
||||
// Existierende Konfigurationen aktualisieren
|
||||
sslConfigs.forEach(config => {
|
||||
const [key, value] = config.split('=');
|
||||
const regex = new RegExp(`^${key}=.*$`, 'm');
|
||||
|
||||
if (envContent.match(regex)) {
|
||||
// Update existierende Konfiguration
|
||||
envContent = envContent.replace(regex, config);
|
||||
} else {
|
||||
// Neue Konfiguration hinzufügen
|
||||
envContent += `\n${config}`;
|
||||
}
|
||||
});
|
||||
|
||||
// Speichern der aktualisierten Umgebungsvariablen
|
||||
fs.writeFileSync(ENV_LOCAL_PATH, envContent);
|
||||
console.log('.env.local Datei aktualisiert mit SSL-Konfigurationen');
|
||||
return true;
|
||||
} catch (error) {
|
||||
console.error(`Fehler bei der Aktualisierung der Umgebungsvariablen: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Next.js-Konfiguration aktualisieren
|
||||
function updateNextConfig() {
|
||||
try {
|
||||
let configContent;
|
||||
|
||||
// next.config.js erstellen oder aktualisieren
|
||||
if (fs.existsSync(NEXT_CONFIG_PATH)) {
|
||||
configContent = fs.readFileSync(NEXT_CONFIG_PATH, 'utf8');
|
||||
} else {
|
||||
configContent = `/** @type {import('next').NextConfig} */\n\nconst nextConfig = {}\n\nmodule.exports = nextConfig\n`;
|
||||
}
|
||||
|
||||
// Prüfen, ob bereits eine HTTPS-Konfiguration vorhanden ist
|
||||
if (configContent.includes('serverOptions:') && configContent.includes('https:')) {
|
||||
console.log('HTTPS-Konfiguration ist bereits in der next.config.js vorhanden.');
|
||||
return true;
|
||||
}
|
||||
|
||||
// HTTPS-Konfiguration hinzufügen
|
||||
const httpsConfig = `
|
||||
/** @type {import('next').NextConfig} */
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const nextConfig = {
|
||||
reactStrictMode: true,
|
||||
webpack: (config) => {
|
||||
return config;
|
||||
},
|
||||
// HTTPS-Konfiguration für die Entwicklung
|
||||
devServer: {
|
||||
https: {
|
||||
key: fs.readFileSync(path.resolve(__dirname, 'ssl/myp.key')),
|
||||
cert: fs.readFileSync(path.resolve(__dirname, 'ssl/myp.crt')),
|
||||
},
|
||||
},
|
||||
// Konfiguration für selbstsignierte Zertifikate
|
||||
serverOptions: {
|
||||
https: {
|
||||
key: fs.readFileSync(path.resolve(__dirname, 'ssl/myp.key')),
|
||||
cert: fs.readFileSync(path.resolve(__dirname, 'ssl/myp.crt')),
|
||||
},
|
||||
},
|
||||
// Zusätzliche Konfigurationen
|
||||
async rewrites() {
|
||||
return [
|
||||
{
|
||||
source: '/api/:path*',
|
||||
destination: 'https://raspberrypi:443/api/:path*',
|
||||
},
|
||||
]
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = nextConfig;
|
||||
`;
|
||||
|
||||
// Speichern der aktualisierten Next.js-Konfiguration
|
||||
fs.writeFileSync(NEXT_CONFIG_PATH, httpsConfig);
|
||||
console.log('next.config.js Datei aktualisiert mit HTTPS-Konfiguration');
|
||||
return true;
|
||||
} catch (error) {
|
||||
console.error(`Fehler bei der Aktualisierung der Next.js-Konfiguration: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Update der Fetch-Konfiguration
|
||||
function updateFetchConfig() {
|
||||
try {
|
||||
const fetchConfigPath = path.join(__dirname, 'src', 'utils', 'api-config.ts');
|
||||
|
||||
if (!fs.existsSync(fetchConfigPath)) {
|
||||
console.warn('Datei api-config.ts nicht gefunden. Überspringe Aktualisierung.');
|
||||
return true;
|
||||
}
|
||||
|
||||
// Lesen der aktuellen Konfiguration
|
||||
let configContent = fs.readFileSync(fetchConfigPath, 'utf8');
|
||||
|
||||
// Sicherstellen, dass SSL-Verbindungen akzeptiert werden
|
||||
if (!configContent.includes('NODE_TLS_REJECT_UNAUTHORIZED=0')) {
|
||||
// Hinzufügen eines Kommentars zu Beginn der Datei
|
||||
configContent = `// SSL-Verbindungen akzeptieren (selbstsignierte Zertifikate)
|
||||
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
|
||||
|
||||
${configContent}`;
|
||||
}
|
||||
|
||||
// Speichern der aktualisierten Fetch-Konfiguration
|
||||
fs.writeFileSync(fetchConfigPath, configContent);
|
||||
console.log('api-config.ts Datei aktualisiert, um selbstsignierte Zertifikate zu akzeptieren');
|
||||
return true;
|
||||
} catch (error) {
|
||||
console.error(`Fehler bei der Aktualisierung der Fetch-Konfiguration: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Hauptfunktion
|
||||
function main() {
|
||||
let success = true;
|
||||
|
||||
success = updateEnvFile() && success;
|
||||
success = updateNextConfig() && success;
|
||||
success = updateFetchConfig() && success;
|
||||
|
||||
if (success) {
|
||||
console.log('\n=== Konfiguration erfolgreich abgeschlossen ===');
|
||||
console.log('Das Frontend wurde für die Verwendung von HTTPS mit dem selbstsignierten Zertifikat konfiguriert.');
|
||||
} else {
|
||||
console.error('\n=== Konfiguration nicht vollständig abgeschlossen ===');
|
||||
console.error('Es gab Probleme bei der Konfiguration des Frontends.');
|
||||
}
|
||||
}
|
||||
|
||||
// Ausführen der Hauptfunktion
|
||||
main();
|
||||
EOF
|
||||
|
||||
# Ausführbar machen
|
||||
chmod +x frontend/configure_ssl.js
|
||||
|
||||
# Frontend konfigurieren
|
||||
if command -v node &> /dev/null; then
|
||||
frontend_config_success=$(exec_command "cd frontend && node configure_ssl.js" "Konfiguriere Frontend")
|
||||
else
|
||||
echo -e "${YELLOW}Node.js ist nicht installiert. Überspringe Frontend-Konfiguration.${NC}"
|
||||
echo -e "${YELLOW}Sie können die Frontend-Konfiguration später manuell durchführen durch:${NC}"
|
||||
echo -e "${NC}cd frontend && node configure_ssl.js${NC}"
|
||||
fi
|
||||
|
||||
# 5. Docker-Compose Datei aktualisieren
|
||||
echo ""
|
||||
echo -e "${CYAN}5. Aktualisiere Docker-Compose-Konfiguration...${NC}"
|
||||
|
||||
docker_compose_file="docker-compose.yml"
|
||||
if [ -f "$docker_compose_file" ]; then
|
||||
if ! grep -q -- "--dual-protocol" "$docker_compose_file"; then
|
||||
# Backup erstellen
|
||||
cp "$docker_compose_file" "${docker_compose_file}.bak"
|
||||
|
||||
# Konfiguration aktualisieren
|
||||
sed -i 's/command: python -m app\.app/command: python -m app.app --dual-protocol/g' "$docker_compose_file"
|
||||
|
||||
echo -e "${GREEN}✓ Docker-Compose-Datei wurde aktualisiert, um den dual-protocol-Modus zu aktivieren.${NC}"
|
||||
else
|
||||
echo -e "${GREEN}✓ Docker-Compose-Datei ist bereits korrekt konfiguriert.${NC}"
|
||||
fi
|
||||
else
|
||||
echo -e "${YELLOW}✗ Docker-Compose-Datei nicht gefunden. Überspringe diese Konfiguration.${NC}"
|
||||
fi
|
||||
|
||||
# 6. Docker-Container aktualisieren
|
||||
echo ""
|
||||
echo -e "${CYAN}6. Möchten Sie die Docker-Container neu starten?${NC}"
|
||||
read -p "Neu starten (j/n): " restart_docker
|
||||
|
||||
if [ "$restart_docker" = "j" ]; then
|
||||
if command -v docker-compose &> /dev/null || command -v docker &> /dev/null; then
|
||||
echo "Starte Docker-Container neu..."
|
||||
|
||||
if command -v docker-compose &> /dev/null; then
|
||||
exec_command "docker-compose down && docker-compose up -d" "Starte Docker-Container neu mit docker-compose"
|
||||
else
|
||||
exec_command "docker compose down && docker compose up -d" "Starte Docker-Container neu mit docker compose"
|
||||
fi
|
||||
else
|
||||
echo -e "${YELLOW}Docker ist nicht installiert oder nicht im PATH. Überspringe Neustart der Container.${NC}"
|
||||
fi
|
||||
fi
|
||||
|
||||
# Abschluss
|
||||
echo ""
|
||||
echo -e "${CYAN}===================================================="
|
||||
echo -e " SSL-Konfiguration abgeschlossen"
|
||||
echo -e "====================================================${NC}"
|
||||
echo ""
|
||||
echo -e "${GREEN}Das SSL-Zertifikat wurde erfolgreich generiert und konfiguriert.${NC}"
|
||||
echo -e "${GREEN}Sie können nun auf folgende Weise auf die Anwendung zugreifen:${NC}"
|
||||
echo -e "${GREEN}- Backend: https://raspberrypi:443${NC}"
|
||||
echo -e "${GREEN}- Frontend: https://localhost:3000${NC}"
|
||||
echo ""
|
||||
echo -e "${YELLOW}Hinweis: Bei der ersten Verbindung müssen Sie möglicherweise${NC}"
|
||||
echo -e "${YELLOW}das selbstsignierte Zertifikat in Ihrem Browser akzeptieren.${NC}"
|
||||
echo ""
|
||||
Reference in New Issue
Block a user