Skip to main content

Produktive Inventar App Installation

Inventar App Installation - Debian 12 Server

Phase 1: System vorbereiten
sudo apt update && sudo apt upgrade -y
sudo apt install nginx mariadb-server python3 python3-pip python3-venv certbot python3-certbot-nginx redis-server -y
sudo mysql_secure_installation
Phase 1.1: Redis absichern

Redis wird für das Rate-Limiting benötigt. Standardmäßig ist es unsicher konfiguriert. Wir sorgen dafür, dass es nur auf lokale Anfragen hört.

sudo nano /etc/redis/redis.conf

Suchen Sie die Zeile # bind 127.0.0.1 ::1 und entfernen Sie das #-Zeichen am Anfang. Speichern Sie die Datei und starten Sie Redis neu:

sudo systemctl restart redis-server

Testen Sie die Verbindung. Die Antwort sollte "PONG" sein.

redis-cli ping
Phase 2: Datenbank einrichten

MySQL als root-Benutzer anmelden und Datenbank erstellen:

sudo mysql -u root -p
Datenbank, Benutzer und alle Tabellen erstellen:

(Ersetzen Sie 'IhrStarkesDbPasswort' durch ein sicheres Passwort, das Sie sich notieren).

CREATE DATABASE inventar;
CREATE USER 'inventar_user'@'localhost' IDENTIFIED BY 'IhrStarkesDbPasswort';
GRANT ALL PRIVILEGES ON inventar.* TO 'inventar_user'@'localhost';
FLUSH PRIVILEGES;
USE inventar;

CREATE TABLE users (
id INTEGER NOT NULL AUTO_INCREMENT,
username VARCHAR(80) NOT NULL,
password_hash VARCHAR(128) NOT NULL,
role VARCHAR(20) NOT NULL,
is_2fa_enabled BOOLEAN,
totp_secret VARCHAR(32),
PRIMARY KEY (id),
UNIQUE (username)
);
CREATE TABLE categories (
id INTEGER NOT NULL AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
prefix VARCHAR(3) NOT NULL,
parent_id INTEGER,
PRIMARY KEY (id),
UNIQUE (prefix),
FOREIGN KEY(parent_id) REFERENCES categories (id)
);
CREATE TABLE items (
id INTEGER NOT NULL AUTO_INCREMENT,
item_uid VARCHAR(50) NOT NULL,
name VARCHAR(120) NOT NULL,
quantity INTEGER NOT NULL,
location VARCHAR(120),
brand VARCHAR(80),
color VARCHAR(50),
size VARCHAR(50),
`condition` VARCHAR(50),
price FLOAT,
shipping_size VARCHAR(50),
notes TEXT,
image_file VARCHAR(120),
created_at DATETIME NOT NULL,
PRIMARY KEY (id),
UNIQUE (item_uid)
);
CREATE TABLE logs (
id INTEGER NOT NULL AUTO_INCREMENT,
user_id INTEGER NOT NULL,
item_id INTEGER,
action VARCHAR(100) NOT NULL,
details TEXT,
timestamp DATETIME NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY(user_id) REFERENCES users (id),
FOREIGN KEY(item_id) REFERENCES items (id)
);
CREATE TABLE item_categories (
item_id INTEGER NOT NULL,
category_id INTEGER NOT NULL,
PRIMARY KEY (item_id, category_id),
FOREIGN KEY(item_id) REFERENCES items (id),
FOREIGN KEY(category_id) REFERENCES categories (id)
);

EXIT;
Phase 3: Projektverzeichnis und App-Installation

Projekt aus dem Download entpacken oder von Git klonen.

# Beispiel: Entpacken des Downloads
# unzip inventar-app.zip
# mv inventar-app /opt/inventar_projekt
cd /opt/inventar_projekt

# Python-Umgebung erstellen
python3 -m venv venv
source venv/bin/activate

# Alle Abhängigkeiten über setup.py installieren
pip install -e .
Phase 4: Anwendungsdateien anpassen

Wichtig: Passen Sie das Datenbank-Passwort in der Konfigurationsdatei an Ihr gewähltes Passwort an.

nano src/inventar/config.py
# in src/inventar/config.py
class Config:
# ...
SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://inventar_user:IhrStarkesDbPasswort@localhost/inventar'
# ...
Phase 5: Admin-Benutzer erstellen

Erstellen Sie im Hauptverzeichnis (`/opt/inventar_projekt`) eine temporäre Datei nano create_admin.py:

1 # /opt/inventar_projekt/create_user.py
 2
 3 from inventar import create_app, db
 4 from inventar.models import User
 5
 6 # Erstellt eine App-Instanz, um den Datenbank-Kontext zu haben
 7 app = create_app()
 8
 9 # --- WICHTIG: Passen Sie diese Werte an, falls nötig ---
