Casdoor im Docker installieren

Hier ist eine Anleitung zur Installation des Casdoor IAM Sytsems mit Docker. Eine Installation ohne Docker kann ich nicht empfehlen, da es viele Abhängigkeiten gibt die aufeinander abgestimmt werden müssen.

Option A: Stable (Plain debian 12) Docker-Compose mit external DB

				
					sudo apt update && sudo apt upgrade -y
sudo apt install -y ca-certificates curl gnupg lsb-release

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
"deb [arch=$(dpkg --print-architecture) \
 signed-by=/etc/apt/keyrings/docker.gpg] \
 https://download.docker.com/linux/debian \
 $(lsb_release -cs) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

sudo systemctl enable docker
sudo systemctl start docker
sudo systemctl status docker

				
					sudo mkdir -p /opt/casdoor/conf
cd /opt/casdoor

2. PostgreSQL persistent machen

A) Named Volume (empfohlen)

				
					docker volume create casdoor_pg_data

B) Bind-Mount auf Host-Verzeichnis

				
					sudo mkdir -p /opt/casdoor/pg/data
sudo chown 999:999 /opt/casdoor/pg/data    # UID/GID 999 ist default für Postgres-Container

Erstelle: docker-compose.yaml

				
					nano docker-compose.yaml

				
					version: "3.8"

services:
  db:
    image: postgres:14-alpine
    container_name: casdoor_postgres
    restart: unless-stopped
    environment:
      # User, Passwort und Datenbank werden beim ersten Start angelegt
      POSTGRES_USER: casdoor
      POSTGRES_PASSWORD: Str0ngPassw0rt!
      POSTGRES_DB: casdoor
    # Variante A: Named Volume
    volumes:
      - casdoor_pg_data:/var/lib/postgresql/data
    # Variante B: statt oben, auskommentieren und aktivieren:
    # volumes:
    #   - ./pg/data:/var/lib/postgresql/data
    networks:
      - casdoor_net

  casdoor:
    image: casbin/casdoor:latest
    container_name: casdoor
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - ./conf/app.conf:/conf/app.conf
    environment:
      - RUNNING_IN_DOCKER=true
    extra_hosts:
      - "host.docker.internal:host-gateway"
    networks:
      - casdoor_net

networks:
  casdoor_net:

volumes:
  casdoor_pg_data:

Erstelle: /conf/app.conf

				
					cd conf
nano app.conf

passwort anpassen an yaml

				
					appname = casdoor
httpport = 8000
runmode = prod

# Session und CORS
SessionOn = true
copyrequestbody = true
origin = "https://auth.example.com" # Ersetze durch deine tatsächliche Domain

# Datenbank
driverName = postgres
dataSourceName = host=db port=5432 user=casdoor password=Str0ngPassw0rt! dbname=casdoor sslmode=disable


#Passe die DB daten an!


# Log- und Debug-Einstellungen
showSql = true
logPostOnly = true

# Weitere Einstellungen
verificationCodeTimeout = 10
staticBaseUrl = "https://cdn.casbin.org"
enableGzip = true

Nginx + SSL

				
					sudo apt update
sudo apt install -y nginx certbot python3-certbot-nginx
sudo systemctl enable nginx

				
					nano /etc/nginx/sites-available/casdoor

4 mal domain einsetzen

				
					# /etc/nginx/sites-available/casdoor

server {
    listen 80;
    server_name auth.example.de;

    # Leite alles auf HTTPS um
    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name auth.example.de;

    # SSL-Zertifikate (werden von Certbot verwaltet)
    ssl_certificate     /etc/letsencrypt/live/auth.example.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/auth.example.de/privkey.pem;
    ssl_protocols       TLSv1.2 TLSv1.3;
    ssl_ciphers         HIGH:!aNULL:!MD5;

    # Optionale Härtung
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    location / {
        proxy_pass         http://127.0.0.1:8000;
        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;
    }
}

				
					systemctl stop nginx

				
					 certbot certonly \
  --standalone \
  -d auth.example.de

				
					ln -sf /etc/nginx/sites-available/casdoor /etc/nginx/sites-enabled/casdoor

Alles starten

				
					nginx -t
