Home > Werkzeuge > Redmine: Projektverwaltung und Ticketsystem

Redmine: Projektverwaltung und Ticketsystem

Der Name Redmine steht für eine flexible Webapplikation zur Projektverwaltung und Aufgabenverteilung, wofür sie ursprünglich auf Basis des Ruby on Rails Frameworks entwickelt wurde. Redmine kann jedoch auch für das Bugtracking als Ticketsystem verwendet werden und dient der Organisation von Teams. Redmine ist ein plattform- und datenbankübergreifendes Werkzeug bei der Softwareentwicklung. Redmine ist eine open-source Anwendung, die unter der GNU General Public License v2 (GPL) erschienen ist.

Die wichtigsten Features von Redmine im Überblick:

  • Alle Projekte können in einer einzigen Instanz von Redmine verwaltet werden.
  • In jedem Projekt kann jeder Nutzer eine andere Rolle einnehmen. Projekte können entweder öffentlich oder privat definiert werden. D.h. jeder hat Einsicht in das Projekt oder nur Projektmitglieder.
  • Für jedes Projekt können jeweils einzelne Module wie zum Beispiel Wiki, Repository, Ticketsystem, usw. ein- oder ausgeschaltet.
  • Zugehörige Projektteile können als Subprojekte eines Hauptprojekts defniert werden.
  • Es können eigene Rollen für Benutzer festgelegt werden, d.h. welche Rechte hat die Rolle in den einzelnen Modulen.
  • Für das Ticketsystem können eigene Status-Typen und mögliche Arten eines Tickets definiert werden.
  • Bei der Einrichtung von Redmine kann festgelegt werden wie der Workflow bei der Ticketabarbeitung durch eine Rolle beinflusst werden soll. D.h. Welche Rolle kann beispielsweise neue Tickets zuordnen, aufklären, schließen, sein Feedback abgeben.
  • Anhand des Datums der Anliegens und dessen Fälligkeitdatum werden Gantt-Diagramme und Kalender generiert.
  • Time Tracking: Aufgewendete Zeiten können auf Projekt- oder Ticket-Ebene angebenen werden. Einfache Berichte bestimmen aufgewendete Zeit pro Nutzer, Ticket-Art, Kategorie oder Aktivität.
  • Für Tickets, Zeitangaben, Projekt und Nutzer können eigene Felder angelegt werden, und diese wie reguläre Felder zur Filterung nutzen. Verschiedene Formate wie Text, Datum, Boolean, Integer, Drop-Down-Lisen und Checkboxen werden unterstützt.
  • News, Dokumente und Dateien können gepostet und ausgetauscht werden.
  • Pro Projekt kann man jeweils Wiki und Forum anlegen.
  • Repository-Browser und Diff-Viewer: Bereits existierende Repositories können an das Projekt angeschlossen werden. Es ist dadurch möglich in diesen zu browsen und kann deren Änderungen einsehen. Unterstützt werden folgende Versionskontrollsysteme: Subversion, CVS, Mercurial, Darcs, Bazaar and Git.

Aus meinem Studium möchte ich hier nun eine kleine Ausarbeitung über Redmine vorstellen. Diese ist im Grunde eine kompakte Beschreibung was Redmine überhaupt ist und welche Funktionen die Projektverwaltungssoftware bietet.

1. Was ist Redmine?
Während der Entwicklung eines Projekts sammeln sich viele ToDos, die man allen Beteiligten Entwicklern für eine erfolgreiche Zusammenarbeit zur Verfügung stellen muss. Aber nun ist die Frage wie man eben diese Sachen am Besten hinterlegt, sodass eine geordnete Struktur entsteht, die von jedem Mitarbeiter sehr leicht eingesehen und wiedergefunden werden kann. In Form von Notizzetteln, Textdateien oder anderen Medien wie Wiki wäre eine Möglichkeit. Nach den ersten Versionen kommen auch noch Reports zu Bugs hinzu, die ausgewertet und von jemanden behoben werden müssen.Redmine schafft genau dieses, es vereint mehrere Komponenten in einem einzigen System, nämlich Notizen, Spezifikationen, Protokolle, Erläuterungen, Bugreports, Handbücher, etc. an einem einzigen Ort zu speichern und abrufbar zu machen.Redmine ist eine flexible Webanwendung für Projektmanagement und Aufgabenverteilung in der Softwareentwicklung. Die Aufgabenverteilung ist in kleinen sowie in großen Teams möglich. Ursprünglich war Redmine für die reine Projektverwaltung konzipiert. Im Verlauf der Entwicklung kam das Ticketsystem hinzu, welches sehr viel Potential mit sich bringt, sodass Redmine heute von vielen Softwarefirmen als großer Bugtracker eingesetzt wird und stellt somit eine sehr gute Organisationsmöglichkeit für Teams dar. Durch die Webanwendung haben mobile Mitarbeiter und Teams direkten Zugriff auf den gleichen Datenbestand.Die Software ist Open Source und ist unter der GNU General Public License v2 erschienen. Auf der Grundlage von Ruby on Rails ist die Software sehr strukturiert aufgebaut. Das integrierte Plugin-System bietet zudem die Möglichkeit die Software sehr schnell mit neuen Funktionen zu erweitern und an seine eigenen Bedürfnisse anzupassen. Bereits fertige Plugins stehen auf der offiziellen Webseite bereit. Ein weiterer wichtiger Aspekt ist, dass Redmine plattform- und datenbankunabhängig ist, sodass die Software im Grunde für jedes Softwareprojekt, sei es in Java, C++ oder PHP eingesetzt werden kann.

