How to Install ClassicPress with Lighttpd on Alpine Linux

This article assumes you have already read my companion guide, How to Install WordPress with Lighttpd and Debian 13,which serves as the primary installation reference. Rather than repeating the same installation procedure, this guide focuses exclusively on the Alpine Linux-specific commands,configuration changes, filesystem layout, and service management required to run ClassicPress on a Lighttpd server.

Introduction

ClassicPress installs and operates almost identically to WordPress, making it an excellent choice for users who prefer a stable, lightweight content management system without the rapid feature changes introduced in recent WordPress releases. Combined with Alpine Linux and Lighttpd, it forms an efficient publishing stack that performs exceptionally well on low-resource virtual private servers, ARM devices, containers, and home labs. Throughout this article, whenever the installation process is identical to the Debian guide, I simply reference it rather than duplicating the instructions. This keeps the documentation easier to maintain while allowing us to concentrate on the parts that make Alpine Linux unique.

Who Is This Guide For?

This is intentionally a niche guide and is not aimed at first-time Linux users. It assumes you are comfortable working from the command line, editing configuration files, and administering your own server. If you are looking for a complete walkthrough of installing a CMS on Lighttpd, begin with my How to Install WordPress with Lighttpd and Debian 13 guide before returning here. This article is intended for Linux enthusiasts, self-hosters, developers, and system administrators who have deliberately chosen Alpine Linux because of its small footprint, security-focused design and minimal resource requirements. It is equally suitable for home labs, Raspberry Pi deployments, low-cost VPS instances and container-based environments where every megabyte of memory matters.

Because Alpine Linux, Lighttpd and ClassicPress each occupy relatively small communities compared to their mainstream alternatives, documentation covering all three together is surprisingly limited. One of my objectives in writing this article is to document a practical deployment that has worked well for me, while helping others avoid the small Alpine-specific issues that can consume hours during an otherwise straightforward installation. If you are already comfortable with Debian, Ubuntu or another mainstream Linux distribution, think of this article as a field guide to Alpine Linux rather than another installation tutorial. It complements the Debian companion article by documenting only the commands, filesystem layout and configuration differences that make Alpine unique.

Why Alpine Linux?

Alpine Linux has quietly become one of the most popular Linux distributions for containers and lightweight servers. Unlike traditional server operating systems that include hundreds of packages by default, Alpine follows a minimalist philosophy, installing only the components you actually need. The result is a significantly smaller installation footprint, lower memory consumption, faster boot times, and a reduced attack surface.

Instead of using GNU libc (glibc), Alpine is built around musl libc and BusyBox, while OpenRC replaces the more common systemd init system. These design decisions make Alpine remarkably efficient, although they also mean that administrators familiar with Debian or Ubuntu need to learn a slightly different way of managing packages, services, and system configuration.

For the LightyPress stack, Alpine is a natural fit. Lighttpd has always been known for its low memory usage, and ClassicPress has modest hardware requirements compared to many modern CMS platforms. Together they create a web server capable of comfortably hosting personal websites, blogs, documentation portals, or small business sites on entry-level VPS plans with very limited resources. If your objective is simplicity, predictable performance, and minimal resource consumption rather than maximum package availability, Alpine Linux is an excellent foundation for a ClassicPress server.

Install ClassicPress with Lighttpd on Alpine Linux

Software Versions Used

This guide was tested using:

Alpine Linux 3.22
Lighttpd 1.4.x
PHP 8.4
MariaDB 11.x
ClassicPress 2.x

Newer versions should require only minor adjustments to package names and PHP module versions.

Installing the Required Packages

If you have already completed the base operating system installation and network configuration, installing the software stack on Alpine Linux is straightforward. Unlike Debian, which uses the apt package manager, Alpine relies on apk, a lightweight and fast package manager that installs only the required dependencies. The package names are also slightly different, particularly for PHP and its extensions, so it is worth verifying the package names available in your chosen Alpine release. The following command installs Lighttpd, MariaDB, PHP-FPM, and the extensions commonly required by ClassicPress.

