How To Install OpenEMR on Ubuntu 24.04 LTS

In this tutorial, we will show you how to install OpenEMR on Ubuntu 24.04 LTS. OpenEMR stands as a powerful open-source electronic health record and medical practice management solution designed for healthcare providers of all sizes. With robust features including patient demographics tracking, appointment scheduling, electronic medical records, prescription management, billing capabilities, and comprehensive reporting tools, OpenEMR offers a complete solution for modern healthcare practices. In this detailed guide, we’ll walk through the complete process of installing OpenEMR on Ubuntu 24.04 LTS, providing you with clear instructions to set up this valuable healthcare management system.

Understanding OpenEMR

OpenEMR represents one of the most widely-used open-source electronic health record (EHR) systems globally, serving thousands of medical practices and healthcare facilities. This comprehensive platform includes everything needed to manage a modern healthcare practice efficiently.

OpenEMR’s core features include patient record management, which allows clinicians to document patient encounters, record vitals, and manage medical histories. The scheduling system enables efficient appointment booking and management. The integrated billing module streamlines financial operations with insurance claim submission capabilities. Comprehensive reporting tools help practice managers analyze operational and clinical data effectively.

What sets OpenEMR apart from proprietary systems is its adaptability. Healthcare organizations can customize the platform to match their specific workflows and requirements without expensive licensing fees. The software complies with healthcare standards including HIPAA, making it suitable for regulated healthcare environments.

OpenEMR benefits from an active global community providing ongoing development, security updates, and multilingual support, currently available in over 30 languages. This community-driven approach ensures the platform continues evolving to meet healthcare providers’ changing needs.

Prerequisites for Installation

Before beginning the OpenEMR installation process, ensure your system meets these requirements to prevent potential issues:

Hardware Requirements:

• CPU: 2 cores minimum (4+ cores recommended for busy practices)
• RAM: 4GB minimum (8GB+ recommended)
• Storage: 20GB minimum free space (SSD storage highly recommended)
• Network: Stable internet connection for updates and remote access

Software Requirements:

• Ubuntu 24.04 LTS fresh installation
• LAMP stack components (Linux, Apache, MySQL/MariaDB, PHP)
• PHP 8.1 or higher with specific extensions
• MySQL 5.7+ or MariaDB 10.3+
• SSH access to your server

Domain Configuration:

• Valid domain name (if creating a public-facing installation)
• DNS properly configured to point to your server

Security Considerations:

• Basic firewall configuration
• Regular backup solution
• SSL certificate for secure connections
• Separate user account with sudo privileges

While OpenEMR can run on minimal hardware, performance will significantly improve with better specifications, especially when serving multiple simultaneous users. For production environments, consider implementing redundancy and backup solutions to ensure data integrity and availability.

Preparing Your Ubuntu 24.04 LTS Environment

Proper preparation of your Ubuntu environment is crucial for a smooth OpenEMR installation. Follow these steps to create an optimized foundation for your healthcare system:

First, ensure your system packages are completely up-to-date by executing:

sudo apt update
sudo apt upgrade -y

Next, install essential utilities that will facilitate the installation process:

sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

For security purposes, create a dedicated user account rather than running everything as root:

sudo adduser openemr_admin
sudo usermod -aG sudo openemr_admin

Configure your server’s firewall to permit only necessary connections:

sudo ufw allow OpenSSH
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
sudo ufw status

Ensure your system time is accurately synchronized to prevent issues with scheduled tasks and appointment management:

sudo apt install ntp
sudo systemctl start ntp
sudo systemctl enable ntp

Finally, set the correct timezone for your server to match your practice’s location:

sudo timedatectl set-timezone your_timezone

Replace “your_timezone” with your actual timezone (e.g., America/New_York or Europe/London). A properly prepared environment will significantly reduce installation problems and improve system security and reliability.

Installing and Configuring the Web Server

Apache serves as the recommended web server for OpenEMR, providing reliable performance and extensive documentation. Follow these steps to install and configure Apache for optimal OpenEMR functionality:

Install Apache web server using apt:

sudo apt install apache2 -y

Verify the installation was successful:

sudo systemctl status apache2

