Redmine es una aplicación web de seguimiento de problemas y gestión de proyectos flexible y de código abierto. Se utiliza ampliamente para gestionar proyectos, rastrear errores y gestionar tareas y plazos. Desarrollado con Ruby on Rails, Redmine es altamente personalizable y admite una amplia gama de funciones para la colaboración en equipo y la organización de proyectos.

Redmine es una alternativa popular a las herramientas comerciales de gestión de proyectos debido a su flexibilidad, personalización y naturaleza de código abierto.

En este artículo configuraremos redmine en el contenedor Docker junto con el servidor de base de datos, mysql y también nginx como proxy inverso.

Instalar ventana acoplable

Utilizamos el servidor ubuntu alojado en AWS EC2 y la guía de instalación oficial de 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

Usamos la última versión de Docker junto con Docker Compose.

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

Ok, Docker instalado, a continuación necesitamos configurar que nuestro usuario (ubuntu) pueda acceder a Docker directamente sin sudo.

sudo groupadd docker
sudo usermod -aG docker $USER

y luego cerrar sesión y volver a iniciar sesión en nuestro servidor. ¡Docker está listo!
Podemos usar este comando a continuación para iniciar el contenedor acoplable cuando se reinicie nuestro servidor.

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

el contenedor acoplable es suficiente por ahora.

Crear archivo de redacción acoplable

Crearemos un archivo de redacción acoplable.

nano docker-compose.yaml

y pega este código 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

a continuación, creamos el archivo de configuración de nginx, la misma carpeta que el archivo 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;
        }
    }

y crear una carpeta llamada certs y luego colocar nuestros certificados allí mismo.

Crear contenedor

ejecutemos nuestro archivo de redacción acoplable con el comando

docker-compose up -d

cuando ejecutamos este archivo de composición de Docker, se creará una red automáticamente y se vincularán tres servicios (nginx, redmine, db) en esa red.

podemos verificar nuestro contenedor con el comando :

docker ps -a

y luego probar la aplicación redmine en nuestro navegador con el puerto 80 y el puerto 443 con conexión https. utilice el usuario 'admin' y la contraseña 'admin' para iniciar sesión en nuestra aplicación redmine.

este artículo básicamente tiene el mismo resultado cuando lo instalamos directamente en vps, consulte este artículo.

¡Esperamos que este artículo te ayude!