2013

Redmine Manual para el usuario

David Soto Mateluna

Centro de Innovación y transferencia
tecnológica - DUOC UC
19/08/2013
 1. Índice

2. Introducción. ......................................................................................................................... 3
3. Características de la plataforma............................................................................................ 4
3.1 Manejo de usuarios ....................................................................................................... 4
3.2 Proyectos ....................................................................................................................... 6
3.3 Informes ...................................................................................................................... 10
3.4 Mi página ..................................................................................................................... 12
3.5 Horas y avance ............................................................................................................ 12
3.6 Buscador global ........................................................................................................... 13
3.7 Preferencias de usuario ............................................................................................... 13
3.8 Administración del sistema ......................................................................................... 14
3.9 Calendario ................................................................................................................... 15
4. Medidas de seguridad de la infraestructura ....................................................................... 16
4.1 Funciones y obligaciones del personal(usuarios) ........................................................ 16
4.2 Control de acceso ........................................................................................................ 16
4.3 Identificación y autenticación ..................................................................................... 16
5. Caso de ejemplo para utilizar Redmine .............................................................................. 17
5.1 primeros pasos ............................................................................................................ 17
5.2 Creación de proyectos................................................................................................. 19
5.3 Integración con Git (Repositorio de Versiones) .......................................................... 22
5.4 Peticiones .................................................................................................................... 24
5.5 Calendario ................................................................................................................... 29
6. Conclusión ........................................................................................................................... 30
7. Enlaces................................................................................................................................. 30

Redmine manual de usuario Página 2

 2. Introducción.

Este manual pretende ser una guía en el uso del gestor proyectos Redmine. En su
contenido podremos observar los aspectos más esenciales para poder utilizar de una
manera muy fácil esta.

Redmine es un gestor de proyecto escrito en Ruby on Rails de código abierto de

extendido uso, tanto en el ámbito público como el privado, y destinada a facilitar el
control y seguimiento de proyectos, canalizando la comunicación entre los distintos
actores participantes y ofreciendo además un amplio abanico de posibilidades de
personalización.

Además este nos permite administrar a los usuarios del proyecto, los errores con un
sistema de tickets, wiki, calendario...etc. Tiene integración con diversos sistemas de
control de versiones como SVN, CVS, Git, Mercurial, Bazaar y Darcs.

Redmine manual de usuario Página 3

 3. Características de la plataforma

3.1 Manejo de usuarios

Redmine permite asignar distintos miembros y cargos a un proyecto.

Inicialmente se identifican 4 roles principales , sobre los que se modelará la
política de permisos y restricciones de acceso, tanto a información como a
herramientas (informes, dedicación, etc). A continuación se propone un
escenario de capacidades que, en cualquier caso, será consensuado con
la Dirección del Proyecto antes de su implantación.

Administrador de Directores de proyecto: dispone de todos los privilegios de

gestión de la plataforma.

 Responsable de la administración general del sistema.

 Dispone de acceso a datos agregados sobre múltiples proyectos, como
dedicación, avance, etc. así como cualquier otro indicador mediante el
 módulo de generación de informes.
 Puede añadir nuevos proyectos y sub proyectos (ilimitado)
 Puede gestionar (añadir, borrar, habilitar-deshabilitar) usuarios sin
límite.
 Pleno acceso y gestión de parámetros de los proyectos.
 Pleno acceso a la gestión de actividades y sub actividades de los
proyectos.
 Pleno acceso a la gestión de privilegios y flujos de trabajo asociados a
cada tipo de actividad.

Administrador de proyectos: su ámbito de actuación queda reducido a un

proyecto o conjunto de proyectos de los que es responsable.

 Puede asignar recursos (usuarios) ya existentes a un proyecto.

 Establece el cargo.
 Pleno acceso a la generación de informes sobre actividad en el ámbito.
de los proyectos que le están asignados.

Redmine manual de usuario Página 4

 Usuarios: personal disponible que participa en proyectos con distintos niveles
de responsabilidades. En función de las necesidades que se identifiquen, se
modelaran distintos perfiles/cargos de usuario atendiendo al papel que
desempeñan en los proyectos.

Stakeholders:

 Participan de forma puntual en proyectos.

 Cuentan con acceso limitado a la información.

