Mark ICT - Just More Than ICT

Traefik als reverse proxy voor meerdere Docker-websites, met automatisch Let's Encrypt-certificaat

Hoe u met Traefik meerdere Docker-websites op één server achter één reverse proxy zet, inclusief automatische SSL-certificaten via Let's Encrypt en een GitLab CI/CD-pipeline die nieuwe versies automatisch uitrolt.

Mark de Groot · · 7 min lezen

Serverrack symbool voor meerdere websites op één infrastructuur

Wie meerdere websites of applicaties op één server draait, loopt al snel tegen dezelfde vraag aan: hoe zorg je dat ze allemaal via poort 443 bereikbaar zijn, mét een geldig SSL-certificaat, zonder voor elke site handmatig Nginx-configuratie en certificaten te beheren? Bij Mark ICT draaien we onze eigen websites en klantportalen allemaal op deze manier: één Traefik-proxy regelt het binnenkomende verkeer en de certificaten, losse Docker-containers draaien de eigenlijke sites, en een GitLab CI/CD-pipeline rolt nieuwe versies automatisch uit zodra er code naar de main-branch wordt gepusht.

In deze blog laten we de volledige, werkende opzet zien: van de Traefik-proxy met automatische Let's Encrypt-certificaten tot de docker-compose.yml van een losse website en de pipeline die alles deployt.

Waarom Traefik als reverse proxy

Een reverse proxy staat tussen het internet en uw containers: al het binnenkomende verkeer op poort 80/443 komt eerst bij de proxy aan, die bepaalt - op basis van het domein in het verzoek - naar welke container het verkeer moet. Dat heeft een paar praktische voordelen zodra u meer dan één website op een server draait:

  • Eén poort 443, meerdere sites. Elke container hoeft geen eigen poort naar buiten open te zetten; de proxy regelt de routing op domeinnaam.
  • Automatische certificaten. Traefik vraagt zelf certificaten aan bij Let's Encrypt, zodra het een nieuwe host-regel tegenkomt, en vernieuwt ze ook automatisch voordat ze verlopen.
  • Configuratie staat bij de website, niet bij de proxy. Traefik leest zijn routeringsregels uit Docker-labels op de containers zelf. Een nieuwe website toevoegen betekent dus geen wijziging aan de proxy-configuratie - alleen de nieuwe container krijgt de juiste labels.

Het alternatief - voor elke site een eigen Nginx-configuratiebestand en certificaten met bijvoorbeeld Certbot bijhouden - werkt, maar wordt al snel omslachtig zodra het aantal sites groeit. Traefik is daarvoor specifiek gebouwd: het is een reverse proxy die zichzelf aanpast aan wat er in Docker draait.

De opzet in grote lijnen

                 internet
                    |
                  :80 / :443
                    |
               +----------+
               | Traefik  |   <- vraagt Let's Encrypt-certificaten aan
               +----------+
                    |
        gedeeld Docker-netwerk
          /         |         \
    site-a       site-b     portaal-c
   (container)  (container) (container)

Traefik en elke website draaien als losse docker compose-projecten, verbonden via één extern (shared) Docker-netwerk. Dat is belangrijk: Traefik moet de containers van elke website kunnen bereiken, maar de websites hoeven onderling niets van elkaar te weten.

Stap 1: de Traefik-proxy opzetten

Dit draait één keer op de server, los van de websites zelf. Maak een map, bijvoorbeeld /opt/traefik, met het volgende docker-compose.yml:

# /opt/traefik/docker-compose.yml
services:
  traefik:
    image: traefik:v3.3
    restart: unless-stopped
    command:
      # Docker-provider: lees routeringsregels uit labels op containers
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false
      - --providers.docker.network=web

      # Entrypoints: http op 80 (voor de redirect), https op 443
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --entrypoints.web.http.redirections.entrypoint.to=websecure
      - --entrypoints.web.http.redirections.entrypoint.scheme=https

      # Let's Encrypt via de HTTP-01-challenge
      - --certificatesresolvers.le.acme.email=mark@markict.nl
      - --certificatesresolvers.le.acme.storage=/letsencrypt/acme.json
      - --certificatesresolvers.le.acme.httpchallenge=true
      - --certificatesresolvers.le.acme.httpchallenge.entrypoint=web

      # Dashboard uit in productie; zet eventueel aan achter een eigen auth-laag
      - --api.dashboard=false
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./letsencrypt:/letsencrypt
    networks:
      - web

