Docker can be an efficient way to run web applications in production, but you may want to run multiple applications on the same Docker host. In this situation, you’ll need to set up a reverse proxy since you only want to expose ports
443 to the rest of the world.
Traefik is a Docker-aware reverse proxy that includes its own monitoring dashboard. In this tutorial, you’ll use Traefik to route requests to two different web application containers: a Wordpress container and an Adminer container, each talking to a MySQL database. You’ll configure Traefik to serve everything over HTTPS using Let’s Encrypt.
To follow along with this tutorial, you will need the following:
One Ubuntu 16.04 server set up by following the Ubuntu 16.04 initial server setup guide, including a sudo non-root user and a firewall.
Docker installed on your server, which you can do by following How to Install and Use Docker on Ubuntu 16.04.
Docker Compose installed with the instructions from How to Install Docker Compose on Ubuntu 16.04.
A domain and three A records,
monitor, that each point to the IP address of your server. You can learn how to point domains to DigitalOcean Droplets by reading through DigitalOcean’s Domains and DNS documentation. Throughout this tutorial, substitute your domain for
example.com in the configuration files and examples.
The Traefik project has an official Docker image, so we will use that to run Traefik in a Docker container.
But before we get our Traefik container up and running, we need to create a configuration file and set up an encrypted password so we can access the monitoring dashboard.
We’ll use the
htpasswd utility to create this encrypted password. First, install the utility, which is included in the
- sudo apt-get install apache2-utils
Then generate the password with
secure_password with the password you’d like to use for the Traefik admin user:
- htpasswd -nb admin secure_password
The output from the program will look like this:
You’ll use this output in the Traefic configuration file to set up HTTP Basic Authentication for the Traefik health check and monitoring dashboard. Copy the entire output line so you can paste it later.
To configure the Traefik server, we’ll create a new configuration file called
traefik.toml using the TOML format. TOML is a configuration language similar to INI files, but it is standardized. This file lets us configure the Traefik server and various integrations, or providers, we want to use. In this tutorial, we will use three of Traefik’s available providers:
acme, which is used to support TLS using Let’s Encrypt.
- nano traefik.toml
First, add two named entry points,
https, that all backends will have access to by default:
defaultEntryPoints = ["http", "https"]
We’ll configure the
https entry points later in this file.
Next, configure the
web provider, which gives you access to a dashboard interface. This is where you’ll paste the output from the
... [web] address = ":8080" [web.auth.basic] users = ["admin:your_encrypted_password"]
The dashboard is a separate web application that will run within the Traefik container. We set the dashboard to run on port
web.auth.basic section configures HTTP Basic Authentication for the dashboard. Use the output from the
htpasswd command you just ran for the value of the
users entry. You could specify additional logins by separating them with commas.
Next, define the entry points. The
entryPoints section configures the addresses that Traefik and the proxied containers can listen on. Add these lines to the file:
... [entryPoints] [entryPoints.http] address = ":80" [entryPoints.http.redirect] entryPoint = "https" [entryPoints.https] address = ":443" [entryPoints.https.tls]
http entry point handles port
80, while the
https entry point uses port
443 for TLS/SSL. We automatically redirect all of the traffic on port
80 to the
https entry point to force secure connections for all requests.
Finally, add this section to configure Let’s Encrypt certificate support for Traefik:
... [acme] email = "email@example.com" storage = "acme.json" entryPoint = "https" onHostRule = true onDemand = false
This section is called
acme because ACME is the name of the protocol used to communicate with Let’s Encrypt to manage certificates. To have Traefik generate certificates for our hosts, we set the
entryPoint key needs to point to the entry point handling port
443, which in our case is the
https entry point.
The last two keys,
onDemand, dictate how Traefik should go about generating certificates. We want to fetch our certificates as soon as our containers with specified hostnames are created, and that’s what the
onHostRule setting will do. The
onDemand setting would attempt to generate certificates the first time that a request is made. This would slow down the first request and be very noticeable to the visitor, so we’ll avoid that.
Save the file and exit the editor. With all of this configuration in place, we can fire up Traefik.
Next, create a Docker network for the proxy to share with containers. The Docker network is necessary so that we can use it with applications that are run using Docker Compose. Let’s call this network
- docker network create proxy
When the Traefik container starts, we will add it to this network. Then we can add additional containers to this network later for Traefik to proxy to.
Next, create an empty file which will hold our Let’s Encrypt information. We’ll share this into the container so Traefik can use it:
- touch acme.json
Traefik will only be able to use this file if the root user inside of the container has unique read and write access to it. To do this, lock down the permissions on
acme.json so that only the owner of the file has read and write permission.
- chmod 600 acme.json
Once the file gets passed to Docker, the owner will automatically change to the root user inside the container.
Finally, create the Traefik container with this command:
- docker run -d \
- -v /var/run/docker.sock:/var/run/docker.sock \
- -v $PWD/traefik.toml:/traefik.toml \
- -v $PWD/acme.json:/acme.json \
- -p 80:80 \
- -p 443:443 \
- -l traefik.frontend.rule=Host:monitor.example.com \
- -l traefik.port=8080 \
- --network proxy \
- --name traefik \
- traefik:1.3.6-alpine --docker
The command is a little long so let’s break it down.
We use the
-d flag to run the container in the background as a daemon. We then share our
docker.sock file into the container so that the Traefik process can listen for changes to containers. We also share the
traefik.toml configuration file and the
acme.json file we created into the container.
Next, we map ports
:443 of our Docker host to the same ports in the Traefik container so Traefik receives all HTTP and HTTPS traffic to the server.
Then we set up two Docker labels that tell Traefik to direct traffic to the hostname
monitor.example.com to port
:8080 within the Traefik container, exposing the monitoring dashboard.
We set the network of the container to
proxy, and we name the container
Finally, we use the
traefik:1.3.6-alpine image for this container, because it’s small.
A Docker image’s
ENTRYPOINT is a command that always runs when a container is created from the image. In this case, the command is the
traefik binary within the container. You can pass additional arguments to that command when you launch the container. In our case, we pass the argument
--docker to the
ENTRYPOINT which ensures that the
docker provider is registered with the default settings. The
docker provider enables Traefik to act as a proxy in front of Docker containers. The default configuration of the Docker provider works well for us, so we won’t need to configure it in our
With the container started, you now have a dashboard you can access to see the health of your containers. You can also use this dashboard to visualize the frontends and backends that Traefik has registered. Access the monitoring dashboard by pointing your browser to
https://monitor.example.com. You will be prompted for your username and password, which are admin and the password you configured in Step 1.
Once logged in,. you’ll see an interface similar to this:
There isn’t much to see just yet, but leave this window open, and you will see the contents change as you add containers for Traefik to work with.
We now have our Traefik proxy running, configured to work with Docker, and ready to monitor other Docker containers. Let’s start some containers for Traefik to act as a proxy for.
With the Traefik container running, you’re ready to run applications behind it. Let’s launch the following cotainers behind Traefik:
We’ll manage both of these applications with Docker Compose using a
- nano docker-compose.yml
Add the following lines to the file to specify the version and the networks we’ll use:
version: "3" networks: proxy: external: true internal: external: false
We use Docker Compose version
3 because it’s the newest major version of the Compose file format.
For Traefik to recognize our applications, they must be part of the same network, and since we created the network manually, we pull it in by specifying the network name of
proxy and setting
true. Then we define another network so that we can connect our exposed containers to a database container that we won’t expose through Traefik. We’ll call this network
Next, we’'ll define each of our
services, one at a time. Let’s start with the
blog container, which we’ll base on the official WordPress image. Add this configuration to the file:
version: "3" ... services: blog: image: wordpress:4.7.5-apache environment: WORDPRESS_DB_PASSWORD: labels: - traefik.backend=blog - traefik.frontend.rule=Host:blog.example.com - traefik.docker.network=proxy - traefik.port=80 networks: - internal - proxy depends_on: - mysql
environment key lets you specify environment variables that will be set inside of the container. By not setting a value for
WORDPRESS_DB_PASSWORD, we’re telling Docker Compose to get the value from our shell and pass it through when we create the container. We will define this environment variable in our shell before starting the containers. This way we don’t hard-code passwords into the configuration file.
labels section is where you specify configuration values for Traefik. Docker labels don’t do anything by themselves, but Traefik reads these so it knows how to treat containers. Here’s what each of these labels does:
traefik.backendspecifies the name of the backend service in Traefik (which points to the actual
traefik.frontend.rule=Host:blog.example.comtells Traefik to examine the host requested and if it matches the pattern of
blog.example.comit should route the traffic to the
traefik.docker.network=proxyspecifies which network to look under for Traefik to find the internal IP for this container. Since our Traefik container has access to all of the Docker info, it would potentially take the IP for the
internalnetwork if we didn’t specify this.
traefik.portspecifies the exposed port that Traefik should use to route traffic to this container.
With this configuration, all traffic sent to our Docker host’s port
80 will be routed to the
We assign this container to two different networks so that Traefik can find it via the
proxy network and it can communicate with the database container through the
depends_on key tells Docker Compose that this container needs to start after its dependencies are running. Since WordPress needs a database to run, we must run our
mysql container before starting our
Next, configure the MySQL service by adding this configuration to your file:
services: ... mysql: image: mysql:5.7 environment: MYSQL_ROOT_PASSWORD: networks: - internal labels: - traefik.enable=false
We’re using the official MySQL 5.7 image for this container. You’ll notice that we’re once again using an
environment item without a value. The
WORDPRESS_DB_PASSWORD variables will need to be set to the same value to make sure that our WordPress container can communicate with the MySQL. We don’t want to expose the
mysql container to Traefik or the outside world, so we’re only assigning this container to the
internal network. Since Traefik has access to the Docker socket, the process will still expose a frontend for the
mysql container by default, so we’ll add the label
traefik.enable=false to specify that Traefik should not expose this container.
Finally, add this configuration to define the Adminer container:
services: ... adminer: image: adminer:4.3.1-standalone labels: - traefik.backend=adminer - traefik.frontend.rule=Host:db-admin.example.com - traefik.docker.network=proxy - traefik.port=8080 networks: - internal - proxy depends_on: - mysql
This container is based on the official Adminer image. The
depends_on configuration for this container exactly match what we’re using for the
However, since we’re directing all of the traffic to port
80 on our Docker host directly to the
blog container, we need to configure this container differently in order for traffic to make it to our
adminer container. The line
traefik.frontend.rule=Host:db-admin.example.com tells Traefik to examine the host requested. If it matches the pattern of
db-admin.example.com Traefik will route the traffic to the
Save the file and exit the text editor.
Next, set values in your shell for the
MYSQL_ROOT_PASSWORD variables before you start your containers:
- export WORDPRESS_DB_PASSWORD=secure_database_password
- export MYSQL_ROOT_PASSWORD=secure_database_password
secure_database_password with your desired database password.
With these variables set, run the containers using
- docker-compose up -d
Now take another look at the Traefik admin dashboard. You’ll see that there is now a
backend and a
frontend for the two exposed servers:
example.com with your domain. You’ll be redirected to a TLS connection and can now complete the Wordpress setup:
Now access Adminer by visiting
db-admin.example.com in your browser, again substituting
example.com with your domain. The
mysql container isn’t exposed to the outside world, but the
adminer container has access to it through the
internal Docker network that they share using the
mysql container name as a host name.
On the Adminer login screen, use the username root, use
mysql for the server, and use the value you set for
MYSQL_ROOT_PASSWORD for the password. Once logged in, you’ll see the Adminer user interface:
Both sites are now working, and you can use the dashboard at
monitor.example.com to keep an eye on your applications.
In this tutorial, you configured Traefik to proxy requests to other applications in Docker containers.
Traefik’s declarative configuration at the application container level makes it easy to configure more services, and there’s no need to restart the
traefik container when you add new applications to proxy traffic to since Traefik notices the changes immediately through the Docker socket file it’s monitoring.
To learn more about what you can do with Traefik, head over to the official Traefik documentation.
Join our DigitalOcean community of over a million developers for free! Get help and share knowledge in our Questions & Answers section, find tutorials and tools that will help you grow as a developer and scale your project or business, and subscribe to topics of interest.Sign up
Click below to sign up and get $200 of credit to try our products over 60 days!