Redmine manual de usuario Página 5

 3.2 Proyectos

El módulo de administración de Redmine permite gestionar fácilmente múltiples

proyectos. A través de una interfaz de usuario sencilla, el sistema permite archivar
eliminar, archivar y realizar búsquedas sobre el listado de proyectos, así como dar de
alta nuevos proyectos y sub proyectos.

El primer paso para la creación de un nuevo proyecto es la introducción de los detalles

particulares del proyecto. Datos como cliente/departamento, descripción, presupuesto
y miembros que van a participar son algunos de los ejemplos más claros.

Esta información es suministrada por el Administrador de proyecto al que se ha

asignado y está disponible para su consulta y/o modificación posterior a través de la
pestaña “configuración” (de acceso está restringido a los perfiles anteriores).

Redmine manual de usuario Página 6

El administrador del proyecto podrá seleccionar además entre el conjunto de
disponibles en la plataforma de forma opcional para adecuarla a las necesidades del
nuevo proyecto.

Entre estas herramientas se encuentran:

 Tablón de noticias.
 Control de tiempo.
 Documentos.
 Ficheros.
 Cuadro de métricas.

Redmine manual de usuario Página 7

El proyecto ya está registrado y dispone de un conjunto de herramientas.
El siguiente paso será incorporar a las personas que participarán de forma directa en la
realización de tareas.

Una vez formalizada la creación del nuevo proyecto y configurados los detalles sobre
módulos, miembros, etc.se puede dar paso a la creación de tareas y sub tareas que lo
componen.

Redmine permite establecer distintas categorías, facilitando así el seguimiento de

actividades al contar con mayor granularidad, además de permitir la personalización
de atributos de información asociados a cada tipo de actividad. A continuación se
recoge la información básica a cada tarea.

Redmine manual de usuario Página 8

El sistema permite además vincular dos o más tareas en base a distintos tipos de
relación, concretamente:

 Tarea A es duplicada de B.
 A bloquea B.
 A es una sub tarea de B.
 A es anterior a B.

Cada tarea registra el historial de trabajo a modo de “bitácora”, facilitando el

seguimiento y la evaluación de acciones realizadas desde su creación hasta el cierre.

Redmine ofrece la posibilidad de exportar esta información en formato imprimible

(pdf) así como añadir la información a un canal de feeds.

Redmine manual de usuario Página 9

 3.3 Informes

Redmine con una potente herramienta de generación de informes que permitirá sacar
el mayor partido a la información recogida en la plataforma Distinguimos entre tres
tipos de informes:

 Informes de actividad y dedicación al proyecto: tienen como finalidad la de

obtener información sobre tiempo dedicado a las distintas actividades del
proyecto de forma sencilla y en base a distintos criterios fácilmente
personalizables.

La herramienta permite además exportar los resultados a formato de hoja de

cálculo (CSV).

Redmine manual de usuario Página 10

  Informes de situación sobre tareas, estado y avance: permite generar
informes personalizados en base a cualquier criterio o criterios de selección. El
sistema permite además almacenar El resultado de estos informes puede
exportarse.

Redmine manual de usuario Página 11

 3.4 Mi página

La página personal de cada usuario puede ser personalizada fácilmente, añadiendo

nuevos bloques de información y organizándolos mediante “drag & drop”, accediendo
a información sobre proyectos, tareas, noticias y comunicaciones, actividad reciente,
informes y notas.

3.5 Horas y avance

Redmine permite conocer el avance del proyecto tomando como punto de partida el
esfuerzo estimado e incurrido a nivel de tarea.

Redmine manual de usuario Página 12

 3.6 Buscador global

El motor de búsqueda facilita la localización de información relativa a proyectos,

tareas, usuarios, noticias y documentos.

3.7 Preferencias de usuario

Las preferencias de usuario (nombre, apellido, dirección de correo a efectos de
notificación, nivel de notificación) son fácilmente configurables a través de “Mi
cuenta”. Las notificaciones llegan de forma automática a través de correo electrónico,
indicando en el asunto el nombre de proyecto, código de tarea e información sobre la
notificación (cambio de estado, nueva tarea, nuevo comentario).

Redmine manual de usuario Página 13

 3.8 Administración del sistema

