Docker deployment in Laravel - Step-by-Step Execution

Concept Flow - Docker deployment

Write Dockerfile

↓

Build Docker Image

↓

Run Container

↓

Container Starts Laravel App

↓

App Listens on Port

↓

Access App via Browser

This flow shows how you write a Dockerfile, build an image, run a container, and access the Laravel app inside Docker.

Execution Sample

Laravel

FROM php:8.2-fpm
WORKDIR /var/www/html
COPY . .
RUN docker-php-ext-install pdo pdo_mysql
CMD ["php", "artisan", "serve", "--host=0.0.0.0", "--port=8000"]

This Dockerfile sets up a PHP environment for Laravel, copies the app, installs extensions, and runs the Laravel development server.

Execution Table

Step	Action	Details	Result
1	Read Dockerfile	FROM php:8.2-fpm	Base PHP image selected
2	Set working directory	WORKDIR /var/www/html	Working directory set inside container
3	Copy app files	COPY . .	Laravel app files copied into container
4	Install PHP extensions	RUN docker-php-ext-install pdo pdo_mysql	PDO extensions installed
5	Set container start command	CMD ["php", "artisan", "serve", "--host=0.0.0.0", "--port=8000"]	Container will run php artisan serve on start
6	Build image	docker build -t laravel-app .	Docker image 'laravel-app' created
7	Run container	docker run -p 8000:8000 laravel-app	Container runs, Laravel dev server listens on port 8000
8	Access app	Open browser at localhost:8000	Laravel app responds to requests
9	Exit	Stop container	Container stops, app no longer accessible

💡 Container stops when user stops it; app no longer accessible

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 7	Final
Docker Image	None	Partial (files copied)	Complete (extensions installed)	Complete (ready to run)	laravel-app
Container State	Not running	Not running	Not running	Running (php artisan serve active)	Stopped

Key Moments - 3 Insights

Why do we need to copy the Laravel app files into the Docker image?

Because the container runs isolated, it needs the app files inside to serve the Laravel application. See execution_table step 3.

Why do we map port 8000 on the host to port 8000 inside the container?

Docker maps host port 8000 to container port 8000, so external requests to 8000 reach the Laravel dev server on 8000. See execution_table step 7.

What happens if we don't install the PDO extensions in the Docker image?

Laravel won't connect to the database properly, causing errors. See execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after step 4?

A Container runs PHP-FPM

B Laravel app files copied

C PDO extensions installed

D Docker image created

💡 Hint

Check the 'Result' column for step 4 in the execution_table.

At which step does the container start running the Laravel app?

A Step 7

B Step 6

C Step 5

D Step 8

💡 Hint

Look for when the container state changes to running in variable_tracker and execution_table.

If you forget to set the CMD in the Dockerfile, what will happen when you run the container?

A Container will run PHP-FPM anyway

B Container will start but exit immediately

C Container will expose port 8000 automatically

D Laravel app will be accessible without issues

💡 Hint

CMD defines the start command; missing it means no process keeps container alive (see execution_table step 5).

Concept Snapshot

Docker deployment for Laravel:
- Write Dockerfile with base PHP image
- Copy app files inside container
- Install needed PHP extensions
- Set CMD to run php artisan serve
- Build image and run container mapping ports
- Access Laravel app via mapped port
- Stop container to end app

Full Transcript

Docker deployment for Laravel involves creating a Dockerfile that starts from a PHP base image, sets a working directory, copies the Laravel app files, installs necessary PHP extensions like PDO, and sets the command to run php artisan serve. Then you build the Docker image and run a container from it, mapping a host port to the container port where the development server listens. You can then access the Laravel app through your browser using the mapped port. Stopping the container stops the app. This process isolates the app environment and makes deployment consistent.

Practice

1. What is the main purpose of using Docker for deploying a Laravel application?

easy

A. To package the Laravel app with all its dependencies for consistent environments

B. To write Laravel code faster using special Docker commands

C. To replace Laravel's routing system with Docker's networking

D. To automatically generate Laravel migrations

Solution

1. Step 1: Understand Docker's role in deployment

   Docker packages the app and its environment so it runs the same everywhere.

2. Step 2: Relate this to Laravel deployment

   Laravel apps need PHP, web server, database, and dependencies; Docker bundles these.

3. Final Answer:

   To package the Laravel app with all its dependencies for consistent environments -> Option A

4. Quick Check:

   Docker ensures consistent app environment = C [OK]

