How to Install PHP 8 on Debian Server: A Step-by-Step Guide

For web developers and system administrators, keeping up with the latest software versions is crucial for performance, security, and access to new features. PHP 8, the latest major version of the popular scripting language, offers significant improvements over its predecessors. This guide provides a comprehensive walkthrough on how to install PHP 8 on a Debian server, focusing on integrating it with Apache web server. We will cover both mod_php and the preferred php-fpm methods to equip you with the knowledge to choose the best setup for your needs.

Choosing the Right PHP Installation Method: mod_php vs. PHP-FPM

When it comes to integrating PHP with Apache, two primary methods stand out: mod_php and php-fpm.

mod_php: This method installs PHP as an Apache module. It’s simpler to configure initially, as PHP becomes a part of the Apache process itself. However, this tight integration can lead to performance issues and instability, especially under high load, as PHP processes share Apache’s resources.
PHP-FPM (FastCGI Process Manager): PHP-FPM runs as a separate process, independent of Apache. This separation offers significant advantages in terms of performance, stability, and resource management. PHP-FPM excels in handling high traffic websites and provides more control over process management, making it the recommended method for production environments.

While mod_php might seem easier for basic setups, php-fpm is generally preferred for its robustness and efficiency. This guide will primarily focus on php-fpm installation, while also providing steps for mod_php for those who require it.

Installing PHP 8 with PHP-FPM on Debian

While the original article mentioned PHP-FPM as “TBD”, we will provide a standard approach to installing PHP 8 with PHP-FPM on Debian. This method leverages Debian’s package manager for a straightforward installation.

Update Package Lists: Begin by updating your Debian server’s package lists to ensure you have the latest package information. Open your terminal and execute:
```
sudo apt update
```
Install PHP 8.0 and PHP-FPM: Install PHP 8.0 and the PHP-FPM package along with common PHP extensions.
```
sudo apt install php8.0 php8.0-fpm php8.0-common php8.0-mysql php8.0-xml php8.0-cli
```
This command installs:
- php8.0: The core PHP 8.0 package.
- php8.0-fpm: The PHP-FPM process manager for PHP 8.0.
- php8.0-common: Common files for PHP 8.0.
- php8.0-mysql: PHP extension for MySQL database interaction.
- php8.0-xml: PHP extension for XML manipulation.
- php8.0-cli: PHP command-line interface.
You can customize the list of extensions based on your application’s requirements.
Configure PHP-FPM for Apache: PHP-FPM needs to be configured to work with Apache. Debian systems usually handle this configuration automatically. PHP-FPM configuration files are typically located in /etc/php/8.0/fpm/pool.d/. The default pool configuration www.conf is generally sufficient for most setups.
Configure Apache to Use PHP-FPM: Enable the Apache proxy module and PHP-FPM integration by enabling the proxy_fcgi and setenvif modules, and configuring Apache to pass PHP requests to PHP-FPM. You can use the following command to enable necessary apache modules:
```
sudo a2enmod proxy_fcgi setenvif
sudo a2enconf php8.0-fpm
```
This command does the following:
- a2enmod proxy_fcgi setenvif: Enables the proxy_fcgi and setenvif Apache modules, which are necessary for proxying requests to PHP-FPM.
- a2enconf php8.0-fpm: Enables the PHP-FPM configuration for PHP 8.0, which sets up Apache to handle PHP files using PHP-FPM.
Restart Apache and PHP-FPM: For the changes to take effect, restart both Apache and PHP-FPM services:
```
sudo systemctl restart apache2
sudo systemctl restart php8.0-fpm
```

Installing PHP 8 as Apache SAPI Module (mod_php) on Debian

The following steps detail how to install PHP 8 as an Apache SAPI module (mod_php) on Debian. This method is based on compiling PHP from source, similar to the original article’s approach, but adapted for Debian and PHP 8.