You should see an “active (running)” status. Now, enable Apache to start automatically at boot:

sudo systemctl enable apache2

Create a dedicated virtual host configuration for OpenEMR by creating a new configuration file:

sudo nano /etc/apache2/sites-available/openemr.conf

Add the following configuration, replacing “your_domain.com” with your actual domain name:

<VirtualHost *:80>
    ServerAdmin webmaster@your_domain.com
    ServerName your_domain.com
    ServerAlias www.your_domain.com
    DocumentRoot /var/www/html/openemr
    
    <Directory /var/www/html/openemr>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
    
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Enable the site configuration and the required Apache modules:

sudo a2ensite openemr.conf
sudo a2enmod rewrite
sudo a2enmod headers
sudo systemctl restart apache2

For performance optimization, adjust Apache’s configuration to better handle OpenEMR’s requirements:

sudo nano /etc/apache2/mods-available/mpm_prefork.conf

Update the settings to match these values (adjust based on your server’s resources):

<IfModule mpm_prefork_module>
    StartServers             5
    MinSpareServers          5
    MaxSpareServers         10
    MaxRequestWorkers       150
    MaxConnectionsPerChild   0
</IfModule>

Finally, restart Apache to apply all changes:

sudo systemctl restart apache2

With these configurations in place, your web server is now optimized to host OpenEMR securely and efficiently.

Setting Up the Database

OpenEMR requires a properly configured database to store patient records, scheduling information, and system data. MariaDB serves as an excellent choice for OpenEMR installations due to its performance and compatibility:

Install MariaDB server using apt:

sudo apt install mariadb-server -y

Secure the MariaDB installation:

sudo mysql_secure_installation

During this process:

• Skip setting root password when prompted (Ubuntu uses the auth_socket plugin by default)
• Answer ‘Y’ to remove anonymous users
• Answer ‘Y’ to disallow root login remotely
• Answer ‘Y’ to remove test database
• Answer ‘Y’ to reload privilege tables

Next, create a dedicated database and user for OpenEMR:

sudo mysql -u root

At the MariaDB prompt, execute these commands:

CREATE DATABASE openemr CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'openemruser'@'localhost' IDENTIFIED BY 'your_strong_password';
GRANT ALL PRIVILEGES ON openemr.* TO 'openemruser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Be sure to replace “your_strong_password” with an actual strong password.

For optimal database performance with OpenEMR, modify the MariaDB configuration:

sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf

Add or modify these settings under the [mysqld] section:

[mysqld]
innodb_buffer_pool_size = 1G
innodb_log_file_size = 256M
max_allowed_packet = 64M
tmp_table_size = 64M
max_heap_table_size = 64M

Restart MariaDB to apply the changes:

sudo systemctl restart mariadb

These configurations create an optimized database environment specifically tailored for OpenEMR’s requirements. The database optimization will significantly improve system performance, especially when handling larger patient databases or during peak usage periods.

Installing PHP and Required Extensions

PHP serves as the foundation for OpenEMR’s functionality, making proper configuration essential. Ubuntu 24.04 includes PHP packages in its repositories, but OpenEMR requires specific versions and extensions:

First, install PHP and the core extensions required by OpenEMR:

sudo apt install php php-cli php-fpm php-mysql php-json php-opcache php-mbstring php-xml php-gd php-curl php-zip php-soap php-ldap php-imap -y

Verify the installed PHP version meets OpenEMR’s requirements:

php -v

OpenEMR requires PHP 8.1 or higher. If your installed version is lower, you may need to add a repository for newer PHP versions:

sudo add-apt-repository ppa:ondrej/php -y
sudo apt update

Then install the specific PHP version:

sudo apt install php8.2 php8.2-cli php8.2-fpm php8.2-mysql php8.2-json php8.2-opcache php8.2-mbstring php8.2-xml php8.2-gd php8.2-curl php8.2-zip php8.2-soap php8.2-ldap php8.2-imap -y

Optimize PHP for OpenEMR by creating a custom configuration file:

sudo nano /etc/php/8.2/apache2/conf.d/20-openemr.ini

Add these optimization settings:

memory_limit = 256M
max_execution_time = 60
max_input_time = 90
post_max_size = 30M
upload_max_filesize = 30M
session.gc_maxlifetime = 3600
date.timezone = Your/Timezone

Remember to replace “Your/Timezone” with your actual timezone.

Restart Apache to load the new PHP configuration:

sudo systemctl restart apache2

Proper PHP configuration is crucial for OpenEMR’s stability and performance. These settings provide an optimal balance between performance and resource usage while ensuring all necessary functionality is available to the application.

Implementing SSL/TLS Security

Securing healthcare data transmission is essential for HIPAA compliance and patient privacy. Implementing SSL/TLS encryption for your OpenEMR installation helps protect sensitive information:

First, install Certbot, a tool that automates the process of obtaining and renewing Let’s Encrypt SSL certificates:

sudo apt install certbot python3-certbot-apache -y

Obtain an SSL certificate for your domain:

sudo certbot --apache -d your_domain.com -d www.your_domain.com

Follow the prompts to complete the certificate acquisition process. Certbot will automatically configure Apache to use the new certificate.

Verify the renewal process works correctly:

sudo certbot renew --dry-run

For additional security, implement strict transport security headers by editing your Apache configuration:

sudo nano /etc/apache2/sites-available/openemr-le-ssl.conf

Add these lines inside the VirtualHost block:

Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains"
Header always set X-Content-Type-Options "nosniff"
Header always set X-XSS-Protection "1; mode=block"
Header always set X-Frame-Options "SAMEORIGIN"

Restart Apache to apply the changes:

sudo systemctl restart apache2

These security measures ensure that all data transmitted between users and your OpenEMR server remains encrypted and protected. The SSL certificate implementation is particularly important for healthcare applications handling protected health information (PHI) under HIPAA regulations.

Downloading and Preparing OpenEMR

Now that your server environment is ready, it’s time to download and prepare the OpenEMR application files:

First, navigate to the web server’s document root directory:

cd /var/www/html

Download the latest stable version of OpenEMR using wget:

sudo wget https://sourceforge.net/projects/openemr/files/OpenEMR%20Current/7.0.2/openemr-7.0.2.tar.gz

Verify the integrity of the downloaded file by checking its checksum (replace with the current checksum):

md5sum openemr-7.0.2.tar.gz

Extract the downloaded archive:

sudo tar -xvzf openemr-7.0.2.tar.gz

Rename the extracted directory to “openemr” for easier access:

sudo mv openemr-7.0.2 openemr

Set the correct ownership and permissions for the OpenEMR files:

sudo chown -R www-data:www-data /var/www/html/openemr
sudo chmod 666 /var/www/html/openemr/sites/default/sqlconf.php
sudo chmod 666 /var/www/html/openemr/interface/modules/zend_modules/config/application.config.php

Create and set permissions for required directories:

sudo chmod -R 755 /var/www/html/openemr/sites/default/documents
sudo chmod -R 755 /var/www/html/openemr/sites/default/edi
sudo chmod -R 755 /var/www/html/openemr/sites/default/era
sudo chmod -R 755 /var/www/html/openemr/sites/default/letter_templates
sudo chmod -R 755 /var/www/html/openemr/interface/main/calendar/modules/PostCalendar/pntemplates/cache
sudo chmod -R 755 /var/www/html/openemr/interface/main/calendar/modules/PostCalendar/pntemplates/compiled
sudo chmod -R 755 /var/www/html/openemr/gacl/admin/templates_c

Clean up the downloaded archive file:

sudo rm openemr-7.0.2.tar.gz

These steps prepare the OpenEMR application files with the correct permissions, ensuring the web-based installer can run properly in the next stage of the installation process.

Configuring Nginx for OpenEMR

While Apache is the most common web server for OpenEMR installations, Nginx provides better performance for high-traffic deployments. If you prefer Nginx, follow these steps instead of the Apache configuration:

First, remove Apache if it’s already installed:

sudo apt remove apache2 -y

Install Nginx and PHP-FPM:

sudo apt install nginx php-fpm -y

Create a server block configuration for OpenEMR:

sudo nano /etc/nginx/sites-available/openemr

