Complete Ubuntu Server Setup 2026 – Modern LAMP Stack Installation Guide

Updated: November 2026
Tutorial Level: Beginner to Intermediate
Server Type: Ubuntu Linux Server
Technology: Linux, Apache, MySQL, PHP, phpMyAdmin

1. Introduction: Why Do We Need a LAMP Server?

If you want to host a PHP website, WordPress application, business management software, custom PHP project or database-driven web application, you need a web server environment.

One of the most popular solutions for this purpose is the LAMP Stack.

LAMP is an abbreviation for four technologies:

Technology	Full Name	Main Purpose
L	Linux	Server operating system
A	Apache	Web server
M	MySQL	Database management
P	PHP	Server-side programming language

These four technologies work together to deliver dynamic websites and web applications.

For example, when a visitor opens your website, Apache receives the HTTP request, PHP processes the application logic, MySQL retrieves the required information, and Apache sends the generated HTML response to the visitor’s browser.

The result is a complete web application environment.

However, server technology has changed significantly over the years. Older tutorials often recommend PHP 7.4, outdated installation methods and unrestricted file permissions. Those instructions should not be copied directly into a modern production server.

This guide uses the current Ubuntu 26.04 LTS release and its PHP 8.5 package series as the main installation baseline.

We will configure:

Ubuntu Server 26.04 LTS.
Apache HTTP Server 2.4.
PHP 8.5 and commonly required PHP extensions.
MySQL Server from Ubuntu repositories.
phpMyAdmin for browser-based database management.
Apache Virtual Hosts for domain-based hosting.
UFW firewall for network protection.
Let’s Encrypt SSL certificates through Certbot.
Proper Linux file ownership and permissions.
Basic production server security.

Important: Ubuntu 26.04 LTS is the recommended baseline for a new installation in this tutorial. If you already operate Ubuntu 24.04 LTS, do not blindly replace your existing operating system or PHP version. Check application compatibility before upgrading.

Official Ubuntu release information: https://documentation.ubuntu.com/release-notes/26.04/

2. Understanding the Server Requirements

Before installing anything, make sure your server has sufficient resources.

Recommended hardware

Component	Minimum for testing	Recommended for a small production website
CPU	1 vCPU	2 vCPU or more
RAM	1 GB	2–4 GB or more
Storage	20 GB SSD	40 GB SSD or more
Network	Internet connection	Stable public network
Operating System	Ubuntu Server	Ubuntu 26.04 LTS

These are practical planning recommendations, not mandatory Ubuntu requirements. Actual resources depend on website traffic, database size, PHP applications and background processes.

Important software versions

For this tutorial, the baseline is:

Ubuntu: 26.04 LTS.
PHP: 8.5.
Apache: Ubuntu-supported Apache 2.4 package.
MySQL: Ubuntu-supported MySQL Server package.
phpMyAdmin: Stable release available through the official Ubuntu package repository.

PHP 8.5 is an actively supported PHP branch. PHP 7.4 is no longer supported, so it should not be selected for a new internet-facing application.

PHP version support reference:

https://www.php.net/supported-versions.php

3. Connect to Your Ubuntu Server

First, connect to your server.

If you have a local Ubuntu machine, open Terminal.

If you have a remote VPS, connect through SSH:

ssh username@YOUR_SERVER_IP

Replace username with your actual Linux username and YOUR_SERVER_IP with your server’s public IP address.

For example:

ssh ubuntu@192.0.2.10

The IP address above is only an example.

After connecting, check the operating system:

lsb_release -a

Check the Linux kernel:

uname -r

Check available disk space:

df -h

Check memory:

free -h

These commands help you understand the current server environment before making changes.

Important: Do not work as the root user for every operation. Use a normal administrator account with sudo. This reduces the risk of accidentally damaging important system files.

4. Update and Upgrade Ubuntu Packages

The first installation step is updating Ubuntu’s package information.

Run:

sudo apt update

This command downloads the latest available package information from the configured Ubuntu repositories.

Next, upgrade installed packages:

sudo apt upgrade -y

Remove unnecessary packages:

sudo apt autoremove --purge -y

Clean the package cache:

sudo apt clean

Check whether a reboot is required:

if [ -f /var/run/reboot-required ]; then
    echo "System reboot required"
else
    echo "No reboot required"
fi

If a reboot is required, schedule it when it is safe to interrupt your server:

sudo reboot

After rebooting, reconnect using SSH.

