Containerization of PHP and Nginx [2025]

Containerizing PHP and Nginx involves creating Docker containers for each service and configuring them to work together seamlessly. This approach ensures consistency across different environments, simplifies deployment, and enhances scalability. Below are the detailed steps to create a basic Docker configuration for PHP and Nginx, based on a simple PHP application.

Create the Project Structure
Create a PHP Application
Configure Nginx
Create Dockerfile for PHP
Create Dockerfile for Nginx
Create docker-compose.yml
Build and Run the Containers
Verify the Setup
Additional Considerations
Conclusion

1. Create the Project Structure

Start by setting up your project with the following structure:

project
├── index.php
├── nginx
│   └── nginx.conf
├── Dockerfile
├── Dockerfile-nginx
└── docker-compose.yml

This structure organizes your PHP application, Nginx configuration, Dockerfiles, and Docker Compose file in a clear and maintainable manner.

2. Create a PHP Application

Create a simple PHP application to serve as the basis for containerization. In the root of your project (./index.php), add the following code:

<?php
  echo "Hello!";
?>

This basic script will help you verify that your container setup is working correctly.

3. Configure Nginx

Create an Nginx configuration file in nginx/nginx.conf with the following content:

server {
    listen 80;
    server_name localhost;

    root /var/www/html;
    index index.php index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME /var/www/html$fastcgi_script_name;
    }
}

Explanation:

listen 80;: Nginx listens on port 80 for incoming HTTP requests.
server_name localhost;: Defines the server name.
root /var/www/html;: Sets the root directory for the server.
index index.php index.html;: Specifies the index files.
location /: Handles requests to the root URL, trying to serve the requested file or returning a 404 error if not found.
location ~ .php$: Processes PHP files using PHP-FPM running in the php container on port 9000.

4. Create Dockerfile for PHP

Create a Dockerfile in the root of your project to set up the PHP environment:

# Use the official PHP image with PHP-FPM
FROM php:8.1-fpm

# Set working directory
WORKDIR /var/www/html

# Install necessary PHP extensions
RUN docker-php-ext-install mysqli pdo pdo_mysql

# Copy application files
COPY . /var/www/html

# Set permissions
RUN chown -R www-data:www-data /var/www/html

# Expose port 9000
EXPOSE 9000

# Start PHP-FPM server
CMD ["php-fpm"]

Explanation:

FROM php:8.1-fpm: Uses the official PHP image with PHP-FPM.
WORKDIR /var/www/html: Sets the working directory inside the container.
RUN docker-php-ext-install mysqli pdo pdo_mysql: Installs necessary PHP extensions.
COPY . /var/www/html: Copies the application code into the container.
RUN chown -R www-data:www-data /var/www/html: Sets appropriate permissions.
EXPOSE 9000: Exposes port 9000 for communication with Nginx.
CMD ["php-fpm"]: Starts the PHP-FPM server.

5. Create Dockerfile for Nginx

Create a Dockerfile-nginx in the nginx directory to set up the Nginx environment:

# Use the official Nginx image
FROM nginx:latest

# Remove the default Nginx configuration
RUN rm /etc/nginx/conf.d/default.conf

# Copy the custom Nginx configuration
COPY nginx.conf /etc/nginx/conf.d

# Copy application files to serve static content if needed
COPY ../ /var/www/html

# Expose port 80
EXPOSE 80

# Start Nginx
CMD ["nginx", "-g", "daemon off;"]

Explanation:

FROM nginx:latest: Uses the latest official Nginx image.
RUN rm /etc/nginx/conf.d/default.conf: Removes the default Nginx configuration.
COPY nginx.conf /etc/nginx/conf.d: Copies your custom Nginx configuration.
COPY ../ /var/www/html: Copies application files for serving static content.
EXPOSE 80: Exposes port 80 for HTTP traffic.
CMD ["nginx", "-g", "daemon off;"]: Starts Nginx in the foreground.

6. Create docker-compose.yml

Create a docker-compose.yml file in the root of your project to orchestrate the PHP and Nginx containers:

version: '3.8'

