• Docker-compose basic example
    • Setup
    • Details

    Docker-compose basic example

    In this section we quickly go over a basic docker-compose file exposing a simple service using the docker provider.This will also be used as a starting point for the the other docker-compose guides.

    Setup

    • Edit a docker-compose.yml file with the following content:
    1. version: "3.3"
    3. services:
    5.   traefik:
    6.     image: "traefik:v2.0.0-rc3"
    7.     container_name: "traefik"
    8.     command:
    9.       #- "--log.level=DEBUG"
    10.       - "--api.insecure=true"
    11.       - "--providers.docker=true"
    12.       - "--providers.docker.exposedbydefault=false"
    13.       - "--entrypoints.web.address=:80"
    14.     ports:
    15.       - "80:80"
    16.       - "8080:8080"
    17.     volumes:
    18.       - "/var/run/docker.sock:/var/run/docker.sock:ro"
    20.   whoami:
    21.     image: "containous/whoami"
    22.     container_name: "simple-service"
    23.     labels:
    24.       - "traefik.enable=true"
    25.       - "traefik.http.routers.whoami.rule=Host(`whoami.localhost`)"
    26.       - "traefik.http.routers.whoami.entrypoints=web"
    • Replace whoami.localhost by your own domain within the traefik.http.routers.whoami.rule label of the whoami service.
    • Run docker-compose up -d within the folder where you created the previous file.
    • Wait a bit and visit http://your_own_domain to confirm everything went fine.You should see the output of the whoami service. Something similar to:
    1. Hostname: d7f919e54651
    2. IP: 127.0.0.1
    3. IP: 192.168.64.2
    4. GET / HTTP/1.1
    5. Host: whoami.localhost
    6. User-Agent: curl/7.52.1
    7. Accept: */*
    8. Accept-Encoding: gzip
    9. X-Forwarded-For: 192.168.64.1
    10. X-Forwarded-Host: whoami.localhost
    11. X-Forwarded-Port: 80
    12. X-Forwarded-Proto: http
    13. X-Forwarded-Server: 7f0c797dbc51
    14. X-Real-Ip: 192.168.64.1

    Details

    • As an example we use whoami (a tiny Go server that prints os information and HTTP request to output) which was used to define our simple-service container.

    • We define an entry point, along with the exposure of the matching port within docker-compose, which basically allow us to "open and accept" HTTP traffic: 

    1. command:
    2.   # Traefik will listen to incoming request on the port 80 (HTTP)
    3.   - "--entrypoints.web.address=:80"
    5. ports:
    6.   - "80:80"
    • We expose the Traefik API to be able to check the configuration if needed:
    1. command:
    2.   # Traefik will listen on port 8080 by default for API request.
    3.   - "--api.insecure=true"
    5. ports:
    6.   - "8080:8080"

    Note

    If you are working on a remote server, you can use the following command to display configuration (require curl & jq): 

    1. curl -s 127.0.0.1:8080/api/rawdata | jq .
    • We allow Traefik to gather configuration from Docker:
    1. traefik:
    2.   command:
    3.     # Enabling docker provider
    4.     - "--providers.docker=true"
    5.     # Do not expose containers unless explicitly told so
    6.     - "--providers.docker.exposedbydefault=false"
    7.   volumes:
    8.     - "/var/run/docker.sock:/var/run/docker.sock:ro"
    10. whoami:
    11.   labels:
    12.     # Explicitly tell Traefik to expose this container
    13.     - "traefik.enable=true"
    14.     # The domain the service will respond to
    15.     - "traefik.http.routers.whoami.rule=Host(`whoami.localhost`)"
    16.     # Allow request only from the predefined entry point named "web"
    17.     - "traefik.http.routers.whoami.entrypoints=web"