2. Features

Multiprojekt-Fähigkeit

Redmine kann nicht nur für ein Projekt eingesetzt werden. Es bietet den Entwicklern die Möglichkeit mehrere Projekt in einer einzigen Instanz anzulegen und zu verwalten. Deswegen wird Redmine auch von vielen Softwarefirmen gerne als Werkzeug zur Projektverwaltung eingesetzt. Man kann entweder mehrere unterschiedliche Projekte parallel in der gleichen Instanz anlegen oder aber die Projekte beliebig tief verschachteln. Dies ist vor allem bei großen Projekten eine gute Möglichkeit zur Trennung der einzelnen Systembausteine, um eine Übersichtlichkeit zu schaffen. Zugehörige Projekte werden in Redmine als Unterprojekte angelegt. In diesen Unterprojekten können nun jeweils weitere Projekte in der dritten Stufe angelegt werden. Es entsteht folglich eine Hierarchie wie beispielsweise bei einem Dateisystem.

(Abbildung 1: Projektübersicht)

Die Abbildung 1 zeigt die Projektansicht, die von jedem Mitglied auf der Unterseite „Projekte“ eingesehen werden kann. Wie man im Beispiel sieht, wurden die drei Hauptprojekte „Fahrrad-Shop“, „Preis-Robotor“ und „Softwareprojekt Müller“ angelegt. Diese stellen die erste Ebene dar. „Fahrrad-Shop“ hat noch die Unterprojekte „Bestell-Modul“, „Kunden-Modul“ sowie „Reklamationsmodul“. Das „Bestell-Modul“ hat in der dritten Ebene noch ein Unterprojekt „Warenkorb-Modul“.

Das besondere daran ist, dass man nach Anlegen weiterer Unterprojekte für jedes dieser Projekte separat alle Einstellungen vornehmen kann, die man auch für das Oberprojekt bereits am Anfang vorgenommen hat. Uneingeschränkt sind demnach auf jeder Hierarchie-Ebene allen verfügbaren Einstellungen vorhanden. Dies sorgt auf jeder Hierarchie-Ebene für eine individuelle Form des Projektmanagements. Module können ein- und ausgeschaltet werden. Separat von bereits angelegten Oberprojekten können den Mitgliedern nun zusätzliche oder andere Rollen zugeordnet werden, Ticket-Kategorien können bearbeitet werden, ein projektbezogenes Wiki kann angelegt werden, neue Foren können angelegt werden, Aktivitäten bezüglich der Zeiterfassung können aktiviert oder deaktiviert werden sowie einige andere Einstellungen wie Projektbeschreibung, Projektversionen können projektweise bearbeitet werden. Der gesamte Workflow kann so leichter an das jeweilige Unterprojekt angepasst und optimiert werden.

(Abbildung 2: Einstellungsmöglichkeiten für ein Projekt, hier „Fahrrad-Shop“)

Durch die Rollen und Rechte, die man als Administrator definiert, können Benutzer unterschiedliche Rollen in verschiedenen Projekten haben. So kann ein Benutzer in einem Oberprojekt ein Entwickler sein, der Tickets bearbeiten und annehmen kann. In einem Unterprojekt davon kann er wiederum ein Manager sein, der in diesem Projekt alle Einstellungen und Möglichkeiten des Projektmanagements hat. Auf der dritten Ebene kann er wiederum nur ein Reporter sein, der Programme testet und über Probleme berichtet und diese mit neuen Tickets öffentlich macht.

Rollen und Rechte

Die Einstellungen zu den Rollen und Rechten ist in Redmine auf sehr bequeme Art zu erledigen. Die Rechtevergabe erfolgt in Redmine in der Administrationsoberfläche per Klick. Nach Auswahl der Rolle können durch Setzen von Häkchen die Rechte in den einzelnen Modulen sehr schnell vergeben und später genauso schnell angepasst werden. Eine noch schnellere Möglichkeit zur Rechteverwaltung bietet sich durch die tabellarisch aufgebaute Berechtigungsübersicht an. In dieser sind spaltenweise die Rollen und zeilenweise die Berechtigungen aufgelistet.

(Abbildung 3: Berechtigungsübersicht)

Standardmäßig sind in Redmine bereits fünf Rollen in der Datenbank vorhanden. Es sind die Rollen „Anonymous“ und „Non member“, für die man die Rechte verwalten kann. Die Rollen selbst können aus systemtechnischen Gründen nicht gelöscht werden. Des Weiteren sind drei Musterrollen vorhanden, die man auch löschen und durch eigene Rollen ersetzen kann. Diese wäre einmal der „Reporter“, der „Entwickler“ sowie der „Manager“. Die erste wichtige Einstellungsmöglichkeit einer Rolle, außer bei „Anonymous“ und „Non member“, ist natürlich, ob dieser Rolle Tickets zugewiesen werden sollen. Die Berechtigungen sind standardmäßig in neun Bereiche, den entsprechend vorhandenen Modulen in Redmine, eingeteilt. Dies wären einmal allgemeine Projekt-Berechtigungen, ob eine Rolle beispielsweise „Projekte erstellen“ oder „Projekte bearbeiten“ kann. Es können Berechtigungen für Foren getroffen werden.

