---
# System prepended metadata

title: 'Django Deployment: Anleitung für DA Server (Linux)'

---

# Django Deployment: Anleitung für DA Server (Linux)

Nginx ist bereits vorinstalliert und SSL-Zertifikate (Let's Encrypt) sind für deine Domain bereits eingerichtet. Standardmäßig werden unter deiner URL die HTML-Dateien aus dem Verzeichnis `/var/www/html/` angezeigt. Um die URL auf deine Django-App (localhost:8000) weiterzuleiten und HTTPS zu aktivieren, bearbeite bitte die Nginx-Config unter dem Pfad `/etc/nginx/sites-available/default`.

## Platzhalter-Übersicht

Ersetze folgende Platzhalter mit deinen eigenen Werten:

- `<your-server-url>` - Deine Server-IP-Adresse
- `<your-port>` - Dein SSH-Port
- `<your-username>` - Dein GitHub-Benutzername
- `<your-repository>` - Name deines GitHub-Repositories
- `<your-domain.com>` - Deine Domain
- `<your-project-name>` - Name deines Projekts (für Logs/Supervisor)
- `<your-django-app>` - Name deiner Django-App (der Ordner mit settings.py)

## 1. SSH-Zugriff über Mac-Terminal

```bash
ssh root@<your-server-url> -p <your-port>
```

- Beim ersten Verbinden nach dem **Host Key Fingerprint** gefragt → mit `yes` bestätigen.
- Passwort eingeben → du bist nun als `root` eingeloggt.
- Bereits installierte Pakete prüfen:

```bash
apt list --installed
```

> Hinweis: sudo ist nicht nötig, da du als root eingeloggt bist.
> 

## 2. Neuen User erstellen

```bash
# Neuen User mit Namen, z.B django anlegen (Name ist beliebig)
adduser django --disabled-password --gecos ""

# Wichtige Berechtigung für Nginx setzen!
# Das Home-Verzeichnis muss für den Webserver (Nginx) durchquerbar sein,
# damit dieser später auf die Static Files im Unterordner zugreifen kann.
# Wir geben "Anderen" (u.a. dem Nginx-Prozess) Lese- und Ausführungsrechte (755).
chmod 755 /home/django/
```

## 3. Git installieren

Pakete aktualisieren und Git installieren (dafür bleibst du auf root)

```bash
apt-get update
apt-get install git python3-venv
```

## 4. SSH-Key für GitHub generieren

```bash
# Ins Verzeichnis des Users django wechseln
su - django

# SSH-Key erzeugen, um Zugriff auf GitHub zu erhalten:
ssh-keygen         # Enter mehrfach drücken, keine Passphrase nötig
cd .ssh
cat id_rsa.pub     # Public Key kopieren

```

- Public Key bei GitHub hinterlegen: **Settings → SSH keys → New SSH key**
- Verbindung testen:

```bash
ssh -T git@github.com

```

## 5. Projekt von GitHub klonen

- Neuen Ordner für Projekte erstellen:

```bash
# Zurück zum Startverzeichnis des User django wechseln
cd
# Neuen Ordner erstellen
mkdir -p /home/django/projects
```

- Projekt per SSH klonen:

```bash
cd /home/django/projects
git clone git@github.com:<your-username>/<your-repository>.git
cd <your-repository>
```

## 6. Projekt einrichten

```bash
# Virtuelle Umgebung im Projektordner erstellen
python3 -m venv venv
source venv/bin/activate

# Abhängigkeiten installieren
pip install -r requirements.txt
pip install gunicorn

# Datenbank-Migrationen ausführen
python manage.py migrate

# Superuser anlegen
python manage.py createsuperuser
```

## 7. Django Projekt anpassen

settings.py anpassen:

```bash
cd /home/django/projects/<your-repository>/<your-django-app>
nano settings.py
```

Hier musst du deine URL (IP oder die eigene Domain) unter ALLOWED_HOSTS hinzufügen:

```python
DEBUG = False

ALLOWED_HOSTS = ['<your-domain.com>']

# Static Files Konfiguration
STATIC_URL = '/static/'
STATIC_ROOT = '/home/django/projects/<your-repository>/staticfiles'

# Optional: Media Files für Uploads
MEDIA_URL = '/media/'
MEDIA_ROOT = '/home/django/projects/<your-repository>/media'
```

## 8. Static Files sammeln

```bash
cd /home/django/projects/<your-repository>
source venv/bin/activate
python manage.py collectstatic --noinput
```

Dieser Befehl kopiert alle statischen Dateien (CSS, JS, etc.) aus deinen Apps in den `staticfiles` Ordner, von wo Nginx sie direkt ausliefert.

Server neu starten:

```bash
# Zurück zu root wechseln
exit

# Server neu starten
service nginx restart
```

**Wichtig:** Nach jedem Update deiner Static Files (z.B. CSS-Änderungen) musst du `python manage.py collectstatic` erneut ausführen, damit die Änderungen live gehen.

## 9. Nginx konfigurieren

```bash
# Zurück zu root wechseln (falls noch nicht geschehen)
exit

# Nginx ist bereits vorinstalliert und muss nur noch konfiguriert werden:
nano /etc/nginx/sites-enabled/default
```

In der bereits vorinstallierten Datei die folgenden Blöcke anpassen (ergänzen bzw. auskommentieren):

```bash
server {
    listen 80;
    server_name <your-domain.com>;

    # For SSL certificate creation and renewal
    location /.well-known/acme-challenge/ {
        root /var/www/html;
        allow all;
    }

    # Redirect all HTTP to HTTPS
    location / {
        return 301 https://<your-domain.com>$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name <your-domain.com>;

    # SSL/TLS configs
    ssl_certificate /etc/letsencrypt/live/<your-domain.com>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<your-domain.com>/privkey.pem;

    # Legacy / PHP / WordPress style locations (not used for Django)
    # location / {
    #     try_files $uri $uri/ /index.php?$query_string;
    # }
    
    # SSL certificate renewal (handled via HTTP, no need to serve via HTTPS)
    # location /.well-known/acme-challenge/ {
    #    root /var/www/html;
    #    allow all;
    # }

    # Serve static files directly
    location /static/ {
        alias /home/django/projects/<your-repository>/staticfiles/;
        expires 30d;
        add_header Cache-Control "public, immutable";
    }

    # Optional: Serve media files (uploads) directly
    location /media/ {
        alias /home/django/projects/<your-repository>/media/;
        expires 30d;
    }

    # Proxy all other requests to Django/Gunicorn
    location / {
        include proxy_params;
        proxy_pass http://127.0.0.1:8000;
    }
    
    # Optional error pages (not necessary with Django/Gunicorn)
    # error_page 500 502 503 504 /50x.html;
    # location = /50x.html {
    #    root /var/www/html/example.com/;
    # }

    # PHP processing (not needed for Django)
    # location ~ \.php$ {
    #     root /var/www/html/example.com/;
    #     fastcgi_pass 127.0.0.1:9001;
    #     fastcgi_index index.php;
    #     fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    #     include fastcgi_params;
    #     include /etc/nginx/fastcgi_params;
    # }
}

```

## 10. Supervisor einrichten

Logverzeichnisse anlegen:

```bash
cd /var/log/
mkdir <your-project-name>
cd <your-project-name>
touch gunicorn.log
touch gunicorn.err.log
```

Installation:

```bash
apt-get install supervisor
```

Konfigurationsdatei öffnen:

```bash
nano /etc/supervisor/conf.d/<your-project-name>-gunicorn.conf
```

Konfiguration hinterlegen:

```bash
[program:<your-project-name>_gunicorn]
user=django
directory=/home/django/projects/<your-repository>
command=/home/django/projects/<your-repository>/.venv/bin/gunicorn <your-django-app>.wsgi:application --bind 127.0.0.1:8000 --workers 3
autostart=true
autorestart=true
stdout_logfile=/var/log/<your-project-name>/gunicorn.log
stderr_logfile=/var/log/<your-project-name>/gunicorn.err.log
```

Log-Berechtigungen anpassen:

```bash
chown -R django:django /var/log/<your-project-name>
```

Supervisor und Nginx starten:

```bash
supervisorctl reread
supervisorctl update
supervisorctl restart <your-project-name>_gunicorn
nginx -t  # Konfiguration testen
service nginx restart
```

Bei Problemen kann man Supervisor auch komplett neu starten:

```bash
service supervisor start
service supervisor status
```