How to Setup Lamp Stack

How to Setup LAMP Stack The LAMP stack is one of the most widely used open-source web development platforms in the world. Acronym for Linux, Apache, MySQL (or MariaDB), and PHP, LAMP provides a robust, secure, and scalable foundation for hosting dynamic websites and web applications. From small blogs to enterprise-grade platforms like WordPress, Drupal, and Joomla, LAMP powers a significant portio

alex

Oct 30, 2025 - 10:15

How to Setup LAMP Stack

The LAMP stack is one of the most widely used open-source web development platforms in the world. Acronym for Linux, Apache, MySQL (or MariaDB), and PHP, LAMP provides a robust, secure, and scalable foundation for hosting dynamic websites and web applications. From small blogs to enterprise-grade platforms like WordPress, Drupal, and Joomla, LAMP powers a significant portion of the internet. Understanding how to set up a LAMP stack is an essential skill for developers, system administrators, and anyone looking to deploy web applications on a private or cloud-based server.

This guide provides a comprehensive, step-by-step walkthrough for setting up a LAMP stack on a modern Linux distribution—specifically Ubuntu 22.04 LTS, which is widely supported and frequently used in production environments. We’ll cover installation, configuration, security hardening, performance optimization, and real-world use cases. By the end of this tutorial, you’ll have a fully functional LAMP environment ready to host your next web project.

Step-by-Step Guide

Prerequisites

Before beginning the setup, ensure you have the following:

A server running Ubuntu 22.04 LTS (or another Debian-based distribution)
Root or sudo privileges
Basic familiarity with the Linux command line
A stable internet connection

If you’re using a cloud provider like AWS, Google Cloud, or DigitalOcean, launch a new Ubuntu 22.04 instance with at least 1GB of RAM and 20GB of disk space. For development purposes, a local virtual machine using VirtualBox or VMware will also work.

Step 1: Update the System

Always begin by updating your system’s package list and upgrading existing packages to their latest versions. This ensures compatibility and security.

sudo apt update && sudo apt upgrade -y

This command fetches the latest package information from the Ubuntu repositories and installs all available updates. Allow the process to complete before proceeding.

Step 2: Install Apache Web Server

Apache is the most popular web server software in the world, known for its reliability, flexibility, and extensive documentation. Install it using the following command:

sudo apt install apache2 -y

Once installed, Apache starts automatically. Verify its status with:

sudo systemctl status apache2

You should see output indicating that Apache is active and running. To ensure it starts on boot, enable it:

sudo systemctl enable apache2