services:
  php:
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - .:/var/www/html
    networks:
      - app-network

  nginx:
    build:
      context: ./nginx
      dockerfile: Dockerfile-nginx
    ports:
      - "80:80"
    depends_on:
      - php
    volumes:
      - .:/var/www/html
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Explanation:

version: '3.8': Specifies the Docker Compose version.
services: Defines the services (php and nginx).
- php:
  - build: Builds the PHP container using the specified Dockerfile.
  - volumes: Mounts the current directory to /var/www/html inside the container.
  - networks: Connects to the app-network.
- nginx:
  - build: Builds the Nginx container using the specified Dockerfile.
  - ports: Maps port 80 of the host to port 80 of the container.
  - depends_on: Ensures Nginx starts after PHP.
  - volumes: Mounts the current directory to /var/www/html inside the container.
  - networks: Connects to the app-network.
networks:
- app-network: Defines a bridge network for inter-service communication.

7. Build and Run the Containers

Navigate to the root of your project in the terminal and execute the following command to build and start the containers:

docker-compose up -d --build

-d: Runs the containers in detached mode.
--build: Forces a rebuild of the Docker images.

Expected Output:

Creating network "project_app-network" with the default driver
Building php
Step 1/7 : FROM php:8.1-fpm
...
Successfully built abc123def456
Successfully tagged project_php:latest
Building nginx
Step 1/5 : FROM nginx:latest
...
Successfully built ghi789jkl012
Successfully tagged project_nginx:latest
Creating project_php_1    ... done
Creating project_nginx_1 ... done

8. Verify the Setup

After the containers are up and running, open your web browser and navigate to http://localhost. You should see the message:

Hello!

This confirms that Nginx is correctly serving the PHP application through the Docker containers.

Troubleshooting Tips

Port Conflicts: Ensure that port 80 is not being used by another service on your host machine.
Container Logs: If you encounter issues, check the logs using:
```
docker-compose logs
```
Container Status: Verify that all containers are running using:
```
docker-compose ps
```

9. Additional Considerations

While the above setup provides a basic containerization of PHP and Nginx, consider the following enhancements for more complex applications:

Environment Variables

Manage configuration settings using environment variables. You can define them in the docker-compose.yml file under each service or use a .env file for better security and flexibility.

services:
  php:
    environment:
      - APP_ENV=production
      - DB_HOST=db
  nginx:
    environment:
      - NGINX_HOST=localhost

Database Integration

If your PHP application requires a database, add another service (e.g., MySQL or PostgreSQL) to the docker-compose.yml and configure PHP to connect to it.

services:
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: app_db
      MYSQL_USER: app_user
      MYSQL_PASSWORD: app_password
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - app-network

volumes:
  db_data:

Update the php service to include the database connection details.

Persistent Storage

Ensure that any data you want to persist (like database files) is stored in Docker volumes to prevent data loss when containers are recreated.

Scaling Services

Docker Compose allows you to scale services. For example, you can run multiple instances of the PHP service to handle increased load:

docker-compose up --scale php=3 -d

Security

Update Docker Images: Always keep your Docker images updated to include the latest security patches.

Multi-Stage Builds: Use multi-stage builds to minimize the image size and reduce the attack surface.

FROM node:14 AS build
WORKDIR /app
COPY . .
RUN npm install && npm run build

FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html

User Permissions: Run containers with non-root users where possible to enhance security.

Logging and Monitoring

Implement logging and monitoring solutions to track the performance and health of your containers. Tools like Prometheus, Grafana, and ELK Stack can be integrated for comprehensive monitoring.

10. Conclusion

Containerizing PHP and Nginx using Docker simplifies the deployment process, ensures consistency across different environments, and enhances scalability. By following the steps outlined above, you can set up a robust environment for your PHP applications, making development and deployment more efficient and manageable.

Embracing containerization not only streamlines your workflow but also positions your applications for better performance and reliability in production environments. As you grow your applications, consider integrating more advanced Docker features and orchestration tools like Kubernetes to further optimize your infrastructure.

Happy Coding!

Feel free to follow me for more insights on containerization, Docker, and web development best practices.

Dev.quizz.vn

Thursday, 9 January 2025