Hint: Docker bundles app and tools for same setup everywhere [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Confusing Docker with Laravel features
• Believing Docker replaces Laravel's internal functions

2. Which file is typically used to define the environment and instructions to build a Docker image for a Laravel app?

easy

A. .env

B. docker-compose.yml

C. Dockerfile

D. composer.json

Solution

1. Step 1: Identify Dockerfile's purpose

   Dockerfile contains commands to build the Docker image step-by-step.

2. Step 2: Differentiate from other files

   docker-compose.yml runs containers; .env holds app configs; composer.json manages PHP packages.

3. Final Answer:

   Dockerfile -> Option C

4. Quick Check:

   Dockerfile builds image = A [OK]

Hint: Dockerfile builds image; compose runs containers [OK]

Common Mistakes:

• Confusing docker-compose.yml with Dockerfile
• Thinking .env defines Docker build steps
• Mixing composer.json with Docker configs

3. Given this docker-compose.yml snippet for Laravel:

services:
  app:
    build: .
    ports:
      - "8000:80"
    volumes:
      - .:/var/www/html
  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: secret

What happens when you run docker-compose up?

medium

A. It builds the app image, runs app on port 8000, and starts MySQL with root password

B. It only runs MySQL container without the app

C. It builds app image but fails to start MySQL due to missing password

D. It runs app on port 80 without MySQL

Solution

1. Step 1: Analyze docker-compose services

   App service builds from current folder, maps port 8000 to container's 80, mounts code volume. DB uses MySQL image with root password set.

2. Step 2: Understand docker-compose up behavior

   It builds and starts all defined services, so both app and db run with given configs.

3. Final Answer:

   It builds the app image, runs app on port 8000, and starts MySQL with root password -> Option A

4. Quick Check:

   Compose runs all services with configs = B [OK]

Hint: docker-compose up runs all services with given configs [OK]

Common Mistakes:

• Assuming only one service runs
• Missing environment variable for MySQL password
• Confusing port mapping direction

4. You wrote this Dockerfile for Laravel but get an error when building:

FROM php:8.1-fpm
RUN apt-get update && apt-get install -y git zip unzip
COPY . /var/www/html
RUN composer install

What is the likely cause of the build failure?

medium

A. apt-get update should be run after composer install

B. COPY command syntax is incorrect

C. PHP version 8.1-fpm is not supported by Laravel

D. Missing installation of Composer before running composer install

Solution

1. Step 1: Check Dockerfile commands order

   Composer is a separate tool and must be installed before running composer install.

2. Step 2: Identify missing Composer installation

   Dockerfile does not install Composer, so the command fails.

3. Final Answer:

   Missing installation of Composer before running composer install -> Option D

4. Quick Check:

   Composer must be installed before use = D [OK]

Hint: Install Composer before running composer commands [OK]

Common Mistakes:

• Assuming PHP image includes Composer by default
• Thinking COPY syntax causes build error
• Believing PHP 8.1-fpm is incompatible with Laravel

5. You want to deploy a Laravel app with Docker using docker-compose. You need PHP, MySQL, and Redis services. Which docker-compose.yml snippet correctly sets up these services with proper ports and environment variables?

hard

A. services:
app:
image: laravel/php
ports:
- "80:80"
db:
image: mysql
environment:
MYSQL_PASSWORD: secret
cache:
image: redis
ports:
- "6379:6379"

B. services:
app:
build: .
ports:
- "8080:80"
volumes:
- .:/var/www/html
db:
image: mysql:8
environment:
MYSQL_ROOT_PASSWORD: secret
cache:
image: redis:latest
ports:
- "6379:6379"

C. services:
app:
build: .
ports:
- "80:8080"
db:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: root
cache:
image: redis
ports:
- "6379:6379"

D. services:
app:
build: .
ports:
- "8000:8000"
db:
image: mysql:8
environment:
MYSQL_ROOT_PASSWORD: secret
cache:
image: redis:latest

Solution

1. Step 1: Check app service configuration

   services: app: build: . ports: - "8080:80" volumes: - .:/var/www/html db: image: mysql:8 environment: MYSQL_ROOT_PASSWORD: secret cache: image: redis:latest ports: - "6379:6379" builds app from current folder, maps port 8080 to container port 80, and mounts code volume correctly.

2. Step 2: Verify db and cache services

   MySQL uses image mysql:8 with root password set; Redis uses latest image and exposes default port 6379.

3. Step 3: Compare other options for correctness

   services: app: image: laravel/php ports: - "80:80" db: image: mysql environment: MYSQL_PASSWORD: secret cache: image: redis ports: - "6379:6379". This option misses the volume mount for app code and uses wrong environment variable for MySQL (MYSQL_PASSWORD instead of MYSQL_ROOT_PASSWORD); the option with app ports "80:8080" has wrong port mapping; the option without ports for Redis misses exposing the Redis port.

4. Final Answer:

   services: app: build: . ports: - "8080:80" volumes: - .:/var/www/html db: image: mysql:8 environment: MYSQL_ROOT_PASSWORD: secret cache: image: redis:latest ports: - "6379:6379" -> Option B

5. Quick Check:

   Correct service setup with ports and env = A [OK]

Hint: Check ports and env vars carefully for all services [OK]

Common Mistakes:

• Swapping port mappings (host:container)
• Using wrong environment variable names
• Omitting volume mounts for app code
• Not exposing Redis port