Add the following configuration, replacing “your_domain.com” with your actual domain:

server {
    listen 80;
    server_name your_domain.com www.your_domain.com;
    root /var/www/html/openemr;
    index index.php index.html;

    client_max_body_size 32M;

    access_log /var/log/nginx/openemr.access.log;
    error_log /var/log/nginx/openemr.error.log;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\.ht {
        deny all;
    }
}

Enable the configuration by creating a symbolic link:

sudo ln -s /etc/nginx/sites-available/openemr /etc/nginx/sites-enabled/

Test the Nginx configuration for syntax errors:

sudo nginx -t

If the test is successful, restart Nginx:

sudo systemctl restart nginx

For SSL configuration with Nginx, install Certbot’s Nginx plugin:

sudo apt install python3-certbot-nginx -y
sudo certbot --nginx -d your_domain.com -d www.your_domain.com

Optimize Nginx performance by editing its configuration:

sudo nano /etc/nginx/nginx.conf

Update the worker processes and connections based on your server’s CPU cores:

worker_processes auto;
events {
    worker_connections 1024;
    multi_accept on;
}

These Nginx configurations provide excellent performance for OpenEMR, especially in environments with many concurrent users. The configuration includes proper PHP handling and optimized settings for healthcare application workloads.

Running the OpenEMR Web Installer

With all components properly configured, you’re now ready to complete the OpenEMR installation through its web-based installer:

Open your web browser and navigate to your domain (https://your_domain.com) or server IP address (https://your_server_ip).

You’ll be greeted by the OpenEMR setup screen:

1. The first screen checks file and directory permissions. If all permissions are correctly set, you’ll see “Ready” indicators in green. Click “Proceed to Step 1” to continue.
2. On the “Step 1” screen, select “I have already created the database” since we’ve already set up the MariaDB database. Click “Proceed to Step 2.”
3. For “Step 2,” enter the database connection information:
   • Server Host: localhost
   • Server Port: 3306
   • Database Name: openemr
   • Login Name: openemruser
   • Password: [your database password]

   Also, create your initial administrator account:

   • Initial User: admin
   • Password: [create a strong password]

   Click “Create DB and User” to proceed.

4. The installer will create necessary database tables and configure the system. This may take a few minutes.
5. On the “Step 3” screen, you’ll see the installation status. Once complete, the page will display your username and password. Make sure to save this information securely.
6. In the “Step 4” screen, review the PHP configuration. Some settings might show as incorrect (like max_input_time and max_execution_time), but you can ignore these as we’ve already set them in the PHP configuration.
7. Click on “Proceed to OpenEMR” to access your new installation.

The first time you access OpenEMR, you’ll have the option to register for important announcements, including security updates. It’s highly recommended to register to stay informed about critical updates.

Post-Installation Security Hardening

After successfully installing OpenEMR, implementing additional security measures is essential for protecting sensitive healthcare data:

Implement IP Restrictions

If your OpenEMR instance will only be accessed from specific locations, restrict access to those IP addresses:

For Apache:

sudo nano /etc/apache2/sites-available/openemr-le-ssl.conf

Add within the VirtualHost block:

<Location />
    Require ip 192.168.1.0/24
    Require ip 10.0.0.0/8
    # Add other trusted IP ranges
</Location>

For Nginx:

sudo nano /etc/nginx/sites-available/openemr

Add within the server block:

location / {
    allow 192.168.1.0/24;
    allow 10.0.0.0/8;
    # Add other trusted IP ranges
    deny all;
    try_files $uri $uri/ /index.php?$args;
}

Set Up Fail2ban to Prevent Brute Force Attacks

sudo apt install fail2ban -y
sudo nano /etc/fail2ban/jail.local

Add the following configuration:

[openemr]
enabled = true
port = http,https
filter = openemr
logpath = /var/log/auth.log
maxretry = 5
findtime = 600
bantime = 3600

Create a custom filter:

sudo nano /etc/fail2ban/filter.d/openemr.conf

Add:

[Definition]
failregex = ^.*Login failure.*from IP: <HOST>.*$
ignoreregex =

Restart fail2ban:

sudo systemctl restart fail2ban

Secure File Permissions

Tighten file permissions after installation:

sudo find /var/www/html/openemr -type d -exec chmod 750 {} \;
sudo find /var/www/html/openemr -type f -exec chmod 640 {} \;

Maintain appropriate permissions on specific directories:

sudo chmod 770 -R /var/www/html/openemr/sites/default/documents
sudo chmod 770 -R /var/www/html/openemr/sites/default/edi
sudo chmod 770 -R /var/www/html/openemr/sites/default/era

Enable Regular Updates

Create a script for automated updates:

sudo nano /usr/local/bin/update-system.sh

Add:

#!/bin/bash
apt update
apt upgrade -y

Make it executable and add to crontab:

sudo chmod +x /usr/local/bin/update-system.sh
sudo crontab -e

Add this line to run weekly:

0 2 * * 0 /usr/local/bin/update-system.sh > /var/log/update-system.log 2>&1

These security measures significantly reduce the risk of unauthorized access to your OpenEMR installation while maintaining functionality for legitimate users.

Optimizing OpenEMR Performance

A properly optimized OpenEMR installation provides better user experience and more efficient workflow for healthcare providers. Implement these optimization techniques to enhance performance:

PHP Optimization

Adjust PHP opcache settings for improved performance:

sudo nano /etc/php/8.2/apache2/conf.d/10-opcache.ini

Add or modify these settings:

opcache.enable=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=4000
opcache.revalidate_freq=60
opcache.fast_shutdown=1

Database Optimization

Fine-tune MySQL/MariaDB for better performance:

sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf

Add or adjust these settings in the [mysqld] section:

query_cache_size = 32M
query_cache_limit = 2M
join_buffer_size = 4M
tmp_table_size = 64M
max_heap_table_size = 64M

Implement Redis for Session Caching

Install Redis for faster session handling:

sudo apt install redis-server php-redis -y
sudo systemctl enable redis-server

Configure PHP to use Redis for session storage:

sudo nano /etc/php/8.2/apache2/conf.d/30-redis-sessions.ini

Add:

session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379"

Web Server Compression

Enable compression to reduce bandwidth and improve load times:

For Apache:

sudo nano /etc/apache2/mods-available/deflate.conf

Add:

AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/json
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/javascript
AddOutputFilterByType DEFLATE text/plain

For Nginx:

gzip on;
gzip_comp_level 5;
gzip_min_length 256;
gzip_proxied any;
gzip_types application/javascript application/json text/css text/html text/javascript text/plain;

Restart web and PHP services to apply changes:

sudo systemctl restart apache2 mariadb redis-server
sudo systemctl restart php8.2-fpm

These optimization techniques will significantly improve OpenEMR’s responsiveness, particularly for practices with multiple concurrent users or larger patient databases.

Backup and Recovery Planning

Implementing a robust backup strategy is critical for healthcare data protection. Follow these steps to create an effective backup system for your OpenEMR installation:

Create an Automated Database Backup Script

sudo nano /usr/local/bin/backup-openemr-db.sh

Add the following content:

#!/bin/bash

# Set variables
BACKUP_DIR="/var/backups/openemr/database"
DATE=$(date +"%Y-%m-%d_%H-%M-%S")
MYSQL_USER="openemruser"
MYSQL_PASSWORD="your_database_password"
DB_NAME="openemr"
BACKUP_RETENTION=14 # days

# Create backup directory if it doesn't exist
mkdir -p $BACKUP_DIR

# Perform database backup
mysqldump --user=$MYSQL_USER --password=$MYSQL_PASSWORD --opt $DB_NAME | gzip > $BACKUP_DIR/openemr_db_$DATE.sql.gz

# Delete backups older than retention period
find $BACKUP_DIR -type f -name "openemr_db_*.sql.gz" -mtime +$BACKUP_RETENTION -delete

Make the script executable:

sudo chmod +x /usr/local/bin/backup-openemr-db.sh

Create a File System Backup Script

sudo nano /usr/local/bin/backup-openemr-files.sh

Add the following content:

#!/bin/bash

# Set variables
BACKUP_DIR="/var/backups/openemr/files"
DATE=$(date +"%Y-%m-%d_%H-%M-%S")
OPENEMR_DIR="/var/www/html/openemr"
BACKUP_RETENTION=14 # days

# Create backup directory if it doesn't exist
mkdir -p $BACKUP_DIR

# Perform file backup
tar -czf $BACKUP_DIR/openemr_files_$DATE.tar.gz $OPENEMR_DIR

# Delete backups older than retention period
find $BACKUP_DIR -type f -name "openemr_files_*.tar.gz" -mtime +$BACKUP_RETENTION -delete

Make the script executable:

sudo chmod +x /usr/local/bin/backup-openemr-files.sh

Schedule Regular Backups with Cron

sudo crontab -e

Add these lines to run daily backups:

# Database backup daily at 1 AM
0 1 * * * /usr/local/bin/backup-openemr-db.sh > /var/log/openemr-db-backup.log 2>&1

# File backup daily at 2 AM
0 2 * * * /usr/local/bin/backup-openemr-files.sh > /var/log/openemr-files-backup.log 2>&1

Test Backup and Restore Procedures

Regularly test your backup restoration process:

# Test database restore
gunzip -c /var/backups/openemr/database/openemr_db_YYYY-MM-DD_HH-MM-SS.sql.gz | mysql -u openemruser -p openemr_test

# Test file restore
mkdir -p /var/www/html/openemr_test
tar -xzf /var/backups/openemr/files/openemr_files_YYYY-MM-DD_HH-MM-SS.tar.gz -C /var/www/html/openemr_test

For additional protection, consider implementing an off-site backup solution by adding scripts to transfer backups to a remote server or cloud storage service. Regular testing of the restore process is essential to ensure your backup strategy will be effective when needed.

Troubleshooting Common Issues

Even with careful installation, issues may arise when setting up OpenEMR. Here are solutions to common problems:

Database Connection Failures

If you encounter “Cannot connect to the MySQL database” errors:

1. Verify the database service is running:

   sudo systemctl status mariadb

2. Check database credentials in the configuration file:

   sudo nano /var/www/html/openemr/sites/default/sqlconf.php

3. Test database connectivity manually:

   mysql -u openemruser -p openemr

4. Reset database permissions if needed:

   sudo mysql -u root
   GRANT ALL PRIVILEGES ON openemr.* TO 'openemruser'@'localhost';
   FLUSH PRIVILEGES;
   EXIT;

Blank Pages After Installation

If you see blank pages after installation:

1. Check for PHP errors in the log:

   sudo tail -f /var/log/apache2/error.log

2. Verify PHP extensions are installed:

   php -m | grep -E 'mysql|mbstring|xml|gd|curl|zip|soap'

3. Install any missing extensions:

   sudo apt install php-mbstring php-xml php-gd php-curl php-zip php-soap -y
   sudo systemctl restart apache2

4. Check file permissions:

   sudo chown -R www-data:www-data /var/www/html/openemr
   sudo chmod 755 /var/www/html/openemr

SSL/TLS Certificate Issues

If encountering SSL certificate problems:

1. Verify certificate status:

   sudo certbot certificates

2. Renew certificates if needed:

   sudo certbot renew --force-renewal

3. Check Apache SSL configuration:

   sudo apachectl -t

Permission-Related Problems

For file permission issues:

1. Reset critical directory permissions:

   sudo chmod 755 /var/www/html/openemr/sites/default/documents
   sudo chmod 755 /var/www/html/openemr/sites/default/edi
   sudo chmod 755 /var/www/html/openemr/sites/default/era
   sudo chmod 666 /var/www/html/openemr/sites/default/sqlconf.php

2. Verify ownership:

   sudo chown -R www-data:www-data /var/www/html/openemr

These troubleshooting steps address the most common issues encountered during OpenEMR installation and initial configuration. If problems persist, consult the OpenEMR community forums or documentation for more specific guidance.

Congratulations! You have successfully installed OpenEMR. Thanks for using this tutorial for installing OpenEMR medical office workflow software on Ubuntu 24.04 LTS system. For additional help or useful information, we recommend you check the official OpenEMR website.