sudo systemctl start nginx

cd /opt/casdoor
docker compose up -d
docker compose logs -f casdoor

Datenbank Dump zeiehen

				
					sudo mkdir -p /opt/casdoor/backups
sudo chown $(id -u):$(id -g) /opt/casdoor/backups

Unkomprimiertes sql dump

				
					# zieht nur die casdoor-Datenbank
docker exec -i casdoor_postgres \
  pg_dump -U casdoor casdoor \
  > /opt/casdoor/backups/casdoor_$(date +%F).sql

Per PowerShell herunterldaen

				
					scp root@XXX.XXX.XXX.XXX:/opt/casdoor/backups/casdoor_$(Get-Date -Format yyyy-MM-dd).sql C:\Users\jonas\Downloads\

Wiederherstellen

Wenn es ich um einen anderen Server handelt auf dem das Backup wiederhergestellt werden soll, muss vorher der ordner erstellt sein in den die sql datei hochgeladen werden soll.

				
					scp C:\Users\jonas\Downloads\casdoor_2025-07-03.sql root@XXX.XXX.XXX.XXX:/opt/casdoor/backups/

(oder per ftp in /backups hochladen)

Alle docker container stoppen und nur db starten

				
					docker compose down

docker compose up -d db

alte DB droppen und eine leere neu anlegen

				
					# Drop
docker exec -i casdoor_postgres dropdb -U casdoor casdoor

# Recreate
docker exec -i casdoor_postgres createdb -U casdoor casdoor

Dump einspielen

				
					cat /opt/casdoor/backups/casdoor_2025-07-03.sql \
  | docker exec -i casdoor_postgres psql -U casdoor -d casdoor

				
					docker compose up -d casdoor

CRON Einrichten (stündliches backup auf FTP speicher)

				
					sudo apt install -y sshpass

				
					nano /opt/casdoor/backup-hourly.sh

				
					sudo tee /opt/casdoor/backup-hourly.sh > /dev/null <<'EOF'
#!/bin/bash
# Backup-DB dump, gzip, und per SSH auf Remote-Storage kopieren

# Konfiguration
REMOTE_USER="XXXXXXX"
REMOTE_HOST="host.example.de"
REMOTE_PORT=22
REMOTE_DIR="dir/dir/backup-auth-db"
SSH_PASS="DeinRemotePasswortHier"

# Filename mit Datum+Stunde
TS=$(date +'%F_%H%M')
REMOTE_PATH="${REMOTE_DIR}/casdoor_${TS}.sql.gz"

# Backup & Upload
docker exec -i casdoor_postgres pg_dump -U casdoor casdoor \
  | gzip \
  | sshpass -p "${SSH_PASS}" ssh -o StrictHostKeyChecking=no -p "${REMOTE_PORT}" \
      "${REMOTE_USER}@${REMOTE_HOST}" "cat > \"${REMOTE_PATH}\""
      
# remote (sshpass-Beispiel, falls noch Passwort-basiert)
sshpass -p "$SSH_PASS" ssh -o StrictHostKeyChecking=no -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST" \
  "find $REMOTE_DIR -type f -name 'casdoor_*.sql.gz' -mtime +40 -delete"
EOF

				
					sudo chmod 700 /opt/casdoor/backup-hourly.sh

				
					# jede volle Stunde (Minute 0), stündliches Casdoor-Backup aufs Remote-Laufwerk
0 * * * * /opt/casdoor/backup-hourly.sh >> /var/log/casdoor-backup.log 2>&1

				
					sudo /opt/casdoor/backup-hourly.sh

Option B: Stable (Plesk) Docker-Compose mit external DB

1. Dateien Anlegen

Erstelle: docker-compose.yaml

				
					version: "3.8"

services:
  casdoor:
    image: casbin/casdoor:latest
    container_name: casdoor
    ports:
      - "8000:8000"  # Casdoor wird über diesen Port erreichbar sein
    volumes:
      - ./conf/app.conf:/conf/app.conf
    environment:
      - RUNNING_IN_DOCKER=true
    extra_hosts:
      - "host.docker.internal:host-gateway"

Erstelle: /conf/app.conf

				
					appname = casdoor
