So installierst du OpenEMR auf Rocky Linux 9
OpenEMR ist eine Open-Source-Software für die elektronische Gesundheitsakte und das Praxismanagement. Es ist vom Office of the National Coordinator for Health Information Technology (ONC) zertifiziert und bietet integrierte Gesundheitsakten, Praxismanagement, Terminplanung, elektronische Rechnungsstellung, Internationalisierung, kostenlosen Support und mehr. Die Software kann demografische Daten von Patienten erfassen, Termine für Patienten festlegen, sehr detaillierte Gesundheitsakten mit Laborberichten, Medikamenten und Prozeduren führen, Rezepte verfolgen, bei der medizinischen Abrechnung helfen, detaillierte Berichte erstellen und mehrere Sprachen unterstützen.
In diesem Tutorial lernst du, wie du die OpenEMR-Software auf einem Server mit Rocky Linux 9 installierst.
Voraussetzungen
- Ein Server, auf dem Rocky Linux 9 läuft.
- Ein sudo-Benutzer ohne Root-Rechte.
- Ein vollständig qualifizierter Domainname (FQDN) wie
openemr.example.com. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo dnf update
- Ein paar Pakete, die dein System benötigt.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
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
OpenEMR benötigt HTTP- und HTTPS-Ports, um zu funktionieren. Öffne sie.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Lade die Firewall neu, um die Änderungen zu übernehmen.
$ sudo firewall-cmd --reload
Liste alle Dienste erneut auf.
$ sudo firewall-cmd --permanent --list-services
Du solltest die folgende Ausgabe erhalten.
cockpit dhcpv6-client http https ssh
Schritt 2 – 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 zur Erstellung des offiziellen Nginx-Repositorys.
$ 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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere den Nginx-Server.
$ sudo dnf install -y nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.24.0
Aktiviere und starte den Nginx-Server.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Servers.
$ 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-06-15 10:20:00 UTC; 1s ago
Docs: http://nginx.org/en/docs/
Process: 1411 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 1412 (nginx)
Tasks: 2 (limit: 5922)
Memory: 1.9M
CPU: 7ms
CGroup: /system.slice/nginx.service
??1412 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??1413 "nginx: worker process"
Schritt 3 – Installiere MySQL
Rocky Linux 9 wird mit der neuesten Version von MySQL ausgeliefert. Du kannst sie mit einem einzigen Befehl installieren.
$ sudo dnf install mysql-server
Überprüfe die Version von MySQL.
$ mysql --version mysql Ver 8.0.32 for Linux on x86_64 (Source distribution)
Aktiviere und starte den MySQL-Dienst.
$ sudo systemctl enable mysqld --now
Führe das Skript zur sicheren Installation von MySQL aus.
$ sudo mysql_secure_installation
Du wirst aufgefordert, die Validate Password Component zu installieren. Sie prüft die Stärke der in MySQL verwendeten Passwörter. Drücke Y, um sie zu installieren. Als Nächstes wirst du aufgefordert, die Stufe der Passwortüberprüfung festzulegen. Wähle 2, da dies die stärkste Stufe ist.
Securing the MySQL server deployment. Connecting to MySQL using a blank password. 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
Als Nächstes wirst du aufgefordert, ein neues Root-Passwort festzulegen. Gib das Passwort entsprechend den oben genannten Anforderungen ein. Gib Y ein, wenn du aufgefordert wirst, mit dem gewählten Root-Passwort fortzufahren.
Please set the password for root here. New password: Re-enter new password: Estimated strength of the password: 100 Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y
Als Nächstes gibst du Y ein, um anonyme Benutzer zu entfernen, Remote-Root-Logins zu verbieten, die Testdatenbank zu entfernen und die Berechtigungstabellen neu 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!
Schritt 4 – MySQL konfigurieren
Melde dich in der MySQL-Shell an. Gib dein Root-Passwort ein, wenn du dazu aufgefordert wirst.
$ sudo mysql -u root -p
Erstelle eine Beispieldatenbank.
mysql> CREATE DATABASE openemr;
Erstelle ein SQL-Benutzerkonto.
mysql> CREATE USER 'openemruser'@'localhost' IDENTIFIED BY 'Your_password2';
Erteile dem Benutzer alle Rechte für die Datenbank.
mysql> GRANT ALL PRIVILEGES ON openemr.* TO 'openemruser'@'localhost';
Lösche die Benutzerrechte.
mysql> FLUSH PRIVILEGES;
Beende die Shell.
mysql> exit
Schritt 5 – Installiere PHP und seine Erweiterungen
Wir müssen PHP 8.2 installieren, damit OpenEMR funktioniert. Der erste Schritt besteht darin, das Epel-Repository zu installieren.
$ 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 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 die erforderlichen Erweiterungen, die für OpenEMR benötigt werden.
$ sudo dnf install php-fpm php-mysql php-bcmath php-xml php-zip php-curl php-mbstring php-gd php-tidy php-intl php-cli php-soap ImageMagick php-ldap
Installiere die TIFF Tools-Bibliothek. Diese Bibliothek ist nicht im Basis-Repository verfügbar, sondern im CRB (ehemals Powertools) Repository.
$ sudo dnf install libtiff-tools --enablerepo=crb
Überprüfe die Installation.
$ php --version PHP 8.2.7 (cli) (built: Jun 6 2023 21:28:56) (NTS gcc x86_64) Copyright (c) The PHP Group Zend Engine v4.2.7, Copyright (c) Zend Technologies
Aktiviere und starte den PHP-FPM-Dienst.
$ sudo systemctl enable php-fpm --now
Schritt 6 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installiere den Snapd-Installer. Er benötigt das EPEL-Repository, das wir bereits für PHP installiert haben, also können wir diesen Schritt überspringen.
Installiere Snapd.
$ sudo dnf install -y snapd
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und stelle sicher, dass deine Snapd-Version 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
Gib den folgenden Befehl ein, um Certbot zu installieren.
$ sudo snap install --classic certbot
Stelle mit folgendem 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 die Installation.
$ certbot --version certbot 2.6.0
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 openemr.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/openemr.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-06-15 12:29:25 UTC 54min left Thu 2023-06-15 11:18:44 UTC 16min ago dnf-makecache.timer dnf-makecache.service Thu 2023-06-15 12:51:00 UTC 1h 15min left - - snap.certbot.renew.timer snap.certbot.renew.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 7 – OpenEMR herunterladen
Besuche die OpenEMR-Downloadseite und hole dir den Link für die neueste Version von OpenEMR. Lade OpenEMR auf den Server herunter.
$ wget https://sourceforge.net/projects/openemr/files/OpenEMR%20Current/7.0.1/openemr-7.0.1.tar.gz
Entpacke die Dateien.
$ tar -pxzf openemr-7.0.1.tar.gz
Verschiebe die entpackten Dateien in das Web-Root-Verzeichnis.
$ sudo mv openemr-7.0.1 /var/www/html/openemr
Erteile dem Nginx-Benutzer Rechte für das Web-Root-Verzeichnis.
$ sudo chown -R nginx:nginx /var/www/html/openemr
Schritt 8 – SELinux konfigurieren
Ändere den Dateisicherheitskontext für OpenEMR.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/openemr(/.*)?"
Wende die Richtlinie an.
$ sudo restorecon -Rv /var/www/html/openemr/
Wende die Richtlinie an, um Nginx den Zugriff auf MySQL zu erlauben.
$ 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
Schritt 8 – PHP-FPM konfigurieren
Ö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=www-data und group=www-data 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 und ;listen.mode=0660 in der Datei und ändere sie wie unten gezeigt.
; 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
Als nächstes kommentierst du die folgende Zeile aus, indem du ein Semikolon davor setzt.
;listen.acl_users = apache,nginx
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erhöhe die Ausführungszeit für PHP-FPM und PHP-CLI auf 60 Sekunden.
$ sudo sed -i 's/max_execution_time = 30/max_execution_time = 60/' /etc/php.ini
Setze den Wert der Variable max_input_time auf 1.
$ sudo sed -i 's/max_input_time = 60/max_input_time = -1/' /etc/php.ini
Erhöhe das Speicherlimit für PHP-FPM von 128 MB auf 512 MB.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php.ini
Erhöhe die Datei-Upload-Größe auf 30 MB.
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 30M/' /etc/php.ini $ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 30M/' /etc/php.ini
Erhöhe die Anzahl der maximalen Eingabevariablen auf 3000.
$ sudo sed -i 's/;max_input_vars = 1000/max_input_vars = 3000/g' /etc/php.ini
Erlaube aus PHP-Sicht den Zugriff auf lokale Dateien mit LOAD DATA-Anweisungen.
$ sudo sed -i 's/;mysqli.allow_local_infile = On/mysqli.allow_local_infile = On/g' /etc/php.ini
Starte den PHP-FPM-Dienst neu.
$ sudo systemctl restart php-fpm
Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Schritt 9 – Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/openemr.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/openemr.conf
Füge den folgenden Code in die Datei ein.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name openemr.example.com;
access_log /var/log/nginx/openemr.access.log;
error_log /var/log/nginx/openemr.error.log;
# SSL
ssl_certificate /etc/letsencrypt/live/openemr.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/openemr.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/openemr.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
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;
# use https://blog.cloudflare.com/announcing-1111 Cloudfare+Apnic labs, It is free and secure
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] valid=300s;
root /var/www/html/openemr;
index index.php;
location / {
try_files $uri $uri/ /index.php;
}
# Pass PHP Scripts To FastCGI Server
location ~* \.php$ {
try_files $uri =404;
fastcgi_index index.php;
fastcgi_pass unix:/run/php-fpm/www.sock; # Depends On The PHP Version
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT $realpath_root;
include fastcgi_params;
}
# deny access to writable files/directories
location ~* ^/sites/*/(documents|edi|era) {
deny all;
return 404;
}
# deny access to certain directories
location ~* ^/(contrib|tests) {
deny all;
return 404;
}
# Alternatively all access to these files can be denied
location ~* ^/(admin|setup|acl_setup|acl_upgrade|sl_convert|sql_upgrade|gacl/setup|ippf_upgrade|sql_patch)\.php {
deny all;
return 404;
}
location = /favicon.ico {
log_not_found off;
access_log off;
}
location = /robots.txt {
log_not_found off;
access_log off;
}
location ~ /\. {
deny all;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name openemr.example.com;
return 301 https://$host$request_uri;
}
Beachte, dass das Stammverzeichnis, das in der Nginx-Konfiguration verwendet werden soll, /var/www/html/openemr ist.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ö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.
Ü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.
$ sudo systemctl restart nginx
Schritt 10 – Installiere OpenEMR
Öffne die URL https://openemr.example.com in deinem Browser und du wirst den folgenden Einrichtungsbildschirm sehen.
Hier werden die Dateiberechtigungen geprüft und bestätigt, ob du mit Schritt 1 fortfahren kannst oder nicht. Wenn du das Wort ready in grüner Schrift siehst, bedeutet das, dass du fortfahren kannst. Klicke auf die blaue Schaltfläche, um mit Schritt 1 fortzufahren.
Auf der nächsten Seite wirst du gefragt, ob du möchtest, dass das Installationsprogramm die Datenbank erstellt oder eine vorgefertigte Datenbank verwendet. Wähle die Option Ich habe die Datenbank bereits erstellt und klicke auf die Schaltfläche, um zu Schritt 2 zu gelangen.
Auf der nächsten Seite gibst du die Zugangsdaten für die Datenbank ein, die du in Schritt 4 konfiguriert hast. Gib auch die Zugangsdaten für dein Administratorkonto ein. Achte darauf, dass dein Benutzername 12 oder mehr Zeichen lang ist, sonst bekommst du eine Fehlermeldung. Du kannst hier die Zwei-Faktor-Authentifizierung (2FA) aktivieren, aber es wird empfohlen, sie später nach der Installation zu konfigurieren. Klicke auf die Schaltfläche, um die Datenbank und das Benutzerkonto zu erstellen.
Auf der nächsten Seite wird der Installationsstatus angezeigt und du bekommst den Benutzernamen und das Passwort angezeigt. Klicke auf die Schaltfläche, um mit Schritt 4 fortzufahren.
Auf der nächsten Seite werden die empfohlenen und aktuellen Werte aus deiner php.ini Datei aufgelistet. Vergewissere dich, dass die aktuellen Werte den Anforderungen entsprechen. Das Installationsprogramm zeigt aus irgendeinem Grund die falschen Werte für die Variable max_execution_time an, auch wenn du sie richtig gesetzt hast. Das kannst du ignorieren. Du kannst die aktuellen Werte mit den folgenden Befehlen überprüfen.
Wenn du zufrieden bist, klicke auf die Schaltfläche, um mit Schritt 5 fortzufahren.
Im nächsten Schritt werden die Einstellungen für den Apache-Server aufgeführt, die wir ignorieren, da wir den Nginx-Server verwenden. Klicke auf die Schaltfläche, um zur nächsten Seite zu gelangen.
Hier wirst du aufgefordert, ein Thema für das Administrationspanel auszuwählen. Wähle die Option Aktuell halten und klicke auf die Schaltfläche, um fortzufahren. Du kannst das Thema später im Administrationsbereich ändern, allerdings kannst du dann nicht mehr sehen, wie es aussieht. Wenn du es auf der Installationsseite auswählst, kannst du vor der Auswahl auch sehen, wie es aussieht. Wir bleiben bei dem Standardthema.
Auf der letzten Seite findest du einige abschließende Hinweise zur Software und zu den Anmeldedaten für das Konto. Klicke auf die Schaltfläche Start, um die Anmeldeseite zu öffnen.
Du bekommst ein OpenEMR-Registrierungs-Popup, um Ankündigungen von deren Website zu erhalten. Du kannst es ignorieren, deine Anmeldedaten eingeben und auf die Schaltfläche Anmelden klicken, um auf das Dashboard zuzugreifen.
Wenn du die Zwei-Faktor-Authentifizierung während der Installation nicht konfiguriert hast, kannst du dies nachholen, indem du oben rechts auf das Avatar-Symbol klickst und die Option MFA Management auswählst.
Auf der nächsten Seite wählst du die Authentifizierungsmethode aus dem Dropdown-Menü aus und beginnst mit der Konfiguration.
Von nun an kannst du OpenEMR für die Verwaltung deines Gesundheitsunternehmens nutzen.
Fazit
Damit ist unser Tutorium zur Installation von OpenEMR auf einem Rocky Linux 9 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.