So installierst du Monica Personal CRM auf Rocky Linux 9
Normalerweise wird Customer Relationship Management (CRM) Software für Unternehmen entwickelt, um ihre Kunden zu verwalten. CRM-Software hilft Unternehmen dabei, Daten von Kunden zu sammeln und ihnen über verschiedene Kommunikationsmittel zu helfen.
Monica Personal CRM hingegen richtet sich an Einzelpersonen und ihre Beziehungen zu Familie und Freunden. Monica CRM hilft dabei, alles zu organisieren und zu speichern, was es über die Menschen in deinem Umfeld zu wissen gibt. Es ist quelloffen und völlig kostenlos zu benutzen.
In dieser Anleitung lernst du, wie du Monica Personal CRM auf einem Rocky Linux 9 Server installierst.
Voraussetzungen
- Ein Server mit Rocky Linux 9 und mindestens 1,5 GB RAM. Wenn dein Server weniger als 1,5 GB RAM hat, werden die Yarn-Installationsaufgaben höchstwahrscheinlich fehlschlagen. Rüste auf einen Server mit besserem RAM auf, bevor du mit diesem Tutorial fortfährst, um eine reibungslose Installation zu gewährleisten.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Einen Fully Qualified Domain Name (FQDN) wie
monica.example.com, der auf deinen Server zeigt. - Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun.
- Alles ist auf dem neuesten Stand.
$ sudo dnf update
- Ein paar wichtige Pakete werden benötigt, damit das Tutorial und Monica CRM laufen. Einige davon befinden sich bereits auf deinem Server.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --permanent --list-services
Es sollte die folgende Ausgabe angezeigt werden.
cockpit dhcpv6-client ssh
Lasse HTTP- und HTTPS-Ports zu.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --permanent --list-services
Du solltest eine ähnliche Ausgabe sehen.
cockpit dhcpv6-client http https ssh
Lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
Schritt 2 – Git installieren
Git ist normalerweise auf Rocky Linux 9 vorinstalliert. Falls es aber nicht installiert ist, kannst du es mit dem folgenden Befehl installieren.
$ sudo dnf install git -y
Überprüfe die Version von Git.
$ git --version git version 2.39.3
Führe die folgenden Befehle aus, um Git so zu konfigurieren, dass es deinen Namen und deine E-Mail-Adresse aufnimmt.
$ git config --global user.name "Your Name" $ git config --global user.email "youremail@domain.com"
Schritt 3 – Node installieren
Monica CRM benötigt Node.js, um zu funktionieren.
$ curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/nodesource.gpg
Installiere das Nodesource RPM-Paket. Die aktuelle Node LTS Version ist 20.x, aber sie funktioniert nicht mit dem Yarn Paketmanager, deshalb haben wir sie vorerst auf 18.x gesetzt.
$ NODE_MAJOR=18 $ sudo yum install https://rpm.nodesource.com/pub_$NODE_MAJOR.x/nodistro/repo/nodesource-release-nodistro-1.noarch.rpm -y
Installiere Node.js.
$ sudo yum install nodejs -y --setopt=nodesource-nodejs.module_hotfixes=1
Überprüfe, ob es richtig installiert ist.
$ node --version v18.18.2
Aktualisiere NPM.
$ sudo npm install -g npm@latest
Überprüfe die NPM-Version.
$ npm --version 10.2.4
Schritt 4 – Yarn installieren
Yarn ist ein weiterer Javascript-Paketmanager, der neben Node.js von Monica CRM benötigt wird. Die übliche Methode zur Installation von Yarn ist, es global zu installieren. So wird sichergestellt, dass alle Test- und Automatisierungswerkzeuge in einem Projekt dieselbe Version von Yarn verwenden und Inkonsistenzen vermieden werden.
Installiere Yarn mit dem folgenden Befehl.
$ sudo npm install --global yarn
Überprüfe die Installation von Yarn.
$ yarn --version 1.22.21
Schritt 5 – Nginx installieren
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code in die Datei ein.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Nginx.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.24.0
Aktiviere und starte den Nginx Serverdienst.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Thu 2023-11-23 01:10:33 UTC; 1s ago
Docs: http://nginx.org/en/docs/
Process: 4560 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 4561 (nginx)
Tasks: 2 (limit: 10841)
Memory: 1.9M
CPU: 11ms
CGroup: /system.slice/nginx.service
??4561 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??4562 "nginx: worker process"
Öffne die IP-Adresse deines Servers in deinem Webbrowser. Du solltest die folgende Seite sehen, d.h. dein Server ist betriebsbereit.
Schritt 6 – Installiere PHP und Erweiterungen
Rocky Linux 9 wird standardmäßig mit PHP 8.1 ausgeliefert. Um immer auf der neuesten PHP-Version zu bleiben oder wenn du mehrere PHP-Versionen installieren möchtest, müssen wir das REMI-Repository nutzen.
Der erste Schritt besteht darin, das Epel-Repository zu holen.
$ sudo dnf install epel-release -y
Als nächstes installierst du das Remi-Repository.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Prüfe, ob PHP-Streams verfügbar sind.
$ dnf module list php -y Name Stream Profiles Summary php 8.1 common [d], devel, minimal PHP scripting language Remi's Modular repository for Enterprise Linux 9 - x86_64 Name Stream Profiles Summary php remi-7.4 common [d], devel, minimal PHP scripting language php remi-8.0 common [d], devel, minimal PHP scripting language php remi-8.1 common [d], devel, minimal PHP scripting language php remi-8.2 common [d], devel, minimal PHP scripting language php remi-8.3 common [d], devel, minimal PHP scripting language Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
Die Standardversion ist 8.1. Aktiviere das PHP 8.2 Repository von Remi.
$ sudo dnf module reset php -y $ sudo dnf module enable php:remi-8.2
Installiere PHP und seine Erweiterungen.
$ sudo dnf install php php-bcmath php-cli php-curl php-common \
php-fpm php-gd php-gmp php-intl php-mbstring \
php-mysql php-opcache php-redis php-xml php-zip -y
Überprüfe die installierte Version von PHP.
$ php --version
PHP 8.2.13 (cli) (built: Nov 21 2023 09:55:59) (NTS gcc x86_64)
Copyright (c) The PHP Group
Zend Engine v4.2.13, Copyright (c) Zend Technologies
with Zend OPcache v8.2.13, Copyright (c), by Zend Technologies
Aktiviere und starte den PHP-FPM-Dienst.
$ sudo systemctl enable php-fpm --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status php-fpm
? php-fpm.service - The PHP FastCGI Process Manager
Loaded: loaded (/usr/lib/systemd/system/php-fpm.service; enabled; preset: disabled)
Active: active (running) since Thu 2023-11-23 01:21:11 UTC; 1s ago
Main PID: 5643 (php-fpm)
Status: "Ready to handle connections"
Tasks: 6 (limit: 10841)
Memory: 15.7M
CPU: 85ms
CGroup: /system.slice/php-fpm.service
??5643 "php-fpm: master process (/etc/php-fpm.conf)"
??5644 "php-fpm: pool www"
??5645 "php-fpm: pool www"
??5646 "php-fpm: pool www"
??5647 "php-fpm: pool www"
??5648 "php-fpm: pool www"
Schritt 7 – Composer installieren
Composer dient als Abhängigkeitsmanager für PHP. Er ist auch der Abhängigkeitsmanager des Laravel PHP-Frameworks, auf dem Monica CRM basiert.
Lade das Composer-Installationsskript herunter.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Überprüfe das heruntergeladene Installationsprogramm.
$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e21205b207c3ff031906575712edab6f13eb0b361f2085f1f1237b7126d785e826a450292b6cfd1d64d92e6563bbde02') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
Du wirst die folgende Ausgabe erhalten.
Installer verified
Führe das Installationsskript aus, um die neueste Version von Composer herunterzuladen.
$ php composer-setup.php
Entferne das Installationsskript.
$ php -r "unlink('composer-setup.php');"
Verschiebe die heruntergeladene Binärdatei in das Verzeichnis /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Bestätige die Installation.
$ composer --version Composer version 2.6.5 2023-10-06 10:11:52
Schritt 8 – MariaDB installieren
MariaDB ist ein Drop-in-Ersatz für MySQL. Das bedeutet, dass die Befehle zum Ausführen und Betreiben von MariaDB die gleichen sind wie die für MySQL.
Rocky Linux 9 wird standardmäßig mit MariaDB 10.5.22 ausgeliefert, das ein wenig veraltet ist. Um die neueste stabile Version von MariaDB zu erhalten, musst du das offizielle Repository verwenden.
Erstelle die Repository-Datei von MariaDB und öffne sie zum Bearbeiten.
$ sudo nano /etc/yum.repos.d/mariadb.repo
Füge den folgenden Code in die Datei ein.
[mariadb] name = MariaDB baseurl = http://yum.mariadb.org/10.11/rhel9-amd64 module_hotfixes=1 gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB gpgcheck=1
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Gib den folgenden Befehl ein, um den MariaDB-Server zu installieren. Beachte, dass der Paketname groß geschrieben wird. Das offizielle MariaDB-Paket, das Rocky Linux ausliefert, heißt einfach mariadb-server. Achte darauf, dass du die beiden nicht verwechselst.
$ sudo dnf install MariaDB-server -y
Überprüfe, ob MariaDB korrekt installiert ist.
$ mysql --version
Du solltest die folgende Ausgabe sehen.
mysql Ver 15.1 Distrib 10.11.6-MariaDB, for Linux (x86_64) using EditLine wrapper
Du kannst auch mariadb --version verwenden, um die Version zu überprüfen.
Starte und aktiviere den MariaDB-Dienst.
$ sudo systemctl enable --now mariadb
Der MariaDB-Dienst ist bereits aktiviert und läuft. Überprüfe seinen Status mit dem folgenden Befehl.
$ sudo systemctl status mariadb
? mariadb.service - MariaDB 10.11.6 database server
Loaded: loaded (/usr/lib/systemd/system/mariadb.service; enabled; preset: disabled)
Drop-In: /etc/systemd/system/mariadb.service.d
??migrated-from-my.cnf-settings.conf
Active: active (running) since Thu 2023-11-23 01:23:52 UTC; 2s ago
Docs: man:mariadbd(8)
https://mariadb.com/kb/en/library/systemd/
Process: 6831 ExecStartPre=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
Process: 6832 ExecStartPre=/bin/sh -c [ ! -e /usr/bin/galera_recovery ] && VAR= || VAR=`cd /usr/bin/..; /usr/bin/galera_recovery`; [ $? -eq 0 ] && systemctl set-environment _WSREP_START_POSITION=$VAR >
Process: 6850 ExecStartPost=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
Main PID: 6840 (mariadbd)
Status: "Taking your SQL requests now..."
Tasks: 10 (limit: 10841)
Memory: 193.1M
CPU: 162ms
CGroup: /system.slice/mariadb.service
??6840 /usr/sbin/mariadbd
Führe den folgenden Befehl aus, um die Standardkonfiguration durchzuführen, z. B. ein Root-Passwort zu vergeben, anonyme Benutzer zu entfernen, den Root-Login aus der Ferne zu verbieten und Testtabellen zu löschen.
$ sudo mariadb-secure-installation
Du wirst nach deinem Root-Passwort gefragt. Da wir kein Root-Passwort festgelegt haben, drückst du die Eingabetaste, um fortzufahren.
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!
In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.
Enter current password for root (enter for none): [PRESS ENTER]
OK, successfully used password, moving on...
Als Nächstes wirst du gefragt, ob du zum Plugin unix_socket wechseln möchtest. Das unix_socket Plugin ermöglicht es dir, dich mit deinen Linux-Benutzerdaten bei MariaDB anzumelden. Wähle n, um den Wechsel zu überspringen, da du bereits ein geschütztes root Konto hast.
Setting the root password or using the unix_socket ensures that nobody can log into the MariaDB root user without the proper authorisation. You already have your root account protected, so you can safely answer 'n'. Switch to unix_socket authentication [Y/n] n ... skipping.
Als nächstes wirst du gefragt, ob du dein Root-Passwort ändern möchtest. Unter Rocky Linux 9 ist das Root-Konto für MariaDB eng mit der automatischen Systemwartung verknüpft, daher solltest du die konfigurierten Authentifizierungsmethoden für das Konto nicht ändern. Andernfalls könnte eine Paketaktualisierung das Datenbanksystem zerstören, indem der Zugriff auf das Administratorkonto aufgehoben wird. Gib n ein, um fortzufahren.
You already have your root account protected, so you can safely answer 'n'. Change the root password? [Y/n] n ... skipping.
Drücke von nun an y und dann Enter, um die Standardeinstellungen für alle folgenden Fragen zu akzeptieren. Dadurch wird der Zugang für anonyme Benutzer entfernt, die Datenbanken werden getestet, die Remote-Root-Anmeldung wird deaktiviert und die Änderungen werden geladen.
By default, a MariaDB installation has an anonymous user, allowing anyone to log into MariaDB 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? [Y/n] 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? [Y/n] y ... Success! By default, MariaDB 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? [Y/n] 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? [Y/n] y ... Success! Cleaning up... All done! If you've completed all of the above steps, your MariaDB installation should now be secure. Thanks for using MariaDB!
Das war’s schon. Wenn du dich das nächste Mal bei der MariaDB-Shell anmelden willst, verwende den folgenden Befehl.
$ sudo mysql
Gib dein Linux-Root-Passwort ein, wenn du dazu aufgefordert wirst.
Welcome to the MariaDB monitor. Commands end with ; or \g. Your MariaDB connection id is 9 Server version: 10.11.6-MariaDB MariaDB Server Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others. Type 'help;' or '\h' for help. Type '\c' to clear the current input statement. MariaDB [(none)]>
Drücke exit, um die MariaDB-Shell zu schließen.
Schritt 9 – MariaDB konfigurieren
Melde dich in der MariaDB-Shell an.
$ sudo mysql
Erstelle eine neue MySQL-Datenbank, einen Datenbankbenutzer und ein Passwort für deine Monica CRM-Installation.
MariaDB> CREATE DATABASE monica CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; MariaDB> CREATE USER 'monicauser'@'localhost' IDENTIFIED BY 'yourpassword'; MariaDB> GRANT ALL PRIVILEGES ON monica.* TO 'monicauser'@'localhost';
Ersetze monica, monicauser und yourpassword durch die Anmeldedaten deiner Wahl. Wähle ein sicheres Passwort.
Erstelle außerdem einen administrativen Benutzer mit denselben Fähigkeiten wie das Root-Konto.
MariaDB> GRANT ALL ON *.* TO 'admin'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
Flush die Berechtigungen, um sicherzustellen, dass sie in der aktuellen Sitzung gespeichert werden.
MariaDB> FLUSH PRIVILEGES;
Beende die MariaDB-Shell.
MariaDB> exit
Schritt 10 – Herunterladen von Monica
Erstelle das Web-Root-Verzeichnis für Monica CRM.
$ sudo mkdir /var/www/html/monica -p
Setze den aktuell angemeldeten Benutzer als Eigentümer dieses Verzeichnisses.
$ sudo chown -R $USER:$USER /var/www/html/monica
Wechsle in das Verzeichnis.
$ cd /var/www/html/monica
Klone das offizielle Monica-Github-Repository an dieser Stelle. Beachte den Punkt (.) am Ende des Befehls, der bedeutet, dass Monica in das aktuelle Verzeichnis und nicht in ein Unterverzeichnis geklont wird.
$ git clone https://github.com/monicahq/monica.git .
Hol dir die neuesten Daten von GitHub.
$ git fetch
Checke die neueste Version von Monica aus. Die aktuellste Version findest du auf der Seite Monica releases. Zum Zeitpunkt der Erstellung dieses Tutorials ist die neueste Version 4.0.0. Ersetze 4.0.0 durch die Version, die du installieren willst, in dem unten stehenden Befehl.
$ git checkout tags/v4.0.0
Du erhältst dann die folgende Ausgabe.
Note: switching to 'tags/v4.0.0'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this state without impacting any branches by switching back to a branch. If you want to create a new branch to retain commits you create, you may do so (now or later) by using -c with the switch command. Example: git switch -c <new-branch-name> Or undo this operation with: git switch - Turn off this advice by setting config variable advice.detachedHead to false HEAD is now at e1a3e1315 build: delete heroku workflow (#6540)
Schritt 11 – Installation von Monica
Vergewissere dich, dass du dich im Stammverzeichnis von Monica befindest.
$ cd /var/www/html/monica
Kopiere die Beispiel-Umgebungsvariablendatei, um eine Datei für die Konfiguration von Monica CRM zu erstellen.
$ cp .env.example .env
Ändere die folgenden Werte wie gezeigt. Setze die Variable APP_ENV auf production. Damit wird das HTTPS-Protokoll erzwungen. Setze die Variable APP_URL auf den Domänennamen von Monica zusammen mit dem HTTPS-Protokoll. Lege die Anmeldedaten für die Datenbank fest, die du im vorherigen Schritt erstellt hast. In unserem Lernprogramm verwenden wir den SES SMTP-Dienst von Amazon. Gib die Details für den Dienst ein, den du verwenden willst. Wenn du keinen verwendest, kannst du diese Felder auslassen.
APP_ENV=production ... APP_URL=https://monica.example.com ... DB_DATABASE=monicadb DB_USERNAME=monicauser DB_PASSWORD=YourPassword23! ... MAIL_MAILER=smtp MAIL_HOST=email-smtp.us-west-2.amazonaws.com MAIL_PORT=587 MAIL_USERNAME=SESID MAIL_PASSWORD=SESKey MAIL_ENCRYPTION=tls # Outgoing emails will be sent with these identity MAIL_FROM_ADDRESS=name@example.com MAIL_FROM_NAME="Monica CRM" # New registration notification sent to this email APP_EMAIL_NEW_USERS_NOTIFICATION=name@example.com ...
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere alle benötigten Pakete für Monica mit Composer.
$ composer install --no-interaction --no-dev
Verwende Yarn, um die Frontend-Pakete zu installieren und die Assets (JS, CSS und Schriftarten) zu erstellen.
$ yarn install $ yarn run production
Erstelle den Wert APP_KEY und fülle ihn automatisch in der Datei .env aus. Du wirst mit einer Ja- oder Nein-Frage gefragt, ob du fortfahren möchtest. Gib Ja ein, um fortzufahren.
$ php artisan key:generate
Gib den folgenden Befehl ein, um Migrationen durchzuführen, die Datenbank zu seeden und Symlink-Verzeichnisse zu erstellen. Du wirst mit einer Ja- oder Nein-Frage gefragt, ob du fortfahren möchtest. Gib Ja ein, um fortzufahren. Gib deine E-Mail-Adresse und dein Passwort ein, um einen Standardbenutzer zu erstellen, und verwende diese Werte in dem Befehl.
$ php artisan setup:production --email=your@email.com --password=yourpassword -v
Du erhältst die folgende Ausgabe, die dich über die erfolgreiche Installation informiert.
Monica v4.0.0 is set up, enjoy. ? Filling database INFO Seeding database. ----------------------------- | | Welcome to Monica v4.0.0 | ----------------------------- | You can now sign in to your account: | username: your@email.com | password: <hidden> | URL: https://monica.example.com ----------------------------- Setup is done. Have fun.
Schritt 12 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erzeugen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installierst du den Snapd-Installer. Er benötigt das EPEL (Extra Packages for Enterprise Linux) Repository, um zu funktionieren. Da wir es aber bereits in Schritt 3 installiert haben, können wir direkt fortfahren.
Installiere Snapd.
$ sudo dnf install -y snapd
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe, ob Certbot richtig funktioniert.
$ certbot --version certbot 2.7.4
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d monica.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/monica.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 --------------------------------------------------------------------------------------------------------------------------- Thu 2023-11-23 02:34:37 UTC 45min left Thu 2023-11-23 00:57:54 UTC 51min ago dnf-makecache.timer dnf-makecache.service Thu 2023-11-23 08:49:00 UTC 6h left - - snap.certbot.renew.timer snap.certbot.renew.service Fri 2023-11-24 00:00:00 UTC 22h left Thu 2023-11-23 00:30:29 UTC 1h 18min 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 13 – SELinux konfigurieren
Ändere den Dateisicherheitskontext für OpenEMR.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/monica(/.*)?"
Wende die Richtlinie an.
$ sudo restorecon -Rv /var/www/html/monica/
Wende die Richtlinie an, um Nginx den Zugriff auf MariaDB zu ermöglichen.
$ sudo setsebool -P httpd_can_network_connect_db 1
Wende die Richtlinie an, um Verbindungen zu externen Hosts zu erlauben. Dies wird für den Versand von E-Mails benötigt.
$ sudo setsebool -P httpd_can_network_connect 1
Mit MariaDB 10.11 wirst du mit einem weiteren Problem konfrontiert: SELinux verhindert, dass sich PHP-FPM mit MariaDB verbindet. Das kann durch die Installation eines SELinux-Moduls gelöst werden. Der erste Schritt besteht darin, eine Datei type enforcement zu erstellen.
Erstelle die Datei my-phpfpm.te in deinem Home-Verzeichnis und öffne sie zum Bearbeiten.
$ cd ~ $ nano my-phpfpm.te
Füge den folgenden Code in die Datei ein.
module my-phpfpm 1.0;
require {
type unconfined_service_t;
type httpd_t;
type httpd_sys_content_t;
class dir write;
class unix_stream_socket connectto;
}
#============= httpd_t ==============
#!!!! This avc is allowed in the current policy
allow httpd_t httpd_sys_content_t:dir write;
#!!!! This avc is allowed in the current policy
allow httpd_t unconfined_service_t:unix_stream_socket connectto;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Im nächsten Schritt wandelst du sie mit folgendem Befehl in ein Richtlinienmodul um. Ändere den Dateinamen in dem Befehl nicht, sonst funktioniert er nicht. Das Modul heißt my-phpfpm und der Dateiname sollte mit dem Namen des Moduls übereinstimmen.
$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te
Als Nächstes müssen wir das Richtlinienmodul kompilieren, um ein Richtlinienpaket zu erstellen.
$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod
Der letzte Schritt besteht darin, das Richtlinienpaket mit dem Befehl semodule zu laden, der die zu verwendende Richtlinie installiert.
$ sudo semodule -i my-phpfpm.pp
Schritt 14 – PHP-FPM konfigurieren
Öffne php.ini zur Bearbeitung.
$ sudo nano /etc/php.ini
Um die Datei-Upload-Größen festzulegen, änderst du die Werte der Variablen upload_max_filesize und post_max_size. Dieser Wert bestimmt die Größe der Datei, die du auf Monica hochladen kannst. Standardmäßig ist er auf 10 MB eingestellt, was wir mit PHP konfigurieren werden.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 10M/' /etc/php.ini $ sudo sed -i 's/post_max_size = 8M/post_max_size = 10M/' /etc/php.ini
Konfiguriere das Speicherlimit von PHP je nach den Ressourcen und Anforderungen deines Servers.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php.ini
Öffne die Datei /etc/php-fpm.d/www.conf.
$ sudo nano /etc/php-fpm.d/www.conf
Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user=apache und group=apache in der Datei und ändere sie in nginx.
... ; Unix user/group of processes ; Note: The user is mandatory. If the group is not set, the default user's group ; will be used. ; RPM: apache user chosen to provide access to the same directories as httpd user = nginx ; RPM: Keep a group allowed to write in log dir. group = nginx ...
Finde die Zeilen listen.owner = nobody, listen.group = nobody, listen.mode = 0660 in der Datei und ändere sie wie folgt, nachdem du sie auskommentiert hast.
; Set permissions for unix socket, if one is used. In Linux, read/write ; permissions must be set in order to allow connections from a web server. Many ; BSD-derived systems allow connections regardless of permissions. The owner ; and group can be specified either by name or by their numeric IDs. ; Default Values: user and group are set as the running user ; mode is set to 0660 listen.owner = nginx listen.group = nginx listen.mode = 0660
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den PHP-fpm-Prozess neu. Vergewissere dich, dass Nginx installiert ist, bevor du den PHP-Dienst neu startest, sonst schlägt er fehl, da er die Gruppe nginx nicht finden kann.
$ sudo systemctl restart php-fpm
Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Schritt 15 – Nginx konfigurieren
Erlaube Nginx den Zugriff auf das Stammverzeichnis Monica.
$ sudo chown -R nginx:nginx /var/www/html/monica
Setze die richtigen Verzeichnisberechtigungen für das Verzeichnis storage.
$ sudo chmod -R 775 /var/www/html/monica/storage
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ 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.
Erstelle und öffne die Datei /etc/nginx/conf.d/monica.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/monica.conf
Füge den folgenden Code in die Datei ein. Ersetze monica.example.com durch deinen Domainnamen. Vergewissere dich, dass der Wert von client_max_body_size auf 10 MB eingestellt ist, was der Standard-Uploadgröße von Dateien in Monica entspricht. Es ist derselbe Wert, den wir zuvor mit PHP konfiguriert haben.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name monica.example.com;
root /var/www/html/monica/public;
index index.php;
client_max_body_size 10M;
access_log /var/log/nginx/monica.access.log;
error_log /var/log/nginx/monica.error.log;
ssl_certificate /etc/letsencrypt/live/monica.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/monica.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/monica.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;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location ~ \.php$ {
fastcgi_index index.php;
fastcgi_split_path_info ^(.+\.php)(.*)$;
fastcgi_keep_conn on;
include fastcgi_params;
fastcgi_pass unix:/run/php-fpm/www.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name monica.example.com;
return 301 https://$host$request_uri;
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe deine Nginx-Konfiguration.
$ sudo nginx -t
Starte den Nginx-Server neu.
$ sudo systemctl restart nginx
Schritt 16 – Zugriff auf Monica CRM
Öffne die URL https://monica.example.com in deinem Browser und du gelangst zur Anmeldeseite wie unten dargestellt.
Gib die E-Mail-Adresse und das Passwort ein, die du in Schritt 12 konfiguriert hast, und klicke auf die Schaltfläche Anmelden, um fortzufahren. Du gelangst zum Willkommensbildschirm, von dem aus du die Anwendung nutzen kannst.
Schritt 17 Cron einrichten
Monica CRM benötigt mehrere Hintergrundprozesse, um einen reibungslosen Ablauf zu gewährleisten. Diese werden mit der Cron-Funktion verwaltet. Dazu richtest du einen Cron ein, der jede Minute den Befehl php artisan schedule:run ausführt.
Starte den crontab-Editor. Wir geben nginx als Benutzer an, da dieser Zugriff auf das Verzeichnis /var/www/html/monica hat. Im Befehl selbst geben wir nano als Editor an, was der einfachste Weg ist, um loszulegen.
$ sudo editor=NANO crontab -u nginx -e
Als Nächstes wirst du zum crontab-Editor weitergeleitet. Füge diese Zeile am Ende der Datei ein.
* * * * * php /var/www/html/monica/artisan schedule:run >> /dev/null 2>&1
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Das war’s schon. Monicas geplante Aufgaben werden nun regelmäßig über die Cron-Funktionalität ausgeführt.
Schritt 18 – Monica CRM aktualisieren
Der erste Schritt zur Sicherung von Monica CRM besteht darin, sicherzustellen, dass es gesichert ist. Du kannst das SQL von der Einstellungsseite aus sichern. Klicke auf das Symbol Einstellungen oben rechts im Dashboard, um die Seite Kontoeinstellungen zu öffnen. Öffne dann die Seite Daten exportieren aus dem linken Menü.
Klicke auf die Schaltfläche Nach SQL exportieren, um die Datenbank zu exportieren. Es gibt auch eine Option Export nach Json, die viel mehr als nur die SQL-Daten sichert, aber es gibt keine Möglichkeit, sie zu importieren. Wahrscheinlich wird der Status für beide Exporte als fehlgeschlagen angezeigt, aber wenn du das Verzeichnis /var/www/html/monica/storage/app/public/exports auf deinem Server durchsuchst, solltest du beide Dateien sehen.
$ ls /var/www/html/monica/storage/app/public/exports -al total 84 drwxr-xr-x 2 nginx nginx 4096 Nov 22 09:47 . drwxrwxr-x 4 nginx nginx 4096 Nov 22 09:47 .. -rw-r--r-- 1 nginx nginx 53712 Nov 22 09:47 cvlK5RAl7VVLdYLplnSZ8SFGHHwDZy9cjRhtoOWB.json -rw-r--r-- 1 nginx nginx 17050 Nov 22 09:47 dgZf5T0SnXeAuZ67HfaFLu2JosyUsByJcp2C8nlv.sql
Jetzt, wo wir die Daten gesichert haben, ist es Zeit für ein Update.
Wechsle in das Verzeichnis Monica.
$ cd /var/www/html/monica
Da die Berechtigungen für das Verzeichnis auf nginx gesetzt sind, müssen wir sudo verwenden, um Befehle auszuführen. Es ist jedoch besser, die Berechtigungen vorübergehend zu ändern, anstatt sudo zu verwenden, was wir auch tun werden.
$ sudo chown -R $USER:$USER /var/www/html/monica
Hol dir die neuesten Git-Änderungen.
$ git fetch
Klone die gewünschte Version. Für unseren Lehrgang beziehen wir uns auf die Beta-Version. Verwende sie nicht auf einem Produktionsserver.
$ git checkout tags/v5.0.0-beta.3
Aktualisiere die Abhängigkeiten.
$ composer install --no-interaction --no-dev
Installiere die Frontend-Pakete.
$ yarn install
Baue die JavaScript- und CSS-Assets.
$ yarn run production
Führe den folgenden Befehl aus, um die Instanz zu aktualisieren. Dabei werden die Migrationsskripte für die Datenbank ausgeführt und alle Caches für Config, Route und View geleert, um den Prozess zu optimieren.
$ php artisan monica:update --force
Wenn du die SQL-Datenbank in einer anderen Monica-Instanz wiederherstellen willst, musst du sicherstellen, dass deine Instanz komplett leer ist, d.h. keine Tabellen und keine Daten enthält. Wenn du das sichergestellt hast, führst du den folgenden Befehl aus, um den Datenbankmigrationsprozess zu starten.
$ php artisan migrate
Als nächstes importierst du die Datei monica.sql mit dem folgenden Befehl.
$ sudo mysqlimport -u monicauser -p monica /var/www/html/monica/storage/app/public/exports/dgZf5T0SnXeAuZ67HfaFLu2JosyUsByJcp2C8nlv.sql
Du wirst nach deinem Monica-Benutzer-DB-Passwort gefragt, das du zuvor festgelegt hast. Melde dich dann mit den Anmeldedaten der alten Instanz an.
Wenn du damit fertig bist, stellst du die Rechte für das Monica-Verzeichnis für den Benutzer nginx wieder her.
$ sudo chown -R nginx:nginx /var/www/html/monica
Fazit
Dies ist der Abschluss unseres Tutorials, in dem du gelernt hast, wie du die Monica CRM Software auf einem Rocky Linux 9 Server installierst. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.