Ob eine Rolle „Foren verwalten“ darf oder neue „Forenbeiträge hinzufügen“ oder „Forenbeiträge löschen“ kann. Weiterhin gibt es Berechtigungen für Dokumente, Dateien, Ticket-Verfolgung, News, das Projektarchiv, Zeiterfassung sowie das Wiki.

(Abbildung 4: Berechtigungen für die Rolle „Manager“)

In der Abbildung 4 sind die Berechtigungen für die Rolle „Manager“ zu sehen, welche bei einer neuen Instanz von Redmine standardmäßig alle aktiviert sind. So kann der „Manager“ beispielsweise „Tickets löschen“, „Tickets hinzufügen“ oder „Beobachter löschen“. Die Reihenfolge der Rollen in der Selectbox-Auswahl kann verändert werden, sodass beispielsweise nicht zwangsläufig die Rollennamen nach Alphabet sortiert werden, sondern wie man es selbst in der Administration gerne wünscht.

Ticketsystem und Workflow

Das Hauptmodul auf dem sicherlich einer der Schwerpunkte von Redmine liegt, ist natürlich das Ticketsystem. Redmine bietet als webbasierte Projektmanagement-Software ein flexibles System zur Verwaltung von Tickets, das durch Anlegen eigener Ticket-Kategorien, Status-Typen und Prioritäten nach Belieben erweitert werden.

Tracker

Standardmäßig sind in Redmine drei Tracker vordefiniert, der Tracker „Fehler“, „Feature“ sowie „Unterstützung“. Für jedes Projekt in Redmine kann jeder angelegte Tracker aktiviert und deaktiviert werden. Für ein Hauptprojekt kann der Tracker aktiviert sein, für ein Unterprojekt davon wiederum deaktiviert. Bereits angelegte Tracker können bearbeitet oder gelöscht werden. Nach Belieben können zusätzliche Tracker angelegt und ähnlich den Rollen in ihrer Reihenfolge bearbeitet werden.

(Abbildung 5: Tracker „Fehler“, aktiviert für alle Projekte)

Ticket-Status

Für das Ticket-System können eigene Ticketstatus-Typen angelegt werden. Beim Aufsetzen einer neuen Redmine-Instanz sind bereits sechs Status-Typen vorhanden. Der Statustyp „Neu“ ist die Standardeinstellung für neue Tickets. Weitere bereits vorhandene Statustypen sind „In Bearbeitung“, „Gelöst“, „Feedback“, „Erledigt“ und „Abgewiesen“. Die vier letzten Statustypen sind mit der „Ticket geschlossen“-Markierung versehen. Wenn Tickets von einem Benutzer in einen dieser Statustypen geändert werden, so sind die Tickets geschlossen und deren Bearbeitung ist eingestellt. Alle vorhandenen Statustypen können gelöscht und durch eigene Typen ersetzt werden. Die Sortiermöglichkeit ist auch hier wieder gegeben.

(Abbildung 6: Übersicht der Ticket-Statustypen in der Administration)

Workflow

Jedes Workflow lässt sich nach eigenen Wünschen einstellen. Mit Angabe der Rolle und des jeweiligen Trackers kann der Workflow bearbeitet werden. Tabellarisch sind  dann zeilenweise der gegenwärtige Status sowie spaltenweise die neuen Berechtigungen angeordnet. Ebenfalls wie bei den Berechtigungen für Rollen kann nun per Klick festgelegt werden, ob beispielsweise die jeweilige Rolle für den angegebenen Tracker den Status-Typ „Neu“ in „In Bearbeitung“, „Gelöst“, „Feedback“, „Erledigt“ oder „Abgewiesen“ ändern kann. Für jede Rolle und jeden Tracker gibt man den Arbeitsfluss an, zum Beispiel in welchen Status-Typ „Feedback“-Tickets geändert werden können.

Um die Einstellungen beim Workflow besser zu verstehen, ist in Abbildung 7 ein Beispiel zu sehen. In diesem Beispiel ist die Workflow-Einstellung für die Rolle „Entwickler“ auf dem Tracker „Feature“ zu sehen. Wie man sieht, hat die Rolle eingeschränkte Rechte im Ticketsystem. Tickets, die sich im Status „Erledigt“ oder „Abgewiesen“ befinden, kann diese Rolle nicht in einen anderen Status überführen. Die Rolle darf kein Ticket in den Status „Abgewiesen“ ändern. Es darf auch kein Ticket in den Status „Neu“ überführt werden, denn dies würde normalerweise keinen Sinn ergeben. Sehr präzise Einstellungen für die Abarbeitung der Tickets sollten hier somit bereits im Vorfeld getroffen werden.

(Abbildung 7: Workflow-Einstellungen für die Rolle „Entwickler“ auf dem Tracker „Feature“)

Ticketübersicht

Die Ticketansicht in Redmine ist sehr übersichtlich gestaltet. Tabellarisch sind die Tickets aufgelistet, mit Trackername, Status-Typ, Priorität, dem Titel des Tickets, dem Benutzernamen an wen das Ticket zugewiesen wurde sowie das Datum der letzten Aktualisierung. All diese Spalten werden in der Ticketansicht per Default angezeigt. Als Benutzer kann man unter Optionen weitere Spalten für die Ansicht aktivieren oder die bereits vorhandenen deaktivieren. Im Administrationsmenü unter „Konfiguration“ → „Tickets“ können unter „Default-Spalten in der Ticket-Auflistung“ weitere Spalten für die Standardansicht aktiviert werden, zum Beispiel „Autor“, „Projekt“, „Kategorie“, „Zielversion“ und einige andere Felder.
Bereits abgeschlossene Tickets werden auf jeder Unterseite sowie in allen Javascript-Popups, auf der sie jeweils verlinkt sind, als durchgestrichen und grau dargestellt. Die Aufmerksamkeit der Entwickler soll schließlich nicht auf bereits erledigte Probleme und Fehler gelenkt werden. Trotzdem können als „Erledigt“ markierte Tickets eingesehen werden und bearbeitet werden.