networks:
  web:
    name: web

Een paar dingen die hier bewust zo staan:

  • exposedbydefault=false: Traefik routeert alléén containers die expliciet het label traefik.enable=true hebben. Zonder deze instelling zou elke container op het netwerk automatisch (en ongewenst) bereikbaar worden.
  • /var/run/docker.sock als read-only volume: Traefik moet de Docker-API kunnen uitlezen om containers en hun labels te zien. Dat socket read-only mounten is een kleine extra beveiligingslaag, al blijft het socket zelf gevoelig - geef alleen vertrouwde software toegang tot deze server.
  • ./letsencrypt/acme.json: hier bewaart Traefik de aangevraagde certificaten. Zorg dat dit bestand rechten 600 heeft (touch letsencrypt/acme.json && chmod 600 letsencrypt/acme.json), anders weigert Traefik certificaten op te slaan.
  • Het netwerk web wordt hier aangemaakt (name: web) zodat losse website-projecten er later aan kunnen koppelen zonder dat ze het zelf hoeven te definiëren.

Start de proxy met:

cd /opt/traefik
mkdir -p letsencrypt && touch letsencrypt/acme.json && chmod 600 letsencrypt/acme.json
docker compose up -d

Stap 2: een website aansluiten

Elke website is een los docker compose-project met zijn eigen docker-compose.yml, dat alleen via labels aan Traefik doorgeeft hoe het bereikbaar moet zijn. Een voorbeeld voor een Next.js-website (hetzelfde patroon werkt voor elke container die intern op een vaste poort luistert):

# ~/websites/voorbeeldsite/docker-compose.yml
services:
  web:
    image: registry.gitlab.com/uwaccount/voorbeeldsite:latest
    restart: unless-stopped
    environment:
      - NODE_ENV=production
    networks:
      - web
    labels:
      - traefik.enable=true
      - traefik.docker.network=web
      # Welk domein hoort bij deze container
      - traefik.http.routers.voorbeeldsite.rule=Host(`www.voorbeeldsite.nl`)
      - traefik.http.routers.voorbeeldsite.entrypoints=websecure
      - traefik.http.routers.voorbeeldsite.tls.certresolver=le
      # Op welke interne poort de container luistert
      - traefik.http.services.voorbeeldsite.loadbalancer.server.port=3000

networks:
  web:
    external: true
    name: web

Belangrijk hier is networks.web.external: true: dit project maakt het netwerk niet aan (dat deed de Traefik-proxy al in stap 1), het sluit er alleen op aan. Zodra deze container start, ziet Traefik de labels, maakt een router aan voor www.voorbeeldsite.nl, vraagt automatisch een Let's Encrypt-certificaat aan voor dat domein (via de le-resolver uit stap 1) en stuurt verkeer naar poort 3000 binnen de container.

Wilt u meerdere domeinen op dezelfde container (bijvoorbeeld een kale domeinnaam die doorverwijst naar www.), dan voegt u een tweede router met een eigen regel toe, of gebruikt u een redirect-middleware:

      - traefik.http.routers.voorbeeldsite-redirect.rule=Host(`voorbeeldsite.nl`)
      - traefik.http.routers.voorbeeldsite-redirect.entrypoints=websecure
      - traefik.http.routers.voorbeeldsite-redirect.tls.certresolver=le
      - traefik.http.routers.voorbeeldsite-redirect.middlewares=naar-www
      - traefik.http.middlewares.naar-www.redirectregex.regex=^https://voorbeeldsite\.nl/(.*)
      - traefik.http.middlewares.naar-www.redirectregex.replacement=https://www.voorbeeldsite.nl/$${1}

Elke nieuwe website volgt dit patroon: eigen docker-compose.yml, eigen labels, aansluiten op het bestaande web-netwerk. De Traefik-configuratie zelf blijft ongewijzigd.

Stap 3: automatisch deployen met een GitLab CI/CD-pipeline