Why is this important?

Server software receives security updates regularly. An outdated operating system can contain known vulnerabilities. Updating the system before installing the web stack gives you a cleaner and safer starting point.

Official reference:

https://ubuntu.com/server/docs

5. Install Apache Web Server

Apache HTTP Server is responsible for receiving browser requests and delivering website content.

Install Apache:

sudo apt install apache2 -y

Enable Apache to start automatically when Ubuntu boots:

sudo systemctl enable apache2

Start the Apache service:

sudo systemctl start apache2

Check its current status:

sudo systemctl status apache2

You should see:

Active: active (running)

This means Apache is running successfully.

Check the installed Apache version:

apache2 -v

Test Apache in your browser

Open your browser and enter:

http://YOUR_SERVER_IP

If Apache is working correctly, you should see the default Apache welcome page.

The default website directory is:

/var/www/html/

The default Apache configuration directory is:

/etc/apache2/

Apache’s main configuration file is:

/etc/apache2/apache2.conf

Useful Apache commands

Restart Apache:

sudo systemctl restart apache2

Reload configuration without a full service restart:

sudo systemctl reload apache2

Stop Apache:

sudo systemctl stop apache2

Start Apache:

sudo systemctl start apache2

Check configuration syntax:

sudo apache2ctl configtest

Expected result:

Syntax OK

Official Apache documentation:

https://httpd.apache.org/docs/2.4

6. Install MySQL Database Server

MySQL is a relational database management system. It stores application data in structured tables.

For example, a WordPress website uses MySQL-compatible database storage for posts, pages, users, settings and other information.

Install MySQL:

sudo apt install mysql-server -y

Enable automatic startup:

sudo systemctl enable mysql

Start the database service:

sudo systemctl start mysql

Check the service:

sudo systemctl status mysql

Check the MySQL version:

mysql --version

Open the MySQL administrative console

On a standard Ubuntu MySQL installation, the local administrative account commonly uses Unix socket authentication.

Therefore, use:

sudo mysql

You should now see the MySQL prompt:

mysql>

To exit:

EXIT;

Basic MySQL security

Run the security configuration utility:

sudo mysql_secure_installation

Follow the prompts carefully.

Depending on the installed MySQL version and authentication configuration, the available questions may differ.

Recommended security decisions include:

Remove anonymous database accounts.
Disable remote root login.
Remove the test database if it is not needed.
Reload privilege information.
Keep administrative access restricted.

Do not assume that the MySQL root account needs a password-based login. Ubuntu installations commonly use socket authentication for local administrative access.

Official MySQL documentation:

https://dev.mysql.com/doc/refman/8.4/en/installing.html

Ubuntu MySQL installation guide:

https://ubuntu.com/server/docs/databases-mysql

7. Install PHP 8.5 and Required Extensions

PHP is the programming language responsible for processing dynamic website content.

For example, a PHP application can receive a login request, validate the submitted information, communicate with MySQL and generate a response.

Ubuntu 26.04 provides PHP 8.5 packages.

Install PHP and the Apache PHP integration:

sudo apt install php libapache2-mod-php php-cli -y

Now install commonly required PHP extensions:

sudo apt install php-common php-mysql php-curl php-gd php-mbstring php-xml php-zip php-intl php-bcmath php-soap php-opcache php-readline php-imagick -y

These extensions provide additional functionality.

Extension	Purpose
php-mysql	Connect PHP applications to MySQL
php-curl	Send and receive HTTP requests
php-gd	Image processing
php-mbstring	Multibyte text processing
php-xml	XML processing
php-zip	ZIP archive handling
php-intl	Internationalization
php-bcmath	High-precision mathematical calculations
php-soap	SOAP web services
php-opcache	Improves PHP execution performance
php-imagick	Advanced image processing

Some applications require additional extensions. Always check the application’s official installation requirements before adding unnecessary packages.

Check the PHP version

Run:

php -v

You should see a PHP 8.5 version if the default PHP package is installed successfully.

Check loaded extensions:

php -m

Check PHP configuration:

php --ini

Verify Apache PHP integration

Create a temporary PHP test file:

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

Add:

<?php
phpinfo();

Save the file.

Restart Apache:

sudo systemctl restart apache2

Open:

http://YOUR_SERVER_IP/info.php

You should see the PHP information page.

Security warning: Delete this file immediately after testing.

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

A public phpinfo page can expose sensitive configuration details, installed extensions and server information.

