Local WordPress Development with Lando (or Docker made easy)

Earlier this year I wrote a guide on how to use Docker to develop in WordPress. I really enjoyed working on that post, and it looks like you liked it too (thanks for all your comments and emails). If you didn’t read the post, here’s a quick reminder:

Docker is a program that allows you to package software in containers and run them on top of virtual machines. The main advantage of Docker is that its containers run using the virtualization environment provided by the host operating system, resulting in fast and light containers.

The main problem Docker has is that its configuration is cumbersome. For example, to create a WordPress development environment, we need to start two (at least) services: a database service and a webapp server.

In the post that commented at the beginning we saw a tool, Docker Compose, that allows to define all the services we have to spin up for a given project. With Docker Compose, we managed to define in a single file docker-compose.yml all the dependencies of our project and kick it off with a single command.

Or that is what I initially promised, because I closed the post by explaining how to configure yet another Docker service that would allow you to use beautiful domain names in your WordPress installations. If you remember, with the original docker-compose.yml file, our WordPress dev env would be accessible via http://localhost:8080. But if we wanted to use something like http://myplugin.local we had to set up a proxy that could resolve domain names and add more settings to our docker-compose.yml…

I know, I know—it was quite complicated to get things up and running! But once you had everything properly set up, it was quite easy, right? Anyway, I’ve decided to introduce you my new friend: Lando. He’ll help you set up new development environments in seconds.

Enter Lando

I think the best way to introduce yourself to Lando is by using a sentence from his documentation:

Lando is for developers who want to avoid the buildt-in-masochism of directly using docker or docker-compose.

Lando’s docs

Yup, apparently using docker and docker-compose is for masochists… So let’s see how we can specify quickly and without complications all the services we need to work on a new WordPress project.

Installing Lando

The first thing you should do to be able to use Lando is (surprise, surprise!) install it on your computer. The installation process is extremely simple and is very well documented, but we can summarize it in the following steps:

1. Lando requires Docker. If you are on Linux, install Docker Community Edition first. If you are on Mac or Windows, Lando’s installer itself will install Docker if it is not already available.
2. Download the appropriate Lando installer for your operating system. In my case, for example, I downloaded the file lando-v3.0.0-rc.22.deb (I’m on Linux) and installed it with dpkg. For Mac, use the .dmg file and, for Windows, the .exe.
3. Run the installer and follow the steps.

And that’s it!

Nelio A/B Testing

I was very impressed by the quality of this plugin, how easy it was to set up, and the outstanding support Nelio provides. I highly recommend Nelio A/B Testing.

Josette Millar

WordPress.org

View Plans

How to Create a new WordPress Project in Lando

The first thing we have to do is go to the project folder we want to work with (or create a new one for it). In my case, I will create a new WordPress dev env to develop our Nelio A/B Testing plugin, so I’ll cd to the folder where I downloaded the project: ~/dev/plugins/nelio-ab-testing.

Once there, we have to create Lando’s configuration file. This file is similar to docker-compose.yml, but much simpler. For starters, you don’t even need to write it—Lando can do it for you! Simply use lando init to create a new development environment:

lando init \
  --recipe wordpress
  --source remote
  --remote-url https://wordpress.org/latest.tar.gz
  --webroot wordpress
  --name "Nelio AB Testing" # name the project as you want

Let’s see what the previous instruction does:

• First, we tell Lando we want to create a new configuration file in the current directory using lando init.
• The first parameter (--recipe wordpress) tells Lando that we want to create a WordPress project. This will help Lando know the services it has to set up (a database, a web server, etc).
• Then we indicate we want Lando to download WordPress from WordPress.org.
• With --webroot wordpress we tell Lando where WordPress is going to be installed. Since we just specified that WordPress has to be downloaded from WordPress.org and the zip Lando will download will create a wordpress folder after unzipping, that’s the location we use for Lando.
• Finally, we specify the name of our project (Lando will use it to generate friendly URL domains).

After running the previous command, you will see how Lando installs everything and welcomes you with the following info:

NOW WE'RE COOKING WITH FIRE!!!
Your app has been initialized!
Go to the directory where your app was initialized and run `lando start` to get rolling.
Check the LOCATION printed below if you are unsure where to go.
Oh... and here are some vitals:
 NAME      my-site                                               
 LOCATION  /tmp/plugin                                           
 RECIPE    wordpress                                             
 DOCS      https://docs.devwithlando.io/tutorials/wordpress.html

