Introduction
Laravel Sail is a light-weight command-line interface for interacting with Laravel's default Docker development environment. Sail provides a great starting point for building a Laravel application using PHP, MySQL, and Redis without requiring prior Docker experience.
At its heart, Sail is the docker-compose.yml
file and
the sail
script that is stored at the root of your project.
The sail
script provides a CLI with convenient methods for
interacting with the Docker containers defined by the
docker-compose.yml
file.
Laravel Sail is supported on macOS, Linux, and Windows (via WSL2).
Installation & Setup
Laravel Sail is automatically installed with all new Laravel applications so you may start using it immediately. To learn how to create a new Laravel application, please consult Laravel's installation documentation for your operating system. During installation, you will be asked to choose which Sail supported services your application will be interacting with.
Installing Sail Into Existing Applications
If you are interested in using Sail with an existing Laravel application, you may simply install Sail using the Composer package manager. Of course, these steps assume that your existing local development environment allows you to install Composer dependencies:
composer require laravel/sail --dev
After Sail has been installed, you may run the
sail:install
Artisan command. This command will publish
Sail's docker-compose.yml
file to the root of your
application:
php artisan sail:install
Finally, you may start Sail. To continue learning how to use Sail, please continue reading the remainder of this documentation:
./vendor/bin/sail up
Adding Additional Services
If you would like to add an additional service to your existing Sail
installation, you may run the sail:add
Artisan command:
php artisan sail:add
Using Devcontainers
If you would like to develop within a Devcontainer,
you may provide the --devcontainer
option to the
sail:install
command. The --devcontainer
option will instruct the sail:install
command to publish a
default .devcontainer/devcontainer.json
file to the root of
your application:
php artisan sail:install --devcontainer
Configuring A Shell Alias
By default, Sail commands are invoked using the
vendor/bin/sail
script that is included with all new
Laravel applications:
./vendor/bin/sail up
However, instead of repeatedly typing vendor/bin/sail
to
execute Sail commands, you may wish to configure a shell alias that
allows you to execute Sail's commands more easily:
alias sail='[ -f sail ] && sh sail || sh vendor/bin/sail'
To make sure this is always available, you may add this to your shell
configuration file in your home directory, such as ~/.zshrc
or ~/.bashrc
, and then restart your shell.
Once the shell alias has been configured, you may execute Sail
commands by simply typing sail
. The remainder of this
documentation's examples will assume that you have configured this
alias:
sail up
Starting & Stopping Sail
Laravel Sail's docker-compose.yml
file defines a variety
of Docker containers that work together to help you build Laravel
applications. Each of these containers is an entry within the
services
configuration of your
docker-compose.yml
file. The laravel.test
container is the primary application container that will be serving your
application.
Before starting Sail, you should ensure that no other web servers or
databases are running on your local computer. To start all of the Docker
containers defined in your application's docker-compose.yml
file, you should execute the up
command:
sail up
To start all of the Docker containers in the background, you may start Sail in "detached" mode:
sail up -d
Once the application's containers have been started, you may access the project in your web browser at: http://localhost.
To stop all of the containers, you may simply press Control + C to
stop the container's execution. Or, if the containers are running in the
background, you may use the stop
command:
sail stop
Executing Commands
When using Laravel Sail, your application is executing within a Docker container and is isolated from your local computer. However, Sail provides a convenient way to run various commands against your application such as arbitrary PHP commands, Artisan commands, Composer commands, and Node / NPM commands.
When reading the Laravel documentation, you will often see references to Composer, Artisan, and Node / NPM commands that do not reference Sail. Those examples assume that these tools are installed on your local computer. If you are using Sail for your local Laravel development environment, you should execute those commands using Sail:
# Running Artisan commands locally...
php artisan queue:work
# Running Artisan commands within Laravel Sail...
sail artisan queue:work
Executing PHP Commands
PHP commands may be executed using the php
command. Of
course, these commands will execute using the PHP version that is
configured for your application. To learn more about the PHP versions
available to Laravel Sail, consult the PHP
version documentation:
sail php --version
sail php script.php
Executing Composer Commands
Composer commands may be executed using the composer
command. Laravel Sail's application container includes a Composer 2.x
installation:
sail composer require laravel/sanctum
Installing Composer Dependencies For Existing Applications
If you are developing an application with a team, you may not be the one that initially creates the Laravel application. Therefore, none of the application's Composer dependencies, including Sail, will be installed after you clone the application's repository to your local computer.
You may install the application's dependencies by navigating to the application's directory and executing the following command. This command uses a small Docker container containing PHP and Composer to install the application's dependencies:
docker run --rm \
-u "$(id -u):$(id -g)" \
-v "$(pwd):/var/www/html" \
-w /var/www/html \
laravelsail/php82-composer:latest \
composer install --ignore-platform-reqs
When using the laravelsail/phpXX-composer
image, you
should use the same version of PHP that you plan to use for your
application (74
, 80
, 81
, or
82
).
Executing Artisan Commands
Laravel Artisan commands may be executed using the
artisan
command:
sail artisan queue:work
Executing Node / NPM Commands
Node commands may be executed using the node
command
while NPM commands may be executed using the npm
command:
sail node --version
sail npm run dev
If you wish, you may use Yarn instead of NPM:
sail yarn
Interacting With Databases
MySQL
As you may have noticed, your application's
docker-compose.yml
file contains an entry for a MySQL
container. This container uses a Docker volume so
that the data stored in your database is persisted even when stopping
and restarting your containers.
In addition, the first time the MySQL container starts, it will
create two databases for you. The first database is named using the
value of your DB_DATABASE
environment variable and is for
your local development. The second is a dedicated testing database named
testing
and will ensure that your tests do not interfere
with your development data.
Once you have started your containers, you may connect to the MySQL
instance within your application by setting your DB_HOST
environment variable within your application's .env
file to
mysql
.
To connect to your application's MySQL database from your local
machine, you may use a graphical database management application such as
TablePlus. By default, the MySQL
database is accessible at localhost
port 3306 and the
access credentials correspond to the values of your
DB_USERNAME
and DB_PASSWORD
environment
variables. Or, you may connect as the root
user, which also
utilizes the value of your DB_PASSWORD
environment variable
as its password.
Redis
Your application's docker-compose.yml
file also contains
an entry for a Redis container. This
container uses a Docker volume so
that the data stored in your Redis data is persisted even when stopping
and restarting your containers. Once you have started your containers,
you may connect to the Redis instance within your application by setting
your REDIS_HOST
environment variable within your
application's .env
file to redis
.
To connect to your application's Redis database from your local
machine, you may use a graphical database management application such as
TablePlus. By default, the Redis
database is accessible at localhost
port 6379.
MeiliSearch
If you chose to install the MeiliSearch service when
installing Sail, your application's docker-compose.yml
file
will contain an entry for this powerful search-engine that is compatible
with Laravel Scout. Once you have started your
containers, you may connect to the MeiliSearch instance within your
application by setting your MEILISEARCH_HOST
environment
variable to http://meilisearch:7700
.
From your local machine, you may access MeiliSearch's web based
administration panel by navigating to http://localhost:7700
in your web browser.
File Storage
If you plan to use Amazon S3 to store files while running your
application in its production environment, you may wish to install the
MinIO service when installing Sail. MinIO
provides an S3 compatible API that you may use to develop locally using
Laravel's s3
file storage driver without creating "test"
storage buckets in your production S3 environment. If you choose to
install MinIO while installing Sail, a MinIO configuration section will
be added to your application's docker-compose.yml
file.
By default, your application's filesystems
configuration
file already contains a disk configuration for the s3
disk.
In addition to using this disk to interact with Amazon S3, you may use
it to interact with any S3 compatible file storage service such as MinIO
by simply modifying the associated environment variables that control
its configuration. For example, when using MinIO, your filesystem
environment variable configuration should be defined as follows:
FILESYSTEM_DISK=s3
AWS_ACCESS_KEY_ID=sail
AWS_SECRET_ACCESS_KEY=password
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=local
AWS_ENDPOINT=http://minio:9000
AWS_USE_PATH_STYLE_ENDPOINT=true
In order for Laravel's Flysystem integration to generate proper URLs
when using MinIO, you should define the AWS_URL
environment
variable so that it matches your application's local URL and includes
the bucket name in the URL path:
AWS_URL=http://localhost:9000/local
You may create buckets via the MinIO console, which is available at
http://localhost:8900
. The default username for the MinIO
console is sail
while the default password is
password
.
Warning!!
Generating temporary storage URLs via thetemporaryUrl
method is not supported when using MinIO.
Running Tests
Laravel provides amazing testing support out of the box, and you may
use Sail's test
command to run your applications feature and unit tests. Any CLI options that are
accepted by PHPUnit may also be passed to the test
command:
sail test
sail test --group orders
The Sail test
command is equivalent to running the
test
Artisan command:
sail artisan test
By default, Sail will create a dedicated testing
database so that your tests do not interfere with the current state of
your database. In a default Laravel installation, Sail will also
configure your phpunit.xml
file to use this database when
executing your tests:
<env name="DB_DATABASE" value="testing"/>
Laravel Dusk
Laravel Dusk provides an expressive,
easy-to-use browser automation and testing API. Thanks to Sail, you may
run these tests without ever installing Selenium or other tools on your
local computer. To get started, uncomment the Selenium service in your
application's docker-compose.yml
file:
selenium:
image: 'selenium/standalone-chrome'
volumes:
- '/dev/shm:/dev/shm'
networks:
- sail
Next, ensure that the laravel.test
service in your
application's docker-compose.yml
file has a
depends_on
entry for selenium
:
depends_on:
- mysql
- redis
- selenium
Finally, you may run your Dusk test suite by starting Sail and
running the dusk
command:
sail dusk
Selenium On Apple Silicon
If your local machine contains an Apple Silicon chip, your
selenium
service must use the
seleniarm/standalone-chromium
image:
selenium:
image: 'seleniarm/standalone-chromium'
volumes:
- '/dev/shm:/dev/shm'
networks:
- sail
Previewing Emails
Laravel Sail's default docker-compose.yml
file contains
a service entry for Mailpit. Mailpit
intercepts emails sent by your application during local development and
provides a convenient web interface so that you can preview your email
messages in your browser. When using Sail, Mailpit's default host is
mailpit
and is available via port 1025:
MAIL_HOST=mailpit
MAIL_PORT=1025
MAIL_ENCRYPTION=null
When Sail is running, you may access the Mailpit web interface at: http://localhost:8025
Container CLI
Sometimes you may wish to start a Bash session within your
application's container. You may use the shell
command to
connect to your application's container, allowing you to inspect its
files and installed services as well execute arbitrary shell commands
within the container:
sail shell
sail root-shell
To start a new Laravel
Tinker session, you may execute the tinker
command:
sail tinker
PHP Versions
Sail currently supports serving your application via PHP 8.2, 8.1,
PHP 8.0, or PHP 7.4. The default PHP version used by Sail is currently
PHP 8.2. To change the PHP version that is used to serve your
application, you should update the build
definition of the
laravel.test
container in your application's
docker-compose.yml
file:
# PHP 8.2
context: ./vendor/laravel/sail/runtimes/8.2
# PHP 8.1
context: ./vendor/laravel/sail/runtimes/8.1
# PHP 8.0
context: ./vendor/laravel/sail/runtimes/8.0
# PHP 7.4
context: ./vendor/laravel/sail/runtimes/7.4
In addition, you may wish to update your image
name to
reflect the version of PHP being used by your application. This option
is also defined in your application's docker-compose.yml
file:
image: sail-8.1/app
After updating your application's docker-compose.yml
file, you should rebuild your container images:
sail build --no-cache
sail up
Node Versions
Sail installs Node 18 by default. To change the Node version that is
installed when building your images, you may update the
build.args
definition of the laravel.test
service in your application's docker-compose.yml
file:
build:
args:
WWWGROUP: '${WWWGROUP}'
NODE_VERSION: '14'
After updating your application's docker-compose.yml
file, you should rebuild your container images:
sail build --no-cache
sail up
Sharing Your Site
Sometimes you may need to share your site publicly in order to
preview your site for a colleague or to test webhook integrations with
your application. To share your site, you may use the share
command. After executing this command, you will be issued a random
laravel-sail.site
URL that you may use to access your
application:
sail share
When sharing your site via the share
command, you should
configure your application's trusted proxies within the
TrustProxies
middleware. Otherwise, URL generation helpers
such as url
and route
will be unable to
determine the correct HTTP host that should be used during URL
generation:
/**
* The trusted proxies for this application.
*
* @var array|string|null
*/
protected $proxies = '*';
If you would like to choose the subdomain for your shared site, you
may provide the subdomain
option when executing the
share
command:
sail share --subdomain=my-sail-site
Note:
Theshare
command is powered by Expose, an open source tunneling service by BeyondCode.
Debugging With Xdebug
Laravel Sail's Docker configuration includes support for Xdebug, a popular and powerful debugger
for PHP. In order to enable Xdebug, you will need to add a few variables
to your application's .env
file to configure Xdebug. To
enable Xdebug you must set the appropriate mode(s) before starting
Sail:
SAIL_XDEBUG_MODE=develop,debug,coverage
Linux Host IP Configuration
Internally, the XDEBUG_CONFIG
environment variable is
defined as client_host=host.docker.internal
so that Xdebug
will be properly configured for Mac and Windows (WSL2). If your local
machine is running Linux, you should ensure that you are running Docker
Engine 17.06.0+ and Compose 1.16.0+. Otherwise, you will need to
manually define this environment variable as shown below.
First, you should determine the correct host IP address to add to the
environment variable by running the following command. Typically, the
<container-name>
should be the name of the container
that serves your application and often ends with
_laravel.test_1
:
docker inspect -f {{range.NetworkSettings.Networks}}{{.Gateway}}{{end}} <container-name>
Once you have obtained the correct host IP address, you should define
the SAIL_XDEBUG_CONFIG
variable within your application's
.env
file:
SAIL_XDEBUG_CONFIG="client_host=<host-ip-address>"
Xdebug CLI Usage
A sail debug
command may be used to start a debugging
session when running an Artisan command:
# Run an Artisan command without Xdebug...
sail artisan migrate
# Run an Artisan command with Xdebug...
sail debug migrate
Xdebug Browser Usage
To debug your application while interacting with the application via a web browser, follow the instructions provided by Xdebug for initiating an Xdebug session from the web browser.
If you're using PhpStorm, please review JetBrain's documentation regarding zero-configuration debugging.
Warning!!
Laravel Sail relies onartisan serve
to serve your application. Theartisan serve
command only accepts theXDEBUG_CONFIG
andXDEBUG_MODE
variables as of Laravel version 8.53.0. Older versions of Laravel (8.52.0 and below) do not support these variables and will not accept debug connections.
Customization
Since Sail is just Docker, you are free to customize nearly
everything about it. To publish Sail's own Dockerfiles, you may execute
the sail:publish
command:
sail artisan sail:publish
After running this command, the Dockerfiles and other configuration
files used by Laravel Sail will be placed within a docker
directory in your application's root directory. After customizing your
Sail installation, you may wish to change the image name for the
application container in your application's
docker-compose.yml
file. After doing so, rebuild your
application's containers using the build
command. Assigning
a unique name to the application image is particularly important if you
are using Sail to develop multiple Laravel applications on a single
machine:
sail build --no-cache