Effortlessly Manage Your PHP Stack: A Guide to Dockerizing Nginx, MariaDB, and PHP-FPM on CentOS

• PHP (Hypertext Preprocessor): A server-side scripting language used to create dynamic web pages. PHP code is executed on the web server before the content is sent to the user's browser.
• MySQL (or MariaDB): A relational database management system (RDBMS) that stores and organizes data in a structured way. Web applications often use MySQL to store information like user accounts, product details, or blog posts.
• Docker: A containerization platform that allows you to package an application with all its dependencies into a standalone unit called a container. This ensures consistent behavior and portability across different environments.

Why Docker?

Traditionally, setting up a LAMP (Linux, Apache, MySQL, PHP) or LEMP (Linux, Nginx, MariaDB, PHP) stack involved installing each component individually on the server. This could lead to configuration issues and inconsistencies. Docker simplifies the process by:

• Isolation: Each container runs in isolation, preventing conflicts with other applications or the host system.
• Portability: Containers can be easily moved between different machines with Docker installed, ensuring consistent behavior.
• Reproducibility: The exact environment is defined in the Dockerfile, making it easy to replicate for development, testing, and production.

1. Install Docker: Follow the official instructions for your CentOS version to install Docker.
2. Define Services (using Docker Compose):
   • Create a file named docker-compose.yml in your project directory.
   • This file specifies the services to be included in your application stack:
     • php-fpm: The FastCGI Process Manager that handles PHP script execution efficiently.
     • nginx: The web server that serves static content and forwards PHP requests to php-fpm.
     • mariadb: The MariaDB database server.
   • You can configure details like ports, environment variables, and volumes within the docker-compose.yml file.
   • Volumes allow you to persist data generated by the containers on the host machine, ensuring it isn't lost when the container restarts.

Example docker-compose.yml:

version: "3.8"  # Specify Docker Compose version

services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"  # Map container port 80 to host port 80 (HTTP)
    volumes:
      - ./your-project-directory:/var/www/html  # Mount your project directory into the container's web root
  php-fpm:
    image: php:7.4-fpm  # Specify desired PHP version
    volumes:
      - ./your-project-directory:/var/www/html
  mariadb:
    image: mariadb:latest
    environment:
      MYSQL_ROOT_PASSWORD: your_strong_password  # Set a strong password for the root user
    volumes:
      - mariadb-data:/var/lib/mysql  # Create a named volume to persist database data

volumes:
  mariadb-data:  # Define the named volume for database persistence

Starting the Stack:

1. Navigate to the directory containing docker-compose.yml.
2. Run the command docker-compose up -d to start all services in detached mode (running in the background).

Benefits of this approach:

• Faster Development: Quickly spin up and bring down your development environment.
• Consistent Environment: Ensures the same environment across development, testing, and production (if Docker is used there too).
• Easier Collaboration: Team members can easily create their development environments without manual configuration.
• Simplified Management: Use Docker commands to manage and update your application stack.

Additional Considerations:

• Security: Always set strong passwords for database users and consider additional security measures.
• Configuration: You may need to adjust the configuration files for each service depending on your specific application requirements.
• Resource Management: Docker containers can consume system resources. Monitor usage and adjust resource allocation if needed.

version: "3.8"  # Specify Docker Compose version

services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"  # Map container port 80 to host port 80 (HTTP)
    volumes:
      - ./your-project-directory:/var/www/html  # Mount your project directory into the container's web root
  php-fpm:
    image: php:7.4-fpm  # Specify desired PHP version
    volumes:
      - ./your-project-directory:/var/www/html
  mariadb:
    image: mariadb:latest
    environment:
      MYSQL_ROOT_PASSWORD: your_strong_password  # Set a strong password for the root user
    volumes:
      - mariadb-data:/var/lib/mysql  # Create a named volume to persist database data

volumes:
  mariadb-data:  # Define the named volume for database persistence

Explanation:

• version: Specifies the Docker Compose file format version (here, 3.8).
• services: Defines the services that make up your application stack:
  • nginx: Uses the official nginx:latest image.
  • php-fpm: Uses the official php:7.4-fpm image (you can choose a different version based on your needs).
• ports: Maps container port 80 (where Nginx listens for requests) to the host machine's port 80 (standard HTTP port).
• volumes: Mounts your project directory (./your-project-directory) on the host machine to the /var/www/html directory within the container. This allows Nginx to access your PHP files.
• environment: Sets the MYSQL_ROOT_PASSWORD environment variable for the mariadb service to a strong password (replace your_strong_password with your actual password).
• volumes (defined outside the services): Creates a named volume called mariadb-data that persists the MariaDB database data (/var/lib/mysql) on the host machine, even if the container restarts.

Running the Stack:

Once you've saved the docker-compose.yml file in your project directory, run the following command to start all services in detached mode (running in the background):

docker-compose up -d

Remember:

• Replace ./your-project-directory with the actual path to your project directory on the host machine.
• Use a strong password for the MariaDB root user and consider additional security measures in production environments.

This method involves manually installing each component on the CentOS server:

• Install packages: Use yum to install httpd (Apache web server), php, php-fpm, mariadb-server, and other required dependencies based on your application needs.
• Configure services: Edit configuration files for each service:
  • /etc/httpd/conf/httpd.conf (Nginx uses a different configuration file)
  • /etc/php-fpm/php-fpm.conf
  • /etc/my.cnf (MariaDB configuration)
• Start and manage services: Use systemd commands like systemctl start httpd, systemctl enable php-fpm, and systemctl start mariadb to manage the services.

Pros:

• More granular control over configuration.
• No additional software (Docker) needed.

Cons:

• More time-consuming and error-prone setup.
• Less portable and requires manual configuration on each server.
• Updating individual components can be complex.

Using Platform-as-a-Service (PaaS):

If you prefer a managed environment, consider using a PaaS (Platform-as-a-Service) offering like OpenShift, AWS Elastic Beanstalk, or Google Cloud Platform App Engine. These platforms handle provisioning, configuration, and scaling of your application stack, including PHP, database, and web server.

• Fastest setup and easiest management.
• Automatic scaling and resource allocation.

• Vendor lock-in and potential cost depending on the platform.
• Less control over the underlying infrastructure.

Choosing the Right Method:

The best method depends on your project requirements, technical expertise, and desired level of control. Here's a general guideline:

• Docker Compose (recommended): Great for development, testing, and deployments where portability and fast environment setup are essential.
• Manual Installation: Suitable for experienced users who need fine-grained control over configuration but are comfortable with manual setup.
• PaaS: Ideal for rapid deployments and environments with limited technical staff but consider potential vendor lock-in and pricing models.