El usuario administrador dispone de un panel a través del cual gestionar los principales
parámetros de la plataforma, como la gestión de usuarios, grupos y perfiles. La gestión
de usuarios se realiza a través de un cómodo listado a través del cual se puede buscar
a un usuario a través del buscador, modificar sus preferencias, añadir o eliminar
nuevos usuarios. Este mismo registro muestra la antigüedad de los usuarios, así como
el registro de acceso a la plataforma.

Un mismo usuario puede desempeñar distintas funciones dependiendo del proyecto.

Para facilitar la gestión de cargos.

Una de las herramientas más versátiles proporcionadas es la de personalización de

flujos de trabajo. A través de esta herramienta es posible modelar de forma sencilla el
proceso de trabajo en el día a día de los proyectos. Para ello, Redmine permite asignar
flujos de trabajo en base a cargo, tipo de actividad y estado de las peticiones/tareas.

Redmine manual de usuario Página 14

 3.9 Calendario

El módulo de calendario permite consultar las actividades planificadas y asignadas a

cada usuario, así como hitos relevantes del proyecto o cualquier otro tipo de evento,
facilitando la tarea de planificación de tareas y reuniones, y la gestión más eficiente de
los recursos disponibles.
Mediante el uso de la extensión "Periodic Tasks" se incluye la posibilidad de
programar actividades periódicas (reuniones de seguimiento, auditorías, etc.).

Redmine manual de usuario Página 15

 4. Medidas de seguridad de la infraestructura

4.1 Funciones y obligaciones del personal(usuarios)

Como primera medida básica, se propone realizar una relación de perfiles que por
alguna razón justificada, necesiten acceso a los sistemas de
información del proyecto. Es decir, se debe crear una relación de:

 Los perfiles o personas que requieran algún tipo de acceso.

 La relación de sistemas de información a los que tienen acceso.
 El nivel de acceso (acceso de lectura, acceso de modificación, etc.).

4.2 Control de acceso

No sólo se deberá tener una relación de los accesos para que los perfiles adecuados
tengan claros sus permisos, también se pondrán los medios para que los usuarios sólo
tengan acceso a los recursos que precisen para el desarrollo de sus funciones.

4.3 Identificación y autenticación

El proceso de identificación deberá garantizar tener un nivel de seguridad óptimo. El

mecanismo deberá permitir la identificación de forma inequívoca y personalizada de
todo aquel usuario que intente acceder al sistema de información y la verificación de
que está autorizado.
Las contraseñas de los sistemas de identificación deberán ser almacenadas,
distribuidas y asignadas garantizando la confidencialidad e integridad.
Para tal fin, se utilizarán sistemas de cifrado de contraseñas a la par de conexiones
seguras en el proceso de identificación.
Además, se introducirá una medida de nivel medio que limite el número de
posibilidades de introducir la contraseña incorrecta.
Gracias a esta medida se anulará el éxito de cualquier ataque por fuerza bruta.

Redmine manual de usuario Página 16

 5. Caso de ejemplo para utilizar Redmine

5.1 primeros pasos

Nota: Para poner en práctica este caso de ejemplo debes ejecutar el archivo redmine-
livedemo-0.4.2-win32 e ir a la siguiente dirección: http://localhost:3000/

Tenemos una empresa desarrolladora que desea probar Redmine en un proyecto que
ha empezado hace poco, proyecto "rooteando". Este proyecto tiene dos
desarrolladores: Alfonso y Juan, tienen un repositorio Git donde tienen el código del
proyecto. En Redmine realizaremos las siguientes tareas:

 Juan será el jefe de proyecto y le asignaremos ese rol en Redmine, utilizara la

cuenta de "administrador" para trabajar.
 Crear el usuario Alfonso y le asignaremos el rol de desarrollador.
 Crear el proyecto rooteando y asignarle los usuarios.
 Crear nuevas versiones del proyecto.
 Gestionar diferentes tipos de peticiones.
 Integrar el repositorio de Git en Redmine y hacer varias pruebas.

Redmine está instalado y funcionando, Juan se encuentra en la pantalla inicial de

Redmine, ver imagen anterior, pulsamos en Conexión. Como es la primera vez que nos
conectamos ,el identificador es "admin" y la contraseña es "admin". De esta forma
tendremos acceso al usuario administrador que tiene todos los permisos asignados, lo
primero es cambiarle la contraseña por defecto. En la parte superior de la página
tenemos varios opciones, una de ella es Administración.