Official PHP installation guidance:

https://ubuntu.com/server/docs/how-to-install-and-configure-php

Official PHP documentation:

https://www.php.net/manual/en

8. Install phpMyAdmin

phpMyAdmin is a browser-based database administration application.

Instead of entering every SQL command manually, administrators can use its graphical interface to:

Create databases.
Create database tables.
Insert and edit records.
Execute SQL queries.
Import and export SQL files.
Manage database users.
Inspect database structures.

For this installation, use the stable phpMyAdmin package supplied by Ubuntu’s configured repositories.

First, check package availability:

apt-cache policy phpmyadmin

If the package is available, install it:

sudo apt install phpmyadmin -y

During installation, follow the package configuration prompts.

If a web server selection screen appears, select:

apache2

Use the Space key to select an option if required, then press Enter.

If the installer asks whether to configure a database for phpMyAdmin using dbconfig-common, follow the package instructions and provide a strong password where required.

The exact prompts can vary between package versions.

Install additional PHP dependencies if they are not already present:

sudo apt install php-mbstring php-zip php-gd php-curl php-xml php-mysql -y

Enable the required Apache PHP modules where necessary:

sudo phpenmod mbstring

Restart Apache:

sudo systemctl restart apache2

Open phpMyAdmin

Visit:

http://YOUR_SERVER_IP/phpmyadmin

If the installation and Apache configuration were successful, the phpMyAdmin login page should appear.

Important: Do not assume that every installation requires manually adding an Include directive to apache2.conf. The Ubuntu package normally handles its Apache configuration. Check the actual configuration before adding anything manually.

Check whether the configuration file exists:

ls -l /etc/phpmyadmin/apache.conf

Check enabled Apache configuration:

ls -l /etc/apache2/conf-enabled/

If the package did not enable the configuration automatically, inspect the package’s installation instructions and enable the supplied configuration using:

sudo a2enconf phpmyadmin

Then test and reload Apache:

sudo apache2ctl configtest
sudo systemctl reload apache2

Official phpMyAdmin download and documentation

Stable releases:

https://www.phpmyadmin.net/downloads

Documentation:

https://docs.phpmyadmin.net/en/latest

As of November 2026, phpMyAdmin 5.2.3 is the latest listed stable release on its official download page. Development snapshots should not be confused with stable production releases.

9. Create a Secure MySQL Database and User

One of the biggest mistakes in older server tutorials is giving a normal website user unrestricted access to every database.

For example, this old command is dangerous for ordinary application accounts:

GRANT ALL PRIVILEGES ON *.* TO 'spwuser'@'localhost';

It grants global privileges rather than limiting the account to its own application database.

A better approach is to create a separate database and user for each application.

Step 1: Open MySQL

sudo mysql

Step 2: Create a database

CREATE DATABASE speedlink3_db
CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;

Step 3: Create a database user

CREATE USER 'speedlink3_user'@'localhost'
IDENTIFIED BY 'REPLACE_WITH_A_STRONG_UNIQUE_PASSWORD';

Replace the example password with a long, unique password. Do not publish your actual password in a tutorial, source-code repository or screenshot.

Step 4: Grant access to the specific database

GRANT ALL PRIVILEGES ON speedlink3_db.*
TO 'speedlink3_user'@'localhost';

Step 5: Verify the permissions

SHOW GRANTS FOR 'speedlink3_user'@'localhost';

Step 6: Exit MySQL

EXIT;

Now the application user can manage its own database without receiving unrestricted access to all databases on the server.

For production applications, grant only the permissions that the application actually requires. For example, a read-only reporting account should not receive write privileges.

Security note: Never use the MySQL root account inside a public website’s PHP configuration.

10. Configure Apache mod_rewrite

The Apache mod_rewrite module allows websites to rewrite or redirect URLs.

It is useful for:

WordPress permalinks.
PHP MVC frameworks.
Custom routing systems.
Search-engine-friendly URLs.
Redirecting old website URLs.

Enable the module:

sudo a2enmod rewrite

Check whether it is enabled:

apache2ctl -M | grep rewrite

Expected output:

rewrite_module (shared)

Configure AllowOverride correctly

The older approach changes:

AllowOverride None

to:

AllowOverride All

This can work, but enabling every type of override across the entire web directory is broader than necessary.

For a simple application that specifically requires .htaccess rewriting, configure its own VirtualHost directory:

<Directory /var/www/example.com/public>
    Options -Indexes +FollowSymLinks
    AllowOverride FileInfo
    Require all granted
</Directory>

If the application requires additional .htaccess directives, adjust the permitted override categories based on its documented requirements.

Alternatively, configure rewrite rules directly inside the VirtualHost configuration. This avoids relying on .htaccess for every request.

Apache mod_rewrite reference:

https://httpd.apache.org/docs/2.4/mod/mod_rewrite.html

11. Configure Proper Website Directory Permissions

This is one of the most important differences between an old tutorial and a modern secure server.

Older tutorials often recommend:

chmod -R 777 /var/www/html

Never use this as a normal production setup.

Permission 777 gives every local user and process read, write and execute access to those files and directories. If a website is compromised, unrestricted permissions can make the damage much worse.

Instead, use appropriate ownership and permissions.

For example, create a separate website directory:

sudo mkdir -p /var/www/example.com/public

Set the administrator as the owner and Apache’s group as the group:

sudo chown -R "$USER":www-data /var/www/example.com

Set directory permissions:

sudo find /var/www/example.com -type d -exec chmod 755 {} \;

Set file permissions:

sudo find /var/www/example.com -type f -exec chmod 644 {} \;

Apache can now read the website files without giving everyone write access.

What if an application needs writable directories?

Some PHP applications need writable upload, cache, session or storage directories.

Create only the required writable directory and assign its permissions deliberately.

Example:

sudo mkdir -p /var/www/example.com/storage
sudo chown -R www-data:www-data /var/www/example.com/storage
sudo chmod -R 750 /var/www/example.com/storage

Use the application’s official deployment instructions to determine which directories need write access.

Do not make the entire website writable just because one upload directory needs write access.

12. Configure Apache Virtual Hosts

Virtual Hosts allow a single Apache server to host multiple websites.

For example:

example.com
website2.com
business.example.com

Each domain can have its own website directory and Apache configuration.

Create the website directory:

sudo mkdir -p /var/www/example.com/public

Create a test homepage:

sudo nano /var/www/example.com/public/index.php

Insert:

<?php
echo "Welcome to the 2026 Ubuntu LAMP Server!";

Save the file.

Now create a VirtualHost configuration:

sudo nano /etc/apache2/sites-available/example.com.conf

Add the following configuration:

<VirtualHost *:80>

    ServerName example.com
    ServerAlias www.example.com

    DocumentRoot /var/www/example.com/public

    <Directory /var/www/example.com/public>
        Options -Indexes +FollowSymLinks
        AllowOverride FileInfo
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/example-error.log
    CustomLog ${APACHE_LOG_DIR}/example-access.log combined

</VirtualHost>

Replace example.com with your actual domain.

Enable the website:

sudo a2ensite example.com.conf

Disable the default website if it is no longer required:

sudo a2dissite 000-default.conf

Check the Apache configuration:

sudo apache2ctl configtest

If the result is:

Syntax OK

Reload Apache:

sudo systemctl reload apache2

Before the website becomes publicly accessible, configure the domain’s DNS A record to point to the server’s public IPv4 address. Configure an AAAA record only if the server has working IPv6 connectivity.

You can now visit:

http://example.com

Your website should display the PHP test message.

13. Configure UFW Firewall

A web server should not expose unnecessary network ports.

Ubuntu provides UFW (Uncomplicated Firewall), a simple firewall management utility.

Install it if required:

sudo apt install ufw -y

Before enabling the firewall on a remote server, allow SSH access:

sudo ufw allow OpenSSH

Allow HTTP:

sudo ufw allow 80/tcp

Allow HTTPS:

sudo ufw allow 443/tcp

Enable UFW:

sudo ufw enable

Check firewall status:

sudo ufw status verbose

You should see rules allowing SSH, HTTP and HTTPS.

Why should MySQL port 3306 remain closed publicly?

A standard LAMP application running on the same server can connect to MySQL through localhost.

Therefore, you generally do not need to expose port 3306 to the public internet.

Do not run:

sudo ufw allow 3306

unless you have a specific remote database requirement and have properly restricted access to trusted IP addresses.

Official Ubuntu firewall documentation:

https://ubuntu.com/server/docs/firewalls

14. Configure Free SSL Certificate Using Let’s Encrypt

HTTPS protects information transferred between the visitor’s browser and your web server.

A website using HTTPS can protect login credentials, form submissions and other transmitted data from ordinary network interception.

