Using Laravel with Docker and Docker-Compose
In this tutorial we'll learn how we can use Docker and Compose to develop and run Laravel applications locally. Following this tutorial you'll learn:
- what's Docker and Docker-compose
- how to install Docker and Docker-compose
- how to use Docker to install and run Laravel applications
Docker is a container tool that allows developers and organizations to build, run and deploy applications using containers.
Containers are standalone images that allow developers to package applications with their dependencies. They share the system kernel and resources for the system where they are running and they provide isolated environments for applications.
Docker makes use of
Dockerfile files to define and describe the parts and dependencies used by an application and also commands to run in order to install the dependences and start the application etc.
The official documentation describes docker-compose as
Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services. Then, with a single command, you create and start all the services from your configuration. To learn more about all the features of Compose, see the list of features.
Using docker-compose involves three easy steps:
First, you need to define/describe your app environment with a
Dockerfileso you can reproduce it anywhere.
Second, you need to create
docker-compose.ymlfile and define the services required for running your application so you can run them in multi containers.
Finally you just need to run
docker-compose upand Compose will start all the services for your application
Creating a Laravel Project
Let's create a Laravel project and then see how we can dockerize it using Docker.
We have different ways to create Laravel projects: Using Composer (PHP package manager), cloning from GitHub and downloading using cURL.
If you have Composer installed on your system then you can simply use the following command to create a Laravel project:
composer create-project --prefer-dist laravel/laravel laravelproject
Using GitHub Repository
Alternatively if you don't want to install Composer in your system, you can also clone Laravel from GitHub using:
git clone https://github.com/laravel/laravel.git laravelproject
Or also using cURL:
curl -L https://github.com/laravel/laravel/archive/5.5.zip
Installing the Project Dependencies
Now let's install the project's dependencies. If you have Composer installed, simply run the following command from within your project's root folder:
If you don't have Composer installed on your system. You can also use Docker with the official composer image to install dependencies by running the following command from the project's root folder:
docker run --rm -v $(pwd):/app composer/composer install
--rm switch tells Docker to automatically clean up and remove the container after doing the task and exiting.
This is what the docs says about that:
By default a container’s file system persists even after the container exits. This makes debugging a lot easier (since you can inspect the final state) and you retain all your data by default. But if you are running short-term foreground processes, these container file systems can really pile up. If instead you’d like Docker to automatically clean up the container and remove the file system when the container exits, you can add the
-v $(pwd):/app instructs Docker to mount the current directory on the host system retrieved using
/app in the container . What
app? Simply because the composer tool in the container will look for a
composer.json file in this folder.
After finishing the installation, either way, you'll find a
vendor folder with all dependencies inside your Laravel project.
Creating a Dockerfile
Now, after installing Docker and Docker-compose and creating the laravel project let's create a
Dockerfile to define our environmenet. Create a new
Dockerfile file in the application directory and start by adding the first command:
This tells Docker to download and use the
RUN apt-get update -y && apt-get install -y libmcrypt-dev openssl RUN docker-php-ext-install pdo mcrypt mbstring
apt-get to install the dependencies and extensions required by Laravel.
If you want to install Composer you can also add this command:
RUN apt-get -y curl RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
WORKDIR /app COPY . /app
This tells Docker to set the working directory in the container to
/app and copy the files (Laravel project) in our current folder (in our system host) to the
/app folder in the container.
If you didn't install the dependencies using the previous methods you can install them using:
RUN composer install
Now, let's run the
artisan serve command using the
CMD php artisan serve --host=0.0.0.0 --port=8000
This will serve the Laravel project from the port
Finally, you need to expose the port
8000 from the container using:
This is the complete Dockerfile:
FROM php:7 RUN apt-get update -y && apt-get install -y libmcrypt-dev openssl RUN docker-php-ext-install pdo mcrypt mbstring RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer RUN docker-php-ext-install pdo mcrypt mbstring WORKDIR /app COPY . /app RUN composer install CMD php artisan serve --host=0.0.0.0 --port=8000 EXPOSE 8000
Building the Docker Image
After creating the
Dockerfile, you are ready to create the actual Docker image. From your terminal, navigate to the root folder of your project and run:
docker build -t my-laravel-image .
-t switch we can specify the tag/name of the Docker image. For the dot means the current folder will be used as the context for the image to be built. Remember the
COPY command in the
Dockerfile? its source folder is this folder so we can copy the files from our project to the container file-system.
Running the Docker Image Using Docker
After building the Docker image (
my-laravel-image) you can now run it using:
docker run -p 8000:8000 my-laravel-image
You can now access your application from your browser at
Running the Docker Image Using Docker-compose
Docker-compose is more useful to build multi containers for the same application but it can also used to run a single Docker image. So first, create a
docker-compose.yml file in the root folder of your project and add the following content:
web: image: my-laravel-image ports: - 8000:8000 volumes: - ./:/app
We are defining a volume using
./:/var/www which simply mount our current directory
./ in the host system to
/app in the container. This will allow you to work on the source code in your project's folder and changes will be reflected in the container file-system (in our case
/app) without executing any other commands.
In this tutorial, we've seen how to use Docker to create a development environment with Laravel. We've seen how to use both Docker and docker-compose to run our Laravel application in an isolated container.