Redmine manual de usuario Página 17

Donde podemos administrar las diferentes aspectos de Redmine. Pulsamos en la
opción de Usuarios, donde se mostrara una lista de los usuarios, ahora solo tenemos el
usuario "admin", este usuario será el que utilice Juan aunque podría crear un usuario
con privilegios de administrador. Pulsamos en el usuario "admin" para que muestre
todos los atributos que este posee.

Prácticamente todos los cuadros están etiquetados de forma muy clara con lo que no
tienen mucha explicación, es posible que tengas que cambiar el idioma a español.
Escribimos una nueva dirección de correo electrónico en el cuadro de Información y
pulsamos en el botón de Guardar.

Redmine manual de usuario Página 18

 5.2 Creación de proyectos
Lo siguiente es crear un proyecto nuevo, sin salir de la página anterior en la parte
derecha pulsamos en Proyectos. En la página de Proyectos aparece una lista de los
proyectos que gestiona Redmine, en esta caso no muestra nada porque no hay
proyectos, para crear un proyecto pulsar en el Nuevo proyecto.

Se especifica el nombre del proyecto, en este ejemplo es rooteando, una descripción

opcional y un identificador. Si dejamos la opción de Público marcada el proyecto será
visible para todo el mundo, si la desmarcamos será obligatorio hacer "Login o inicio de
sesión" para ver el proyecto. En el apartado de Módulos, se eligen los módulos que
estarán disponibles para el proyecto y en Peticiones decidimos que tipo de peticiones
estarán disponibles, Juan marca todas las opciones. Pulsamos en Guardar y ya está
creado el proyecto.

Desde este momento en el apartado Proyecto de la opción aparecerá en la lista de

proyectos rooteando, ahora habrá que asignarle usuarios al proyecto, en principio será
el usuario Juan, que será el usuario "admin", y después crearemos el usuario Alfonso,
cada usuario tendrá asignado un perfil. En Redmine hay varias perfiles definidos y cada
perfil con una serie permisos asignados.

Redmine manual de usuario Página 19

Dentro de la sección de Administración pulsamos en Proyectos, ahora se verá el
proyecto creado anteriormente, pulsamos en el "proyecto rooteando". Se mostrara el
apartado de Configuración para el proyecto , en la parte superior veremos una serie de
pestañas con diferentes opciones que podemos configurar. Pulsamos en la pestaña
Miembros.

En esta pestaña se asignan al proyecto los usuarios y el perfil que tendrá asignado para
este proyecto, en el lateral se ven los usuarios y perfiles disponibles. Solo aparece el
usuario "admin", que será utilizado por Juan, y tres perfiles, en este caso marcamos el
usuario "admin" , el perfil Jefe de proyecto y pulsamos en Añadir. Juan será el jefe de
proyecto del proyecto rooteando con lo que tendrá todos los permisos.

Redmine manual de usuario Página 20

Si se quiere ver todos los perfiles disponibles y los permisos de cada perfil. Pulsamos
en la opción Administración->Perfiles y permisos. Se mostraran todos los perfiles
disponibles, incluso podremos crear nuevos perfiles pulsando en Nuevo perfil, si
pulsamos en informes de permisos.

Tenemos la lista de permisos activados para cada perfil, se puede personalizar cada
perfil marcando y desmarcando en los permisos.
Juan crea el usuario Alfonso que le asignara el perfil de Desarrollador, dentro de
Administración pulsamos en Usuarios, Nuevo usuario, se rellenan los datos para
Alfonso y para finalizar se pulsa en Crear.

Ahora se verá una pestaña nueva, Proyectos, que servirá para asignar proyectos al
usuario creado, seleccionamos en Nuevo "proyecto a rooteando" y en perfil
escogemos Desarrollador y añadimos el usuario.
Ahora tenemos dos usuario, Juan y Alfonso, que tiene asignado el "proyecto
rooteando" y diferentes perfiles, jefe de proyecto y desarrollador.

Redmine manual de usuario Página 21

 5.3 Integración con Git (Repositorio de Versiones)
