How To Install Elgg on Fedora 42

Elgg is a powerful open-source social networking engine that empowers organizations, educational institutions, and communities to build their own feature-rich social platforms. Written in PHP and utilizing a MySQL or MariaDB database backend, Elgg provides a flexible framework for creating online communities with blogs, file sharing, user profiles, groups, and activity streams. Whether you’re setting up a campus network, an organizational intranet, or a community platform, Elgg delivers enterprise-grade social networking capabilities with complete control over your data and infrastructure.

Fedora 42, with its cutting-edge package management and robust security features, serves as an excellent hosting environment for Elgg installations. This comprehensive tutorial walks you through every step of installing and configuring Elgg on Fedora 42, from initial system preparation to post-installation optimization. By following this guide, system administrators, web developers, and tech enthusiasts will have a fully functional social networking platform ready to accommodate hundreds or thousands of users.

The installation process typically takes 30-45 minutes and covers LAMP stack configuration, database setup, security hardening, SSL implementation, and performance optimization. Let’s dive into the complete installation process.

Prerequisites

Before beginning the Elgg installation on your Fedora 42 server, ensure you have the necessary system resources and access privileges. A successful deployment requires adequate hardware specifications and proper administrative credentials.

Your Fedora 42 server should have a minimum of 2GB RAM and 20GB disk space, though 4GB RAM is recommended for production environments handling significant user traffic. Root access or sudo privileges are essential for installing packages and configuring system services. Basic familiarity with Linux command-line operations will help you navigate through the installation steps efficiently.

Elgg has specific software requirements that we’ll install during this tutorial. The platform requires PHP 8.0 or higher with several mandatory extensions including GD for image processing, mbstring for multi-byte character handling, XML for parsing, JSON for data interchange, ZIP for archive management, and cURL for URL operations. You’ll also need either Apache or Nginx as your web server, along with MySQL 5.7+ or MariaDB 10.2+ for database management.

URL rewriting support is crucial for Elgg’s clean URL structure, which we’ll configure in Apache. An active internet connection is necessary for downloading packages and Elgg itself. The entire process should take approximately 30-45 minutes depending on your internet speed and server performance.

Step 1: Update Fedora System

Maintaining an updated system is fundamental for security and compatibility. Before installing any new software, refreshing your Fedora 42 package repositories ensures you’re working with the latest stable versions of all system components.

Log into your Fedora 42 server via SSH or direct console access. Execute the DNF package manager update command to refresh repository metadata and upgrade all installed packages:

sudo dnf update -y

DNF (Dandified YUM) is Fedora’s modern package manager, offering improved performance and dependency resolution compared to its predecessor. The -y flag automatically confirms all prompts, streamlining the update process. This command downloads and installs security patches, bug fixes, and feature updates across your entire system.

After the update completes, upgrade any remaining packages:

sudo dnf upgrade -y

If kernel updates were applied, reboot your system to ensure the new kernel loads properly:

sudo reboot

Verify your Fedora version after the system restarts:

cat /etc/fedora-release

This should confirm you’re running Fedora 42. System updates typically take 5-10 minutes depending on how many packages require updating.

Step 2: Install Apache Web Server

Apache HTTP Server is the world’s most popular web server software, powering millions of websites globally. It will serve as the foundation for hosting your Elgg installation.

Install Apache using DNF:

sudo dnf install httpd -y

This command downloads and installs Apache along with all required dependencies. Once installation completes, start the Apache service immediately:

sudo systemctl start httpd

Enable Apache to automatically start when your server boots:

sudo systemctl enable httpd

Verify that Apache is running correctly:

sudo systemctl status httpd

You should see an “active (running)” status in green text. Next, configure the firewall to allow HTTP and HTTPS traffic. Fedora uses firewalld for firewall management:

sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https

Reload the firewall configuration to apply changes:

sudo firewall-cmd --reload

Test your Apache installation by opening a web browser and navigating to your server’s IP address. You should see the default Fedora Apache test page, confirming successful installation. Find your server IP with:

ip addr show

Step 3: Install MariaDB Database Server

