Direkt zum Hauptinhalt

Installation via Docker

Beschreibung

Kimai via Docker mit https via Letsencrypt.


Installation

Vorbereitung

Als erstes erstellen wir unsere Verzeichnisse

mkdir -p /root/kimai/mariadb
mkdir -p /root/kimai/data

Nun erstellen wir im Verzeichnis /root/kimai eine neue Datei namens .env

nano /root/kimai/.env

Inhalt:

# MySQL Credentials
MYSQL_ROOT_PASSWORD=12345678
MYSQL_USER=kimai
MYSQL_PASSWORD=1234567890
MYSQL_DATABASE=kimai

# Volume directories
MARIADB_VOLUME_DIR=/root/kimai/mariadb
DATA_VOLUME_DIR=/root/kimai/data

# Domain and email for Let's Encrypt
DOMAIN_NAME=ihredomain.de
LETSENCRYPT_EMAIL=ihre-email@beispiel.de


Docker-compose Datei erstellen

nano /root/kimai/docker-compose.yml

Inhalt

version: '3.3'

services:
  mariadb:
    image: mariadb:latest
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
    volumes:
      - ${MARIADB_VOLUME_DIR}:/var/lib/mysql

  kimai:
    image: kimai/kimai2:fpm-alpine-1.14-prod
    restart: unless-stopped
    environment:
      - DATABASE_URL=mysql://${MYSQL_USER}:${MYSQL_PASSWORD}@mariadb/${MYSQL_DATABASE}
    volumes:
      - ${DATA_VOLUME_DIR}:/opt/kimai/var

  webserver:
    image: nginx:alpine
    restart: unless-stopped
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ${DATA_VOLUME_DIR}:/opt/kimai/var
      - ./certbot-etc:/etc/letsencrypt
      - ./certbot-www:/var/www/certbot
      - ./certbot-log:/var/log/letsencrypt
    ports:
      - "80:80"
      - "443:443"

  certbot:
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./certbot-etc:/etc/letsencrypt
      - ./certbot-www:/var/www/certbot
      - ./certbot-log:/var/log/letsencrypt
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew --webroot --webroot-path=/var/www/certbot --email ${LETSENCRYPT_EMAIL} --agree-tos --no-eff-email --domain ${DOMAIN_NAME}; sleep 12h & wait $${!}; done;'"

volumes:
  mariadb_data:
  kimai_data:
  certbot-etc:
  certbot-www:

Nun sicher stellen das die ports 80 und 443 auch über die Domain auf den Server ereichbar sind.

hier ein kleines script das auf den port 80 lauscht um dies zu testen

nano /root/kimai/testeweb.sh

Inhalt

#!/bin/bash

# Funktion, die aufgerufen wird, wenn das Skript ein SIGINT-Signal (Ctrl+C) empfängt
cleanup() {
    echo "Server wird beendet..."
    exit 0
}

# Trap für das SIGINT-Signal einrichten
trap cleanup SIGINT

# Endlosschleife für den Server
while true; do
    # Listen on port 80
    { echo -ne "HTTP/1.1 200 OK\r\nContent-Length: $(echo -n "Hello, World!" | wc -c)\r\n\r\nHello, World!"; } | nc -l -p 80 -q 1
done

Danach ausführbar machen

chmod +x /root/kimai/testeweb.sh

nun das Script starten, kann mit strg+c wieder abgebrochen werden.
Nun kann getestet werden ob Firewall/Portforwarding richtig funktioniert, idem in einem Webbrowser die public ip aufegrufen wird.
Es muss eine hello World Seite zurück gegben werden.


Nun das Init shell script erstellen was die cert Verzeichnisse und die nginx.conf erstellt.
Das programm holt sich den cert Pfad aus der docker-compose datei. Denn der certbot wird mit docker compose im Shellscript gestartet.
jetzt muss nur noch sichergestellt werden das der Domainname auf die ip zeigt

nano /root/kimai/setup.sh

Inhalt

#!/bin/bash

# Laden der Umgebungsvariablen aus der .env-Datei
if [ -f .env ]; then
    export $(grep -v '^#' .env | xargs)
else
    echo ".env-Datei nicht gefunden!"
    exit 1
fi

# Überprüfen, ob DOMAIN_NAME und LETSENCRYPT_EMAIL gesetzt sind
if [ -z "$DOMAIN_NAME" ] || [ -z "$LETSENCRYPT_EMAIL" ]; then
    echo "DOMAIN_NAME und/oder LETSENCRYPT_EMAIL sind in der .env-Datei nicht gesetzt!"
    exit 1
fi

# Erstellen der benötigten Verzeichnisse
mkdir -p ./certbot-etc
mkdir -p ./certbot-www
mkdir -p ./certbot-log

# Erstellen der Nginx-Konfigurationsdatei
cat << EOF > ./nginx.conf
user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '\$remote_addr - \$remote_user [\$time_local] "\$request" '
                      '\$status \$body_bytes_sent "\$http_referer" '
                      '"\$http_user_agent" "\$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    server {
        listen 80;
        server_name ${DOMAIN_NAME};

        location / {
            proxy_pass http://kimai:8001;
            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;
        }
        
        # Umleitung von HTTP zu HTTPS
        return 301 https://\$host\$request_uri;
    }

    server {
        listen 443 ssl;
        server_name ${DOMAIN_NAME};

        ssl_certificate /etc/letsencrypt/live/${DOMAIN_NAME}/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/${DOMAIN_NAME}/privkey.pem;

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

        # Weitere SSL-Konfigurationen und Sicherheitseinstellungen
    }
}
EOF

# Ausführen des certbot für den ersten Lauf
docker-compose run --rm certbot certonly --webroot --webroot-path=/var/www/certbot \
    --email ${LETSENCRYPT_EMAIL} --agree-tos --no-eff-email \
    --domain ${DOMAIN_NAME} --rsa-key-size 4096

echo "Setup abgeschlossen. Bitte überprüfen und anpassen Sie die nginx.conf entsprechend."

Das script ausführbar machen

chmod +x /root/kimai/setup.sh

Docker installieren, env anpassen Webcheck und Container starten

apt install docker-compose

Nun die .env Datei wenn nicht schon geschenen, an die eigenen Bedüfnisse anpassen.
Dann das setup.sh script ausführen.


Container Starten

Ins kimai Verzeichnis gehen

cd /root/kimai

Nun

docker-compose up

ausführen, dort gibts dann die consolen ausgabe.

Wenn alles läuft und initialisiert ist den Container mit 

 docker-compose down

wieder stoppen und dann als Daemon mit

 docker-compose up -d


wieder starten

nach oben