Install Dependencies: Before compiling PHP from source, you need to install the necessary development dependencies, including Apache development headers (apache2-dev) and build tools.
```
sudo apt update
sudo apt install build-essential apache2-dev libxml2-dev libjpeg-dev libpng-dev libfreetype6-dev libcurl4-openssl-dev
```
This command installs:
- build-essential: Essential packages for compiling software.
- apache2-dev: Apache development headers needed to compile mod_php.
- libxml2-dev, libjpeg-dev, libpng-dev, libfreetype6-dev, libcurl4-openssl-dev: Development libraries for common PHP extensions. You can adjust these based on your required PHP extensions.
Download and Extract PHP 8 Source Code: Download the PHP 8 source code from the official PHP website (https://www.php.net/downloads). Choose the source code package (e.g., php-8.x.x.tar.gz). Extract the downloaded archive:
```
wget https://www.php.net/distributions/php-8.2.11.tar.gz # Replace with the latest PHP 8 version
tar -xvzf php-8.2.11.tar.gz
cd php-8.2.11
```
Image from PHP.net showing the PHP logo, representing the source of PHP downloads.
Configure and Compile PHP: Configure the PHP build with Apache 2 module support using the --with-apxs2 option, pointing to your apxs2 binary. Then compile and install PHP.
```
./configure --with-apxs2=/usr/bin/apxs2 --with-mysqli --with-pdo-mysql --with-curl --with-jpeg --with-png --with-freetype --with-xml
make
sudo make install
```
- --with-apxs2=/usr/bin/apxs2: Specifies the path to the apxs2 tool, which is used to build Apache modules. Adjust the path if apxs2 is located elsewhere on your system.
- --with-mysqli, --with-pdo-mysql, --with-curl, --with-jpeg, --with-png, --with-freetype, --with-xml: Enable commonly used PHP extensions. Customize this list based on your needs.
- make: Compiles the PHP source code.
- sudo make install: Installs PHP to the system.
Enable PHP 8 Module in Apache: After installation, the libphp.so module should be created and placed in Apache’s modules directory. You need to manually enable the PHP 8 module in your Apache configuration. Edit your Apache configuration file (e.g., /etc/apache2/apache2.conf or /etc/httpd/conf/httpd.conf depending on your Debian version and Apache setup) and add the following line within the “Dynamic Shared Object (DSO) Support” section:
```
LoadModule php_module /usr/lib/apache2/modules/libphp.so # Adjust path if necessary
```
Note: Ensure that only one LoadModule directive for PHP is active. If you have older PHP versions configured, comment out or remove their LoadModule lines to avoid conflicts.
Configure Apache to Handle PHP Files: Configure Apache to process PHP files by adding the following lines to your Apache configuration file or within your virtual host configuration:
```
<FilesMatch .php$>
    SetHandler application/x-httpd-php
</FilesMatch>
```
Restart Apache: Restart the Apache service to load the new PHP module and configurations:
```
sudo systemctl restart apache2
```

Final Steps and Verification

After installing PHP 8 using either php-fpm or mod_php, it’s essential to verify the installation and ensure Apache is correctly using the new PHP version.

Create a phpinfo() File: Create a simple PHP file named info.php in your Apache document root (e.g., /var/www/html/) with the following content:
```
<?php
phpinfo();
?>
```
Access phpinfo() in Browser: Access info.php through your web browser by navigating to http://your_server_ip/info.php or http://your_domain/info.php.

Example of a PHP info page displaying PHP version and configuration details.
Verify PHP Version: The phpinfo() page will display detailed information about your PHP installation. Look for the “PHP Version” line to confirm that you are running PHP 8.x.x.
Check Apache Modules (for mod_php): If you installed mod_php, the phpinfo() page should show “Server API” as “Apache 2.0 Handler”. For php-fpm, it should show “FPM/FastCGI”.

PHP 8.0 and Above Configuration Considerations

As highlighted in the original article, PHP 8 introduced changes in how Apache identifies PHP modules in configuration files. Specifically, the module identifiers changed.

PHP 7: php7_module and mod_php7
PHP 8: php_module and mod_php

If you are upgrading from an older PHP version and your Apache configuration files (like php.conf in /etc/apache2/conf-available/ or /etc/httpd/conf.d/) contain conditional blocks based on these module identifiers, you might need to update them to correctly recognize PHP 8.

For instance, sections in your configuration that look like this for PHP-FPM:

<IfModule !mod_php7.c>
    <IfModule !php7_module.c>
        # PHP-FPM Configuration for PHP 7
    </IfModule>
</IfModule>

Should be updated to include PHP 8 identifiers like this:

<IfModule !mod_php7.c>
    <IfModule !php7_module.c>
        <IfModule !mod_php.c>
            <IfModule !php_module.c>
                # PHP-FPM Configuration for PHP 8 and above
            </IfModule>
        </IfModule>
    </IfModule>
</IfModule>

Or simplified to check only for the current PHP 8 module identifier if you are solely focusing on PHP 8:

<IfModule !php_module.c>
    # PHP-FPM Configuration for PHP 8
</IfModule>

Make similar adjustments to the IfModule sections related to mod_php if necessary, ensuring your Apache configuration correctly handles PHP 8.

Conclusion

This guide has provided detailed steps for installing PHP 8 on a Debian server, covering both php-fpm and mod_php methods. While mod_php offers a simpler initial setup, php-fpm is the recommended approach for its performance and stability benefits, especially in production environments. By following these instructions, you can successfully install PHP 8 and integrate it with your Apache web server, taking advantage of the latest features and improvements PHP 8 offers. Remember to choose the installation method that best suits your needs and server environment. Always verify your installation using phpinfo() and adjust your Apache configurations as needed for optimal performance and compatibility.