MariaDB serves as the relational database management system for storing all Elgg data, including user profiles, posts, relationships, and application settings. MariaDB is a drop-in replacement for MySQL, offering enhanced performance and additional features.

Install MariaDB server and client packages:

sudo dnf install mariadb-server mariadb -y

Start the MariaDB service:

sudo systemctl start mariadb

Enable MariaDB to launch automatically at system startup:

sudo systemctl enable mariadb

Check the service status:

sudo systemctl status mariadb

Now secure your MariaDB installation by running the security script:

sudo mysql_secure_installation

This interactive script guides you through critical security configurations. First, it asks about setting a root password. Press Enter if no current password exists, then type ‘Y’ to set a new root password. Choose a strong, complex password combining uppercase, lowercase, numbers, and special characters.

The script then prompts several security questions. Type ‘Y’ for each:

Remove anonymous users (prevents unauthorized access)
Disallow root login remotely (restricts root access to localhost only)
Remove test database and access (eliminates unnecessary database)
Reload privilege tables (applies changes immediately)

These security measures significantly harden your database server against common attack vectors. MariaDB is now ready to host the Elgg database.

Step 4: Install PHP and Required Extensions

PHP powers Elgg’s server-side functionality, handling everything from user authentication to content rendering. Elgg requires PHP 8.0 or higher along with numerous extensions for full functionality.

Install PHP and all necessary modules with a single comprehensive command:

sudo dnf install php php-mysqlnd php-gd php-mbstring php-xml php-json php-zip php-curl php-cli php-common php-intl php-ldap php-opcache -y

Let’s understand what each extension provides:

php-mysqlnd: MySQL Native Driver enables PHP to communicate with MariaDB databases efficiently. This is the primary database connectivity layer.

php-gd: Graphics Draw library processes images, including profile pictures, thumbnails, and user-uploaded media. Essential for visual content management.

php-mbstring: Multi-byte string handling supports international character sets, crucial for multilingual social platforms.

php-xml: XML parsing capabilities enable Elgg to process structured data formats and configuration files.

php-json: JSON encoding and decoding facilitates data exchange between client and server, especially for AJAX operations.

php-zip: Archive handling allows Elgg to compress and decompress files, useful for plugin management and backups.

php-curl: Client URL library enables Elgg to make HTTP requests to external services and APIs.

php-cli: Command-line interface allows Elgg to execute maintenance tasks and cron jobs from the terminal.

php-opcache: Opcode caching dramatically improves PHP performance by storing precompiled script bytecode in memory.

After installation completes, restart Apache to load the PHP module:

sudo systemctl restart httpd

Verify your PHP installation and version:

php -v

You should see PHP 8.0 or higher. Create a test file to confirm PHP integration with Apache:

echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Navigate to http://your-server-ip/info.php in your browser. You’ll see a detailed PHP information page displaying all installed modules and configuration settings. Remove this file after verification for security:

sudo rm /var/www/html/info.php

Step 5: Configure PHP Settings for Elgg

Elgg requires specific PHP configuration adjustments to handle file uploads, memory allocation, and execution parameters. Default PHP settings are often too restrictive for social networking applications.

Open the main PHP configuration file:

sudo nano /etc/php.ini

Locate and modify the following directives. Use Ctrl+W in nano to search for each setting:

upload_max_filesize: Controls the maximum size of uploaded files. Users will upload profile pictures, documents, and media files:

upload_max_filesize = 100M

post_max_size: Defines the maximum size of POST data PHP will accept. This should equal or exceed upload_max_filesize:

post_max_size = 100M

memory_limit: Sets the maximum amount of memory a script can consume. Social networking platforms perform complex operations requiring substantial memory:

memory_limit = 256M

max_execution_time: Specifies how long a script can run before terminating. Some Elgg operations like large exports need extended time:

max_execution_time = 300

date.timezone: Sets the server timezone. Replace with your actual timezone:

date.timezone = Asia/Jakarta

Find your timezone in the PHP timezone list. Common examples include America/New_York, Europe/London, or Asia/Tokyo.

