Redmine ist eine flexible und Open-Source-Webanwendung für Projektmanagement und Problemverfolgung. Es wird häufig zum Verwalten von Projekten, zum Verfolgen von Fehlern sowie zum Verwalten von Aufgaben und Fristen verwendet. Redmine wurde mit Ruby on Rails entwickelt, ist hochgradig anpassbar und unterstützt eine Vielzahl von Funktionen für die Teamzusammenarbeit und Projektorganisation.

Redmine ist aufgrund seiner Flexibilität, Anpassungsfähigkeit und Open-Source-Natur eine beliebte Alternative zu kommerziellen Projektmanagement-Tools.

In diesem Artikel werden wir Redmine auf dem Docker-Container zusammen mit dem Datenbankserver, MySQL und auch Nginx als Reverse-Proxy einrichten.

Installieren Sie Docker

Wir verwenden einen auf AWS EC2 gehosteten Ubuntu-Server und eine Installationsanleitung von Docker Official.

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Wir verwenden die neueste Version von Docker zusammen mit Docker Compose.

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Ok, Docker installiert, als nächstes müssen wir konfigurieren, dass unser Benutzer (Ubuntu) ohne Sudo direkt auf Docker zugreifen kann.

sudo groupadd docker
sudo usermod -aG docker $USER

und dann abmelden und erneut bei unserem Server anmelden. Docker ist bereit!
Wir können diesen Befehl unten verwenden, um den Docker-Container zu starten, wenn unser Server neu startet.

sudo systemctl enable docker.service
sudo systemctl enable containerd.service

Docker-Container reicht für den Moment.

Erstellen Sie eine Docker-Compose-Datei

Wir werden eine Docker-Compose-Datei erstellen.

nano docker-compose.yaml

und fügen Sie diesen Yaml-Code ein.

version: '3.1'

services:
  nginx:
    # we use the latest of nginx as base
    image: nginx:latest
    restart: always
    # we expose port 80 and 443 to the public as our reverse proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      # we link volume from host for nginx configuration
      - './nginx.conf:/etc/nginx/conf.d/nginx.conf'
      # we link volume from host for nginx certs
      - './certs:/etc/nginx/certs'
      # we link also timezone from the host
      - '/etc/localtime:/etc/localtime:ro'
      - '/etc/timezone:/etc/timezone:ro'
    depends_on:
      # we will wait until server redmine is ready
      - redmine
  redmine:
    # we use redmine from dockerhub as base
    image: redmine
    restart: always
    volumes:
      # we link redmine data to our local storage, so it will persistent when
      # the service redmine restarted
      - 'redmine_data:/usr/src/redmine/files'
      # we link redmine plugin also from the host
      - '/home/bkn/redmine_plugins:/usr/src/redmine/plugins'
      # we link also timezone from the host
      - '/etc/localtime:/etc/localtime:ro'
      - '/etc/timezone:/etc/timezone:ro'
    # we don't expose port on this service because nginx service will do
    # default port redmine expose internally is 3000
    #ports:
      #- 3000:3000
      #- 444:3000
    environment:
      # we create some env for redmine
      REDMINE_DB_MYSQL: db
      REDMINE_DB_PORT: 3306
      REDMINE_DB_DATABASE: redmine_db
      REDMINE_DB_USERNAME: redmine
      REDMINE_DB_PASSWORD: my_p@ssword
      REDMINE_SECRET_KEY_BASE: G75eddsecretkey
    # we will wait until db service is ready
    depends_on:
      - db
  db:
    # we use mysql server for redmine database
    image: mysql:8.0
    restart: always
    volumes:
      # we also link the database storage with volume we created below
      - 'mysql_data:/var/lib/mysql'
    environment:
      # we create some env for mysql
      MYSQL_USER: redmine
      MYSQL_PASSWORD: my_p@ssword
      MYSQL_RANDOM_ROOT_PASSWORD: 1
      MYSQL_ROOT_PASSWORD: JRFFHT534rth4u3!@#
      MYSQL_DATABASE: redmine_db

volumes:
  # we create two volume used by redmine and our database
  mysql_data:
    driver: local
  redmine_data:
    driver: local

Als nächstes erstellen wir eine Nginx-Konfigurationsdatei im selben Ordner wie die Docker-Compose-Datei

nano nginx/nginx.conf

server {
        listen 80;
        server_name proman.withenri.tech;
        location / {
            proxy_pass http://henri_redmine_1:3000;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
server {
        listen 443 ssl;
        server_name proman.withenri.tech;
        ssl_certificate /etc/nginx/certs/withenri.tech_chained.crt;
        ssl_certificate_key /etc/nginx/certs/withenri.tech.key;
        location / {
            proxy_pass http://henri_redmine_1:3000;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }

und erstellen Sie einen Ordner namens certs und platzieren Sie dann unsere Zertifikate genau dort.

Container erstellen

Lassen Sie uns unsere Docker-Compose-Datei mit dem Befehl ausführen

docker-compose up -d

Wenn wir diese Docker-Compose-Datei ausführen, wird automatisch ein Netzwerk erstellt und drei Dienste (nginx, redmine, db) in diesem einen Netzwerk verknüpft.

Wir können unseren Container mit dem Befehl überprüfen:

docker ps -a

und testen Sie dann die Redmine-Anwendung in unserem Browser mit Port 80 und Port 443 mit https-Verbindung. Verwenden Sie den Benutzer „admin“ und das Passwort „admin“, um sich bei unserer Redmine-Anwendung anzumelden.

Dieser Artikel hat im Grunde das gleiche Ergebnis, wenn wir direkt auf VPS installiert haben, siehe diesen Artikel.

Hoffentlich hilft Ihnen dieser Artikel!