Met de proxy en de eerste website handmatig werkend, is de volgende stap dat een git push naar main automatisch een nieuwe Docker-image bouwt én op de server uitrolt. Dat vraagt twee dingen: een GitLab Runner die op (of met toegang tot) de server draait, en een .gitlab-ci.yml in de repository van de website.

Wij gebruiken hiervoor een shell-runner met een eigen tag per project (bijvoorbeeld voorbeeldsite), geregistreerd op de server waar de container moet draaien. Dat is eenvoudiger dan een Docker-in-Docker-opzet en werkt goed zolang de runner alleen voor deployments van vertrouwde code wordt gebruikt.

# .gitlab-ci.yml
stages:
  - build
  - deploy

variables:
  IMAGE: $CI_REGISTRY_IMAGE:latest

build:
  stage: build
  tags:
    - voorbeeldsite
  script:
    - docker build --pull -t "$IMAGE" .
    - echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
    - docker push "$IMAGE"
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'

deploy:
  stage: deploy
  tags:
    - voorbeeldsite
  script:
    - cd /home/deploy/websites/voorbeeldsite
    - docker compose pull
    - docker compose up -d --remove-orphans
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'

Wat hier gebeurt:

  1. build: de pipeline bouwt een nieuwe Docker-image uit de Dockerfile in de repository en pusht die naar de GitLab Container Registry van het project ($CI_REGISTRY_IMAGE, met $CI_REGISTRY_USER/$CI_REGISTRY_PASSWORD die GitLab automatisch beschikbaar stelt in de pipeline). De --pull-vlag zorgt dat de build altijd met de laatste basis-image begint, zodat een kwetsbaarheid daarin niet onopgemerkt blijft hangen.
  2. deploy: op de server zelf (via de runner met tag voorbeeldsite) haalt docker compose pull de net gepushte image op, en docker compose up -d --remove-orphans start de container opnieuw met die nieuwe image. Omdat docker-compose.yml hetzelfde blijft en alleen de image-inhoud wijzigt, blijven de Traefik-labels en het netwerk gewoon staan - er is geen enkele aanraking van de proxy nodig.
  3. rules: beide stappen draaien alleen op main. Feature-branches en merge requests bouwen desgewenst wel (haal de rules-blokken weg of beperk ze tot build als u ook op branches wilt testen), maar deployen nooit automatisch.

Voor dit te laten werken moet de runner op de server zelf toegang hebben tot docker (meestal door de gitlab-runner-gebruiker in de docker-groep te zetten) en moet er op de server al eenmalig een docker-compose.yml en docker login naar de registry staan, precies zoals bij de handmatige eerste opzet uit stap 2.

Het resultaat

Met deze drie stukken samen - de Traefik-proxy, de per-website docker-compose.yml met labels, en de GitLab-pipeline - ziet een nieuwe release er in de praktijk zo uit: een ontwikkelaar pusht naar main, de pipeline bouwt en pusht de image, de server haalt die op en herstart de container, en binnen een minuut draait de nieuwe versie - met een geldig SSL-certificaat dat Traefik zelf blijft vernieuwen, zonder dat daar ooit nog naar gekeken moet worden. Een tweede, derde of tiende website toevoegen is vervolgens een kopie van stap 2 en 3, niet een nieuwe proxy-configuratie.

Dat is ook precies hoe we onze eigen websites en klantportalen bij Mark ICT draaien: meerdere projecten op dezelfde infrastructuur, elk met hun eigen pipeline, zonder dat ze elkaar in de weg zitten.

Hulp nodig bij uw eigen opzet?

Een reverse proxy met automatische certificaten en een CI/CD-pipeline opzetten is eenmalig wat werk, maar betaalt zich daarna telkens weer terug: geen handmatige certificaatvernieuwing meer, geen handmatige deployments, en een nieuwe website toevoegen zonder de bestaande sites te raken. Wilt u uw eigen websites of applicaties op deze manier ingericht hebben, of loopt u tegen een specifiek onderdeel vast? Neem contact op - we denken graag mee over hosting en webontwikkeling die bij uw situatie past.

  • Hosting
  • Webontwikkeling

Klaar om uw ICT eindelijk goed te regelen?

Neem contact op voor een vrijblijvend gesprek. Wij denken graag met u mee over de beste oplossing voor uw organisatie.