Save changes (Ctrl+O, Enter, Ctrl+X in nano) and restart Apache:

sudo systemctl restart httpd

These adjustments ensure Elgg operates smoothly without encountering resource limitations during normal operation or peak usage periods.

Step 6: Create Database for Elgg

Elgg requires a dedicated database with an associated user account possessing full privileges. Proper database setup ensures data integrity and security.

Log into MariaDB as the root user:

mysql -u root -p

Enter the root password you created during the security configuration. You’ll see the MariaDB prompt.

Create a database named elgg_db:

CREATE DATABASE elgg_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

The utf8mb4 character set supports full Unicode including emojis and international characters, essential for modern social platforms.

Create a dedicated database user:

CREATE USER 'elgg_user'@'localhost' IDENTIFIED BY 'StrongPassword123!';

Replace StrongPassword123! with a robust password. Never use simple or dictionary words.

Grant all privileges on the Elgg database to this user:

GRANT ALL PRIVILEGES ON elgg_db.* TO 'elgg_user'@'localhost';

Flush privileges to ensure changes take effect immediately:

FLUSH PRIVILEGES;

Exit MariaDB:

EXIT;

Your database infrastructure is now ready. Record the database name, username, and password securely—you’ll need these during the Elgg web installation wizard.

Step 7: Download Elgg

Obtaining the latest stable Elgg release ensures you benefit from recent security patches, bug fixes, and feature enhancements. Always download from official sources.

Navigate to a temporary directory:

cd /tmp

Visit the official Elgg download page or GitHub releases to identify the latest version. As of this writing, download the current stable release using wget:

wget https://github.com/Elgg/Elgg/releases/download/6.3.1/elgg-6.3.1.zip

Verify the download completed successfully by checking the file size:

ls -lh elgg-6.3.1.zip

The file should be several megabytes in size. If using curl instead of wget, the command would be:

curl -LO https://github.com/Elgg/Elgg/releases/download/6.3.1/elgg-6.3.1.zip

The -L flag follows redirects, and -O saves the file with its original name. Keep this archive—we’ll extract it in the next step.

Step 8: Extract and Install Elgg Files

Properly positioning Elgg files within the web server document root and creating a secure data directory are crucial installation steps.

Install the unzip utility if not already present:

sudo dnf install unzip -y

Extract the Elgg archive:

unzip elgg-6.3.1.zip

This creates a directory like elgg-6.3.1 (version numbers vary). List the contents to verify:

ls -la

Move the extracted Elgg directory to Apache’s document root and rename it for clean URLs:

sudo mv elgg-* /var/www/html/elgg

Create a data directory outside the web root for security. Placing data files outside the publicly accessible web directory prevents direct unauthorized access:

sudo mkdir -p /var/www/elgg_data

This directory stores user uploads, cached files, and application data. Never place it within /var/www/html/ or any publicly accessible location.

Verify the directory structure:

ls -la /var/www/html/
ls -la /var/www/

You should see the elgg directory under /var/www/html/ and elgg_data under /var/www/.

Step 9: Set Permissions and Ownership

Correct file ownership and permissions prevent unauthorized access while allowing Apache to read and write necessary files.

Identify Apache’s user on Fedora (typically apache):

ps aux | grep httpd

The first column shows the user running Apache processes. Set ownership for the Elgg application directory:

sudo chown -R apache:apache /var/www/html/elgg

The -R flag applies changes recursively to all subdirectories and files.

Set ownership for the data directory:

sudo chown -R apache:apache /var/www/elgg_data

Configure appropriate permissions for the Elgg directory:

sudo chmod -R 755 /var/www/html/elgg

Permission 755 means:

Owner (apache): read, write, execute
Group (apache): read, execute
Others: read, execute

Set more restrictive permissions for the data directory:

sudo chmod -R 750 /var/www/elgg_data

Permission 750 restricts access:

Owner: read, write, execute
Group: read, execute
Others: no access

For enhanced security on the settings file (created later), use:

sudo chmod 640 /var/www/html/elgg/elgg-config/settings.php

These permission schemas balance functionality with security, preventing unauthorized modifications while enabling proper application operation.