Ticketansicht

In Abbildung 8 ist ein Ticket in der Detailansicht zu sehen. Das Ticket befindet sich im Status „Neu“ und hat die Priorität „Dringend“. Man findet über das Ticket weitere Informationen, wie beispielsweise die Kategorie, die zugehörige Zielversion, den Fortschritt, die aufgewendete Zeit sowie natürlich eine Fehlerbeschreibung vom Ersteller mit ggf. angehängten Dateien und Dokumenten. Dem Ticket können Unteraufgaben und zugehörige Tickets zugewiesen werden. In der Historie werden alle Ereignisse, die das Ticket betreffen, übersichtlich in chronologischer Reihenfolge aufgelistet. Alle Änderungen, sei es nur die Änderung der Ticket-Kategorie oder eine Änderung der Zielversion, alles wird in Redmine erfasst, sodass über jedes Ereignis informiert wird und man somit auf dem laufenden Stand ist.

(Abbildung 8: Ein Fehler (Ticket) in der Detailansicht)

Dem Verwalter werden zahlreiche Möglichkeiten geboten Tickets und Informationen schnell und auf bequeme Art und Weise zu bearbeiten. So kann der Aufwand in einem einfachen Formular mit optionalem Kommentar, Datum, Aktivität sowie natürlich den Stunden verbucht werden. Mitglieder können Tickets „beobachten“. Zudem können Tickets kopiert, dupliziert oder in andere Projekte mit gleichzeitiger Änderung von Tracker, von zuständiger Person oder Status verschoben werden. Bei der Duplikation können Thema, Beschreibung sowie alle anderen Zusatzinformationen, die auch beim Anlegen eines neuen Tickets angegeben werden, verändert werden.

Benutzerdefinierte Felder

Obwohl Redmine bereits zahlreiche Felder zur Sammlung von zusätzlichen Informationen bietet, gibt es auch noch die Möglichkeit beliebig viele eigene zusätzliche Felder zu definieren. Im Administrationsbereich kann der Datenbestand durch Anlegen eigener Felder erweitert werden. Benutzerdefinierte Felder können bei Informationsangaben zu Tickets, Aufwandszeiten, Projekten, Versionen, Benutzern, Gruppen, Aktivitäten, Ticket-Prioritäten sowie Dokumentenkategorien hinzufügt werden. Für jeden Bereich können sich die Einstellungsmöglichkeiten ändern. So kann bei Tickets zum Beispiel auch der Tracker ausgewählt werden, auf dem dieses neue Feld erscheinen soll. Auch das Format, in welchem die Datenangabe erfolgen soll, kann der Administrator im Vorfeld oder auch bei bereits laufender Redmine-Instanz einstellen. Die Informationen können beispielsweise als Text, langer Text, Zahl oder Fließkommazahl abgespeichert werden. Auch das Datumsformat, Listen, also Selectboxen in der Benutzeransicht, oder Boolean-Werte werden bei benutzerdefinierten Feldern unterstützt. Für spezielle Anwendungen und Daten sind eventuell genauere Angaben erforderlich. Diese Möglichkeit ist durch die Eingabe von regulären Ausdrücke geboten. Eingaben können so auf korrekte Formatierung hin überprüft werden.

(Abbildung 9: Anlegen von einem zusätzlichen Feld bei den Tickets)

In der Abbildung 9 ist das Formular zum Anlegen eines neuen Feldes abgebildet. Neben den bereits erwähnten Einstellungen ist zu sehen, dass zudem auch noch der Standardwert sowie die Minimal- oder Maximallänge angegeben werden kann.

Zeiterfassung

Die Zeiterfassung in Redmine erfolgt auf Projekt- und Ticketebene. Über aufgewendete Zeiten können anhand dieser Angaben und unter Einbeziehung weiterer Filterkriterien wie zum Beispiel  Kategorie, Aktivität, Mitglied, Projekt, Tacker, Version oder Ticket Berichte generiert werden. Berichte geben dann beispielsweise aufgewendete Zeit pro Benutzer, Ticket-Typ, Ticket-Kategorie oder Aktivität wieder.

(Abbildung 10: Aufgewendete Zeit und deren Zusammenfassung nach eignen Kriterien)

Wie man der Abbildung 10 erkennt, kann der Benutzer den Zeitraum angeben für welchen die aufgewendete Zeit tabellarisch anhand der Tickets und deren Zeitverbuchungen berechnet werden soll. Aufgewendete Zeiten können für ein Jahr, Monat, Woche oder einzelne Tage getrennt summiert werden. Für die Sortierung können wie bereits erwähnt weitere Kriterien herangezogen werden. In Abbildung 10 wurde die Zeit pro Projekt und pro Ticket aufgelistet.
Für den Manager und die Projektleitung ist es eine gute Möglichkeit Projekte und deren Gewichtung laufend zu kontrollieren und um den Arbeitsaufwand einzuschätzen zu können. Auf eventuell unerwarteten Mehraufwand kann so reagiert werden und neue Prioritäten können gesetzt werden. Beispielsweise ist dies der Fall, wenn andere Projekte eine größere Bedeutung haben, aber die Arbeitszeit in andere Projekte fließt.