apk update
apk upgrade

apk add \
    lighttpd \
    mariadb \
    mariadb-client \
    php84 \
    php84-fpm \
    php84-mysqli \
    php84-curl \
    php84-gd \
    php84-mbstring \
    php84-xml \
    php84-xmlreader \
    php84-session \
    php84-zip \
    php84-opcache \
    php84-phar \
    php84-tokenizer \
    php84-fileinfo \
    wget \
    unzip \
    curl

The installation itself is no different from the Debian version, and the remaining configuration steps for MariaDB, PHP-FPM, and ClassicPress follow the same sequence described in the companion guide. From this point onwards, this article highlights only those commands and configuration files that are unique to Alpine Linux.

Managing Services with OpenRC

One of the first differences you will notice on Alpine Linux is the absence of systemd. Alpine uses OpenRC, a lightweight init system that is simple to understand and consumes very little memory. Although the service names remain familiar, the commands used to start, stop, restart, and enable services differ from those used on Debian or Ubuntu. Once you become accustomed to OpenRC, day-to-day administration is both predictable and efficient. The following commands enable the required services during boot and start them immediately.

rc-update add lighttpd default
rc-update add mariadb default
rc-update add php-fpm84 default

rc-service lighttpd start
rc-service mariadb start
rc-service php-fpm84 start

Some additional OpenRC commands that you will frequently use while administering your server are shown below.

rc-service lighttpd status
rc-service lighttpd restart

rc-service mariadb restart

rc-service php-fpm84 restart

If you are following the Debian guide alongside this article, simply substitute the systemctl commands with their OpenRC equivalents shown above. The overall installation workflow remains unchanged, with only the service management commands differing between the two operating systems.

Understanding the Alpine Filesystem Layout

Although the overall web server architecture remains unchanged, Alpine Linux uses a slightly different filesystem layout from Debian. The most noticeable difference is the default document root, which is located under /var/www/localhost/htdocs instead of /var/www/html. Configuration files are also organised differently, making it worthwhile to familiarise yourself with their locations before modifying the server. Knowing where these files reside makes troubleshooting significantly easier when configuring Lighttpd, PHP-FPM or ClassicPress.

The directories you will use most frequently are listed below.

Path	Purpose
`/var/www/localhost/htdocs`	Default web root
`/etc/lighttpd`	Lighttpd configuration
`/etc/php84`	PHP configuration
`/etc/php84/php-fpm.d`	PHP-FPM pool configuration
`/run`	Runtime sockets, including PHP-FPM
`/var/log/lighttpd`	Lighttpd log files

With these locations in mind, you can follow the remaining configuration steps from the Debian guide while simply substituting the Alpine paths wherever required.

Configuring Lighttpd for ClassicPress

The Lighttpd configuration itself changes very little between Debian and Alpine Linux. The primary differences are the PHP-FPM socket location, module paths and a few distribution-specific defaults. Rather than replacing the complete configuration, it is usually sufficient to update only the PHP-FPM socket and verify that the required modules are enabled. The rewrite rules required by ClassicPress remain identical to those used by WordPress.

Begin by ensuring that the FastCGI and rewrite modules are enabled.

ls /etc/lighttpd/conf.d/

Verify that your PHP-FPM socket matches the version of PHP installed on the server. A typical configuration references a socket similar to the following.

fastcgi.server = (
    ".php" => (
        (
            "socket" => "/run/php-fpm84/php-fpm.sock",
            "broken-scriptfilename" => "enable"
        )
    )
)

Once the configuration has been updated, test it before restarting the web server.

lighttpd -tt -f /etc/lighttpd/lighttpd.conf

rc-service lighttpd restart

If the configuration test completes without errors, continue with the ClassicPress installation and configuration steps described in the Debian companion guide. Only the filesystem paths and service management commands differ; the remaining Lighttpd configuration is effectively identical.

Installing ClassicPress