Juan y Alfonso ya han comenzado el proyecto de rooteando y tienen un repositorio Git con el
código del proyecto. Lo que quieren es integrar Redmine con el repositorio Git, de esta forma
Redmine tendrá acceso al código. Redmine permite integrar repositorios de diferentes
sistemas de control de versiones como Subversion, Git, Baazar, Mercurial...etc.

Para integrar el repositorio , accedemos como "admin1", pulsamos en el

apartado Administración, Proyectos y escogemos el proyecto rooteando. Accederemos
a la página de Configuración de rooteando, pulsamos en la pestaña de Repositorios y
escogemos el tipo( Git en este caso) se mostraran nuevas opciones.

En el apartado Ruta al repositorio se especifica la ruta hasta el repositorio que

queremos integrar, por ejemplo "/home/pepe/Proyecto/rooteando/", la codificación
la dejamos por defecto y marcamos la última opción para que nos informes de los
"commit", pulsamos en Crear. Es posible que algunas veces no se vean los "commit"
que se han realizado recientemente, para esto recarga la página de Repositorio para
que se muestren.

Redmine manual de usuario Página 22

Ahora se verán todos los archivos que hay en el repositorio, en la parte de abajo se
muestra los "commit" realizados(revisiones). Si pulsamos en un "commit" podremos
verlo con más detalle e incluso ver las diferencias entre versiones. En la parte de arriba
tenemos la opción de Estadísticas donde veremos dos gráficos, unos para los commits
y el otro muestra los "commit" por usuario, otra opción es Ramas que muestra las
diferentes ramas que tenga el repositorio Git.
El repositorio tiene dos ramas, "master" donde se almacena la versión estable del
proyecto y la rama desarrollo donde Juan y Alfonso trabajan habitualmente, cuando
una versión de esta rama se considera estable se fusiona con la rama "master". Si nos
vamos a la opción de Ramas de Redmine y escogemos la rama de desarrollo.

Redmine manual de usuario Página 23

En esta rama tenemos más "commit" que en la rama "master", las ramas son
independientes cada una tiene sus propios "commit", aunque cuando se crea una
rama al principio es una copia de la rama "master", todas las demás opciones
explicadas para la rama "master" son aplicables en esta rama.

5.4 Peticiones
Hay tres tipos de peticiones; Errores, Tareas y Soporte, estas peticiones se pueden
asignar a diferentes usuarios, se le puede especificar un tiempo o asignar una versión
especifica del proyecto. Empecemos con esto último, Juan (el jefe de proyecto) ha
considerado que proyecto ha alcanzado la versión 0.1, con lo que crea una nueva
versión en Redmine. Nos vamos al apartado de Configuración y escogemos la pestaña
Versión, aparece un enlace de Nueva versión, pulsamos en el enlace.

Primero definimos el nombre de versión ,en este caso Juan escoge Versión 0.1 una
descripción "Primera versión estable del proyecto rooteando", escogemos el estado de
la versión, como es la versión con que vamos a trabajar dejamos el estado abierto.
como no cuenta con una página de wiki lo dejamos en blanco, escogemos la fecha
actual (pulsar el botón que se encuentra a la derecha para especificar la fecha) y la
última opción Compartir la dejamos por defecto. Pulsamos en Crear ya tenemos
creada la primera versión de rooteando.

Juan crea dos peticiones en la versión 0.1, la primera será un error que hay que
corregir urgentemente y la segunda es una petición de tipo tarea para añadir una
nueva característica al proyecto .

Redmine manual de usuario Página 24

Nos vamos al apartado de Nueva petición, escogemos el tipo Error y el Tema "fallo en
el acceso a BD", marcamos la opción Privada para que el error solo se pueda ver por
los integrantes del proyecto, opcionalmente podemos poner en Descripción el error
con más detalles. En estado podemos especificar el estado en que se encuentra la
tarea, la dejamos como Nueva, en Prioridad se escoge Urgente porque el error tiene
que estar solucionado lo antes posible, en versión prevista especifica la versión en que
el error será solucionado, escogemos versión 0.1, en Asignado a, Juan decide que
Alfonso se encargue de corregir el error. En el apartado de fechas se especifica la fecha
de inicio, automáticamente coge la fecha actual, y podemos especificar una fecha final,
también se puede especificar el tiempo que vamos a utiliza realizar la petición.
Por último podemos especificar algún fichero y escoger los seguidores de la petición.
Pulsamos en Crear.
Como este error se ha asignado a Alfonso, en su ordenador Alfonso se conecta a
Redmine con su "usuario y contraseña". Para acceder a la petición que se le ha
asignado dentro del proyecto rooteando en el apartado Peticiones se muestra la lista
de peticiones abiertas .

Redmine manual de usuario Página 25

Como este error se ha asignado a Alfonso, en su ordenador Alfonso se conecta a
Redmine con su usuario y contraseña. Para acceder a la petición que se le ha asignado
dentro del proyecto rooteando en el apartado Peticiones se muestra la lista de
peticiones abiertas.

Pulsamos en la petición y se muestra con más detalle. Como Alfonso está trabajando
para corregir el error, decide cambiar el estado de la petición a En curso, para realizar
esto debe pulsar dentro de la petición en el enlace de Actualizar para modificar la
petición.

Redmine manual de usuario Página 26

En la lista desplegable de Estado escogemos En curso y pulsamos Aceptar. El estado de
la petición ha cambiado, ahora si nos vamos a Peticiones veremos que el estado de la
petición ha cambiado.
Cuando Alfonso ha corregido el error decide cerrar petición para indicar que ha
corregido en error. Para realizar esto volvemos a ir a la lista de peticiones, nos
situamos en la petición y pulsamos en el botón derecho del ratón, aparecerá un nuevo
menú y dentro de él nos vamos a Estado y pulsamos en cerrada.

La petición desaparecerá, si nos vamos al apartado de Actividad que muestra todo lo

que ha ocurrido en el proyecto rooteando, veremos que el error ha sido cerrado.

Redmine manual de usuario Página 27

Juan crea la segunda petición que es una tarea, se crea igual que en la petición de
error pero escogiendo en el tipo Tareas, todas las demás opciones son las mismas que
para crear una petición de error. El resultado de la petición se muestra a continuación.

Pulsamos en Crear y la petición esta creada, se puede mirar la petición en el apartado

de Actividad. También podemos ver todas las peticiones en Planificación, que nos
muestra de forma gráfica la evolución de todas las peticiones para las distintas
versiones.

En el apartado Calendario podemos ver de forma cronológica todas las peticiones y los
cambios de estado, si cambiamos la opción de abierta por todos se mostraran todos
los estados que ha tenido una petición.

Redmine manual de usuario Página 28

 5.5 Calendario

Si nuestro proyecto es público es aconsejable utilizar el apartado de Noticias donde podemos

informar del estado del proyecto, futuras versiones u otras noticias.

Redmine dispone de un Wiki donde podemos centralizar toda la documentación del proyecto,
"how to" u otra información que puede ser interesante para los desarrolladores o usuarios.

Con esto finaliza este pequeño tutorial sobre Redmine, se ha visto una parte pequeña de todo
lo que se puede hacer con Redmine.

Redmine manual de usuario Página 29

 6. Conclusión

Redmine nos puede ayudar en gran medida a gestionar de manera ágil todos los
proyectos de nuestra empresa, la documentación asociada, los archivos que anexamos
y todo ello controlando en cada momento la ejecución del mismo. Su administración
es sencilla y permite definir flujos de trabajo que evitarán que la gestión nos inunde la
bandeja de entrada con un correo por cada pequeño detalle a discutir en el mismo.

Para probarlo tenemos la opción de descargarlo e instalarlo a través de un archivo

".exe" que nos permitirá probarlo de forma fiable en local para después si lo
consideramos adecuado llevarlo al servidor de manera que lo ponemos disponible
para todos los usuarios de la empresa. Sin duda merece la pena hacer la prueba.

7. Enlaces
http://www.duoc.cl/escuelait/ : Escuela de informática y telecomunicaciones Duoc UC.

http://www.duoc.cl/escuelait/citt/ : Centro de innovación y transferencia tecnológica

de Duoc UC(Donde se implementara esta plataforma).

http://www.redmine.org/projects/redmine/wiki/Guide : Documentación oficial.

http://qugstart.com/blog/ruby-and-rails/setup-a-git-repository-for-redmine/:
Configuración de un repositorio Git en Redmine.

Redmine manual de usuario Página 30