Diagramme, Kalender und Statistiken

Für eine Übersicht sorgen in Redmine neben dem Kalender auch Gantt-Diagramme. Anhand dem Erstellungsdatum eines Tickets, welches automatisch eingetragen wird, sowie dem Datum, an dem das Ticket als „Erledigt“ markiert wurde, werden sogenannte Gantt-Diagramme erstellt. Zusätzlich anwendbare Filter sorgen in Redmine für benutzerdefinierte Statistiken. Es können Ticketstatistiken erstellt werden, die beispielsweise die Anzahl der Tickets pro Ticket-Typ oder Kategorie, Priorität oder die zugewiesenen Tickets an einen Benutzer wiedergeben.

Gantt-Diagramme

Gantt-Diagramme sind generell ein gutes Mittel, um die Abfolge und die Dauer der Aktivität, in diesem Fall die Bearbeitung eines Tickets, zu verdeutlichen. Die Darstellung erfolgt grafisch in Form von Balken. Auf einer Zeitachse von Beginn bis Ende eines Tickets erstreckt sich der Balken über die Anzahl der Bearbeitungstage.

(Abbildung 11: Gantt-Diagramme in Redmine)

Die Gantt-Diagramme in Redmine geben dem Entwickler und Manager einen Überblick über abgeschlossene, also „Erledigte“ Tickets sowie noch zu erledigende Arbeiten. In der Abbildung sind zwei Beispiel-Tickets zu sehen, die das Prinzip verdeutlichen. Blau sind alle Balken unterlegt, bei denen die Tickets bereits abgeschlossen sind. Man erkennt dies auch an der grau durchgestrichenen Fehler- bzw. Ticketnummer. Das linke Ende des Balkens steht für den Beginn des Tickets, das rechte Ende für das angestrebte Abgabedatum des Tickets.

Kalender

Der Kalender in Redmine stellt eine weitere Möglichkeit zur Verfügung, um eine Übersicht über alle Tickets zu bekommen und diese in einem selbst gewählten Zeitraum aufzulisten. Die Darstellung erfolgt durch Angabe eines Monats eines Jahres. Optionale Filter wie Ticketstatus sind bereits per Default zu sehen und brauchen nur ausgewählt zu werden. Um detailliertere Angaben zu erhalten, können die Filterkriterien ähnlich der Ticketübersicht um zusätzliche Ticketinformationen erweitert werden, wie zum Beispiel um den Autor, die Priorität oder den Beginn oder das Abgabedatum des Tickets.

(Abbildung 12: Ticket-Kalender)

In der Abbildung 12 wurde für die Anzeige der Monat Januar des Jahres 2011 ausgewählt. Wie man sieht, werden hier unsere zwei Beispiel-Tickets angezeigt. Der rote Pfeil vor der Ticketnummer, der nach links gerichtet ist, zeigt an, dass an diesem Tag das Abgabedatum des Tickets ist. Der Beginn einer Aufgabe bzw. eines Tickets wird durch einen grünen, nach rechts gerichteten, Pfeil dargestellt. Aufgaben, die am selben Tag beginnen und enden, werden durch eine rote Raute gekennzeichnet.

Berichte zu Tickets

Eine noch feinere statistische Auswertung von Tickets in Redmine werden durch die Berichte ermöglicht. Anhand des Statustypen eines Tickets kann die Gesamtanzahl der Tickets, beispielsweise pro Tracker, ermittelt werden. Dies ist sehr nützlich, wenn man als Manager sehen will wie „reif“ das zu entwickelnde bzw. bereits entwickelte System ist. Die Tracker Fehler, Feature und Unterstützung werden hier mit der Anzahl der Tickets zu den jeweiligen Status-Typen gegenübergestellt und man sieht grob, ob das System mit Fehlern überlastet ist oder aber die Endnutzer oder Kunden das System annehmen und neue Features anfragen. Hier zeigt sich ein indirektes und „anonymes“ Feedback zur entwickelnden Software. Den gleichen Zweck erfüllen die Statistiken zur Priorität, Version, den Unterprojekten sowie zu den Ticket-Kategorien. Jeder dieser Parameter dient zur groben Einstufung der Reife eines Systems.

(Abbildung 13: Berichte zu Tickets)

In der Abbildung 13 ist die Übersichtsseite der Berichte zu sehen. Zu den bereits oben erwähnten Ticketeigenschaften gibt es Statistiken zu den Entwicklern, die für die Bearbeitung der Tickets zuständig sind, sowie Statistiken zu den Autoren, die Tickets eröffnen. Zugewiesene Tickets zeigen schließlich die Rolle der einzelnen Entwickler und deren Engagement im Projekt an. Für den Projektmanager eine gute Möglichkeit, um die Arbeitsteilung zu verfolgen und eventuell zu korrigieren, indem man Mitarbeiter entlastet und Tickets anderen Mitarbeitern zur Bearbeitung zuweist. Detailliertere Ansichten über alle weiteren Ticket-Statustypen bekommt man, indem man auf die Lupe neben dem Berichtstyp klickt. Es werden anschließend alle Statustypen aufgelistet, statt nur die Typen „offen“ und „geschlossen“. Ein Ticket befindet sich im Status „offen“, wenn es den Status „Neu“ oder „In Bearbeitung“ hat. Der Status „Gelöst“, „Feedback“, „Erledigt“ und „Abgewiesen“ wird unter dem Status „geschlossen“ zusammengefasst.

Dokumente und Dateien

Redmine bietet für die Verwaltung von Dokumenten und Dateien eigenständige Bereiche. Dokumente, wie zum Beispiel Pflichtenheft, Entwurfsskizzen, Diagramme, Beschreibungen zu Schnittstellen, Anforderungsanalysen können hier mit einer Beschreibung hochgeladen werden. Es ist eine Kombination aus kurzem Beschreibungstext und dem eigentlich Anhang von Dokument(en).
Die Dokumentenkategorien können in der Administration global für alle Projekte eingestellt werden. Es erscheinen in den jeweiligen Projekten nur die Kategorien, für die tatsächlich ein oder mehrere Dokumente hochgeladen wurden. Dokumente können nach Kategorie, Datum, Titel und Autor sortiert werden und sorgen für eine strukturierte Übersicht.
Auch „Dateien“ können ähnlich den Dokumenten hochgeladen werden. Es ist eine Art Archiv mit Anhängen aller möglichen Dateitypen. Unter optionaler Angabe von Projekt-Version und einer kurzen Dateibeschreibung werden die Dateien später den Versionen zugeordnet, alphabetisch aufgelistet und zum Download bereitgestellt. Das Dateiarchiv stellt im Grunde genommen einen Speicherplatz für Dateien zur Verfügung. Neue Dateien können in Redmine entweder einzeln im Dateiarchiv abgelegt werden oder als Anhang bei beispielsweise Tickets, Foreneinträgen, Kommentaren, Wiki-Einträgen und wie bereits erwähnt bei Dokumenten angeheftet werden.

(Abbildung 14: Das Dateiarchiv in Projekt „Fahrrad-Shop“)

Foren und Wiki

In einem Team, das an einem größeren Projekt gemeinsam arbeitet gibt es natürlich viel Diskussionsstoff was die Planung angeht. Jeder möchte seine Lösung den anderen Teammitgliedern präsentieren, aber nicht immer ist sie die Beste, auch wenn man fest davon überzeugt ist. Wichtige Entscheidungen sollten dennoch gemeinsam getroffen werden. Auch daran wurde in Redmine gedacht.
Eine Diskussionsplattform wird durch die Foren bereitgestellt. Ein schlichtes, aber dennoch mit allen wichtigen Funktionen versehenes Forensystem kann für jedes Projekt separat mit Foren bzw. Kategorien ausgestattet werden. Unter der jeweiligen Projekt-Konfiguration können beliebig viele Foren mit kurzem Beschreibungstext angelegt und für die Anzeige beim Benutzer sortiert werden.

(Abbildung 15: Forumsystem in Redmine)

Als Ergänzung zu den Dokumenten kann für jedes Projekt ein eigenes Wiki aufgebaut werden. Die Wiki-Engine mit einfacher Syntax bietet hier den Vorteil der schnellen und einfachen Bearbeitung. Basierend auf der Auszeichnungssprache „Textile“ kann so in kurzer Zeit eine Wissensbasis für jedes Projekt aufgebaut werden. Das Wiki ist sehr nützlich für projektbezogene Begriffe und Definitionen, die in Dokumenten eventuell nur kurz angerissen werden. Die Auszeichnungssprache „Textile“ kann auch in den Ticketeinträgen genutzt werden. Dadurch ist in Redmine eine Verknüpfung von Ticketsystem mit dem Wiki, das sozusagen zum Nachschlagewerk wird, möglich. Die Einträge im Wiki können zudem als HTML oder Text abgerufen werden.

Repository und Diff

Von Redmine werden die Versionskontrollsysteme Subversion, Darcs, Mercurial, CVS, Bazaar, Git und ein einfaches Filesystem unterstützt. Im Administrationsbereich können global die einzelnen SCM-Systeme (Software-Configuration-Management-Systeme) aktiviert werden. Es ist sogar eine Verwaltung des Projektarchivs durch Nutzung eines Webservices (WebDAV) möglich. Changesets können automatisch abgerufen werden.

(Abbildung 16: Angabe des Repositories für das Projekt „Fahrrad-Shop“)

Wie in Abbildung 16 zu sehen ist, können bereits existierende Repositories an jedes Projekt separat anhängt werden. Dadurch ist später das Browsen und Suchen im Projektarchiv über Redmine selbst möglich. Der integrierte Diff-Betrachter dient zum Vergleich der Revisionen. Der Vergleich ist auch als Unified diff-Datei abrufbar. Im Administrationsbereich kann eingestellt werden, wie hoch die Anzahl anzuzeigender Revisionen in der Historie einer Datei maximal sein kann.

(Abbildung 17: Der Diff-Browser in Redmine)

Wie man in der Abbilgung 17 erkennt, können die Unterschiede nebeneinander oder untereinander  angezeigt werden. Die Änderungen sind an den jeweiligen Stellen jeweils farblich, rot und grün, so wie man es auch von allen gängigen diff-Betrachtern kennt, unterlegt.

LDAP-Authentifizierung