Test your installation by opening a web browser and navigating to your server’s public IP address or domain name (e.g., http://your-server-ip). You should see the default Apache welcome page: “It works!”

Step 3: Install MySQL (or MariaDB)

MySQL is the relational database management system (RDBMS) used to store and manage data for dynamic websites. While MySQL is the traditional choice, MariaDB—a community-developed fork—is now the default in many Linux distributions due to its performance and open-source licensing.

Install MariaDB with:

sudo apt install mariadb-server -y

Start and enable the service:

sudo systemctl start mariadb

sudo systemctl enable mariadb

Verify the service is running:

sudo systemctl status mariadb

Next, secure your MySQL installation by running the security script:

sudo mysql_secure_installation

This script will guide you through several security-related configurations:

Set a root password for MySQL (highly recommended)
Remove anonymous users
Disallow root login remotely
Remove the test database
Reload privilege tables

Answer “Y” (yes) to all prompts unless you have specific reasons not to. This step significantly improves the security of your database server.

Step 4: Install PHP

PHP is the server-side scripting language that processes dynamic content and interacts with the MySQL database. Ubuntu 22.04 includes PHP 8.1 by default, which is fully supported and secure.

Install PHP and essential extensions:

sudo apt install php libapache2-mod-php php-mysql php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip -y

This command installs:

php: Core PHP interpreter
libapache2-mod-php: Apache module to process PHP files
php-mysql: Extension to connect PHP with MySQL/MariaDB
php-curl: For making HTTP requests
php-gd: For image manipulation
php-mbstring: For multibyte string support (essential for internationalization)
php-xml: For XML parsing
php-soap: For SOAP web services
php-intl: For internationalization and localization
php-zip: For handling ZIP archives

After installation, restart Apache to load the PHP module:

sudo systemctl restart apache2

Step 5: Test PHP Processing

To confirm PHP is working correctly with Apache, create a test file in the web root directory.

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

Add the following content:

<?php
phpinfo();
?>

Save and exit (Ctrl+O, Enter, Ctrl+X).

Now visit http://your-server-ip/info.php in your browser. You should see a detailed page showing your PHP configuration, including loaded modules, environment variables, and server information. This confirms that Apache is successfully passing PHP files to the PHP interpreter.

For security reasons, delete this file after testing:

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

Step 6: Configure Apache Virtual Hosts (Optional but Recommended)

By default, Apache serves content from the /var/www/html directory. For multiple websites or projects, it’s best practice to use virtual hosts.

Create a new directory for your site:

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

Assign ownership to your user (replace your-username with your actual username):

sudo chown -R your-username:your-username /var/www/example.com/html

Set proper permissions for the web root:

sudo chmod -R 755 /var/www/example.com

Create a sample index file:

nano /var/www/example.com/html/index.html

Add the following:

<!DOCTYPE html>
<html>
<head>
<title>Welcome to Example.com</title>
</head>
<body>
<h1>Success! The example.com virtual host is working.</h1>
</body>
</html>

Now create a virtual host configuration file:

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

Insert the following configuration:

<VirtualHost *:80>
ServerAdmin admin@example.com
ServerName example.com
ServerAlias www.example.com
DocumentRoot /var/www/example.com/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Save and exit. Enable the new site:

sudo a2ensite example.com.conf

Disable the default site (optional, but recommended for clean configuration):

sudo a2dissite 000-default.conf

Test the Apache configuration for syntax errors:

sudo apache2ctl configtest

If you see “Syntax OK,” restart Apache:

sudo systemctl restart apache2

To access your site locally, add an entry to your local machine’s hosts file:

your-server-ip example.com www.example.com

On Windows: C:\Windows\System32\drivers\etc\hosts

On macOS/Linux: /etc/hosts

Now visit http://example.com in your browser to see your custom site.

Step 7: Install phpMyAdmin (Optional for Database Management)

phpMyAdmin is a web-based tool for managing MySQL/MariaDB databases. While not required, it’s extremely helpful for beginners.

Install phpMyAdmin:

sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl -y

During installation, you’ll be prompted to choose a web server. Use the arrow keys to select apache2 and press Space to mark it, then Enter.

When asked whether to configure the database for phpMyAdmin with dbconfig-common, select Yes. You’ll then be prompted to set a password for the phpMyAdmin database user—choose a strong password.

After installation, enable the mbstring PHP extension:

sudo phpenmod mbstring

Restart Apache:

sudo systemctl restart apache2

Access phpMyAdmin by visiting:

http://your-server-ip/phpmyadmin

Log in using your MySQL root credentials or a dedicated user account. You now have a full graphical interface to manage databases, users, tables, and queries.

Best Practices

Secure Your LAMP Stack

Security should be a top priority. A misconfigured LAMP stack can become an entry point for attackers. Follow these best practices:

Disable root login for MySQL: Always create dedicated database users with minimal required privileges. Never use the root MySQL user for applications.
Use strong passwords: Enforce complex passwords for MySQL, SSH, and administrative accounts. Use a password manager to store them securely.
Install a firewall: Use UFW (Uncomplicated Firewall) to restrict access:
```
sudo ufw allow 'Apache Full'
sudo ufw allow ssh
sudo ufw enable
```
Disable directory listing: In your Apache configuration, ensure Options -Indexes is set to prevent users from browsing file directories.
Hide PHP version: Edit /etc/php/8.1/apache2/php.ini and set expose_php = Off. Restart Apache after making changes.
Regular updates: Schedule weekly updates for your OS and software packages: sudo apt update && sudo apt upgrade -y
Use HTTPS: Install a free SSL certificate using Let’s Encrypt (see Tools and Resources section).

Optimize Performance

Performance tuning can dramatically improve user experience and server efficiency.

Enable Apache mod_deflate: Compress text-based content (HTML, CSS, JS) to reduce bandwidth:
```
sudo a2enmod deflate
sudo systemctl restart apache2
```

Enable mod_expires: Set cache headers for static assets:

sudo a2enmod expires

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

Add:

<IfModule mod_expires.c> ExpiresActive On ExpiresByType image/jpg "access plus 1 year" ExpiresByType image/jpeg "access plus 1 year" ExpiresByType image/gif "access plus 1 year" ExpiresByType image/png "access plus 1 year" ExpiresByType text/css "access plus 1 month" ExpiresByType application/pdf "access plus 1 month" ExpiresByType text/javascript "access plus 1 month" ExpiresByType application/javascript "access plus 1 month" ExpiresByType application/x-javascript "access plus 1 month" ExpiresByType image/x-icon "access plus 1 year"

</IfModule>

Restart Apache.

Use OPcache for PHP: OPcache improves PHP performance by storing precompiled script bytecode in memory. Edit /etc/php/8.1/apache2/php.ini and ensure:

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

Restart Apache.

Switch to MariaDB with optimized settings: Edit /etc/mysql/mariadb.conf.d/50-server.cnf and adjust buffer sizes based on available RAM. For a 2GB server:
```
[mysqld]
innodb_buffer_pool_size = 512M
max_connections = 100
query_cache_type = 1
query_cache_size = 64M
```
Restart MariaDB.

Backup Strategy

Regular backups are non-negotiable. Implement a three-tier backup system:

Daily database dumps: Use cron to auto-export MySQL databases:

mysqldump -u root -pYourPassword database_name > /backup/db_backup_$(date +%F).sql

Weekly file backups: Archive your web root and configuration files:

tar -czf /backup/www_backup_$(date +%F).tar.gz /var/www/html/ /etc/apache2/ /etc/php/

Offsite storage: Upload backups to cloud storage (e.g., AWS S3, Google Cloud Storage, or rsync to a remote server).

Monitor and Log

Use logging and monitoring to detect issues early:

Check Apache logs: tail -f /var/log/apache2/error.log
Check MariaDB logs: sudo tail -f /var/log/mysql/error.log

Install fail2ban to block brute-force attacks:

sudo apt install fail2ban -y sudo systemctl enable fail2ban

sudo systemctl start fail2ban

Use netdata or glances for real-time system monitoring.

Tools and Resources

Essential Tools

These tools enhance your LAMP stack setup, management, and monitoring:

FileZilla / WinSCP: For secure SFTP file transfers between your local machine and server.
SSH Clients: Use OpenSSH (Linux/macOS) or PuTTY (Windows) for secure remote access.
VS Code with Remote SSH: Edit server files directly from your local IDE.
phpMyAdmin: Web-based MySQL management (installed in Step 7).
Adminer: A lightweight alternative to phpMyAdmin, single PHP file, no installation required.

Let’s Encrypt / Certbot: Free SSL/TLS certificates to enable HTTPS. Install with:

sudo apt install certbot python3-certbot-apache -y

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

Git: For version control of your website code:
```
sudo apt install git -y
```

Composer: PHP dependency manager for modern frameworks (Laravel, Symfony, etc.):

curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer

Documentation and Learning Resources

Apache HTTP Server Documentation
MariaDB Knowledge Base
PHP Manual
Ubuntu Server Documentation
DigitalOcean Tutorials (search “LAMP Ubuntu”)
Traversy Media (YouTube) – Excellent beginner-friendly LAMP walkthroughs

Security Scanners and Auditors

Nmap: Scan your server for open ports: sudo apt install nmap -y && nmap your-server-ip
OpenVAS / Nessus: Advanced vulnerability scanners for enterprise environments.
WPScan (if running WordPress): Scan for plugin/theme vulnerabilities.
Security Headers: Use https://securityheaders.com to test HTTP headers.

Real Examples

Example 1: Hosting a WordPress Site

WordPress is the world’s most popular CMS and runs perfectly on LAMP. Here’s how to install it:

Create a MySQL database and user:

sudo mysql -u root -p CREATE DATABASE wordpress_db; CREATE USER 'wp_user'@'localhost' IDENTIFIED BY 'StrongPassword123!'; GRANT ALL PRIVILEGES ON wordpress_db.* TO 'wp_user'@'localhost'; FLUSH PRIVILEGES;

EXIT;

Download WordPress:

cd /tmp curl -O https://wordpress.org/latest.tar.gz tar xzvf latest.tar.gz

sudo cp -a /tmp/wordpress/. /var/www/example.com/html/

Set permissions:

sudo chown -R www-data:www-data /var/www/example.com/html/
sudo find /var/www/example.com/html/ -type d -exec chmod 750 {} \;
sudo find /var/www/example.com/html/ -type f -exec chmod 640 {} \;

Copy sample config:

cd /var/www/example.com/html/

cp wp-config-sample.php wp-config.php

Edit wp-config.php to add database credentials:

define('DB_NAME', 'wordpress_db');
define('DB_USER', 'wp_user');
define('DB_PASSWORD', 'StrongPassword123!');
define('DB_HOST', 'localhost');

Visit http://example.com in your browser and complete the WordPress installation wizard.

WordPress is now live and fully functional on your LAMP stack.

Example 2: Running a PHP API with Laravel

Laravel is a modern PHP framework. To deploy a Laravel app:

Install Composer (as shown in Tools section).
Create a new project (on your local machine or directly on the server):
```
composer create-project laravel/laravel /var/www/api.example.com
```

Set permissions:

sudo chown -R www-data:www-data /var/www/api.example.com/storage

sudo chown -R www-data:www-data /var/www/api.example.com/bootstrap/cache

Configure Apache virtual host to point to /var/www/api.example.com/public.

Install .env file and generate key:

cd /var/www/api.example.com cp .env.example .env

php artisan key:generate

Run migrations (if needed):
```
php artisan migrate
```
Visit http://api.example.com to see the Laravel welcome page.

Now your Laravel API is accessible via HTTP and ready to serve JSON responses.

Example 3: Multi-Site Development Environment

Use virtual hosts to host multiple sites on one server:

example.com → WordPress blog
store.example.com → WooCommerce e-commerce
api.example.com → Laravel REST API
dev.example.com → Internal development site

Each site has its own document root, database, and configuration. This approach reduces hosting costs and simplifies management. Use DNS subdomains or local hosts file entries to route traffic correctly.

FAQs

What is the difference between LAMP and WAMP?

LAMP stands for Linux, Apache, MySQL, PHP and runs on Linux operating systems. WAMP stands for Windows, Apache, MySQL, PHP and is designed for Windows environments. LAMP is preferred in production due to better performance, stability, and security. WAMP is commonly used for local development on Windows machines.

Can I use PostgreSQL instead of MySQL in a LAMP stack?

Technically, yes. Replacing MySQL with PostgreSQL creates a LAPP stack (Linux, Apache, PostgreSQL, PHP). However, “LAMP” traditionally refers to MySQL. Most PHP applications (WordPress, Drupal, etc.) are designed for MySQL/MariaDB. Use PostgreSQL only if you have specific needs like advanced JSON support or complex transactions.

Is LAMP still relevant in 2024?

Absolutely. While newer stacks like MEAN (MongoDB, Express, Angular, Node.js) or serverless architectures are gaining popularity, LAMP remains the backbone of the web. Over 78% of websites using a server-side language rely on PHP, and Apache continues to be one of the most used web servers. LAMP is reliable, well-documented, and supported by a massive community.

How do I upgrade PHP on my LAMP stack?

Ubuntu’s default repositories provide stable PHP versions. To upgrade to a newer version (e.g., PHP 8.2), add a third-party repository:

sudo apt install software-properties-common sudo add-apt-repository ppa:ondrej/php sudo apt update sudo apt install php8.2 libapache2-mod-php8.2 php8.2-mysql php8.2-curl php8.2-gd php8.2-mbstring php8.2-xml sudo a2dismod php8.1 sudo a2enmod php8.2

sudo systemctl restart apache2

Always test your applications after upgrading PHP, as newer versions may deprecate functions.

How do I fix “Permission denied” errors in Apache?

Common causes:

Incorrect file ownership: Ensure web root is owned by www-data: sudo chown -R www-data:www-data /var/www/your-site
Missing execute permissions on directories: sudo chmod 755 /var/www/your-site
SELinux (on RHEL/CentOS): Disable or configure policies if using Red Hat-based systems.

Can I run multiple PHP versions on one LAMP server?

Yes, using PHP-FPM and Apache virtual hosts with different FastCGI configurations. This advanced setup requires configuring separate FPM pools and proxying requests based on domain. Tools like phpenv or phpbrew can help manage multiple PHP versions on a single machine.

What should I do if MySQL won’t start?

Check the error log: sudo tail -f /var/log/mysql/error.log

Common fixes:

Insufficient disk space: df -h
Corrupted InnoDB tables: Run mysqlcheck --all-databases --repair --use-frm
Port conflict: Ensure no other service is using port 3306: sudo netstat -tlnp | grep :3306

How do I back up a MySQL database?

Use mysqldump:

mysqldump -u username -p database_name > backup.sql

To restore:

mysql -u username -p database_name < backup.sql

For automated backups, use cron jobs.

Conclusion

Setting up a LAMP stack is a foundational skill for anyone entering web development or system administration. This guide has walked you through installing and configuring each component—Linux, Apache, MySQL, and PHP—with attention to security, performance, and scalability. You’ve learned how to create virtual hosts, secure your database, optimize PHP and Apache, and deploy real-world applications like WordPress and Laravel.

The LAMP stack remains a powerful, cost-effective, and proven solution for hosting dynamic websites. While new technologies emerge, LAMP’s simplicity, compatibility, and vast ecosystem ensure its continued relevance. By following the best practices outlined here, you’ve not only built a functional server—you’ve built a secure, maintainable, and production-ready platform.

Continue exploring by deploying your first application, experimenting with caching layers like Redis, or automating deployments with GitHub Actions. The journey from setup to mastery begins with this first step. Now that your LAMP stack is operational, the only limit is your creativity.

alex