10 USERNAME_TO_CREATE = 'admin'
11 NEW_PASSWORD = 'deinpasswort'  # Ändern Sie dies zu einem sicheren Passwort!
12 # --- Ende der Konfiguration ---
13
14 # 'with app.app_context()' stellt sicher, dass wir auf die Datenbank zugreifen können
15 with app.app_context():
16     try:
17         print(f"Suche nach Benutzer '{USERNAME_TO_CREATE}'...")
18         user = User.query.filter_by(username=USERNAME_TO_CREATE).first()
19         
20         if user:
21             # Benutzer existiert -> Passwort aktualisieren, Rolle auf 'admin' setzen und 2FA deaktivieren
22             print(f"Benutzer '{USERNAME_TO_CREATE}' existiert. Aktualisiere Passwort, setze Rolle auf 'admin' und deaktiviere 2FA...")
23             user.set_password(NEW_PASSWORD)
24             user.role = 'admin'
25             user.is_2fa_enabled = False
26             user.totp_secret = None
27             print(f"Benutzer '{USERNAME_TO_CREATE}' wurde erfolgreich aktualisiert.")
28         else:
29             # Benutzer existiert nicht -> Neu anlegen
30             print(f"Benutzer '{USERNAME_TO_CREATE}' nicht gefunden. Erstelle neuen Admin-Benutzer...")
31             user = User(username=USERNAME_TO_CREATE, role='admin')
32             user.set_password(NEW_PASSWORD)
33             db.session.add(user)
34             print(f"Benutzer '{USERNAME_TO_CREATE}' wurde erfolgreich als Admin angelegt.")
35             
36         db.session.commit()
37         print("Änderungen wurden in der Datenbank gespeichert.")
38
39     except Exception as e:
40         db.session.rollback()
41         print(f"\n!!! Ein Fehler ist aufgetreten: {e}")
42         print("Stellen Sie sicher, dass die Datenbankverbindung in 'config.py' korrekt ist und die Tabellen existieren.")
43
Admin-Benutzer erstellen und Skript löschen:
# Virtuelle Umgebung muss aktiviert sein
source venv/bin/activate

# Script ausführen
python create_admin.py

# Script aus Sicherheitsgründen löschen
rm create_admin.py
Phase 5.1: App-Benutzer und Berechtigungen
# Systembenutzer für die App erstellen
sudo useradd -r -s /bin/false -d /opt/inventar_projekt inventaruser

# Besitzer und Gruppe für das Projektverzeichnis setzen
sudo chown -R inventaruser:www-data /opt/inventar_projekt

# Berechtigungen setzen, damit die Gruppe (Nginx) zugreifen kann
sudo chmod -R 775 /opt/inventar_projekt
Phase 6: Nginx-Konfiguration

Erstellen Sie die Nginx-Konfiguration:

sudo nano /etc/nginx/sites-available/inventar
server {
    listen 80;
    server_name Ihre.Domain.hier;

    # Notwendig für Certbot
    location /.well-known/acme-challenge/ {
        root /var/www/html;
    }

    # Alle anderen Anfragen direkt auf HTTPS umleiten
    location / {
        return 301 https://$host$request_uri;
    }
}

Site aktivieren:

sudo ln -s /etc/nginx/sites-available/inventar /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx
Phase 7: Let's Encrypt SSL-Zertifikat erstellen
sudo certbot --nginx -d Ihre.Domain.hier

Certbot wird Ihre Nginx-Datei automatisch für SSL anpassen. Bearbeiten Sie sie danach erneut, um die finale Konfiguration einzutragen.

sudo nano /etc/nginx/sites-available/inventar

Ersetzen Sie den Inhalt mit der finalen Konfiguration:

server {
    server_name Ihre.Domain.hier;

    location /static {
        alias /opt/inventar_projekt/src/inventar/static;
        expires 7d;
    }

    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # KORRIGIERTER PFAD: Zeigt auf den Socket im Projektverzeichnis
        proxy_pass http://unix:/opt/inventar_projekt/inventar.sock;
    }

    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/Ihre.Domain.hier/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/Ihre.Domain.hier/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}

server {
    if ($host = Ihre.Domain.hier) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    listen 80;
    server_name Ihre.Domain.hier;
    return 404; # managed by Certbot
}
Phase 8: Systemd Service einrichten
sudo nano /etc/systemd/system/inventar-app.service
[Unit]
Description=Gunicorn instance to serve Inventar App
After=network.target

[Service]
User=inventaruser
Group=www-data
WorkingDirectory=/opt/inventar_projekt
# KORREKTUR: Beide Variablen in einer Zeile, durch Leerzeichen getrennt
Environment="PATH=/opt/inventar_projekt/venv/bin:/usr/bin:/bin RATELIMIT_STORAGE_URL=redis://:DeinSuperSicheresRedisPasswort123!@localhost:6379/0"
ExecStart=/opt/inventar_projekt/venv/bin/gunicorn --workers 3 --bind unix:/opt/inventar_projekt/inventar.sock -m 002 wsgi:app
[Install]
WantedBy=multi-user.target

Service aktivieren:

sudo systemctl daemon-reload
sudo systemctl start inventar-app.service
sudo systemctl enable inventar-app.service
Phase 9: Finale Schritte
# Service-Status überprüfen
sudo systemctl status inventar-app.service
sudo systemctl status nginx

# Nginx-Konfiguration testen und neu laden
sudo nginx -t
sudo systemctl reload nginx
Wichtige Hinweise:
  • Domain: Stellen Sie sicher, dass Ihre Domain auf die IP-Adresse Ihres Servers zeigt.
  • Firewall: Öffnen Sie die Ports 80 (HTTP) und 443 (HTTPS) mit sudo ufw allow 'Nginx Full'.
  • Backup: Sichern Sie regelmäßig Ihre Datenbank und den /opt/inventar_projekt/src/inventar/static/uploads-Ordner.

Troubleshooting:

# Gunicorn/App Logs anzeigen
sudo journalctl -u inventar-app.service -f

# Nginx Logs anzeigen
sudo tail -f /var/log/nginx/error.log
Back to top