Redmine unterstützt das Protokoll „Lightweight Directory Access“ (LDAP). Durch LDAP- Authentifizierung ist Single Sign-on gegenüber mehreren LDAP-Instanzen möglich. Im Administrationsbereich kann solch ein Authentifizierungs-Modus angelegt werden.
Es kann zudem eine „On-the-fly“-Benutzererstellung aktiviert werden. Das heißt, dass Benutzer, die bereits einen Account auf dem laufenden LDAP-Server haben, sich in Redmine nicht extra registrieren müssen. Es genügt ein Login des Benutzers mit den Login-Daten, die auf dem Verzeichnisdienst hinterlegt sind. Die Attributnamen des Dienstes, welche für die Erstellung des Redmine-Accounts benötigt werden, können bzw. müssen ebenfalls dafür angegeben werden. Es muss mindestens der Mitgliedsname als Attribut angegeben werden. Zusätzliche Felder sind Vorname, Nachname sowie die E-Mailadresse. Sollte keine „On-the-fly“-Benutzerstellung aktiviert sein, so muss sich das Mitglied in Redmine manuell registrieren und somit einen Account erstellen.

(Abbildung 18: Anlegen eines neuen Authentifizierungs-Modus)

Die Aktivierung der Benutzeraccounts kann auf drei Arten erfolgen und im Administrationsbereich eingestellt werden. Accounts können entweder ohne jegliche Bestätigung automatisch, durch einen Administrator oder durch den Benutzer selbst aktiviert werden. Beim Letzteren erfolgt die Bestätigung durch einen Bestätigungslink der an die E-Mailadresse des Nutzers geschickt wird.

News und Benachrichtigungen

Nachrichten über neuste Aktivitäten werden auf Projekt- und Benutzerebene generiert. Neben einem einfach gehaltenen Radaktionssystem für aktuelle Meldungen existieren in Redmine zahlreiche Möglichkeiten, um Benutzer zum Beispiel über neue Projekte oder  neu erstellte Tickets zu informieren.

Tickets können von Benutzern zur Beobachtung markiert werden. Bei neusten Aktivitäten, die das jeweils beobachtete Ticket betreffen, wird der Benutzer per E-Mail informiert. News, Tickets, Foren und deren Beiträge und Auflistungen der Aktivitäten selbst können als Atom-Feed abgerufen werden. Zudem können Tickets als Liste im CSV-Format oder auch als PDF-Datei exportiert werden. Im Bereich „Aktivität“ kann eine Historie der Aktivitäten aller Projekte eingesehen werden. Es werden Aktivitäten, die Tickets, Changesets, News, Dokumente, Dateien, Wiki-Bearbeitungen, Forenbeiträge und Zeitverbuchungen betreffen, angezeigt und, wie bereits vorher erwähnt, als Feed abgerufen werden.

(Abbildung 19: Der Bereich „Aktivität“)

Die Benachrichtigungen des Benutzers per E-Mail, Feeds und alle Abrufmöglichkeiten als PDF oder CSV sind ein wichtiger Faktor, um den Informationsfluss in einem oder zwischen mehreren Projekten sicherzustellen. Mitarbeiter werden durch diese Notify-Systeme sofort über neue Ereignisse benachrichtigt und sind damit auf dem aktuellen Stand der Entwicklung.

Plugin-System

Obwohl Redmine standardmäßig bereits viele Funktionen und einen leistungsstarken Bugtracker für die Verwaltung von Projekten bietet, wurde ein Plugin-System eingebaut, mit dem individuell passende und noch fehlende Funktionalität in die eigene Redmine-Instanz eingebracht werden kann. Basierend auf dem „Rails engines“-Plugin können so eigene Funktionen programmiert werden.
Auf der offiziellen Webseite von Redmine (http://www.redmine.org) wurde für Plugins ein Verzeichnis eingerichtet, in dem Nutzer ihre entwickelten Plugins anbieten können. Viele kostenlose Plugins stehen dort zur freien Verwendung bereit. Eine nützliche Funktion bietet zum Beispiel das Plugin „CMI“ von Emergya Consultoria (http://www.emergya.es). Mit diesem Plugin kann man einen zusammenfassenden Überblick über alle Projekte bekommen. Durch Berechnungen werden mit zusätzlichen grafischen Elementen Metriken angezeigt. Diese zeigen beispielsweise den aktuellen Aufwand, die Kosten oder den Fortschritt sowie Abweichungen von den Zielen seit Projektbeginn an. Der Name „CMI“ ist spanisch und steht für „Cuadro de Mando Integral“, ins Englische übersetzt bedeutet es „Central Panel of Management“.

(Abbildung 20: Das Plugin „CMI“ von Emergya Consultoria, Bildquelle: Emergya)

3. Systemvoraussetzungen

Redmine sollte auf Unix, Linux, Mac, Mac Server und Windows laufen. Notwendig ist hierfür Ruby und Ruby on Rails. Ruby ist ist in der Version 1.8.x notwendig. Die Version 1.9 wird von Redmine derzeit noch nicht unterstützt. RubyGems, das offizielle Paketsystem von Ruby, welches über die Kommandozeile ausgeführt wird, muss mindestens in der Version 1.3.1 installiert sein. Des Weiteren muss das Aufgaben-Automatisierungswerkzeug Rake in der Version 0.8.3 oder höher vorhanden sein. Um Webanwendung an den Webserver anzubinden ist zu noch die Ruby-Webserver-Schnittstelle Rack in der Version 1.0.1 Voraussetzung für eine erfolgreiche Installation.

Die Daten werden bei Redmine in einer Datenbank abgespeichert. Unterstützt werden MySQL 5.0 oder höher, PostgreSQL 8 oder SQLite 3. Die Installation von MySQL 5 wird von den Entwicklern empfohlen.

4. Zusammenfassung

Abschließend kann man sagen, dass Redmine sowohl für kleine als auch für sehr große Softwareteams eine sehr gute Möglichkeit zur schnellen Organisation und bequemen Verwaltung bietet.
In sehr kurzer Zeit ist eine Einarbeitung in Redmine möglich, denn alle wichtigen Funktionen fallen dem Entwickler förmlich ins Auge. Durch die obere Navigation erkennt man die grobe Aufteilung in die einzelnen Module wie beispielsweise Tickets, News, Dokumente und Projektkonfiguration. Die übersichtlich gestaltete Anordnung der einzelnen Steuerungselemente wie Filter und Buttons erleichtert die Benutzerführung. Bereits in wenigen Tagen lernt man das Werkzeug kennen und beherrscht die grundlegenden Funktionen.
Als Webanwendung ist Redmine jederzeit per Browser aufrufbar und man hat über alle Dokumente, Fehler, Nachrichten und alle weiteren Geschehnisse einen Überblick. Auch der Code selbst ist durch die Anknüpfung eines Repositories per Browser einsehbar. Genau diese Bündelung aller Projektdaten schafft ein leistungsstarkes Projektverwaltungssystem.
Nicht nur Redmine greift auf Werkzeuge zu. Auch für andere Werkzeuge gibt es sinnvolle Möglichkeiten auf Redmine zuzugreifen, nämlich von Eclipse aus. Mit dem Plugin Mylyn in Eclipse lassen sich Aufgaben zusammenstellen, um diese gezielt abarbeiten zu können. Jeder dieser Aufgabe werden nur die dafür benötigten Dokumente zugeordnet. In Mylyn stehen verschiedene Konnektoren zur Verfügung, um beispielsweise auf Bugtracker zuzugreifen. Sven Krzyzak (http://sourceforge.net/apps/mediawiki/redmin-mylyncon) stellt mit seinem Projekt „Redmine-Mylyn Connector“ einen Konnektor für Redmine bereit. Die Tickets aus Redmine werden als Aufgaben in Eclipse hinterlegt. So ist es beispielsweise möglich den Ticket-Statustyp und den Fortschritt direkt in Eclipse zu bearbeiten.

5. Quellen

http://www.redmine.org
http://www.redmine.org/projects/redmine/wiki/RedmineInstall
http://www.redmine.org/plugins
http://www.redmine.org/plugins/redmine_cmi
http://de.wikipedia.org/wiki/Redmine
http://de.wikipedia.org/wiki/Gantt-Diagramm
http://de.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol
http://www.it-hempel.de/content/redmine-eclipse-integrieren
http://wiki.ruby-portal.de/Rake

  1. Alex
    24. Januar 2012, 20:49 | #1

    Vielen Dank 😉

    Bis jetzt die beste Beschreibung zu Redmine die ich gelsen habe oder im Web gefunden habe!

    Gruß,
    Alex

    • Peter
      24. Januar 2012, 20:51 | #2

      Vielen Dank für das Lob. 🙂 Verbesserungen in der Beschreibung oder Ergänzungen nehme ich gerne entgegen 😉

  2. Vladi
    14. März 2013, 12:31 | #3

    Vielen Dank auch von mir für den Artikel. Hat mir sehr geholfen die Software besser zu verstehen. Für unsere Firma boin ich auf der Suche nach einer geeigneten Software u.a. Projektverwaltung, Redmine befindet sich nun in der engeren Auswahl. Favorit mit kleinem Vorsprung ist bislang noch Comindware http://www.comindware.com/de/ – aufgrund der übersichtlichen und leicht zu verstehenen Oberfläche.

    Es gibt Unmengen an derartigen Programmen auf dem Markt, die nicht alle sofort zu verstehen sind. Da ist ein Artikel, wie dieser hier, sehr hilfreich!

  3. Michael
    20. Mai 2014, 07:05 | #4

    Vielen Dank für die Ausführungen zu Redmine! – Hört sich sehr interessant an.

    Ich bin auf Deinen Blog gestossen, weil ich nach Texten zum Program ToDoList von AbstractSpoon gesucht habe. In Deinem Blog schriebst Du, dass dies das einzig brauchbare Programm im Open Source Bereich sei.

    –> Was verwendest Du denn nun. ToDoList für kleinere Sachen und Redmine im Betrieb?

    Ich denke, dass Redmine der „Caterpiller“ im diesem Bereich ist und ToDoList eher der kleine schneller Zettelkasten…

    Klär‘ mich bitte auf 🙂

    Gruß Michael

    • Peter
      25. Mai 2014, 14:06 | #5

      Weder noch. 😉 Für meine eigenen Projekte verwende ich nichts. Mittlerweile gibt es viele gute und recht günstige Online-Versionen solcher Management Systeme. Für ein paar Euro im Monat hat man sich den Wartungsaufwand gespart und muss nichts selbst installieren oder hosten. TodoList habe ich lange verwendet. Aber Stift und Papier auf dem Schreibtisch sind bei mir immer noch Standard für eine TODO-Liste. 🙂

  1. Bisher keine Trackbacks