So installierst du die Projektmanagement-Software Redmine unter Debian 11
Redmine ist eine kostenlose und quelloffene Projektmanagementsoftware und ein Tool zur Fehlerverfolgung. Es wurde mit dem Ruby on Rails-Framework geschrieben und kann mit verschiedenen Versionskontrollsystemen integriert werden. Es enthält einen Repository-Browser und einen Diff-Viewer. Es kann für die Verwaltung von Projektfunktionen wie Projektwikis und -foren, Zeiterfassung und rollenbasierte Zugriffskontrolle verwendet werden. Es ist plattform- und datenbankübergreifend und unterstützt 49 Sprachen.
In diesem Tutorial lernst du, wie du Redmine auf einem Debian 11 Server installierst.
Voraussetzungen
- Ein Server, auf dem Debian 11 läuft.
- Ein Nicht-Sudo-Benutzer mit Root-Rechten.
- Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
- Einige wenige Pakete, die dein System benötigt.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release unzip debian-archive-keyring -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
Schritt 1 – Firewall konfigurieren
Bevor du die Pakete installierst, musst du die Firewall so konfigurieren, dass sie HTTP- und HTTPS-Verbindungen zulässt.
Überprüfe den Status der Firewall.
$ sudo ufw status
Du solltest etwas wie das Folgende sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)
Erlaube HTTP- und HTTPs-Ports. Öffne außerdem Port 3000 für Redmine.
$ sudo ufw allow http $ sudo ufw allow https $ sudo ufw allow 3000
Überprüfe den Status erneut, um ihn zu bestätigen.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere 3000 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6) 3000 (v6) ALLOW Anywhere (v6)
Schritt 2 – Apache Server installieren
Wir werden den Apache Webserver verwenden, um Redmine einzusetzen. Installiere Apache mit dem folgenden Befehl.
$ sudo apt install apache2
Überprüfe den Status des Apache-Dienstes.
$ sudo systemctl status apache2
? apache2.service - The Apache HTTP Server
Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2023-03-04 13:28:57 UTC; 41s ago
Docs: https://httpd.apache.org/docs/2.4/
Main PID: 3478 (apache2)
Tasks: 55 (limit: 1129)
Memory: 9.7M
CPU: 27ms
CGroup: /system.slice/apache2.service
??3478 /usr/sbin/apache2 -k start
??3481 /usr/sbin/apache2 -k start
??3482 /usr/sbin/apache2 -k start
Mar 04 13:28:56 redmine systemd[1]: Starting The Apache HTTP Server...
Mar 04 13:28:57 redmine systemd[1]: Started The Apache HTTP Server.
Schritt 3 – Installiere und konfiguriere den MySQL-Server
Wir werden die MySQL-Datenbank verwenden, um die Daten zu speichern. Debian hat MySQL nicht mehr in seinen Repositories. Daher werden wir das offizielle MySQL-Repository für die Installation verwenden.
Importiere den MySQL GPG-Schlüssel.
$ curl https://repo.mysql.com/RPM-GPG-KEY-mysql-2022 | gpg --dearmor | sudo tee /usr/share/keyrings/mysql.gpg >/dev/null
Erstelle eine MySQL-Repository-Datei.
$ echo "deb [signed-by=/usr/share/keyrings/mysql.gpg arch=amd64] http://repo.mysql.com/apt/debian/ `lsb_release -cs` mysql-8.0" | sudo tee /etc/apt/sources.list.d/mysql.list
Aktualisiere die Repository-Liste des Systems.
$ sudo apt update
Installiere MySQL.
$ sudo apt install mysql-server
Du wirst aufgefordert, ein Root-Passwort festzulegen. Wähle ein sicheres Passwort. Als nächstes wirst du aufgefordert, zwischen der neueren MySQL caching_sha2_password Verschlüsselung und der älteren mysql_native_password Verschlüsselung zu wählen. Wähle die neuere, weil Redmine sie unterstützt. Wähle OK, um fortzufahren und die Installation abzuschließen.
Überprüfe den Status des MySQL-Dienstes.
$ sudo systemctl status mysql
? mysql.service - MySQL Community Server
Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enabled)
Active: active (running) since Sun 2023-03-05 08:18:15 UTC; 4h 14min ago
Docs: man:mysqld(8)
http://dev.mysql.com/doc/refman/en/using-systemd.html
Main PID: 10500 (mysqld)
Status: "Server is operational"
Tasks: 38 (limit: 1129)
Memory: 391.5M
CPU: 1min 49.904s
CGroup: /system.slice/mysql.service
??10500 /usr/sbin/mysqld
Mar 05 08:18:14 redmine systemd[1]: Starting MySQL Community Server...
Mar 05 08:18:15 redmine systemd[1]: Started MySQL Community Server.
Sichere MySQL-Installation.
$ sudo mysql_secure_installation
Zuerst wirst du nach dem Root-Passwort gefragt. Gib das Passwort ein, das du während der Installation gewählt hast. Als Nächstes wirst du gefragt, ob du das Validate Password Plugin einrichten möchtest, mit dem du die Stärke deines MySQL-Passworts testen kannst. Wähle Y, um fortzufahren. Im nächsten Schritt wirst du aufgefordert, die Stufe der Passwortüberprüfung auszuwählen. Wähle 2. Das ist die stärkste Stufe und verlangt, dass dein Passwort mindestens acht Zeichen lang ist und eine Mischung aus Groß- und Kleinbuchstaben, Zahlen und Sonderzeichen enthält.
Securing the MySQL server deployment. Enter password for user root: VALIDATE PASSWORD COMPONENT can be used to test passwords and improve security. It checks the strength of password and allows the users to set only those passwords which are secure enough. Would you like to setup VALIDATE PASSWORD component? Press y|Y for Yes, any other key for No: Y There are three levels of password validation policy: LOW Length >= 8 MEDIUM Length >= 8, numeric, mixed case, and special characters STRONG Length >= 8, numeric, mixed case, special characters and dictionary file Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 2
Dir wird die Stärke deines Root-Passworts angezeigt und du wirst gefragt, ob du es ändern möchtest. Gib N ein, wenn du es nicht ändern willst und fahre fort. Wenn du es ändern möchtest, kannst du das jetzt tun, indem du Y eingibst und ein Passwort wählst, das den oben genannten Anforderungen entspricht.
Using existing password for root. Estimated strength of the password: 100 Change the password for root ? ((Press y|Y for Yes, any other key for No) : N ... skipping.
Drücke bei allen folgenden Aufforderungen die Tasten Y und dann ENTER, um anonyme Benutzer und die Testdatenbank zu entfernen, Root-Logins zu deaktivieren und die neu festgelegten Regeln zu laden.
By default, a MySQL installation has an anonymous user, allowing anyone to log into MySQL without having to have a user account created for them. This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment. Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y Success. Normally, root should only be allowed to connect from 'localhost'. This ensures that someone cannot guess at the root password from the network. Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y Success. By default, MySQL comes with a database named 'test' that anyone can access. This is also intended only for testing, and should be removed before moving into a production environment. Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y - Dropping test database... Success. - Removing privileges on test database... Success. Reloading the privilege tables will ensure that all changes made so far will take effect immediately. Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y Success. All done!
Gib die MySQL-Shell ein. Gib dein Root-Passwort ein, um fortzufahren.
$ mysql -u root -p
Erstelle den Benutzer redmine. Vergewissere dich, dass das Passwort den zuvor festgelegten Anforderungen entspricht.
mysql> CREATE USER 'redmine'@'localhost' IDENTIFIED BY 'Your_password2';
Erstelle die Datenbank redmine.
mysql> CREATE DATABASE redmine CHARACTER SET utf8mb4;
Erteile dem Benutzer die Rechte für die Datenbank redmine.
mysql> GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost';
Beende die Shell.
mysql> exit
Schritt 4 – Installiere Ruby und andere Voraussetzungen
Die neueste Version von Redmine ist mit Ruby 3.1 kompatibel. Debian wird mit Ruby 2.7 ausgeliefert, also müssen wir die neueste Version mit dem Ruby Version Manager (RVM) installieren.
Installiere den GPG-Schlüssel von RVM.
$ gpg2 --keyserver keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
Installiere RVM.
$ \curl -sSL https://get.rvm.io | bash -s stable
Quelle die RVM-Skripte.
$ source ~/.rvm/scripts/rvm
Installiere Ruby. Du kannst die neueste Version auf der Ruby-Website überprüfen. Zum Zeitpunkt der Erstellung dieses Tutorials ist Ruby 3.1.3 die neueste Version der Reihe.
$ rvm install ruby-3.1.3
Überprüfe die Installation.
$ ruby -v ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux]
Installiere alle übrigen Pakete, die für Redmine benötigt werden.
$ sudo apt install libxml2-dev libxslt1-dev zlib1g-dev imagemagick libmagickwand-dev libmysqlclient-dev apache2-dev build-essential libcurl4-openssl-dev
Schritt 5 – Redmine installieren
Besuche die Downloadseite von Redmine und überprüfe, ob die neueste stabile Version verfügbar ist. Zum Zeitpunkt der Erstellung dieses Tutorials ist die neueste Version 5.0.5 verfügbar.
Verwende wget, um Redmine herunterzuladen.
$ wget https://www.redmine.org/releases/redmine-5.0.5.tar.gz
Es kann sein, dass du beim Herunterladen des Archivs die folgende Fehlermeldung erhältst, weil eines der Root-Zertifikate auf der Website abgelaufen ist.
WARNING: The certificate of ‘www.redmine.org’ is not trusted. WARNING: The certificate of ‘www.redmine.org’ doesn't have a known issuer. WARNING: The certificate of ‘www.redmine.org’ has expired.
Wenn du diese Fehlermeldung erhältst, führe stattdessen den folgenden Befehl zum Herunterladen aus.
$ wget https://www.redmine.org/releases/redmine-5.0.5.tar.gz --no-check-certificate
Entpacke die Dateien und verschiebe sie in das Verzeichnis /var/www/redmine.
$ tar xfz redmine-5.0.5.tar.gz $ sudo mv redmine-5.0.5 /var/www/redmine
Wechsle in das Verzeichnis /var/www/redmine.
$ cd /var/www/redmine
Du erhältst die folgende Ausgabe und eine Warnung bezüglich der Ruby-Version. Das kannst du getrost ignorieren.
RVM used your Gemfile for selecting Ruby, it is all fine - Heroku does that too, you can ignore these warnings with 'rvm rvmrc warning ignore /var/www/redmine/Gemfile'. To ignore the warning for all files run 'rvm rvmrc warning ignore allGemfiles'. Unknown ruby interpreter version (do not know how to handle): >=2.5.0,<3.2.0.
Erstelle die Redmine-Konfigurationsdateien mit Hilfe der mitgelieferten Beispieldateien.
$ cp config/configuration.yml.example config/configuration.yml $ cp config/database.yml.example config/database.yml $ cp public/dispatch.fcgi.example public/dispatch.fcgi
Öffne die Datei database.yml zum Bearbeiten.
$ nano config/database.yml
Finde deine Datenbankeinstellungen unter dem folgenden Abschnitt und konfiguriere sie.
production: adapter: mysql2 database: redmine host: localhost username: redmine password: "Your_password2" # Use "utf8" instead of "utfmb4" for MySQL prior to 5.7.7 encoding: utf8mb4
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Bundler für die Verwaltung von Ruby Gem-Abhängigkeiten.
$ gem install bundler
Richte die Umgebung für die Installation von Gem-Abhängigkeiten ein.
$ bundle config set --local without 'development test'
Installiere die Gem-Abhängigkeiten.
$ bundle install
Wenn du Probleme mit Gem-Versionen hast, kannst du sie mit dem folgenden Befehl wiederherstellen.
$ gem pristine --all
Füge die Webrick-Abhängigkeit hinzu.
$ bundle add webrick
Erstelle einen zufälligen geheimen Schlüssel, um zu verhindern, dass die Cookies zur Speicherung der Sitzungsdaten manipuliert werden.
$ bundle exec rake generate_secret_token
Erstelle die Datenbankstruktur.
$ RAILS_ENV=production bundle exec rake db:migrate
Füge die Daten in die MySQL-Datenbank ein.
$ RAILS_ENV=production REDMINE_LANG=en bundle exec rake redmine:load_default_data
Erstelle die notwendigen Verzeichnisse und lege die Dateiberechtigungen fest.
$ mkdir -p tmp/pdf $ mkdir -p public/plugin_assets $ chown -R $USER:$USER files log tmp public/plugin_assets $ chmod -R 755 /var/www/redmine/
Führe den folgenden Befehl aus, um eine Rails-Serverinstanz zu starten.
$ bundle exec rails server -u webrick -e production => Booting WEBrick => Rails 6.1.7.2 application starting in production http://0.0.0.0:3000 => Run `bin/rails server --help` for more startup options [2023-03-06 09:12:11] INFO WEBrick 1.7.0 [2023-03-06 09:12:11] INFO ruby 3.1.3 (2022-11-24) [x86_64-linux] [2023-03-06 09:12:11] INFO WEBrick::HTTPServer#start: pid=34652 port=3000
Öffne die URL http://<yourserverIP>:3000/login, um den Redmine-Anmeldebildschirm zu erhalten.
Gib die Standard-Anmeldedaten(admin/admin) ein, um dich anzumelden. Du wirst aufgefordert, das Passwort zu ändern.
Anschließend wirst du auf die Seite Mein Konto weitergeleitet.
Redmine wurde erfolgreich installiert.
Als Nächstes drückst du STRG+C auf dem Terminal, um den Server zu beenden.
Schritt 6 – Phusion Passenger installieren
Phusion Passenger ist ein Ruby-Anwendungsserver, mit dem wir Redmine über einen Drittanbieter-Server bereitstellen können. In unserem Fall werden wir Apache verwenden.
Installiere Passenger.
$ gem install passenger
Installiere das Passenger-Modul für den Apache-Server.
$ passenger-install-apache2-module
Du wirst mit einer Willkommensnachricht begrüßt. Drücke Enter, um fortzufahren.
Welcome to the Phusion Passenger Apache 2 module installer, v6.0.17. This installer will guide you through the entire installation process. It shouldn't take more than 3 minutes in total. Here's what you can expect from the installation process: 1. The Apache 2 module will be installed for you. 2. You'll learn how to configure Apache. 3. You'll learn how to deploy a Ruby on Rails application. Don't worry if anything goes wrong. This installer will advise you on how to solve any problems. Press Enter to continue, or Ctrl-C to abort. --------------------------------------------
Als nächstes wirst du nach der Sprache gefragt. Standardmäßig ist Ruby ausgewählt, also drücke einfach Enter, um fortzufahren.
Which languages are you interested in? Use <space> to select. If the menu doesn't display correctly, press '!' ? ? Ruby ? Python ? Node.js ? Meteor --------------------------------------------
Der gesamte Vorgang wird etwa 10-15 Minuten dauern. Wenn du eine Fehlermeldung wie die folgende bekommst, liegt das höchstwahrscheinlich an zu wenig RAM. Du solltest entweder den RAM-Speicher deines Servers erhöhen oder Swap-Speicher installieren.
c++: fatal error: Killed signal terminated program cc1plus compilation terminated. rake aborted!
Sobald der Vorgang abgeschlossen ist, bekommst du die folgende Meldung.
--------------------------------------------
Almost there!
Please edit your Apache configuration file, and add these lines:
LoadModule passenger_module /home/navjot/.rvm/gems/ruby-3.1.3/gems/passenger-6.0.17/buildout/apache2/mod_passenger.so
<IfModule mod_passenger.c>
PassengerRoot /home/navjot/.rvm/gems/ruby-3.1.3/gems/passenger-6.0.17
PassengerDefaultRuby /home/navjot/.rvm/gems/ruby-3.1.3/wrappers/ruby
</IfModule>
After you restart Apache, you are ready to deploy any number of web
applications on Apache, with a minimum amount of configuration!
Press ENTER when you are done editing.
Drücke noch nicht die Eingabetaste. Öffne eine neue Sitzung auf deinem Server als aktueller Benutzer und führe die folgenden Konfigurationen durch.
Schritt 7 – Apache Server konfigurieren
Erstelle eine Apache-Modulkonfigurationsdatei für Phusion Passenger.
$ sudo nano /etc/apache2/conf-available/00-passenger.conf
Füge den Code ein, den du am Ende der Passenger-Installation erhalten hast.
LoadModule passenger_module /home/navjot/.rvm/gems/ruby-3.1.3/gems/passenger-6.0.17/buildout/apache2/mod_passenger.so
<IfModule mod_passenger.c>
PassengerRoot /home/navjot/.rvm/gems/ruby-3.1.3/gems/passenger-6.0.17
PassengerDefaultRuby /home/navjot /.rvm/gems/ruby-3.1.3/wrappers/ruby
</IfModule>
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle eine weitere Apache-Konfigurationsdatei für die Redmine-Site.
$ sudo nano /etc/apache2/sites-available/redmine.conf
Füge den folgenden Code in diese Datei ein.
Listen 3000
<IfModule mod_passenger.c>
PassengerRoot /home/navjot/.rvm/gems/ruby-3.1.3/gems/passenger-6.0.17
PassengerDefaultRuby /home/navjot/.rvm/gems/ruby-3.1.3/wrappers/ruby
</IfModule>
<VirtualHost *:3000>
ServerName redmine.example.com
DocumentRoot "/var/www/redmine/public"
CustomLog ${APACHE_LOG_DIR}/redmine_access.log combined
ErrorLog ${APACHE_LOG_DIR}/redmine_error.log
LogLevel warn
<Directory "/var/www/redmine/public">
Options Indexes ExecCGI FollowSymLinks
Require all granted
AllowOverride all
</Directory>
</VirtualHost>
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Haupt-Apache-Konfigurationsdatei /etc/httpd/conf/httpd.conf zum Bearbeiten.
$ sudo nano /etc/httpd/conf/httpd.conf
Suche die Variable ServerName und entferne die Raute (#) davor und setze ihren Wert wie folgt.
ServerName localhost
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Aktiviere die Redmine-Site und die Phusion Passenger-Konfiguration.
$ sudo a2ensite redmine.conf $ sudo a2enconf 00-passenger.conf
Überprüfe deine Apache-Konfiguration.
$ sudo apachectl configtest Syntax OK
Gehe zurück und drücke die Eingabetaste, um die Installation von Passenger fortzusetzen. Es werden einige Überprüfungen durchgeführt und du solltest die folgende Meldung sehen, wenn sie erfolgreich abgeschlossen wurde.
Deploying a web application To learn how to deploy a web app on Passenger, please follow the deployment guide: https://www.phusionpassenger.com/library/deploy/apache/deploy/ Enjoy Phusion Passenger, a product of Phusion® (www.phusion.nl) :-) https://www.phusionpassenger.com Passenger® is a registered trademark of Phusion Holding B.V.
Starte deinen Apache-Server neu.
$ sudo systemctl restart apache2
Deine Website sollte nun unter http://redmine.example.com:3000 erreichbar sein.
Dies ist nicht der perfekte Weg, um auf Redmine zuzugreifen. Sie wird immer noch über das unsichere HTTP-Protokoll bedient und verwendet eine Portnummer. Um dies zu verbessern, werden wir Nginx installieren, das als Reverse Proxy fungiert und Redmine über das HTTPS-Protokoll bereitstellt. Bevor wir mit der Installation und Konfiguration von Nginx beginnen, müssen wir das SSL-Zertifikat einrichten.
Schritt 8 – Nginx installieren
Debian 11 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation. Unter Debian muss der folgende Befehl ausgeführt werden: sudo.
$ sudo nginx -v nginx version: nginx/1.22.1
Apache-Listening-Port ändern
Um Konflikte mit Nginx zu vermeiden, müssen wir den Standard-Port ändern, an dem Apache lauscht. Öffne die Datei /etc/apache2/ports.conf zum Bearbeiten.
$ sudo nano /etc/apache2/ports.conf
Ändere den Port wie folgt von 80 auf 8080.
Listen 8080
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Deaktiviere die Standardkonfiguration der Website.
$ sudo a2dissite 000-default.conf
Starte Apache neu.
$ sudo systemctl restart apache2
Starte den Nginx-Server.
$ sudo systemctl start nginx
Überprüfe den Status des Nginx-Servers.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2023-03-06 10:29:44 UTC; 6s ago
Docs: https://nginx.org/en/docs/
Process: 53531 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 53532 (nginx)
Tasks: 2 (limit: 1129)
Memory: 1.7M
CPU: 8ms
CGroup: /system.slice/nginx.service
??53532 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
??53533 nginx: worker process
Schritt 9 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian ist Snapd noch nicht installiert. Installiere deshalb Snapd.
$ sudo apt install snapd
Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Erstelle das SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d redmine.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/redmine.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot Erneuerungszeitplanungsdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES Mon 2023-03-06 11:37:00 UTC 1h 2min left n/a n/a snap.certbot.renew.timer snap.certbot.renew.service Mon 2023-03-06 13:37:15 UTC 3h 2min left Sun 2023-03-05 13:37:15 UTC 20h ago systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service Tue 2023-03-07 00:00:00 UTC 13h left Mon 2023-03-06 00:00:15 UTC 10h ago logrotate.timer logrotate.service
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 10 – Nginx als Reverse-Proxy konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/redmine.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/redmine.conf
Füge den folgenden Code in die Datei ein.
# Redirect all non-encrypted to encrypted
server {
listen 80;
server_name redmine.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
server_name redmine.example.com;
ssl_certificate /etc/letsencrypt/live/redmine.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/redmine.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/redmine.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 8.8.8.8;
access_log /var/log/nginx/redmine.access.log main;
error_log /var/log/nginx/redmine.error.log;
location / {
proxy_pass http://localhost:3000;
proxy_redirect off;
proxy_buffering off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf und bearbeite sie.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.
$ sudo systemctl restart nginx
Deine Redmine-Anwendung sollte nun unter https://redmine.example.com erreichbar sein.
Du solltest den Eintrag für Port 3000 in der Firewall löschen, da er nicht mehr benötigt wird.
$ sudo ufw delete allow 3000
Fazit
Dies ist der Abschluss unseres Tutorials, in dem du gelernt hast, wie du Redmine Project Manager auf einem Debian 11 Server installierst. Außerdem hast du gelernt, wie du die Redmine-Anwendung über Nginx mit dem HTTPS-Protokoll bereitstellst. Wenn du Fragen hast, schreibe sie unten in die Kommentare.