httpport = 8000
runmode = prod

# Session und CORS
SessionOn = true
copyrequestbody = true
origin = "https://auth.example.com" # Ersetze durch deine tatsächliche Domain

# Datenbank
driverName = mysql
dataSourceName = DB_USERn:DB_PW@tcp(host.docker.internal:3306)/
dbName = DB_NAME

#Passe die DB daten an


# Log- und Debug-Einstellungen
showSql = true
logPostOnly = true

# Weitere Einstellungen
verificationCodeTimeout = 10
staticBaseUrl = "https://cdn.casbin.org"
enableGzip = true

3. 💾 DB-Anlegen und Remote Verbindungen für Docker Freigeben

Info Obwohl der Docker-Container physisch auf demselben Server läuft, wird er in einem eigenen Netzwerk-Namespace betrieben und erhält dadurch eine eigene IP-Adresse (z. B. 172.18.0.2). Für den MySQL-Server (und Plesk) ist das keine "localhost"-Verbindung, sondern eine Verbindung von einem anderen Host im Netzwerk.

Deswegen sollten wir Remoteverbindungen zulassen von:

				
					172.0.0.1/16

Docker kann ggf. ein anderes Subnetz nutzen.

Plesk:

abbo > db > benutzer
Tool & Einstellungen > Datenbankserver > Haken setzen

4. Proxyregeln

Addo > Proxyregeln für docker > hinzufügen 8000:8000

Option C: Test Casdoor Instanz Docker-Compose mit DummyDB

🔧 Voraussetzungen

Debian 12 Server mit Root-Zugriff
Domain/Subdomain (z. B. auth.deine-domain.de)
Ports geöffnet in der Firewall:
- 80 (HTTP, für Let’s Encrypt)
- 443 (HTTPS)
- 8000 (optional, lokal für Docker-Container)

1. 🐳 Docker & Docker Compose installieren

				
					sudo apt update && sudo apt upgrade -y

# Docker installieren

				
					sudo apt install -y ca-certificates curl gnupg lsb-release

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | \
sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
"deb [arch=$(dpkg --print-architecture) \
signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/debian \
$(lsb_release -cs) stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Docker-Status prüfen

				
					sudo systemctl status docker

2. 📁 Projektstruktur anlegen

				
					mkdir -p /opt/casdoor
cd /opt/casdoor

3. 🐳 Casdoor Container starten (nur intern erreichbar)

				
					docker run -d \
--name casdoor \
-p 127.0.0.1:8000:8000 \
casbin/casdoor-all-in-one

Casdoor läuft nun unter http://localhost:8000 (nur lokal erreichbar).

4. 🔐 Nginx + Let’s Encrypt Setup

4.1 Nginx installieren

				
					sudo apt install -y nginx
sudo systemctl enable nginx
sudo systemctl start nginx

4.2 Nginx Konfiguration für SSL

				
					sudo apt install -y certbot python3-certbot-nginx

5. 🌐 Domain einrichten & Zertifikat holen

Stelle sicher, dass auth.deine-domain.de auf die IP deines Servers zeigt.

				
					sudo certbot --nginx -d auth.deine-domain.de

6. ⚙️ Nginx Reverse Proxy konfigurieren

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

				
					server {
listen 80;
server_name auth.deine-domain.de;
return 301 https://$host$request_uri;
}

server {
listen 443 ssl;
server_name auth.deine-domain.de;

ssl_certificate /etc/letsencrypt/live/auth.deine-domain.de/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/auth.deine-domain.de/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;

location / {
proxy_pass http://127.0.0.1:8000;
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;
}
}

Dann aktivieren:

				
					sudo ln -s /etc/nginx/sites-available/casdoor /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

7. Casdoor aufrufen

Gehe zu:

https://auth.deine-domain.de

Logge dich ein mit:

Benutzername: admin
Passwort: 123

Tipps:

für das setzen einer Signup/DefaultGroup kann es sein dass die API genutzt werden muss, da das Input Feld „Defaultgroup“ in der Application nicht angezeigt werden kann.
Falls SMTP Provider keine email sendet, probiere: Port auf 587 + Disable SSL = false (STARTTLS)