Step 10: Configure Apache Virtual Host

A virtual host configuration defines how Apache serves your Elgg installation, enabling clean URLs and proper directory access controls.

Create a new virtual host configuration file:

sudo nano /etc/httpd/conf.d/elgg.conf

Add the following comprehensive configuration:

<VirtualHost *:80>
    ServerAdmin admin@yourdomain.com
    ServerName yourdomain.com
    ServerAlias www.yourdomain.com
    DocumentRoot /var/www/html/elgg

    <Directory /var/www/html/elgg>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog /var/log/httpd/elgg_error.log
    CustomLog /var/log/httpd/elgg_access.log combined
</VirtualHost>

Configuration breakdown:

ServerAdmin: Contact email for server administrator
ServerName: Primary domain name
ServerAlias: Alternative domain names (www variant)
DocumentRoot: Location of Elgg files
Options -Indexes: Prevents directory listing
Options +FollowSymLinks: Allows symbolic links
AllowOverride All: Enables .htaccess functionality for URL rewriting
Require all granted: Allows public access
ErrorLog: Error message log location
CustomLog: Access log location

Replace yourdomain.com with your actual domain name or server IP address for testing.

Save and close the file. Test Apache configuration syntax:

sudo apachectl configtest

You should see “Syntax OK”. If errors appear, review the configuration file for typos.

Restart Apache to apply changes:

sudo systemctl restart httpd

Your web server now properly serves Elgg with clean URLs and appropriate security settings.

Step 11: Complete Elgg Web Installation

The web-based installer guides you through final configuration steps, connecting Elgg to your database and establishing initial site settings.

Open your web browser and navigate to:

http://yourdomain.com/elgg

Or using your server IP:

http://your-server-ip/elgg

The Elgg installation wizard launches automatically. The first screen performs a requirements check, verifying that all necessary PHP extensions are installed and configured correctly. Green checkmarks indicate passed requirements; red X marks signal missing components.

If any requirements fail, return to the relevant installation steps to address missing dependencies. Common issues include missing PHP extensions or incorrect file permissions.

Once all requirements pass, click “Next” to proceed to database configuration. Enter the database connection details:

Database Type: MySQL
Database Server: localhost
Database Name: elgg_db
Database Username: elgg_user
Database Password: Your chosen database password
Database Prefix: elgg_ (optional, useful for multiple installations)

Click “Next” to test the database connection. Elgg creates the necessary database tables automatically.

The site settings page appears next. Configure:

Site Name: Choose a descriptive name for your social network
Site Description: Brief description of your platform’s purpose
Site Email: Email address for system notifications
Site URL: Your domain or IP address (auto-detected)
Data Directory: /var/www/elgg_data

Ensure the data directory path exactly matches what you created earlier.

The final step creates your administrator account:

Display Name: Your name
Username: Admin username (avoid “admin” for security)
Email: Your email address
Password: Strong administrator password

Click “Install” to complete the process. Elgg creates the database schema, configures initial settings, and prepares your social networking platform. This takes 30-60 seconds.

Upon successful installation, you’re redirected to your new Elgg site’s homepage. Log in with your administrator credentials to access the admin dashboard.

Step 12: Configure Cron Jobs

Cron jobs automate essential maintenance tasks including sending email notifications, rotating logs, cleaning temporary files, and executing scheduled operations. Elgg requires properly configured cron jobs for optimal functionality.

Elgg provides multiple cron intervals: minute, fiveminute, fifteenmin, halfhour, hourly, daily, weekly, monthly, and yearly. Each interval handles different types of tasks based on urgency and resource requirements.

Modern Elgg installations use the elgg-cli command-line tool for cron execution. Edit your crontab:

crontab -e

Add the following line for comprehensive cron coverage:

* * * * * /usr/bin/php /var/www/html/elgg/elgg-cli cron -q

This executes Elgg’s cron system every minute. The -q flag operates in quiet mode, suppressing output.

For granular control over specific intervals, add individual entries:

*/5 * * * * /usr/bin/php /var/www/html/elgg/elgg-cli cron -i fiveminute -q
0 * * * * /usr/bin/php /var/www/html/elgg/elgg-cli cron -i hourly -q
0 0 * * * /usr/bin/php /var/www/html/elgg/elgg-cli cron -i daily -q

The cron syntax format is:

* * * * * command
│ │ │ │ │
│ │ │ │ └─── Day of week (0-7, Sunday = 0 or 7)
│ │ │ └───── Month (1-12)
│ │ └─────── Day of month (1-31)
│ └───────── Hour (0-23)
└─────────── Minute (0-59)

Save and exit the crontab editor. Verify cron jobs are scheduled:

crontab -l

Monitor cron execution in Elgg’s admin panel under Administration > Utilities > Cron. This page displays last execution times for each interval and allows manual triggering for testing purposes.

Properly configured cron jobs ensure your social network sends timely notifications, maintains optimal performance, and executes background maintenance automatically.

Step 13: Post-Installation Security Configuration

Hardening your Elgg installation against common security threats requires several additional configuration steps beyond the basic installation.

Remove the installer directory immediately—this prevents unauthorized reinstallation attempts:

sudo rm -rf /var/www/html/elgg/install

If SELinux is enabled on your Fedora server (check with sestatus), configure appropriate security contexts:

sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/elgg_data(/.*)?"
sudo restorecon -Rv /var/www/elgg_data

These commands allow Apache to write to the data directory while maintaining SELinux protection.

Secure the settings file with restrictive permissions:

sudo chmod 640 /var/www/html/elgg/elgg-config/settings.php

Disable directory listing in Apache (already configured in the virtual host, but verify):

sudo nano /etc/httpd/conf/httpd.conf

Ensure all <Directory> blocks include Options -Indexes.

Implement fail2ban to protect against brute-force login attempts:

sudo dnf install fail2ban -y
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Create a custom fail2ban filter for Elgg by adding rules that monitor authentication failures in Apache logs.

Configure session security in PHP by editing /etc/php.ini:

session.cookie_httponly = 1
session.cookie_secure = 1
session.use_strict_mode = 1

The first directive prevents JavaScript access to cookies, mitigating XSS attacks. The second ensures cookies only transmit over HTTPS (configure after SSL setup). The third prevents session fixation attacks.

Establish regular backup procedures for both database and files:

# Database backup
mysqldump -u root -p elgg_db > /backup/elgg_db_$(date +%Y%m%d).sql

# File backup
tar -czf /backup/elgg_files_$(date +%Y%m%d).tar.gz /var/www/html/elgg /var/www/elgg_data

Schedule these commands in cron for automated daily backups.

Step 14: Install SSL Certificate

HTTPS encryption is essential for social networking platforms handling sensitive user data, passwords, and private communications. Let’s Encrypt provides free SSL certificates with automated renewal.

Install Certbot and the Apache plugin:

sudo dnf install certbot python3-certbot-apache -y

Run Certbot to obtain and install your certificate:

sudo certbot --apache

Certbot launches an interactive wizard. Respond to the prompts:

Enter your email address for renewal notifications and security alerts
Agree to the Terms of Service by typing ‘Y’
Choose whether to share your email with EFF (optional)
Select which domains to secure (choose your ServerName from the list)
Choose whether to redirect all HTTP traffic to HTTPS (recommended—select option 2)

Certbot automatically:

Obtains the SSL certificate from Let’s Encrypt
Configures Apache with SSL settings
Creates a new virtual host on port 443
Sets up automatic certificate renewal

Test the SSL certificate:

sudo certbot renew --dry-run

This simulates the renewal process without actually renewing the certificate. A successful dry run confirms automatic renewal will work.

Let’s Encrypt certificates expire after 90 days. Certbot installs a systemd timer that automatically renews certificates before expiration:

sudo systemctl list-timers | grep certbot

Verify your SSL installation by visiting your site via HTTPS:

https://yourdomain.com/elgg

Check the padlock icon in your browser’s address bar. Click it to view certificate details and confirm proper installation.

Update Elgg’s site URL in the admin panel to use HTTPS:

Log into Elgg as administrator
Navigate to Administration > Settings > Basic Settings
Update the Site URL to https://yourdomain.com/elgg
Save changes

Your social network now encrypts all data transmission between users and your server, protecting sensitive information from interception.

Step 15: Initial Elgg Configuration

Customize your new Elgg installation through the admin dashboard to tailor the platform to your community’s needs.

Log into your Elgg site using your administrator credentials. Click your profile icon and select “Administration” to access the admin panel.

Basic Settings: Navigate to Administration > Settings > Basic Settings to configure fundamental site parameters:

Site name and description
Default language (Elgg supports 40+ languages)
Default access level for new content
Time format preferences
Site timezone

Email Configuration: Under Administration > Settings > Email, configure how Elgg sends notifications:

Email FROM address
Email FROM name
Email transport method (typically PHP mail function or SMTP)

For production sites, configure SMTP for reliable email delivery. This requires an SMTP server, username, and password.

User Registration: Administration > Settings > Registration controls how users join your platform:

Enable or disable public registration
Require email validation
Set default user roles
Configure CAPTCHA for spam prevention

Privacy Settings: Administration > Settings > Security & Privacy establishes privacy defaults:

Default content visibility (public, logged-in users, friends only)
User indexing by search engines
Require HTTPS connections
Password strength requirements

Plugin Management: Administration > Configure > Plugins displays all available Elgg plugins. Enable essential plugins like:

Activity streams
Blog
Bookmarks
File repository
Groups
Messages
User profiles

Disable unused plugins to improve performance.

Theme Customization: Administration > Configure > Appearance allows visual customization:

Select or upload themes
Customize colors and logos
Configure navigation menus
Set default profile widgets

Cache Configuration: Administration > Configure > Advanced Settings includes cache management options:

System cache (enabled by default)
Simple cache (enabled by default)
Cache location

Proper caching dramatically improves page load times.

Explore all admin sections to fully understand configuration options. Tailor settings to match your community’s specific requirements and security policies.

Verifying the Installation

Comprehensive testing ensures your Elgg installation functions correctly before launching to users.

Basic Accessibility: Open your site in multiple browsers (Chrome, Firefox, Safari, Edge) to verify cross-browser compatibility. Test both desktop and mobile views.

User Registration: Create a test user account through the normal registration process. Verify that:

Registration form submits successfully
Confirmation email arrives (check spam folders)
Email validation link works
New account can log in

Content Creation: Test core functionality:

Create a blog post with text and images
Upload a profile picture
Update profile information
Create a group
Post an activity update
Upload a file to the file repository

Email Notifications: Trigger notification events:

Post to another user’s activity stream
Send a direct message
Invite someone to a group
Comment on content

Verify that email notifications arrive promptly with correct formatting and functional links.

Cron Job Verification: Check the Cron page (Administration > Utilities > Cron) to confirm all intervals show recent execution times. Green timestamps indicate successful cron runs.

Error Log Review: Examine Apache error logs for issues:

sudo tail -f /var/log/httpd/error_log

Watch the log while performing various site actions. Address any PHP warnings or errors that appear.

Database Connectivity: Verify database operations by creating, editing, and deleting content. All actions should complete without errors.

Performance Testing: Use browser developer tools to check page load times. Initial loads should complete within 2-3 seconds on a properly configured server. Subsequent page loads benefit from caching and should be under 1 second.

Mobile Responsiveness: Test the site on actual mobile devices or using browser responsive design modes. Navigation, content creation, and all features should work smoothly on smartphones and tablets.

Document any issues encountered during testing for troubleshooting.

Troubleshooting Common Issues

Even with careful installation, you may encounter problems. Here are solutions to frequent issues:

Database Connection Failed: This error during installation usually indicates incorrect database credentials. Verify:

Database name matches exactly (case-sensitive)
Username and password are correct
MariaDB is running: sudo systemctl status mariadb
User has proper privileges: log into MariaDB and run SHOW GRANTS FOR 'elgg_user'@'localhost';

Permission Denied Errors: File permission issues prevent Apache from reading or writing files. Fix ownership:

sudo chown -R apache:apache /var/www/html/elgg
sudo chown -R apache:apache /var/www/elgg_data

Verify Apache user:

ps aux | grep httpd

White Screen or 500 Internal Server Error: These generic errors require log investigation. Check Apache logs:

sudo tail -100 /var/log/httpd/error_log

Common causes include:

PHP syntax errors in configuration files
Memory limit exceeded (increase in php.ini)
Missing PHP extensions
.htaccess issues

Enable PHP error display temporarily:

echo "display_errors = On" | sudo tee -a /etc/php.ini
sudo systemctl restart httpd

Apache Configuration Errors: Test configuration syntax after changes:

sudo apachectl configtest

Fix any syntax errors before restarting Apache.

Missing PHP Extensions: If the installer reports missing extensions, install them:

sudo dnf install php-extension-name -y
sudo systemctl restart httpd

Upload Size Limit Errors: Users reporting upload failures need increased limits in php.ini:

sudo nano /etc/php.ini
# Increase upload_max_filesize and post_max_size
sudo systemctl restart httpd

Cron Jobs Not Executing: Verify crontab entries:

crontab -l

Check cron logs:

sudo tail -f /var/log/cron

Ensure the PHP path is correct:

which php

SELinux Blocking Operations: Check SELinux denials:

sudo ausearch -m avc -ts recent

Adjust SELinux contexts as needed:

sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/elgg_data(/.*)?"
sudo restorecon -Rv /var/www/elgg_data

Memory Limit Exceeded: Increase PHP memory in php.ini to 512M or higher for large installations.

When troubleshooting, work systematically: identify the error, check relevant logs, implement fixes, and test thoroughly.

Performance Optimization Tips

Optimizing your Elgg installation ensures fast page loads and smooth user experiences, even under heavy traffic.

Enable PHP OPcache: OPcache stores precompiled PHP code in memory, eliminating repeated compilation. Edit php.ini:

sudo nano /etc/php.d/10-opcache.ini

Ensure these directives:

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

Restart Apache after changes.

Database Query Optimization: Install the MySQL slow query log to identify performance bottlenecks:

sudo nano /etc/my.cnf.d/mariadb-server.cnf

Add under [mysqld]:

slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2

Review slow queries periodically and optimize with proper indexing.

Configure Memcached: Memory caching dramatically improves performance by storing database query results in RAM. Install Memcached:

sudo dnf install memcached php-pecl-memcached -y
sudo systemctl enable memcached
sudo systemctl start memcached

Configure Elgg to use Memcached in Administration > Configure > Advanced Settings.

Apache Performance Tuning: Optimize Apache for better concurrent connection handling. Edit:

sudo nano /etc/httpd/conf.modules.d/00-mpm.conf

Uncomment and configure the prefork MPM:

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

Implement PHP-FPM: PHP-FPM (FastCGI Process Manager) provides better resource management than mod_php:

sudo dnf install php-fpm -y
sudo systemctl enable php-fpm
sudo systemctl start php-fpm

Configure Apache to use PHP-FPM instead of mod_php for improved performance and security.

CDN Integration: Offload static assets (images, CSS, JavaScript) to a Content Delivery Network. This reduces server load and improves global access speeds.

Database Indexing: Ensure critical database tables have proper indexes. Monitor the slow query log and add indexes to frequently queried columns.

Regular Cache Clearing: Schedule automatic cache clearing in Elgg admin or via cron to prevent stale data accumulation.

Server Resource Monitoring: Use monitoring tools to track:

CPU usage
Memory consumption
Disk I/O
Network bandwidth

Tools like htop, netdata, or Nagios provide real-time insights. Address resource bottlenecks proactively before they impact users.

Implement these optimizations incrementally, testing performance after each change. Use tools like Google PageSpeed Insights or GTmetrix to measure improvements.

Congratulations! You have successfully installed Elgg. Thanks for using this tutorial for installing the Elgg Social Networking Platform on your Fedora 42 Linux system. For additional help or useful information, we recommend you check the official Elgg website.

VPS Manage Service Offer

If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal!