Setting Up Multiple Virtual Hosts In Docker With PHP 5.6 And Apache

Aug 9, 2025 by ADMIN 68 views

Mastering Multiple Virtual Hosts in Docker with PHP 5.6 and Apache

Hey guys! Ever found yourself wrestling with setting up multiple virtual hosts in Docker using PHP 5.6 and Apache? It can feel like navigating a maze, especially when commands like a2ensite throw a wrench in your plans. But don't sweat it! This guide is here to walk you through the process step-by-step, ensuring you can smoothly run multiple websites from a single Docker container. Let's dive in!

Understanding the Challenge

Before we get our hands dirty, let's quickly understand why this setup might seem tricky. Docker containers are designed to encapsulate applications and their dependencies, providing a consistent environment across different systems. When you're dealing with virtual hosts, you're essentially trying to configure Apache within the container to serve different websites based on the domain name requested. This requires some careful configuration to ensure everything plays nicely together.

Prerequisites

Make sure you have the following installed on your system:

Docker
Docker Compose (optional, but highly recommended)

Step 1: Setting Up Your Docker Environment

First things first, let's create a basic Docker setup. We'll start with a Dockerfile that sets up our PHP 5.6 with Apache environment. Create a new directory for your project, and inside it, create a file named Dockerfile with the following content:

FROM php:5.6-apache

# Install necessary extensions
RUN apt-get update && apt-get install -y \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    zip \
    unzip \
    && docker-php-ext-install -j$(nproc) gd \
    && docker-php-ext-install pdo_mysql \
    && docker-php-ext-install mysqli

# Enable Apache modules
RUN a2enmod rewrite

# Set document root
ENV APACHE_DOCUMENT_ROOT /var/www/html

# Configure Apache virtual hosts
RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf
RUN sed -ri -e 's!/var/www/!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/apache2.conf

# Copy virtual host configuration
COPY ./vhosts/*.conf /etc/apache2/sites-available/

# Enable virtual hosts
RUN a2ensite 000-default

# Copy application code
COPY ./src/ ${APACHE_DOCUMENT_ROOT}/

# Expose port 80
EXPOSE 80

Keywords: Docker, PHP 5.6, Apache, Dockerfile, Virtual Hosts

Explanation: This Dockerfile starts with the php:5.6-apache image as its base. It then installs essential PHP extensions like GD, PDO MySQL, and MySQLi. We also enable the rewrite module in Apache, which is crucial for pretty URLs and other common web server configurations. The APACHE_DOCUMENT_ROOT environment variable is set to /var/www/html, and we modify the default Apache configuration to reflect this. We'll copy our virtual host configurations into /etc/apache2/sites-available/ and enable them using a2ensite. Finally, we copy our application code into the document root and expose port 80 for web traffic. This foundational setup is super important, guys, because it dictates how our container will behave. So, make sure you understand each part before moving on. Remember, a solid foundation makes the rest of the process way smoother!

Step 2: Crafting Your Virtual Host Configuration Files

Now, let's create the virtual host configuration files. These files tell Apache how to handle requests for different domain names. Create a directory named vhosts in your project directory. Inside vhosts, create configuration files for each of your websites. For example, let's create website1.dev.conf and website2.dev.conf:

website1.dev.conf:

<VirtualHost *:80>
    ServerName website1.dev
    DocumentRoot /var/www/html/website1

    <Directory /var/www/html/website1>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/website1.dev-error.log
    CustomLog ${APACHE_LOG_DIR}/website1.dev-access.log combined
</VirtualHost>

website2.dev.conf:

<VirtualHost *:80>
    ServerName website2.dev
    DocumentRoot /var/www/html/website2

    <Directory /var/www/html/website2>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/website2.dev-error.log
    CustomLog ${APACHE_LOG_DIR}/website2.dev-access.log combined
</VirtualHost>

Keywords: Virtual Host Configuration, Apache, ServerName, DocumentRoot, website1.dev, website2.dev

Explanation: In these configuration files, we define the VirtualHost for each website. The ServerName directive specifies the domain name for the virtual host, and DocumentRoot points to the directory where the website's files are located. The <Directory> block sets permissions for the document root, allowing Apache to access the files. We also define error and access logs for each website. Guys, pay close attention to the DocumentRoot and ServerName directives. These are the heart of your virtual host setup. The DocumentRoot tells Apache where to find the website's files, and the ServerName tells Apache which domain name this virtual host should respond to. If these aren't set correctly, your websites won't load properly. So, double-check these settings to avoid headaches later!

Step 3: Populating Your Website Directories

Next, create the directories for your websites and add some content. Inside your project directory, create src directory, and within src, create website1 and website2 directories. Add an index.php file to each directory:

src/website1/index.php:

<?php
echo "<h1>Welcome to Website 1!</h1>";
?>

src/website2/index.php:

<?php
echo "<h1>Welcome to Website 2!</h1>";
?>

Keywords: Website Directories, index.php, PHP, src directory, Website Content

Explanation: We're setting up the actual content that our websites will display. Each website gets its own directory (website1 and website2) inside the src directory. The index.php file in each directory is a simple PHP script that outputs a heading. This is just a basic example, of course; you'd replace this with your actual website code. But for testing purposes, this is perfect. The key here is to make sure that the directory structure matches what you've specified in your virtual host configuration files. If your DocumentRoot in website1.dev.conf points to /var/www/html/website1, then you need to make sure that directory exists and contains your website's files. It's like giving Apache a map – if the map is wrong, it won't find the treasure! So, double-check your paths and file names to make sure everything lines up.

Step 4: Docker Compose (Recommended)

While you can build and run the Docker container directly, using Docker Compose simplifies the process. Create a docker-compose.yml file in your project directory:

version: "3.8"
services:
  web:
    build: .
    ports:
      - "80:80"
    volumes:
      - ./src:/var/www/html
      - ./vhosts:/etc/apache2/sites-available
    depends_on:
      - php

  php:
    image: php:5.6-apache
    volumes:
      - ./src:/var/www/html
      - ./vhosts:/etc/apache2/sites-available

Keywords: Docker Compose, docker-compose.yml, Docker, Services, Volumes, Ports

Explanation: This docker-compose.yml file defines two services: web and php. The web service builds our Docker image using the Dockerfile in the current directory. It maps port 80 on the host to port 80 in the container, allowing you to access the websites from your browser. It also mounts the src and vhosts directories into the container, so changes to your code and virtual host configurations are immediately reflected. The php service uses the php:5.6-apache image and also mounts the src and vhosts directories. This is a slightly different approach, and you might wonder why we have two services. Well, in this setup, we're essentially running two containers: one for the web server (Apache) and one for PHP. This can be useful in more complex setups where you might want to scale these components independently. However, for our basic virtual host setup, it's a bit overkill. A simpler approach would be to just define a single service that builds from our Dockerfile, as shown in the web service configuration. The important thing is the volume mounts. These ensure that our local files are synced with the container, so we can easily edit our code and configurations without having to rebuild the image every time. Think of it as a live connection between your computer and the container. Super handy, right?

Step 5: Building and Running Your Containers

Now, let's build and run our containers. Open a terminal in your project directory and run:

docker-compose up --build

This command builds the Docker image and starts the containers. Once the containers are running, you can access your websites by adding the following lines to your /etc/hosts file:

127.0.0.1 website1.dev
127.0.0.1 website2.dev

Keywords: Docker Compose, docker-compose up, Docker Build, /etc/hosts, website1.dev, website2.dev

Explanation: The docker-compose up --build command is your magic wand. It tells Docker Compose to build the images (if they haven't been built yet) and start the containers. The --build flag ensures that Docker rebuilds the image if there are any changes to the Dockerfile. Once the containers are up and running, you need to tell your computer how to find these websites. That's where the /etc/hosts file comes in. By adding 127.0.0.1 website1.dev and 127.0.0.1 website2.dev, you're essentially telling your computer to treat website1.dev and website2.dev as if they were running on your local machine (127.0.0.1). This is crucial for testing your virtual host setup locally. Without these entries, your browser won't know where to find website1.dev and website2.dev, and you'll just get an error. So, make sure you add these lines to your /etc/hosts file (you might need administrator privileges to edit this file). Once you've done that, you should be able to access your websites by typing http://website1.dev and http://website2.dev into your browser. Fingers crossed, you should see the "Welcome to Website 1!" and "Welcome to Website 2!" messages we set up earlier!

Step 6: Accessing Your Websites

Open your web browser and navigate to http://website1.dev and http://website2.dev. You should see the respective welcome messages for each website.

Keywords: Accessing Websites, Web Browser, http://website1.dev, http://website2.dev, Welcome Messages

Explanation: This is the moment of truth! If you've followed all the steps correctly, you should now be able to access your websites in your browser. Just type http://website1.dev and http://website2.dev into the address bar, and you should see the welcome messages we set up in the index.php files. If you see those messages, congratulations! You've successfully configured multiple virtual hosts in Docker. Give yourself a pat on the back! But what if you don't see the welcome messages? Don't panic! This is where the real troubleshooting begins. Double-check your /etc/hosts file entries, make sure your Docker containers are running, and verify that your virtual host configurations are correct. Look for any typos or misconfigurations. It's often a small detail that's causing the problem. And remember, the error logs are your best friend. Check the Apache error logs in your container for any clues about what's going wrong. Debugging is a crucial part of the development process, guys, so don't get discouraged. With a little patience and persistence, you'll figure it out!

Common Issues and Troubleshooting

a2ensite command not found: This usually means the Apache tools aren't in your container's PATH. Ensure you're running the command within the container's shell.
Websites not loading: Double-check your /etc/hosts file, virtual host configurations, and Docker port mappings.
Permissions issues: Ensure Apache has the necessary permissions to access your website files.

Keywords: Troubleshooting, a2ensite, /etc/hosts, Virtual Host Configuration, Docker Port Mappings, Permissions Issues, Apache

Explanation: Alright, let's talk about some common pitfalls and how to avoid them. One issue you might run into is the a2ensite command not being found. This usually means that the Apache tools aren't in your container's PATH. The fix is simple: make sure you're running the command within the container's shell. You can do this by using docker exec -it <container_id> bash to get a shell inside the container. Another common problem is websites not loading. This can be caused by a variety of issues, so you'll need to do some detective work. Start by double-checking your /etc/hosts file entries. Make sure they're correct and that you've saved the file properly. Then, verify your virtual host configurations. Are the ServerName and DocumentRoot directives set correctly? Are the paths pointing to the right directories? Also, check your Docker port mappings. Is port 80 on your host machine mapped to port 80 in the container? Permissions issues can also cause problems. Make sure Apache has the necessary permissions to access your website files. You might need to adjust the file permissions or ownership within the container. Guys, troubleshooting is a skill, and it gets easier with practice. The key is to be methodical and break the problem down into smaller parts. Check the obvious things first, and then dig deeper if necessary. And don't forget to consult the error logs! They're your best source of information when things go wrong.

Conclusion

Setting up multiple virtual hosts in Docker with PHP 5.6 and Apache might seem daunting at first, but by following these steps, you can create a robust and scalable environment for your web applications. Remember to double-check your configurations and use the troubleshooting tips to overcome any hurdles. Happy coding!

Keywords: Conclusion, Docker, PHP 5.6, Apache, Virtual Hosts, Web Applications

Explanation: And there you have it! You've successfully navigated the world of virtual hosts in Docker with PHP 5.6 and Apache. It might have seemed like a lot at first, but hopefully, this guide has broken it down into manageable steps. The key takeaways here are the importance of a well-structured Dockerfile, accurate virtual host configurations, and proper Docker Compose setup (if you're using it). Remember to always double-check your configurations, guys. A small typo can cause a lot of headaches. And don't be afraid to experiment and try different things. The more you practice, the more comfortable you'll become with Docker and virtual hosts. So, go forth and build awesome web applications! And if you run into any snags, don't hesitate to come back to this guide or reach out to the community for help. We're all in this together!