Let’s Encrypt provides free TLS certificates.

Certbot helps obtain and configure these certificates automatically.

First, install Certbot:

sudo snap install --classic certbot

Make the Certbot command available:

sudo ln -s /snap/bin/certbot /usr/local/bin/certbot

Make sure your domain points to your server and that the required HTTP/HTTPS ports are reachable.

Now request and install the certificate:

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

Follow the instructions displayed in the terminal.

After successful installation, visit:

https://example.com

Test automatic certificate renewal

Run:

sudo certbot renew --dry-run

This tests the renewal process without replacing a live certificate.

Remember that a valid domain, correct DNS configuration and reachable validation path are necessary for successful certificate issuance.

Official references:

https://certbot.eff.org/instructions

https://ubuntu.com/server/docs/how-to/security/obtain-tls-certificates

15. Configure PHP for Production

A default PHP installation is not automatically optimized for every production application.

PHP configuration is stored in different files depending on how PHP is executed.

For Apache’s PHP module, the configuration file is normally:

/etc/php/8.5/apache2/php.ini

Open it:

sudo nano /etc/php/8.5/apache2/php.ini

Some useful production settings are:

display_errors = Off
log_errors = On
expose_php = Off

file_uploads = On

upload_max_filesize = 32M
post_max_size = 40M

max_execution_time = 60
max_input_time = 60
memory_limit = 256M

date.timezone = Asia/Dhaka

These are example starting values, not universal requirements. Adjust upload size, execution time and memory according to your application and server resources.

Why disable display_errors?

When PHP displays errors publicly, visitors may see internal file paths, database-related information or other implementation details.

It is safer to log errors and inspect them through server logs.

Restart Apache after editing the configuration:

sudo systemctl restart apache2

Check PHP’s effective configuration:

php -i | grep "memory_limit"

Remember that the CLI PHP configuration and Apache PHP configuration may be different.

To inspect the CLI configuration:

php --ini

To inspect the Apache configuration, use the PHP information page temporarily and remove it immediately afterward.

16. Enable Automatic Security Updates

A production server needs regular maintenance.

Ubuntu provides unattended-upgrades for automatically installing selected security updates.

Install it:

sudo apt install unattended-upgrades -y

Enable automatic updates:

sudo dpkg-reconfigure unattended-upgrades

Follow the displayed configuration prompts.

Check its service or timer:

systemctl status unattended-upgrades

Automatic updates do not replace monitoring, backups, application testing or planned maintenance.

For business-critical systems, test updates in a staging environment before applying major changes to production.

Official security reference:

https://ubuntu.com/server/docs/how-to/security

17. Useful Server Monitoring Commands

Once the LAMP stack is installed, you should regularly check its services.

Check Apache

sudo systemctl status apache2

Check MySQL

sudo systemctl status mysql

Check PHP

php -v

Check Apache configuration

sudo apache2ctl configtest

Check enabled Apache modules

apache2ctl -M

Check listening ports

sudo ss -tulpn

Check disk usage

df -h

Check memory usage

free -h

Check running processes

top

Check Apache error logs

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

Check Apache access logs

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

Check MySQL logs

sudo journalctl -u mysql -n 100 --no-pager

These commands are useful when diagnosing website errors, database connection failures, permission problems and server performance issues.

18. Common LAMP Server Problems and Solutions

Problem 1: Apache is not starting

Check the configuration:

sudo apache2ctl configtest

Check service logs:

sudo journalctl -u apache2 -n 100 --no-pager

A configuration error or port conflict may prevent Apache from starting.

Problem 2: PHP code is displayed as plain text

This usually means PHP is not correctly integrated with Apache.

Check installed PHP packages:

dpkg -l | grep -E 'php|libapache2-mod-php'

Check Apache modules:

apache2ctl -M | grep php

Restart Apache after correcting the installation.

Never leave a publicly accessible PHP configuration or test file containing sensitive information.

Problem 3: MySQL connection refused

Check the MySQL service:

sudo systemctl status mysql

Check whether MySQL is listening locally:

sudo ss -lntp | grep 3306

Verify the application’s database name, username, password and host.

For a database installed on the same machine, use:

localhost

or the appropriate local socket configuration supported by your application.

Problem 4: Permission denied

Check ownership:

ls -la /var/www/example.com/

Check permissions:

namei -l /var/www/example.com/public/index.php

Correct the affected directory’s ownership and permissions instead of using chmod 777.

Problem 5: phpMyAdmin returns 404 Not Found

Check whether phpMyAdmin is installed:

dpkg -l | grep phpmyadmin

Check its Apache configuration:

ls -l /etc/apache2/conf-enabled/

If the package configuration exists but is not enabled:

sudo a2enconf phpmyadmin
sudo apache2ctl configtest
sudo systemctl reload apache2

19. Final LAMP Server Verification Checklist

Before hosting a live website, verify every important component.

Component	Verification command	Expected result
Ubuntu	`lsb_release -a`	Ubuntu 26.04 LTS
Apache	`apache2 -v`	Apache 2.4
PHP	`php -v`	PHP 8.5
MySQL	`mysql --version`	Installed MySQL version
Apache service	`systemctl status apache2`	Active
MySQL service	`systemctl status mysql`	Active
PHP extensions	`php -m`	Required modules listed
Rewrite module	`apache2ctl -M`	rewrite_module
Firewall	`sudo ufw status`	Intended rules active
SSL	`sudo certbot certificates`	Valid certificate
Apache configuration	`sudo apache2ctl configtest`	Syntax OK

Your modern LAMP environment is ready when these checks pass and your website is accessible through its configured domain.

20. Important Production Security Recommendations

Installing Apache, MySQL and PHP is only the beginning of server administration.

A production server also needs a security and maintenance strategy.

Follow these recommendations:

Use a non-root Linux administrator account with sudo access.
Use strong, unique passwords for database users.
Never grant unrestricted global database privileges to normal website accounts.
Never use chmod -R 777 on website directories.
Keep MySQL accessible only through localhost unless remote access is genuinely required.
Use HTTPS for all public websites.
Keep Ubuntu, Apache, PHP and database packages updated.
Back up website files and databases regularly.
Test database restoration instead of assuming backups are valid.
Remove temporary test files such as info.php.
Protect phpMyAdmin with additional access restrictions, such as VPN or trusted IP allowlisting.
Monitor Apache and MySQL logs.
Use application-specific writable directories instead of making the whole website writable.
Test application compatibility before upgrading PHP major versions.
Use a staging environment for important production changes.

A secure server is not created by installing more software. It is created by controlling access, maintaining software, monitoring activity and following correct permission practices.

Conclusion

Ubuntu 26.04 LTS provides a modern foundation for building PHP-based websites and business applications.

With Apache, PHP 8.5, MySQL, phpMyAdmin, Virtual Hosts, UFW and Let’s Encrypt, you can build a complete web hosting environment without relying on an expensive commercial control panel.

This setup is suitable as a foundation for:

WordPress websites.
Custom PHP applications.
PHP and MySQL business management systems.
ERP and CRM applications.
Educational websites.
Database-driven portals.
Development and testing environments.

However, remember that a successful installation does not automatically mean a production-ready server. Security, backups, monitoring and application compatibility must remain part of your regular server administration routine.

Build it correctly. Secure it properly. Maintain it continuously.

Official Web References and Documentation

All references below point to official project or vendor documentation.

Technology	Official Reference
Ubuntu 26.04 LTS	https://documentation.ubuntu.com/release-notes/26.04/
Ubuntu Server Documentation	https://ubuntu.com/server/docs/
Apache HTTP Server 2.4	https://httpd.apache.org/docs/2.4/
Apache mod_rewrite	https://httpd.apache.org/docs/2.4/mod/mod_rewrite.html
PHP Official Website	https://www.php.net/
PHP Supported Versions	https://www.php.net/supported-versions.php
Ubuntu PHP Installation	https://ubuntu.com/server/docs/how-to-install-and-configure-php/
MySQL 8.4 Documentation	https://dev.mysql.com/doc/refman/8.4/en/
Ubuntu MySQL Installation	https://ubuntu.com/server/docs/databases-mysql/
phpMyAdmin Downloads	https://www.phpmyadmin.net/downloads/
phpMyAdmin Documentation	https://docs.phpmyadmin.net/en/latest/
Ubuntu Firewall Guide	https://ubuntu.com/server/docs/firewalls/
Ubuntu Security Guide	https://ubuntu.com/server/docs/how-to/security/
Let’s Encrypt	https://letsencrypt.org/
Certbot Instructions	https://certbot.eff.org/instructions

Article update note: Software versions and package availability can change. Always check the official documentation and your Ubuntu repository before installing or upgrading a production server.