Redmine est une application Web flexible et open source de gestion de projet et de suivi des problèmes. Il est largement utilisé pour gérer des projets, suivre les bugs et gérer les tâches et les délais. Développé à l'aide de Ruby on Rails, Redmine est hautement personnalisable et prend en charge un large éventail de fonctionnalités pour la collaboration en équipe et l'organisation de projets.

Redmine est une alternative populaire aux outils de gestion de projet commerciaux en raison de sa flexibilité, de sa personnalisation et de sa nature open source.

Dans cet article, nous allons configurer Redmine sur le conteneur Docker avec le serveur de base de données, MySQL et également Nginx comme proxy inverse.

Installer Docker

Nous utilisons le serveur Ubuntu hébergé sur AWS EC2 et le guide d'installation du responsable Docker.

# 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

Nous utilisons la dernière version de Docker avec Docker Compose.

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

Ok, Docker installé, nous devons ensuite configurer notre utilisateur (ubuntu) pour qu'il puisse accéder directement à Docker sans sudo.

sudo groupadd docker
sudo usermod -aG docker $USER

puis déconnectez-vous et reconnectez-vous à notre serveur. Docker est prêt !
Nous pouvons utiliser cette commande ci-dessous pour démarrer le conteneur Docker au redémarrage de notre serveur.

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

le conteneur Docker est suffisant pour le moment.

Créer un fichier de composition Docker

Nous allons créer un fichier de composition Docker.

nano docker-compose.yaml

et collez ce code yaml.

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

Ensuite, nous créons le fichier de configuration nginx, même dossier que le fichier docker-compose

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;
        }
    }

et créez un dossier appelé certs, puis placez nos certificats ici.

Créer un conteneur

exécutons notre fichier de composition Docker avec la commande

docker-compose up -d

Lorsque nous exécutons ce fichier Docker Compose, un réseau sera créé automatiquement et reliera trois services (nginx, Redmine, db) dans ce même réseau.

nous pouvons vérifier notre conteneur avec la commande :

docker ps -a

puis testez l'application Redmine sur notre navigateur avec le port 80 et le port 443 avec une connexion https. utilisez l'utilisateur 'admin' et le mot de passe 'admin' pour vous connecter à notre application Redmine.

Cet article a fondamentalement le même résultat lorsque nous l'installons directement sur un VPN, reportez-vous à cet article.

J'espère que cet article vous aidera !