Once Lighttpd, PHP-FPM and MariaDB are operational, installing ClassicPress is almost identical to the WordPress installation described in the Debian guide. Instead of downloading WordPress, simply obtain the latest ClassicPress release from the official website, extract it into the web root, and update the configuration file with your database credentials. The installation wizard, file permissions and directory structure are familiar to anyone who has previously installed WordPress. Rather than reproducing those steps here, follow the Debian guide while substituting the ClassicPress package wherever WordPress is referenced.

The only commands that differ are those used to download and extract the application.

cd /var/www/localhost/htdocs

wget https://github.com/ClassicPress/ClassicPress-release/releases/latest/download/classicpress.tar.gz

tar -xzf classicpress.tar.gz

chown -R lighttpd:lighttpd /var/www/localhost/htdocs

After extracting the files, create the configuration file, update the database credentials and complete the installation through your web browser exactly as described in the companion Debian article.

Common Alpine Linux Issues

Most installation problems are not caused by ClassicPress or Lighttpd but by small Alpine-specific differences. The most common issue is an incorrect PHP-FPM socket path, particularly after upgrading PHP to a newer release. Missing PHP extensions are another frequent cause of blank pages or installation failures, especially if XML, mbstring or mysqli packages have not been installed. Fortunately, these problems are easy to diagnose once you know where to look.

If Lighttpd reports a FastCGI error, verify that the PHP-FPM service is running and that the socket path configured in lighttpd.conf matches the socket created under /run. When troubleshooting database connection failures, confirm that MariaDB has been started through OpenRC and that the database credentials in cp-config.php are correct. Finally, review the Lighttpd and PHP log files before making configuration changes, as they usually identify the underlying problem far more quickly than repeated trial and error.

Running ClassicPress on a Low-Resource VPS

One of the strongest reasons for choosing Alpine Linux is its ability to deliver excellent performance on modest hardware. A minimal Alpine installation consumes considerably fewer system resources than most mainstream Linux distributions, leaving more memory available for MariaDB, PHP-FPM and the web server. When combined with Lighttpd and ClassicPress, the result is a publishing platform that remains responsive even on entry-level VPS plans. For personal websites, blogs, documentation portals and small business sites, this lightweight stack is often more than sufficient.

In my own experience, this combination is particularly well suited to self-hosted environments where simplicity and predictability are more important than running the latest enterprise software stack. Alpine's small footprint also makes backups faster, updates simpler and disaster recovery less time-consuming. If you are experimenting with Raspberry Pi boards, mini PCs, virtual machines or cloud instances with limited RAM, this stack provides an excellent balance between performance, stability and ease of administration. It also scales well, allowing you to move the same configuration from a home lab to a production VPS with minimal changes.

This article intentionally avoids duplicating the Debian installation guide. As the LightyPress series grows, future distribution-specific guides will follow the same pattern, documenting only the commands and configuration unique to each operating system.

Resources

The following resources provide additional documentation for the software used in this guide. Where possible, refer to the official documentation first, as it is generally updated more frequently than third-party tutorials.

Conclusion

Alpine Linux, Lighttpd and ClassicPress complement each other remarkably well. Each component follows a philosophy of simplicity, efficiency and long-term stability, making the stack an excellent choice for developers, hobbyists and anyone hosting websites on modest hardware. While Alpine introduces a few differences in package management, service administration and filesystem layout, these are relatively easy to learn and quickly become second nature.

Rather than duplicating the complete installation procedure from the Debian guide, this article has focused on the Alpine-specific commands and configuration changes that matter in day-to-day administration. Used together, the Debian and Alpine guides provide a complete reference for deploying the LightyPress stack across two of the most popular lightweight Linux distributions. Whether you are running a small VPS, a Raspberry Pi, a home server or a cloud instance, this combination offers an efficient, dependable and enjoyable publishing platform.

If you have adopted a similar lightweight hosting stack or discovered useful Alpine-specific optimisations, feel free to share your experience.

Lighttpd Logo