List all files in the current folder and you’ll see Lando created a hidden file named .lando.yml with the following content:

name: my-site
recipe: wordpress
config:
  webroot: wordpress

Extremely simple, right? Now start your service using lando start and you’re good to go:

BOOMSHAKALAKA!!!
Your app has started up correctly.
Here are some vitals:
 NAME            my-site                   
 LOCATION        /tmp/plugin               
 SERVICES        appserver, database       
 APPSERVER URLS  https://localhost:32781   
                 http://localhost:32782    
                 http://nelio-ab-testing.lndo.site  
                 https://nelio-ab-testing.lndo.site

Congrats! You now have a new WordPress installation up and running. If we now go to one of the URLs Lando listed on start, you’ll see you simply need to follow the steps to complete the installation of WordPress:

Completing WordPress Installation Quickly

Obviously you can complete the installation of WordPress using the installer of the previous screen. But there is an even better solution: use WP-CLI, which we also have available in Lando.

To install WordPress with WP-CLI we need to first create a wp-config.php in the wordpress directory. To create that file, we need some information about our database: where it is, its username and password, etc. All this information can be found via lando info, which returns the following JSON:

[
  {
    service: 'appserver',
    urls: [
      'https://localhost:32781',
      'http://localhost:32782',
      'http://nelio-ab-testing.lndo.site',
      'https://nelio-ab-testing.lndo.site'
    ],
    //...
  },
  {
    service: 'database',
    //...
    creds: {
      database: 'wordpress',
      password: 'wordpress',
      user: 'wordpress',
    },
    //...
  }
]

Since the results is a JSON string, we can use Unix’s jq tool to retrieve the specific values we’re interested in. For example, if we want to know the user of our database, just run this:

$ lando info --service database --format json | jq -r ".[0].creds.user"
wordpress

Now, let’s leverage this command and retrieve all the relevant data we need to build the config file using WP-CLI:

# Find WordPress' directory (webroot entry in .lando.yml)
WEBROOT=`grep webroot .lando.yml | cut -d: -f2 | xargs`
# Retrieve database credentials using lando info
DBNAME=`lando info --service database --format json | jq -r ".[0].creds.database"`
DBUSER=`lando info --service database --format json | jq -r ".[0].creds.user"`
DBPASS=`lando info --service database --format json | jq -r ".[0].creds.password"`
DBHOST=`lando info --service database --format json | jq -r ".[0].hostnames[0]"`
# Create WordPress' config file
lando wp config create \
  --dbname=$DBNAME \
  --dbuser=$DBUSER \
  --dbpass=$DBPASS \
  --dbhost=$DBHOST \
  --path=$WEBROOT

Once we have the file created, we can launch the installation command:

# Get WordPress' project name from .lando.yml
PROJECT_NAME=`grep name .lando.yml | cut -d: -f2 | xargs`
SITE_NAME=`echo "$PROJECT_NAME" | sed -e "s/-/ /g" | sed "s/\b[a-z]/\u&/g"`
# Get one of the possible WordPress' URLs ando created (https)
URL=`lando info --service appserver --format json | jq -r ".[0].urls" | grep -vw localhost | grep https: | cut -d'"' -f2`
# Extract the domain from the previous URL (removing https)
DOMAIN=`echo "$URL" | sed -e "s/^https:\/\///"`
# Install WordPress
lando wp core install
 --url=$URL
 --title="$SITE_NAME"
 --admin_user=admin
 --admin_password=password
 --admin_email=admin@$DOMAIN
 --path=$WEBROOT

Done! We already have WordPress installed and working.

How to put our project into WordPress

If we now log in into WordPress and we take a look at the available plugins, we’ll see that our plugin (Nelio A/B Testing, in my example) is not there. That’s because Nelio A/B Testing is not in wordpress/wp-content/plugins/. To fix this, we simply need to create a soft link in this directory that points to the root of our project:

cd wordpress/wp-content/plugins/
ln -s ../../../ nelio-ab-testing
cd -

And that’s it!

It’s now up to you to decide the approach that better suits your needs. If you want to create a WordPress install for every project, just follow the steps I’ve described. If, on the other hand, you want a single WordPress installation with all your themes and plugins in it, then simply create a new folder, init Lando there, and add all your plugins in wordpress/wp-content/plugins/.

I hope you liked this post and tool as much as I did. And I hope it makes your work easier and funnier. Since using Lando, I moved away from Docker completely.

Featured image by Victoire Joncheray on Unsplash.