An Introduction to Docker: Comprehensive Guide to Containerization and Local Deployment
An Introduction to Docker: Comprehensive Guide to Containerization and Local Deployment
Unveiling Docker: A Dive for PHP Developers. Master Docker from scratch & streamline your development workflow.
Technology
February 7, 2024
Mobinul Islam Riyadh
Tanvir Ornob Shishir
Software Engineer specializing in back-end development. Experienced with all stages of the development cycle for dynamic web projects. Well-versed in numerous programming languages including PHP OOP, Laravel, JavaScript, AJAX, C, Rust, Java, and MySQL. Strong background in project management and customer relations. And also well-experienced in Docker, Kubernetes and CICD
Introduction
We’ll go deep into Docker with PHP in this tutorial, going over every step of the way from creating a Dockerfile to executing a PHP app locally. Discover how Docker ensures consistency across many environments by offering a smooth development and deployment experience.
What is Docker?
A complete containerization platform called Docker was created to solve several issues with software development and deployment. By enclosing applications and their dependencies in lightweight, portable containers, it transforms application packaging. By offering a consistent runtime environment, these containers help to reduce problems with inconsistent environments, conflicts between dependencies, and disparities in deployment between various systems. Docker ensures that every container runs independently by isolating programs, improving security, and reducing conflicts between co-existing services. Docker’s efficiency comes from sharing the host operating system’s kernel between containers, which maximizes resource usage and permits quick deployment with little overhead. Scaling is made easier with this method because it is simple to duplicate containers to accommodate different workloads. Docker also helps with version management, which makes it easier to roll back or update using versioned container images. The platform’s adaptability promotes cooperation between the development and operations teams in line with DevOps methodologies. To put it briefly, Docker promotes consistency, efficiency, and scalability across a variety of computer environments by streamlining the whole software development lifecycle.
Why Consider Docker?
- Consistent Application Execution Across Environments:
Docker offers an answer to the age-old “it works on my machine” puzzle. Docker guarantees consistent execution of your PHP application across many development, testing, and production environments by encapsulating it and its dependencies into containers. Because of this uniformity, compatibility problems are reduced, facilitating smoother software engineering collaboration.
Example: Assume that a coworker is testing your PHP application in a separate setting while you are working on it locally. Docker ensures that the application will operate consistently, protecting you both from unexpected problems brought on by inconsistent environments.
- Separation for Environments of Cleaner Development:
Conflicts between several apps and their dependencies can be a pain in the field of software engineering. This problem is solved by Docker, which isolates every application inside its container. Conflicts are reduced and a clear, consistent environment is ensured for testing and development thanks to this isolation.
As an illustration, picture yourself working on two distinct PHP projects, each with its own set of dependencies. Docker containers guarantee that every project has its private environment, avoiding conflicts across libraries or versions.
- Effective Resource Management and Quick Startups:
Docker containers are lightweight and resource-efficient because they share the same operating system kernel. In contrast, conventional virtual machines need a different operating system for every instance. As a result, system resources are used optimally and startup times speed up, improving the development process’s overall effectiveness.
Consider the following scenario: You need to run several instances of your PHP application to perform load testing. Because of Docker’s efficiency, you can scale horizontally without stressing your system, which makes the testing environment responsive and seamless.
- Horizontal Scaling Made Easy for Growing Workloads:
Docker makes scalability easier by enabling developers to run numerous instances of their apps in containers. This method of horizontal scalability is especially helpful in handling surges in traffic or increased workloads. Without the hassles of traditional scaling techniques, software programmers may easily duplicate containers to fulfill demand.
Example: Let’s say there is an unexpected boost in user traffic to your PHP application. Because of Docker’s scalability, you can easily add more containers to meet the growing load and maintain a responsive user interface.
Example: Laravel Dockerfile
FROM php:8.1-fpm
# Set working directory
WORKDIR /var/www
# Install php extensions
RUN chmod +x /usr/local/bin/install-php-extensions && sync && \
install-php-extensions mbstring pdo_mysql zip exif pcntl gd memcached calendar
# Install dependencies
RUN apt-get update && apt-get install -y \
build-essential \
libpng-dev \
libjpeg62-turbo-dev \
libfreetype6-dev \
locales \
zip \
jpegoptim optipng pngquant gifsicle \
unzip \
git \
curl \
lua-zlib-dev \
libmemcached-dev \
nginx \
cron
# Install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
# PHP Error Log Files
RUN mkdir /var/log/php
RUN touch /var/log/php/errors.log && chmod 777 /var/log/php/errors.log
EXPOSE 80 443Example: Docker Compose for the dockerfile
version: '3.9'
services:
php:
build:
context: .
dockerfile: Dockerfile
ports:
- "8080:80"
- "443:443"
volumes:
- ./path/to/your/php/files:/var/www
depends_on:
- mysql
mysql:
image: mysql:8.0
environment:
MYSQL_DATABASE: your_database_name
MYSQL_ROOT_PASSWORD: your_root_password
MYSQL_USER: your_username
MYSQL_PASSWORD: your_password
ports:
- "3306:3306"
volumes:
- mysql_data:/var/lib/mysql
volumes:
mysql_data:After setup, here are some additional details:
- Adding Your Laravel Code:
Place your Laravel project files in the directory specified in the volumes section of the PHP service. This ensures your local code is linked to the container.
- MySQL Configuration:
Ensure your Laravel .env file is configured with the correct MySQL database connection details. The MySQL service is configured with an initial database (your_database_name), root password (your_root_password), and a user with its password. Modify these values based on your application’s needs.
- Running the Docker Compose:
Open a terminal, navigate to the directory containing your docker-compose.yml file, and run:
docker-compose upAccessing Your Laravel Application:
Once the containers are running, you can access your Laravel application at http://localhost: 8080 in your web browser.
For MySQL, you can connect to it using the configured port (3306) and credentials.
Introducing the Next Blog Teaser: Docker Components
We’ll go into more detail and solve the mystery around each of Docker’s essential parts in our next blog post. We’ll explain the functions and importance of everything from volumes to networks to images to containers. With this understanding, you’ll be able to work with Docker more intelligently and design, deploy, and manage applications more easily. A voyage into the core of Docker’s architecture is coming up soon, so stay tuned!