[Docker] [alle OS] Het grote Docker ervaringen en tips topic

[alex3305]

Mars Warrior schreef op maandag 1 december 2025 @ 09:38:
[...]

Ik vroeg me nog wel even af @alex3305 hoe jij omgaat met bijv. Immich: die heeft een eigen stack waar versies hard gecodeerd zijn. Hoe ga je daarmee om qua updates van versies?

Mijn Compose bestanden hebben allemaal hard-coded versies, want dat is hoe Renovate werkt . Mijn Compose bestanden zijn op basis van Jinja templates, want dat is dan weer hoe Ansible werkt . Out-of-the-box gaat dat niet samen. Daarom heb ik voor Renovate een Docker Compose + Jinja matcher gemaakt.

dockerComposeJinja.json (renovate repo)

JSON:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "customManagers": [
    {
      "customType": "regex",
      "description": "Docker Compose Jinja",
      "fileMatch": "(^|/)(?:docker-)?compose[^/]*\\.ya?ml?\\.j2$",
      "matchStrings": [
        "(?:image: \\\"?)(?<depName>.*?)(?::(?<currentValue>.*?))?(?:@(?<currentDigest>sha256:[a-f0-9]+))?\\\"?\\n"
      ],
      "datasourceTemplate": "docker",
      "versioningTemplate": "docker"
    }
  ]
}

Dit aanvullend configuratiebestand staat in mijn Renovate repository, waar ook de standaard configuratie staat. Deze configuratiebestanden gebruik ik dan als configuration presets:

renovate.json (infra repo)

JSON:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "local>renovate-bot/renovate",
    "local>renovate-bot/renovate:dockerComposeJinja"
  ]
}

Met deze configuratie matcht Renovate zoals verwacht mijn Jinja Compose bestanden. Voorbeeld van Immich:

roles/immich/templates/compose.yaml.j2 (infra repo, minimaal voorbeeld)

YAML:

#jinja2: lstrip_blocks: True, trim_blocks: True
---
{{ ansible_managed | comment }}

services:
  server:
    container_name: {{ _compose_stack_name }}-server
    image: ghcr.io/immich-app/immich-server:v2.3.1
    depends_on:
      - machine-learning
      - redis
      - database
    networks:
      internal:
      ingress:

  machine-learning:
    container_name: {{ _compose_stack_name }}-machine-learning
    image: ghcr.io/immich-app/immich-machine-learning:v2.3.1-openvino
    networks:
      internal:

  redis:
    container_name: {{ _compose_stack_name }}-redis
    image: docker.io/valkey/valkey:8-bookworm@sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571
    networks:
      internal:

  database:
    container_name: {{ _compose_stack_name }}-database
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0@sha256:bcf63357191b76a916ae5eb93464d65c07511da41e3bf7a8416db519b40b1c23
    restart: on-failure:5
    networks:
      internal:

networks:
  internal:
  ingress:
    name: {{ swarm_overlay_network }}
    external: true

Tot slot heb ik wederom in de Renovate configuratie van deze repo extra package rules aangemaakt zodat alle Immich updates gecombineerd worden, dat minors van Immich niet zonder goedkeuring gemerged worden en op beperkte tijden plaatsvinden. Dit vind ik zelf prettig en doe ik voor meerdere applicaties.

Het samen pakken zorgt er voor dat er niet meerdere PR's voor 1 Compose file aangemaakt worden. In principe is met meerdere PR's natuurlijk niets mis, maar ik vind het onzin omdat het toch 1 stack is. Eigenlijk wat je zelf ook al zegt . Daarnaast zijn / waren / konden de minors van Immich breaking zijn, net zoals bij bijvoorbeeld Home Assistant. Dan is een automatische merge ongewenst. Immers vindt er een automatische uitrol bij een merge naar main plaats vanuit Forgejo Actions. Dit geldt ook voor de tijdsbeperking. Ik wil niet dat ik 's nachts, 's ochtends of in het weekend een kapotte applicatie ergens heb.

renovate.json (infra repo)

JSON:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "packageRules": [
    {
      "description": "Update Docker dependencies",
      "matchFileNames": [
        "**/compose.yml",
        "**/compose.yaml",
        "**/compose.yml.j2",
        "**/compose.yaml.j2"
      ],
      "automergeSchedule": ["* 9-17 * * 1-5"]
    },
    {
      "description": "Never automerge minor versions for specific packages",
      "matchPackageNames": [
        "*/immich-app/immich-*",
        "immich-app/immich-*"
      ],
      "matchUpdateTypes": ["major", "minor"],
      "minimumReleaseAge": "1 day",
      "automerge": false
    },
    {
      "description": "Add Docker label",
      "matchFileNames": [
        "**/compose.yml",
        "**/compose.yaml",
        "**/compose.yml.j2",
        "**/compose.yaml.j2"
      ],
      "addLabels": ["docker"]
    },
    {
      "description": "Immich",
      "groupName": "Immich",
      "matchFileNames": [".forgejo/workflows/*_immich.*", "roles/immich/**"],
      "addLabels": ["stack/Immich"]
    }
  ]
}

Helaas komt het soms wel voor dat ik handmatig het e.e.a. moet corrigeren of mergen. De Immich-PR's van Renovate willen regelmatig ook een update van PostgreSQL meenemen. Daar ben ik niet zo happig op. Een handmatige merge met daarna een correctie commit vind ik niet bijzonder erg of vervelend. Zoiets komt max eens in de maand voor. Renovate onthoudt namelijk ook welke versies ik actief geweigerd heb en biedt daar dan geen updates meer voor aan:

Renovate Dependency Dashboard


Tot slot zou je nog iets met digests en digest pinning kunnen doen. Ik gebruik dat op een paar plekken. O.a. in Immich en Plex. Die laatste omdat de LinuxServer.io container het versienummer niet (correct) verhoogd. Aan de ene kant vind ik de digests wel fijn vanwege idempotentie, terwijl ik het aan de andere kant er niet duidelijker op vind worden. Alhoewel Docker het toestaat, vind ik eigenlijk dat ontwikkelaars maar 1 keer 1 (Sem)Versie moeten uitbrengen. Rolling major of major.minor kan ik nog wel inkomen en doe ik zelf ook.

[alex3305]

Mars Warrior schreef op maandag 1 december 2025 @ 10:32:
Ik krijg er nu deze dingen uit als pipeline voor Woodpecker bijv.

Het is geen Ansible ( ), maar doet wel alles om zaken op te zetten, te initialiseren en te deployen.

[...]

Leuk dat het voor je werkt en dat je stappen aan het zetten bent . Dit bedoel ik niet vervelend, maar een dergelijke opzet is een enorme rode vlag . Er is een reden dat ik o.a. voor GitLab Runners, Gitea Actions of Forgejo Actions ga hè... Want het mounten van server paden voor deployment is wat mij betreft een hele dikke, grote, vette NO-NO.

Het mounten en rsyncen lijkt in eerste instantie een enorm goed idee totdat het een keer misgaat . Je maakt daarnaast de deployment host afhankelijk van de target host. En het is een aardig beveiligingsrisico vanwege potentieel misbruik van schrijfrechten. Je wilt eigenlijk dat wanneer iemand toegang krijgt tot de deployment node nergens bij kan. Uit ervaring kan ik je vertellen dat ik collega's had die per ongeluk de hele root disk overschreven met zulke geintjes . Want wat als de string replacement niet werkt omdat je die vergeten bent? Dan staat er per ongeluk:

rsync -a --delete . "/deployroot///"

Oeps . Of wat als je deze lompe kerel dit doet:

# CI_REPO_OWNER=".."
# CI_REPO_NAME=".."
rsync -a --delete . "/deployroot/../../"

En nu niet zeggen dat dat niet kan, want met wat creativiteit kan er meer dan je denkt .

Ansible is wat mij betreft de gouden standaard voor dit soort deployments. Met name omdat je ook veiligheid in kan bouwen en omdat communicatie via SSH of WinRM gaat. Ik ken Woodpecker verder niet, maar ik begrijp eerlijk gezegd niet waarom je niet een native CI/CD platform neemt. Dat integreert volgens mij veel makkelijker en maak je het jezelf nu alleen maar lastig...

Ook kun je met GitLab Runners, Forgejo Actions of GitHub Actions de ingebouwde secrets gebruiken voor dit soort deployments waarmee authenticatie naar bijv. target machines per repo beperkt kan worden. Mijn infra repo heeft bijvoorbeeld de Ansible Vault sleutel:"



Maar die kan ik voor de rest niet inzien. Aan mijn account zitten daarnaast de deploy keys gekoppeld:



Dit is de private key van de deploy voor mijn machines.

Bedenk ook dat Forgejo Actions, Gitea Actions afgeleid zijn van GitHub Actions. De meeste actions die te vinden zijn op de GitHub marketplace zijn uitwisselbaar en te gebruiken in Forgejo. Misschien maakt dit je leven ook een stuk makkelijker . Daarnaast zijn er ook legio voorbeelden. Ook maak ik gebruik van de Forgejo Container Registry voor mijn Docker Images. Die koppeling is dan hetzelfde als bij GitHub en de GitHub Container Registry.

In de repo van @alex3305 zag ik nog wat behoorlijke complexe actions om allerhande versies aan te maken zodat je alle stacks samenneemt voor zover ik begrijp in een release, maar dat komt later wel.

Yes, maar je moet niet gaan rennen voordat je gaat lopen hè. Mijn eerste Docker build workflow is al een heel stuk eenvoudiger.

Ik heb zelfs nog een hele tijd Docker container(s) gebruikt, net zoals met Woodpecker. Maar daar ben ik vanaf gestapt omdat ik nu een hosted tool cache gebruik. Daarmee heb ik geen extra ruimte nodig voor (custom) Docker images. Daarbij gebruik ik dan een cache stap zodat Forgejo Actions de cache kan gebruiken bij packages met dezelfde versie(s). Bij mijn infra repo gebruik ik daarvoor de hash van Python's requirements.txt en de hash van Ansible Galaxy requirements.yml:

.forgejo/actions/setup-ansible/action.yml

YAML:

runs:
  using: "composite"
  steps:
    - name: 🏗️ Setup Python
      id: setup-python
      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
      with:
        cache: 'pip'
        cache-dependency-path: 'requirements.txt'

    - name: 👷 Install Python dependencies
      if: steps.setup-python.outputs.cache-hit != 'true'
      shell: bash
      run: pip install -r requirements.txt

    - name: 📦 Setup Ansible Galaxy Cache
      id: ansible-galaxy-cache
      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
      with:
        path: |
          .ansible
          ~/.ansible
        key: ${{ runner.os }}-ansible-${{ hashFiles('**/requirements.yml') }}
        restore-keys: |
          ${{ runner.os }}-ansible-

    - name: 🌌 Install Ansible Galaxy dependencies
      if: steps.ansible-galaxy-cache.outputs.cache-hit != 'true'
      shell: bash
      run: ansible-galaxy install -r requirements.yml

Het is in dit geval maar een paar MB aan cache, maar zorgt ervoor dat Ansible in minder dan 10 seconde is geïnstalleerd en klaar is voor gebruik. Het opstarten van een Ansible container (zonder pull) was gek genoeg een minuutje langzamer. Waarschijnlijk omdat het om Docker in Docker in Docker ging .

[RobertMe]

alex3305 schreef op maandag 1 december 2025 @ 14:15:
Alhoewel Docker het toestaat, vind ik eigenlijk dat ontwikkelaars maar 1 keer 1 (Sem)Versie moeten uitbrengen. Rolling major of major.minor kan ik nog wel inkomen en doe ik zelf ook.

Maar zo makkelijk is het natuurlijk niet. Containers kunnen ook geupdate worden omdat onderliggende (systeem)packages geupdate worden zonder dat de "primaire software" geupdate wordt (wat ls.io dus doet met hun ls<nummertje>). En dan heb je nog suffixes voor heel veel andere zaken, zoals dus -debian of -alpine toevoegsels etc etc (en soms is het niet -debian maar specifiek -bookworm of -trixie of -alpine3.22).

Dus aan de ene kant kun je als registry niet iets van semver afdwingen want dan werken allemaal die suffixes niet meer. En vervolgens kun je ook niet zeggen dat "volledige" versies (major.minor.patch) immutable moeten zijn want semver is niet verplicht. En je kunt dus sowieso ook niet specifieke versies immutable maken want dan kun je geen updates meer doen aan onderliggende software. Als in: stel libssl bevat een lek, dan moeten wel alle images die die lekke versie gebruiken geupdate worden, maar er is geen nieuwe software versie nodig om het lek te fixen (de software hoeft maar de nieuwe .so aan te spreken).

* RobertMe gebruikt nu wel :tag@digest in files. Maar daar kan Renovate niet mee overweg (een hele kleine range bleek dit toevallig wel te doen op het moment dat ik het op zette, en die draai ik nu nog). Maar wat ook zo is is dat Docker de tag volledig negeert als je een digest opgeeft. Wat an zich wellicht logisch is, maar ook weer niet. Maar ik heb er dus wel heel graag een versienummer bij staan zichtbaar, zodat ik weet welke versie het is.
Daarnaast heb ik volgens mij ook wat issues dat bepaalde images niet updaten. Bv sommige containers waar nog een distro naam/versie in de naam staat.

[Mars Warrior]

Ik moet nog even veel lezen zie ik, @alex3305 , maar daar kom ik nog op terug

@RobertMe , bij mij voegt renovate juist digests toe:

YAML:

services:
  gitops-forgejo:
    image: codeberg.org/forgejo/forgejo:13@sha256:88858e7f592f82d4f650713c7bed8c0cd792d7f71475a7467c5650a31cd2eda9
    container_name: gitops-forgejo
    restart: unless-stopped

...
...

  gitops-renovate:
    image: renovate/renovate:42.29.4@sha256:aead5ca948dc1a76ed084ab9716fd83e6a8c8626d38b831d1923cdc17fa4d1b6
    container_name: gitops-renovate
    restart: "no"

Dit is mijn renovate.json bestand:

JSON:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:best-practices",
    ":automergeMinor",
    "schedule:automergeDaily",
    ":dependencyDashboard"
  ],
  "packageRules": [
    {
      "matchCategories": [
        "docker"
      ],
      "managerFilePatterns": [
        "/(^|/)docker-compose\\.ya?ml$/",
        "/Dockerfile$/"
      ]
    }
  ]
}

Nog geen idee hoe Renovate zichzelf start, want de container stopt gewoon na elke run, maar goed. Ik heb nog bergen aan blinde vlekken

Renovate loopt ook vaak zijn eigen renovate.json te migreren zie ik.

Renovate zou dus CalVer en SemVer aan moeten kunnen, maar zou enkel bij SemVer minor/major updates kunnen herkennen en bij CalVer is het gewoon een nieuwe versie ofzo.

[ Voor 9% gewijzigd door Mars Warrior op 02-12-2025 13:15 ]

[RobertMe]

Mars Warrior schreef op dinsdag 2 december 2025 @ 13:13:
@RobertMe , bij mij voegt renovate juist digests toe:

Hmm. Dat deed die bij mij niet. En/maar jij hebt wel "brede" tags, in ieder geval bij Forgeo (als in, "13" en niet "13.x.y"). Denk dat de big daarbij niet optreed, totdat de 13 14 moet worden. Bij het Renovate image gaat het denk ik wel fout? (Kom je snel genoeg achter gezien elke PR/merge een nieuwe release wordt )

Nog geen idee hoe Renovate zichzelf start, want de container stopt gewoon na elke run, maar goed. Ik heb nog bergen aan blinde vlekken

Hij start zichzelf natuurlijk niet Hij stopt, zoals je zelf aanhaalt.
Ik heb hem zelf dan als Podman Quadlet draaien. Dus heb er gewoon een systemd timer naast gezet die elke dag om 16:00 de service (/Quadlet) aftrapt.
Features zoals de GitHub app/hosted variant dan heeft zoals dat die steeds automatisch draait, bv na het aanvinken van "rebase", of een queued PR van op het "dashboard" aanvinken om nu (meteen) een PR aan te maken heb je dan natuurlijk niet.

[Mars Warrior]

RobertMe schreef op dinsdag 2 december 2025 @ 13:19:
[...]
Hmm. Dat deed die bij mij niet. En/maar jij hebt wel "brede" tags, in ieder geval bij Forgeo (als in, "13" en niet "13.x.y"). Denk dat de big daarbij niet optreed, totdat de 13 14 moet worden. Bij het Renovate image gaat het denk ik wel fout? (Kom je snel genoeg achter gezien elke PR/merge een nieuwe release wordt )

Het waren gewone tags, dus :13. Meer niet. Door de config te wijzigen krijg ik nu deze digests erbij

Hij start zichzelf natuurlijk niet Hij stopt, zoals je zelf aanhaalt.
Ik heb hem zelf dan als Podman Quadlet draaien. Dus heb er gewoon een systemd timer naast gezet die elke dag om 16:00 de service (/Quadlet) aftrapt.

Aha. Teveel blinde vlekken nog

Features zoals de GitHub app/hosted variant dan heeft zoals dat die steeds automatisch draait, bv na het aanvinken van "rebase", of een queued PR van op het "dashboard" aanvinken om nu (meteen) een PR aan te maken heb je dan natuurlijk niet.

Huh? Die heb ik wel hoor. Ik heb soms PRs (ook die ik gesloten heb) die ik op het dependency dashboard of in een PR gewoon kan aanvinken. Dat zie je hierboven staan halverwege (If you want to rebase...).


En het Dependency Dashboard als test (recreate PR):



Kan ik nu plotseling dingen die anderen niet kunnen als pure beginner

[RobertMe]

Mars Warrior schreef op dinsdag 2 december 2025 @ 13:43:
[...]

Huh? Die heb ik wel hoor. Ik heb soms PRs (ook die ik gesloten heb) die ik op het dependency dashboard of in een PR gewoon kan aanvinken. Dat zie je hierboven staan halverwege (If you want to rebase...).
[Afbeelding]

En het Dependency Dashboard als test (recreate PR):

[Afbeelding]

Kan ik nu plotseling dingen die anderen niet kunnen als pure beginner

Ik zie die opties ook hoor. Maar als ik ze gebruik gebeurt er pas om 16:00 iets mee, omdat dan Renovate wordt afgetrapt.
Terwijl als ik hetzelfde doe in de repo van het werk waar de Renovate app aan gekoppeld is dan is het resultaat vaak al binnen een minuut te aanschouwen. (Als in: de Renovate app voor GitHub zal allemaal (web) hooks hebben op dit soort events en meteen een nieuwe run starten/in de wachtrij zetten)

[Mars Warrior]

RobertMe schreef op dinsdag 2 december 2025 @ 13:51:
[...]

Ik zie die opties ook hoor. Maar als ik ze gebruik gebeurt er pas om 16:00 iets mee, omdat dan Renovate wordt afgetrapt.
Terwijl als ik hetzelfde doe in de repo van het werk waar de Renovate app aan gekoppeld is dan is het resultaat vaak al binnen een minuut te aanschouwen. (Als in: de Renovate app voor GitHub zal allemaal (web) hooks hebben op dit soort events en meteen een nieuwe run starten/in de wachtrij zetten)

Gelukkig. Voor mij is het allemaal nieuw, dus soms geen idee wat ik doe. Ook git gebruik ik altijd beperkt. Nog nooit een rebase gedaan bijv. omdat ik niet weet wat er dan gebeurt en ik de namen/commando's niet altijd logisch vind

En oja. Ik heb eerder een hoop binnen n8n gebouwd. Daarmee kun je real-time op webhooks reageren en een hele flow aftrappen (binnen n8n), waarin ik lekker scripts kan aftrappen en standaard nodes kan gebruiken die een forgejo pull kunnen doen om zo een update op de server te krijgen via een ssh node die een execute, download of upload kan uitvoeren.

Niks geen Woodpecker of Ansible, gewoon via een workflow manager

Maar goed. Ik lees lekker verder

[ Voor 23% gewijzigd door Mars Warrior op 02-12-2025 14:42 ]

[alex3305]

@Mars Warrior @RobertMe De digests komen tegenwoordig vanuit de config:best-practices .

Ik heb lokaal een eigen Renovate config die ik dus importeer, en daar zat deze niet in. Dus gisteren op mijn infra repo toegevoegd, waar ook Docker Compose in zit, maar helaas

code:

WARN: Error updating branch: update failure (repository=alex/infra, branch=renovate/pin-dependencies)

Maar dat komt dus omdat ik een Regex Matcher gebruik en is een bekend issue . Er is wel een soort van workaround, alleen was ik gisteren zo teleurgesteld dat ik geen zin meer had . Vandaag ook niet meer aan toegekomen.

Leuk dat het werkt @Mars Warrior. Nu even doorpakken en met Forgejo Actions aan de slag . De workflow die ik eerder heb gepost is niet bijster complex en is direct scheduled .

[Mars Warrior]

alex3305 schreef op dinsdag 2 december 2025 @ 20:47:
@Mars Warrior @RobertMe De digests komen tegenwoordig vanuit de config:best-practices .

Wat leren jullie toch een hoop van mij hè 😇

Leuk dat het werkt @Mars Warrior. Nu even doorpakken en met Forgejo Actions aan de slag . De workflow die ik eerder heb gepost is niet bijster complex en is direct scheduled .

Dan moet ik die dind runner container gebruiken toch van jouw?

En dan nog wat moeilijke dingen met Ansible…

YAML:

name: Deploy via Ansible

on:
  push:
    branches: [ main ]
  workflow_dispatch:
    inputs:
      version:
        description: "Tag/branch to deploy (default: main)"
        required: false
        default: "main"

jobs:
  deploy:
    runs-on: self-hosted

    steps:
      # 1. Checkout the stack repo (not used directly, only metadata needed)
      - name: Checkout current repo
        uses: actions/checkout@v3

      # 2. Checkout the Ansible infra repo
      - name: Checkout Ansible infra
        uses: actions/checkout@v3
        with:
          repository: infra/ansible        # <-- jouw infra-repo
          path: ansible

      # 3. Run Ansible inside the container
      - name: Run Ansible deploy
        uses: docker://cytopia/ansible:latest
        with:
          entrypoint: ansible-playbook
        env:
          REPO_OWNER: ${{ github.repository_owner }}
          REPO_NAME:  ${{ github.event.repository.name }}
          VERSION:    ${{ github.event.inputs.version }}
        args: >
          -i ansible/hosts
          ansible/deploy.yml

[RobertMe]

Mars Warrior schreef op dinsdag 2 december 2025 @ 22:28:
[...]

Wat leren jullie toch een hoop van mij hè 😇

Ik wist dat die in een van de presets was inbegrepen

[...]

Dan moet ik die dind runner container gebruiken toch van jouw?

Docker-in-Docker (dind) is bij mijn weten alleen nodig als je Docker wilt gebruiken, maar dat hoeft waarschijnlijk niet? Aangezien je puur deployments wilt doen. dind is dus nodig als je in een workflow (/action) bv een image wilt builden, of een container wilt uitvoeren (bv bij development dat je een linter of static analyzer uitvoert via een container).

[Mars Warrior]

RobertMe schreef op dinsdag 2 december 2025 @ 23:10:
[...]
Ik wist dat die in een van de presets was inbegrepen

Renovate had zelf de renovate.json lopen wijzigen. Zo ben ik erachter gekomen.

[...]

Docker-in-Docker (dind) is bij mijn weten alleen nodig als je Docker wilt gebruiken, maar dat hoeft waarschijnlijk niet? Aangezien je puur deployments wilt doen. dind is dus nodig als je in een workflow (/action) bv een image wilt builden, of een container wilt uitvoeren (bv bij development dat je een linter of static analyzer uitvoert via een container).

Het is die container van @alex3305 die draait ook weer Ansible meen ik.

[StarWing]

Een crosspost van mij vanop een ander forum:

Ik ben al een paar dagen aan het stoeien om een fail2ban in werking te krijgen via een docker container op een Ubuntu server.
Initieel had ik samen met onze Vriend ChatGPT een docker compose gemaakt voor f2b + nextcloud + redis + collabora. Maar dat werkt maar halvelings.
Het probleem ligt bij fail2ban, ik krijg deze niet aan de praat.
Niet via de compose die chatgpt gemaakt heeft, maar ook niet op een losse f2b voor een bestaande emby.

De finale setup zou zijn dat ik een aantal docker containers die extern benaderbaar zijn, voorzie van een f2b jail, zodat failed logins gebanned worden.
Er staat reeds een cloudflare voor die GeoBlock doet, maar dit zou dan een additionele laag zijn.

In eerste instantie had ik een pak foutmeldingen, maar dat kwam blijkbaar door een aanpassing in een van hun laatste commits (zie DEFAULT onder de jail.local).
Mocht iemand zich geroepen voelen om onderstaande eens te bekijken.
Volgens de logs is de jail up & running, maar er wordt nougabollen actie ondernomen door f2b

Achtergrond:
De emby draait tevens in een docker container, en staat achter een reverse proxy: HA op PfSense, en is volledig werkend incl certs.
De HA gaat de traffiek redirecten van https://emby.whatever naar 192.168.10.155:8096

Docker compose fail2ban:

code:

services:
  fail2ban:
    image: lscr.io/linuxserver/fail2ban:latest
    container_name: fail2ban
    cap_add:
      - NET_ADMIN
      - NET_RAW
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Brussels
      - VERBOSITY=-vvvv #optional
    volumes:
      - ./config:/config
#     - /var/log:/var/log:ro
      - /docker/emby/library/logs:/remotelogs/emby:ro #optional
      - /docker/jellyseer/config/logs:/remotelogs/jellyseer:ro
#      - /path/to/nextcloud/log:/remotelogs/nextcloud:ro #optional

Docker compose emby:

code:

services:
  emby:
    image: lscr.io/linuxserver/emby:latest
    container_name: emby
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Brussels
    volumes:
      - /docker/emby/library:/config
      - /docker/emby/backup:/backup
      - /DataDisk/Video:/Video
      - /DataDisk/Audio:/Audio
 #     - /opt/vc/lib:/opt/vc/lib #optional
    ports:
      - 192.168.10.155:8096:8096
      - 192.168.10.155:8920:8920 #optional
    devices:
      - /dev/dri:/dev/dri #optional
 #     - /dev/vchiq:/dev/vchiq #optional
 #     - /dev/video10:/dev/video10 #optional
 #     - /dev/video11:/dev/video11 #optional
 #     - /dev/video12:/dev/video12 #optional
    restart: unless-stopped
    networks:
      - docker_lan
networks:
  docker_lan:
    external: true

jail.local:

code:

[DEFAULT]
#banaction = nftables
#banaction_allports = nftables[type=allports]
banaction = iptables-multiport
banaction_allports = iptables-allports

[emby]
enabled = true
port = 8096,443,80
filter = emby
logpath = /remotelogs/emby/embyserver.txt
maxretry = 3
findtime = 600
bantime = 43200
chain   = DOCKER-USER
#chain   = INPUT
action  = %(known/action)s

Ik heb al gespeeld met chain: docker-user of input, tevens met iptables of nft tables. Maar ik weet niet wat het verschil is tussen beiden.


Onderstaande geeft ook gewoon weer dat de jail draait.

code:

docker exec -it fail2ban fail2ban-client status emby
Status for the jail: emby
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /remotelogs/emby/embyserver.txt
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

filter.d/emby.local is de std van f2ban:

code:

## Version 2023/03/11
# Fail2Ban filter for emby

[INCLUDES]
before = common.conf

[Definition]

_daemon = emby-server

failregex = Server: AUTH-ERROR:\ <HOST>\ -

ignoreregex =

Regextest op de container zelf, voor zover ik dit kan interpreteren:
-log file is leesbaar
-regex is correct

code:

root@vdockersrv:/#  fail2ban-regex /remotelogs/emby/embyserver.txt "http/1.1 Response 401 to ‌‍‍<HOST>"

Running tests
=============

Use   failregex line : http/1.1 Response 401 to ‌‍‍<HOST>
Use         log file : /remotelogs/emby/embyserver.txt
Use         encoding : UTF-8


Results
=======

Failregex: 44 total
|-  #) [# of hits] regular expression
|   1) [44] http/1.1 Response 401 to ‌‍‍<HOST>
`-

Ignoreregex: 0 total

Date template hits:
|- [# of hits] date format
|  [734] {^LN-BEG}ExYear(?P<_sep>[-/.])Month(?P=_sep)Day(?:T|  ?)24hour:Minute:Second(?:[.,]Microseconds)?(?:\s*Zone offset)?
`-

Lines: 1524 lines, 0 ignored, 44 matched, 1480 missed
[processed in 0.18 sec]

Missed line(s): too many to print.  Use --print-all-missed to print all 1480 lines

Maar ik kan een collega gewoon blijven laten inloggen, zonder dat f2ban iets doet, en ik heb geen idee waar ik dit moet gaan zoeken.
Wat nog zou kunnen is dat ik voor mijn emby (en een pak andere containers) een ander netwerk heb, hiervoor heb ik een "docker lan" aangemaakt, terwijl dit in de f2b docker nog niet geconfigureerd staat, maar volgens mij moet de f2b container dit toch gaan blocken op host niveau?

[Mars Warrior]

Gaat lekker, ligt Codeberg eruit terwijl ik wat wilde experimenteren. Website geeft:

De webpagina op https://codeberg.org/ ondervindt mogelijk problemen of is definitief verplaatst naar een nieuw webadres.
ERR_QUIC_PROTOCOL_ERROR

Dus ook een docker compose pull werkt niet

Bash:

docker compose up -d
[+] Running 15/15
 ✘ gitops-forgejo Error     Get "https://codeberg...                      14.5s
 ✔ gitops-renovate Pulled                                                 13.6s
   ✔ 20043066d3d5 Already exists                                           0.0s
   ✔ 9e4e033eb30d Pull complete                                            0.3s
   ✔ 018f6c7aaaac Pull complete                                            1.2s
   ✔ 35578b6f2e42 Pull complete                                            1.5s
   ✔ 80dfdc05cfe7 Pull complete                                            2.0s
   ✔ 1eca13f89a5d Pull complete                                            6.1s
   ✔ 8d74e0a459d6 Pull complete                                            6.7s
   ✔ 10316a1eb140 Pull complete                                            6.7s
   ✔ 34b95407a4fa Pull complete                                            6.7s
   ✔ 4e5a0ac21bc5 Pull complete                                           12.3s
   ✔ 064a0d449bd7 Pull complete                                           12.3s
   ✔ 7343cd103162 Pull complete                                           12.4s
   ✔ 4f4fb700ef54 Pull complete                                           12.4s
Error response from daemon: Get "https://codeberg.org/v2/": net/http: TLS handshake timeout

[ Voor 70% gewijzigd door Mars Warrior op 03-12-2025 10:00 ]

[RobertMe]

Mars Warrior schreef op woensdag 3 december 2025 @ 09:58:
Gaat lekker, ligt Codeberg eruit terwijl ik wat wilde experimenteren.

Ook gewoon Uptime Kuma gebruiken https://status.codeberg.org/status/codeberg

[Mars Warrior]

Codeberg is er weer. Dus alles is up-and-running, maar werken ho-maar!

Ik heb een runner...



Actions zijn enabled...


En ik heb workflows...


Maar toch weer niet blijkbaar...


Crazy like a fool

Update 1:
Haha. Als ik de map geen .forgejo noem maar .github dan heb ik plotseling Actions en worden ze nog uitgevoerd ook

Update 2:
Oepsie. Er stond een spatie voor de ".". Dus er stond " .forgejo/" ipv ".forgejo/". Man, man, man

[ Voor 9% gewijzigd door Mars Warrior op 03-12-2025 14:35 ]

[synoniem]

StarWing schreef op woensdag 3 december 2025 @ 06:22:
Een crosspost van mij vanop een ander forum:

Ik ben al een paar dagen aan het stoeien om een fail2ban in werking te krijgen via een docker container op een Ubuntu server.
Initieel had ik samen met onze Vriend ChatGPT een docker compose gemaakt voor f2b + nextcloud + redis + collabora. Maar dat werkt maar halvelings.
Het probleem ligt bij fail2ban, ik krijg deze niet aan de praat.
Niet via de compose die chatgpt gemaakt heeft, maar ook niet op een losse f2b voor een bestaande emby.

De finale setup zou zijn dat ik een aantal docker containers die extern benaderbaar zijn, voorzie van een f2b jail, zodat failed logins gebanned worden.
Er staat reeds een cloudflare voor die GeoBlock doet, maar dit zou dan een additionele laag zijn.

In eerste instantie had ik een pak foutmeldingen, maar dat kwam blijkbaar door een aanpassing in een van hun laatste commits (zie DEFAULT onder de jail.local).
Mocht iemand zich geroepen voelen om onderstaande eens te bekijken.
Volgens de logs is de jail up & running, maar er wordt nougabollen actie ondernomen door f2b

Achtergrond:
De emby draait tevens in een docker container, en staat achter een reverse proxy: HA op PfSense, en is volledig werkend incl certs.
De HA gaat de traffiek redirecten van https://emby.whatever naar 192.168.10.155:8096

Docker compose fail2ban:

code:

services:
  fail2ban:
    image: lscr.io/linuxserver/fail2ban:latest
    container_name: fail2ban
    cap_add:
      - NET_ADMIN
      - NET_RAW
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Brussels
      - VERBOSITY=-vvvv #optional
    volumes:
      - ./config:/config
#     - /var/log:/var/log:ro
      - /docker/emby/library/logs:/remotelogs/emby:ro #optional
      - /docker/jellyseer/config/logs:/remotelogs/jellyseer:ro
#      - /path/to/nextcloud/log:/remotelogs/nextcloud:ro #optional

Docker compose emby:

code:

services:
  emby:
    image: lscr.io/linuxserver/emby:latest
    container_name: emby
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Brussels
    volumes:
      - /docker/emby/library:/config
      - /docker/emby/backup:/backup
      - /DataDisk/Video:/Video
      - /DataDisk/Audio:/Audio
 #     - /opt/vc/lib:/opt/vc/lib #optional
    ports:
      - 192.168.10.155:8096:8096
      - 192.168.10.155:8920:8920 #optional
    devices:
      - /dev/dri:/dev/dri #optional
 #     - /dev/vchiq:/dev/vchiq #optional
 #     - /dev/video10:/dev/video10 #optional
 #     - /dev/video11:/dev/video11 #optional
 #     - /dev/video12:/dev/video12 #optional
    restart: unless-stopped
    networks:
      - docker_lan
networks:
  docker_lan:
    external: true

jail.local:

code:

[DEFAULT]
#banaction = nftables
#banaction_allports = nftables[type=allports]
banaction = iptables-multiport
banaction_allports = iptables-allports

[emby]
enabled = true
port = 8096,443,80
filter = emby
logpath = /remotelogs/emby/embyserver.txt
maxretry = 3
findtime = 600
bantime = 43200
chain   = DOCKER-USER
#chain   = INPUT
action  = %(known/action)s

Ik heb al gespeeld met chain: docker-user of input, tevens met iptables of nft tables. Maar ik weet niet wat het verschil is tussen beiden.


Onderstaande geeft ook gewoon weer dat de jail draait.

code:

docker exec -it fail2ban fail2ban-client status emby
Status for the jail: emby
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /remotelogs/emby/embyserver.txt
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

filter.d/emby.local is de std van f2ban:

code:

## Version 2023/03/11
# Fail2Ban filter for emby

[INCLUDES]
before = common.conf

[Definition]

_daemon = emby-server

failregex = Server: AUTH-ERROR:\ <HOST>\ -

ignoreregex =

Regextest op de container zelf, voor zover ik dit kan interpreteren:
-log file is leesbaar
-regex is correct

code:

root@vdockersrv:/#  fail2ban-regex /remotelogs/emby/embyserver.txt "http/1.1 Response 401 to ‌‍‍<HOST>"

Running tests
=============

Use   failregex line : http/1.1 Response 401 to ‌‍‍<HOST>
Use         log file : /remotelogs/emby/embyserver.txt
Use         encoding : UTF-8


Results
=======

Failregex: 44 total
|-  #) [# of hits] regular expression
|   1) [44] http/1.1 Response 401 to ‌‍‍<HOST>
`-

Ignoreregex: 0 total

Date template hits:
|- [# of hits] date format
|  [734] {^LN-BEG}ExYear(?P<_sep>[-/.])Month(?P=_sep)Day(?:T|  ?)24hour:Minute:Second(?:[.,]Microseconds)?(?:\s*Zone offset)?
`-

Lines: 1524 lines, 0 ignored, 44 matched, 1480 missed
[processed in 0.18 sec]

Missed line(s): too many to print.  Use --print-all-missed to print all 1480 lines

Maar ik kan een collega gewoon blijven laten inloggen, zonder dat f2ban iets doet, en ik heb geen idee waar ik dit moet gaan zoeken.
Wat nog zou kunnen is dat ik voor mijn emby (en een pak andere containers) een ander netwerk heb, hiervoor heb ik een "docker lan" aangemaakt, terwijl dit in de f2b docker nog niet geconfigureerd staat, maar volgens mij moet de f2b container dit toch gaan blocken op host niveau?

De fail2ban container heeft als network=host en ik vermoed dat dan chain=DOCKER-USER niet werkt. Je zou chain=FORWARD kunnen proberen.

[Mars Warrior]

synoniem schreef op woensdag 3 december 2025 @ 11:09:
[...]

De fail2ban container heeft als network=host en ik vermoed dat dan chain=DOCKER-USER niet werkt. Je zou chain=FORWARD kunnen proberen.

Denk niet dat het daarmee te maken heeft.

Het punt dat deze logging niks ziet:

code:

docker exec -it fail2ban fail2ban-client status emby
Status for the jail: emby
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /remotelogs/emby/embyserver.txt
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

Is de basis van het geheel. Fail2ban praat direct tegen ip/nftables, dat staat los van docker.

Maar ik zie ook dat de regex getest is en ogenschijnlijk werkt. Ik zou verwachten dat de logs van fail2ban mogelijk nog een hint bevatten. Rechten op de logfiles? En waarom heet een logfile .txt, en geen .log?

Wat me wel opvalt, is dat je de logfiles als volume gebruikt, ipv de mappen.

YAML:

  infra-fail2ban:
    image: lscr.io/linuxserver/fail2ban:latest
    container_name: infra-fail2ban
    restart: always
    cap_add:
      - NET_ADMIN
      - NET_RAW
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Amsterdam
      - VERBOSITY=-vv #optional
    volumes:
      - $DOCKERDIR/infra/fail2ban/config:/config
      - /var/log:/var/log:ro
#      - /path/to/airsonic/log:/remotelogs/airsonic:ro #optional
#      - /path/to/apache2/log:/remotelogs/apache2:ro #optional
#      - /path/to/authelia/log:/remotelogs/authelia:ro #optional
#      - /path/to/emby/log:/remotelogs/emby:ro #optional
#      - /path/to/filebrowser/log:/remotelogs/filebrowser:ro #optional

[ Voor 30% gewijzigd door Mars Warrior op 03-12-2025 11:26 ]

[synoniem]

Mars Warrior schreef op woensdag 3 december 2025 @ 11:23:
[...]

Denk niet dat het daarmee te maken heeft.

Het punt dat deze logging niks ziet:

code:

docker exec -it fail2ban fail2ban-client status emby
Status for the jail: emby
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /remotelogs/emby/embyserver.txt
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

Is de basis van het geheel. Fail2ban praat direct tegen ip/nftables, dat staat los van docker.

Fail2ban praat inderdaad direct ip/nftables maar welke, die van de host of docker of container als je network=host gebruikt? En is op de host ip/nftables wel actief

[Mars Warrior]

synoniem schreef op woensdag 3 december 2025 @ 11:51:
[...]

Fail2ban praat inderdaad direct ip/nftables maar welke, die van de host of docker of container als je network=host gebruikt? En is op de host ip/nftables wel actief

Docker praat nog steeds iha iptables, ook als nftables actief is. Dat lost je OS lekker op.

Mijn firewall draait in dezelfde modus als Fail2Ban zie ik:

YAML:

  infra-cs-firewall-bouncer:
    image: ghcr.io/shgew/cs-firewall-bouncer-docker:latest
    container_name: infra-cs-firewall-bouncer
    network_mode: host
    cap_add:
      - NET_ADMIN
      - NET_RAW
    security_opt:
      - no-new-privileges:true

En deze plaatst zijn 'bans' in de volgende chains:

YAML:

iptables_chains:
  - INPUT
  - DOCKER-USER

Maar dan moet je dus wel 'bans' hebben, anders blijven die ipsets gewoon leeg.

Maar dan moet Fail2Ban dus wel iets herkennen in die logfiles. En nogmaals: het verschil is dat ik eerder mappen doorgeef, en geen logfiles zelf.

[alex3305]

Mars Warrior schreef op dinsdag 2 december 2025 @ 22:28:
Dan moet ik die dind runner container gebruiken toch van jouw?

Je moet niets hè. Ik gebruik een dind-runner omdat ik het makkelijk vind dat dat allemaal in 1 container zit. Je zou ook kunnen starten met de de Docker socket op het systeem. Daar ben ik destijds ook mee gestart en is vergelijkbaar met andere containers die gebruik maken van een Docker soicket. Snippet:

YAML:

services:
  forgejo-runner:
    container_name: forgejo-runner
    image: code.forgejo.org/forgejo/runner:latest
    restart: on-failure:20
    command: "forgejo-runner --config /data/config.yaml daemon"
    privileged: true
    networks:
      internal:
    depends_on:
      - forgejo
    environment:
      CONFIG_FILE: /data/config.yaml
      USER_GID: "1000"
      USER_UID: "1000"
    volumes:
      - /opt/forgejo/runner:/data
    user: 1000:1000

En dan nog wat moeilijke dingen met Ansible…
[...]

Dat kan nog iets eenvoudiger

YAML:

name: Deploy with Ansible

# yamllint disable-line rule:truthy
on:
  push:
    branches:
      - main
  pull_request:
    types:
      - opened
      - reopened
      - synchronize
  workflow_dispatch:

jobs:
  deploy:
    name: Deploy
    runs-on: ubuntu-latest
    timeout-minutes: 5

    steps:
      - name: ⤵️ Checkout repository
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6

      - name: 🏗️ Setup Python
        id: setup-python
        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6
        with:
          cache: 'pip'
          cache-dependency-path: 'requirements.txt'

      - name: 👷 Install Python dependencies
        if: steps.setup-python.outputs.cache-hit != 'true'
        shell: bash
        run: pip install -r requirements.txt

      - name: 📦 Setup Ansible Galaxy Cache
        id: ansible-galaxy-cache
        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
        with:
          path: |
            .ansible
            ~/.ansible
          key: ${{ runner.os }}-ansible-${{ hashFiles('**/requirements.yml') }}
          restore-keys: |
            ${{ runner.os }}-ansible-

      - name: 🌌 Install Ansible Galaxy dependencies
        if: steps.ansible-galaxy-cache.outputs.cache-hit != 'true'
        shell: bash
        run: ansible-galaxy install -r requirements.yml

      - name: 🚀 Deploy Forgejo
        # yamllint disable-line rule:line-length
        uses: dawidd6/action-ansible-playbook@v5
        with:
          playbook: playbooks/MY_PLAYBOOK_HERE.yml
          requirements: requirements.yml
          key: ${{ secrets.DEPLOY_KEY }}
          vault_password: ${{ secrets.ANSIBLE_VAULT_KEY }}

Dan heb je (wederom) geen extra container afhankelijkheid.

Ik kan je sterk aanraden om Ansible eerst lokaal werkend te krijgen en vanaf je localhost te deployen naar systemen voordat je het in een CI/CD vorm gaat gieten. De eerste opstap van Ansible is vrij pittig, daarna wordt het een stuk makkelijker, maar de devil is in the details. Daarom zeg ik altijd tegen mensen dat Ansible leren ongeveer 6 maanden kost . Niet omdat je het niet in 1 week kunt leren of ermee uit de voeten kunt, maar omdat er best veel nuances zijn die je wellicht in eerste instantie mist.

Als je er vragen over hebt mag je die ook altijd via DM stellen

[alex3305]

RobertMe schreef op dinsdag 2 december 2025 @ 23:10:
[...]

Docker-in-Docker (dind) is bij mijn weten alleen nodig als je Docker wilt gebruiken, maar dat hoeft waarschijnlijk niet? Aangezien je puur deployments wilt doen. dind is dus nodig als je in een workflow (/action) bv een image wilt builden, of een container wilt uitvoeren (bv bij development dat je een linter of static analyzer uitvoert via een container).

Forgejo Actions runt CI via Docker images. De Docker images hebben eigenlijk alleen een node requirement en that's about it. De basis hiervan is GitHub Actions en nektos/act.

Je kunt elke Docker of Podman socket gebruiken om workflows te triggeren. Bijvoorbeeld de socket van het systeem of een aparte socket in een aparte dind container. Dat eerste paste niet bij mijn energiezuinige setup aangezien ik dan niet zomaar cpuset kon gebruiken. De laatste optie was mogelijk, maar ik vond twee containers nogal wat gedoe. Ook de inter-container communicatie is dan gewoon irritant.

Vanuit Gitea en derde partijen zijn er dind-containers die de act runner combineren met een dind socket. Voor Forgejo bestond dat niet. Vandaar dat ik een eigen image heb gemaakt die act combineert met dind. Daarnaast heb ik nog wat kleine zaken toegevoegd zoals een init systeem en periodieke schoonmaak van images en cache. Dat vond ik zelf handig .

Het werkend krijgen van rootless dind was overigens niet evident. Ook nu is het soms best IMHO wel brak met o.a. Docker vpnkit die niet altijd even efficient is. Ik heb een tijdje terug wat zitten spelen met IPv6 en dat zou het e.e.a. best wel op kunnen lossen. Idem voor een rootless podman aanpak, die out of the box een stuk beter wordt ondersteund. Echter ben ik er nog niet aan toegekomen om dit verder uit te werken dan wat kladjes.

Uiteindelijk ben ik best wel trots dat ik nu een systeem heb dat werkt én open en transparant is. Vooral dat laatste vind ik wel een pluspunt bij een CI systeem. Ik zou niet zomaar images van een derde partij willen vertrouwen in een dergelijk systeem. Vooral niet als ik applicaties uitrol. Ook heb ik ondersteuning voor arm64 zodat je het ook op een Pi zou kunnen gebruiken. Dat doe ik via qemu. Ik vind het echt leuk dat ik dat ook in Forgejo Actions werkend heb gekregen.

[Mars Warrior]

alex3305 schreef op woensdag 3 december 2025 @ 14:53:
[...]
Je moet niets hè. Ik gebruik een dind-runner omdat ik het makkelijk vind dat dat allemaal in 1 container zit. Je zou ook kunnen starten met de de Docker socket op het systeem. Daar ben ik destijds ook mee gestart en is vergelijkbaar met andere containers die gebruik maken van een Docker soicket. Snippet:

Dat weet ik. Ik moet niks en mag alles.
Zoals je aan eerdere screenshots kan zien loopt die container inmiddels en ziet Forgejo hem ook. Dat is al heel wat. Als nu Renovate ook automagisch elke 6 uur draait, dan ben ik al weer een stap verder.

Dan heb je (wederom) geen extra container afhankelijkheid.

Ik kan je sterk aanraden om Ansible eerst lokaal werkend te krijgen en vanaf je localhost te deployen naar systemen voordat je het in een CI/CD vorm gaat gieten. De eerste opstap van Ansible is vrij pittig, daarna wordt het een stuk makkelijker, maar de devil is in the details. Daarom zeg ik altijd tegen mensen dat Ansible leren ongeveer 6 maanden kost . Niet omdat je het niet in 1 week kunt leren of ermee uit de voeten kunt, maar omdat er best veel nuances zijn die je wellicht in eerste instantie mist.

Ik zie bijv. ook hier dat je heel veel kunt met Ansible icm Docker, maar ik zoek nu enkel naar de simpele pull & up. Meer niet eigenlijk. Dus het mag nog te simpel zijn.
Woodpecker liep bijna direct met die rsync. Dus dit is voor mij een tweede stap die het beter maakt.

Dus ik kijk nu ff met de KISS blik

YAML:

# forgejo action
pipeline:
  deploy:
    image: python:3.12
    secrets: [ SSH_KEY ]
    commands:
      - pip install ansible community.docker
      - mkdir -p ~/.ssh
      - echo "$SSH_KEY" > ~/.ssh/id_ed25519
      - chmod 600 ~/.ssh/id_ed25519

      - ansible-playbook -i inventory deploy.yml

YAML:

# Ansible deploy.yml
- hosts: server
  become: yes
  tasks:
    - name: Repo clonen/updaten
      ansible.builtin.git:
        repo: "[e-mail]:docker-stacks/gitops.git"
        dest: /opt/gitops
        version: main

    - name: Docker Compose pull
      community.docker.docker_compose:
        project_src: /opt/gitops/myapp
        pull: yes

    - name: Docker Compose up
      community.docker.docker_compose:
        project_src: /opt/gitops/myapp
        state: present

Hoe ik dan de .env files ook bijwerk is me nog een raadsel, want daar staan natuurlijk geheime dingen in en die gooi je normaliter niet in github/forgejo. Eerder heb ik die wel met GPG in github gezet als backup.

Als je er vragen over hebt mag je die ook altijd via DM stellen

Dat is fijn!

[alex3305]

@Mars Warrior Je bent er bijna !

Dit is enerzijds mening, anderzijds advies, maar je Docker configuratie én Ansible configuratie combineer je dus in 1 repo. Vanuit daar kun je het op twee manieren oppakken (natuurlijk wel meer, maar laten we het alsjeblieft makkelijk houden): Alle Compose bestanden in 1 map en die per host deployen of Compose Role's maken. Dat eerste is vrij naïef, maar doeltreffend. Dat laatste is zeer gewenst.

Wat ik in mijn repo nu dus heb is zoiets (bestandsstructuur):

code:

┌── .forgejo
│   └── workflows/          → Forgejo Actions workflows
├── group_vars              → Inventory group variables
│   └── .../
├── host_vars               → Host specific variables
│   └── .../
├── roles                   → Ansible Roles directory
│   └── .../
├── inventory.yml           → Ansible inventory

Elke Docker Compose applicatie is bij mij een Role. In deze rol heb ik vier vijf of zes directories:

• defaults, voor standaard variabelen (let op, altijd geprefixed met de role_name)
• files, voor statische bestanden
• handlers, voor eenmalige handlers (daar ga ik hier niet verder op in)
• tasks, wat een role moet doen
• templates, de dynamische bestanden (templates)
• vars, de statische role vars

In de templates definieer ik dan per role 1 of 2 bestanden, .env.j2 en compose.yaml.j2 die ik vervolgens met de template module uitrol naar de target host. In mijn geval is dat naar de Dockge Stacks directory. Daarna doe ik een Docker Compose Up. De templates hebben allemaal ongeveer dezelfde layout en secrets komen bij mij altij in de .env bestand. Templates heb ik al eerder hier gepost en de deployment ziet er dan o.a. zo uit:

YAML:

- name: Create Docker Compose Stack directory
  ansible.builtin.file:
    path: "{{ compose_stack_dir }}"
    state: directory
    owner: "{{ compose_stacks_owner }}"
    group: "{{ compose_stacks_group }}"
    mode: "0755"
  register: _compose_directory
  become: true

- name: Template Docker Compose file
  ansible.builtin.template:
    src: "templates/compose.yaml.j2"
    dest: "{{ [_compose_directory.path, 'compose.yaml'] | file_join }}"
    owner: "{{ compose_stacks_owner }}"
    group: "{{ compose_stacks_group }}"
    mode: "0644"
  become: true

# Compose .env  bestand kun je wel gokken :P

- name: Validate Docker Compose stack
  ansible.builtin.command:
    cmd: docker compose config
    chdir: "{{ _compose_directory.path }}"
  register: _docker_compose_config_output
  when: not ansible_check_mode
  failed_when: _docker_compose_config_output.rc != 0
  changed_when: false

- name: Docker Compose up
  community.docker.docker_compose_v2:
    project_src: "{{ _compose_directory.path }}"
    project_name: "{{ compose_stack_name }}"
    state: present
    recreate: "{{ 'always' if compose_recreate else 'auto' }}"
  register: _docker_compose_up_output
  when: not ansible_check_mode

In de group_vars zet ik dan globale variabelen voor een groep. Bijvoorbeeld domeinnamen. In de host_vars komen vervolgens specifieke host variabelen. Bijvoorbeeld memory limit, CPU limit, etc en paden. Immers is dat per host anders.

In de playbook heb ik dan staan welke host, welke rollen moet runnen:

YAML:

- name: Deploy AdGuard Home
  hosts: docker

  roles:
    - role: adguard_home

Bovenstaande rolt dus AdGuard Home op al mijn Docker hosts uit. In de host_vars van mijn secundaire host wordt vervolgens conditioneel AdGuard Home Sync opgezet .

Geheimen heeft Ansible ook iets voor: Ansible Vault. Die maakt versleutelde bestanden en kan deze on-demand ontsleutelen. Op mijn workstation heb ik bijvoorbeeld een Ansible Vault key file staan die automatisch wordt gebruikt. In mijn Forgejo repo staat een secret met daarin dezelfde key die wordt gebruikt bij de workflow.

[StarWing]

Ondertussen al een stap verder, na een aanpassing in de jail.local. Ik post deze vanavond even als ik thuis ben Fail2ban zegt wel dat hij een ip blockt, maar effectief blocken, ho maar....

Ik zou denken dat dit ligt aan een van de volgende zaken:

code:

chain   = DOCKER-USER
#chain   = INPUT

Enerzijds waarbij ik niet weet wat ik moet kiezen, anderzijds dat de beide dockers in een ander netwerk draaien, maar ik zou verwachten dat f2b dit blokkeert op host niveau. Mogelijks nog met het verschil tussen nftables of iptables, maar dit is iets waar ik onvoldoende kennis over heb.

[Mars Warrior]

alex3305 schreef op woensdag 3 december 2025 @ 21:32:
@Mars Warrior Je bent er bijna !

Ik zie nu wel dat de structuur die ik nu nastreef, en ook zou willen behouden, is dat ik per compose stack een repo heb waarin ik alles heb vastgelegd.
Dat komt ook omdat ik het nu nog simpel doe: ik bepaal zelf de compose stack, en deploy die gewoon (met Woodpecker nog, maar Komodo kan datzelfde). Dat is allemaal doodsimpel eigenlijk. Niks geen templates nog in gebruik of wat daar op lijkt.

Ik heb dan ook een agent nodig om alles uit te voeren natuurlijk: aanroep is via HTTP. Het nadeel daarvan is, is dat er al containers moeten draaien. Met Ansible + SSH heb je dat hele probleem natuurlijk niet. Dus die voordelen zijn me wel duidelijk.

• Door eea per stack te doen krijg ik in portainer ook alles per stack te zien. Dat houdt het erg overzichtelijk.
• Ik heb verder ook (nog) geen meerdere servers: alles zit in één ding. Lekker makkelijk.
• Dat je een stack al dan niet naar meerdere hosts kan uitrollen is mooi. Dat is voor nu nog niet nodig, maar het inrichten voor één host, maakt het wel mogelijk dat je later meer hosts kan gebruiken.
• vwb secrets: ik zag die Ansible Vault inderdaad, maar op de één of andere manier voelt dat voor mij niet als superhandig: die bestanden moeten toch ergens staan.

Ik heb daarom ook ff gekeken naar een Bitwarden (Vaultwarden) oplossing om daar de secerts voor de .env bestanden in te pleuren. Dan staat het centraal en afgeschermd, èn kan voor tig compose stacks worden ingezet. Maar geen versiebeheer

Ik neig dus nu naar SOPS om .env variabelen te encrypten (public/private key) die ik in forgejo kan zetten (encrypted .env + public key) en de private key als secret kan invoeren in forgejo. SOPS snapt ook Azure Key Vault. Mogelijk wordt het bedrijf naar nog blij van

De SOPS config file (in forgejo):

YAML:

# .sops.yaml file
creation_rules:
  - path_regex: stack\.env$
    age:
      - "age1q357..."
    encrypted_regex: '^(POSTGRES|S3_|SECRET)'

De .env bestanden blijven dan verder ook gewoon leesbaar:

YAML:

POSTGRES_PASSWORD=ENC[AES256_GCM,...]
S3_SECRET=ENC[AES256_GCM,...]
NO_SECRET=value

De keys kan ik dan ook nog in Bitwarden zetten, zodat dit centraal beheerd kan worden.

---

Ik ben eigenlijk op zoek naar blokjes die ik achter elkaar kan plaatsen: de input en output is elke keer hetzelfde, maar de techniek/oplossing kan anders zijn.
Dat ben ik ook gewend vanuit mijn vakgebied: werken met data en data pipelines. Ook daar kan ik blokken vervangen als het handig is. Zolang de output hetzelfde is, maakt de techniek niet uit.

De CrowdSec firewall werkt ook al op deze manier (soort van Medaillion Architecture met bronze/silver/gold), en als ik de CI/CD pipeline ook zo kan krijgen, dan kan ik zaken plaatsen en stap voor stap uitwerken:

• Bronze = ruwe data (bijv uit git)
• Silver = in stappen bewerkte data (zeg de secrets invullen, templates invullen, etc)
• Gold = finale bestanden die gedeployd worden met Ansible

Een groot deel zal met Forgejo actions & steps kunnen worden ingevuld. En een deel zal dan met Ansible gedaan moeten worden. Ik heb dan gewoon plain compose stacks en geencrypte .env files. Het gedeelte dat "common" is, zou dan uit Ansible moeten komen.

Alleen: als ik dus ook Ansible per stack "configureer". Is dat handig? Ik kan dan wel - zoals ik het nu snap - per server verschillende rollen maken: de ene server heeft een bepaalde stack wel, de andere niet.

Het decrypten met SOPS zal allemaal kunnen, dus technisch zou ik dan met Forgejo Action/Steps en Ansible toch een mooi werkende keten moeten kunnen fabriceren.

[Mars Warrior]

In ander nieuws: Traefik, CrowdSec en de CrowdSec firewall doen het nog steeds erg goed!

Ik heb zelf de nodige bewerkingen die met de CrowdSec Alerts het nodige doen, maar ook de abuseipdb meeneemt in 'bans' die ik in CrowdSec importeer (de cscli imports).

Statjes:

• Totaal zo'n 76 duizend drops van de firewall in de laatste maand
• De imports nemen een groot deel van deze drops voor hun rekening: erg effectief dus
• De extra lijsten die ik van CrowdSec gebruik, de tor en scanner lijsten voegen nauwelijks iets toe.
• Het aandeel per blocklist varieert per dag. De laatste dagen is de import dus erg effectief. Dat betekent veel terugkerende botjes

Door de variatie aan botjes (soms heel veel vanuit AMAZON-02) varieert het aandeel van de blocklists per dag ook sterk. Een ip adres kan zoals je ziet in meerdere blocklists zitten.

Des te hoger het aandeel van de crowdsec blocklist, des te hoger dus het aantal "nieuwe" botjes. Die zitten dan dus niet in de andere lijsten (zoals abuseipdb) die claimen ook recent/up-to-date te zijn.



Het blijkt onmogelijk te zijn om alles te blokkeren. Veel botjes maken gebruik van AMAZON-02: ze draaien ff een uurtje, en verhuizen weer de instance naar een andere regio. maw, je blijft dus nieuwe botjes krijgen en blokkeren (tijdelijk). Een ban die afloopt geeft in het algemeen wel weer een piek (botjes komen direct terug), waarna de bans en drops weer afnemen.

In het algemeen neemt het aantal bans door CrowdSec per dag wel af de laatste weken, maar 0 zal het nooit worden. Het gebruik van de CrowdSec firewall scheelt dus wel bergen events en alerts.

Het zijn dus waardevolle containers in mijn "infra" docker compose stack

[alex3305]

Mars Warrior schreef op donderdag 4 december 2025 @ 11:57:
[...]

Ik zie nu wel dat de structuur die ik nu nastreef, en ook zou willen behouden, is dat ik per compose stack een repo heb waarin ik alles heb vastgelegd.

Dat kan met Ansible Roles ook . Roles kun je namelijk ook in aparte repositories zetten. Dan kun je het zelfs mixen en matchen met gewone bestanden. Installatie doe je dan via Ansible Galaxy, dus...

requirements.yml

YAML:

roles:
  - name: audiobookshelf
    src: https://git.example.com/ansible/audiobookshelf.git
    version: v2.19.4
    scm: git

en dan gewoon

ansible-galaxy install -v -r requirements.yml

Zo deden we dat vroeger op het werk ook. Zal nu niet veel anders zijn. Persoonlijk ben ik daar vanaf gestapt omdat ik anders constant tussen repo's aan het wisselen was. Een mono repo past dat net wat beter in mijn structuur. Anderzijds neig ik toch steeds meer en meer om weer terug te gaan naar aparte repo's voor beheer van Compose roles. Simpelweg omdat ik secrets en group_vars / host_vars eigenlijk helemaal apart wil hebben. En omdat ik nu nog weleens variabelen een beetje slordig gebruik .

Dat komt ook omdat ik het nu nog simpel doe: ik bepaal zelf de compose stack, en deploy die gewoon (met Woodpecker nog, maar Komodo kan datzelfde). Dat is allemaal doodsimpel eigenlijk. Niks geen templates nog in gebruik of wat daar op lijkt.

Ik heb dan ook een agent nodig om alles uit te voeren natuurlijk: aanroep is via HTTP. Het nadeel daarvan is, is dat er al containers moeten draaien. Met Ansible + SSH heb je dat hele probleem natuurlijk niet. Dus die voordelen zijn me wel duidelijk.

Dat je een stack al dan niet naar meerdere hosts kan uitrollen is mooi. Dat is voor nu nog niet nodig, maar het inrichten voor één host, maakt het wel mogelijk dat je later meer hosts kan gebruiken.

Ik heb bijvoorbeeld een Beszel role waarmee uitbreiden dus triviaal is. Immers is het niets anders dan het toevoegen van een machine aan de inventory. Bij grote(re) setups kun je zelfs met nummers of ranges gaan werken. Dat wordt ook standaard ondersteund in Ansible .

vwb secrets: ik zag die Ansible Vault inderdaad, maar op de één of andere manier voelt dat voor mij niet als superhandig: die bestanden moeten toch ergens staan.

Ik heb daarom ook ff gekeken naar een Bitwarden (Vaultwarden) oplossing om daar de secerts voor de .env bestanden in te pleuren. Dan staat het centraal en afgeschermd, èn kan voor tig compose stacks worden ingezet. Maar geen versiebeheer

Ik neig dus nu naar SOPS om .env variabelen te encrypten (public/private key) die ik in forgejo kan zetten (encrypted .env + public key) en de private key als secret kan invoeren in forgejo. SOPS snapt ook Azure Key Vault. Mogelijk wordt het bedrijf naar nog blij van

Ansible Vault werkt dikke prima hoor. Je maakt een key aan en die zet je in een file, variabele of gebruik je simpelweg op de command line. Ik heb zelf de voorkeur voor een vault file. Dat secret kan eventueel ook vanuit Bitwarden komen. De vault file heb ik vervolgens geconfigureerd in mijn ansible.cfg in de repo.

Vervolgens is het niets meer dan:

ansible-vault encrypt host_vars/my_host/vault.yml
# en
ansible-vault decrypt host_vars/my_host/vault.yml

Ansible decrypt met deze setup ook automatisch de vaults bij het uitrollen. Ik heb dan ook de gewoonte om versleutelde variabelen te prefixen met vault_ en te gebruiken met een clear text variabelen. Dus:

YAML:

immich_database_password: "{{ vault_immich_database_password }}"

Anderzijds is het ook mogelijk om random secrets of keys te laten genereren met de seed van bijv. de inventory_hostname. Dan krijg je ook unieke secrets voor niet zo kritische onderdelen.

Vaultwarden met Ansible wordt niet ondersteund. Bitwarden Enterprise met Secrets Manager wel. Er is wel een soort van workaround met de bitwarden-cli, maar dat voelt gaar. Ik heb dat ooit ook gebouwd voor Home Assistant, maar was ik niet zo over te spreken .

*kuch* Ansible - azure.azcollection.azure_rm_keyvault module – Manage Key Vault instance

[StarWing]

Ondertussen terug een stap verder, maar nog geen block te merken

code:

2025-12-05 06:44:47,938 fail2ban.actions        [154]: NOTICE  [emby] Unban 188.188.135.111
2025-12-05 06:45:07,030 fail2ban.filter         [154]: INFO    [emby] Found 188.188.135.111 - 2025-12-05 06:45:06
2025-12-05 06:45:09,032 fail2ban.filter         [154]: INFO    [emby] Found 188.188.135.111 - 2025-12-05 06:45:08
2025-12-05 06:45:11,034 fail2ban.filter         [154]: INFO    [emby] Found 188.188.135.111 - 2025-12-05 06:45:10
2025-12-05 06:45:11,246 fail2ban.actions        [154]: NOTICE  [emby] Ban 188.188.135.111
2025-12-05 06:45:13,237 fail2ban.filter         [154]: INFO    [emby] Found 188.188.135.111 - 2025-12-05 06:45:13

iptabled -L op de host geeft effectief iets weer:

code:

Chain DOCKER-INTERNAL (1 references)
target     prot opt source               destination

Chain DOCKER-USER (1 references)
target     prot opt source               destination
f2b-emby   tcp  --  anywhere             anywhere             multiport dports 8096,http,https

Chain f2b-emby (1 references)
target     prot opt source               destination
REJECT     all  --  188.188.135.111      anywhere             reject-with icmp-port-unreachable
RETURN     all  --  anywhere             anywhere

Maar dit resulteert niet in een effectieve ban

[Mars Warrior]

Nou, nou, nou, nou: ik heb de mega stack "WhoAmI" weten te deployen met Forgejo Actions + Ansible



Ik heb wel alles zo veel mogelijk versimpelt: vanuit iets werkends is het altijd makkelijker om iets uit te bouwen, dan dat je elke keer ergens tegenaan loopt. Dat was nu al namelijk

Dit is de docker-compose.yaml file:

YAML:

services:
  whoami:
    image: traefik/whoami:v1.10.4
    command:
       # It tells whoami to start listening on 2001 instead of 80
       - --port=2001
       - --name=iamfoo

De forgejo action, waarbij ik nog niet heb gekeken naar tool caching enzo. Ff lekker simpel gedaan

YAML:

name: Deploy

on:
  workflow_dispatch:

jobs:
  deploy:
    runs-on: docker
    steps:
      - uses: actions/checkout@v4

      - name: Inject SSH key
        run: |
          mkdir -p ~/.ssh
          echo "${{ secrets.DEPLOY_KEY }}" > ~/.ssh/id_ed25519
          chmod 600 ~/.ssh/id_ed25519

      - name: Install modern Ansible + collections
        run: |
          apt-get update
          apt-get install -y python3 python3-pip
          pip install --upgrade pip
          pip install "ansible>=8.0.0"
          ansible-galaxy collection install community.docker
          pip install docker
          ansible --version

      - name: Run Ansible
        run: ANSIBLE_HOST_KEY_CHECKING=False ansible-playbook -i inventory.ini deploy.yaml

En ik heb alles in één Ansible deploy file gezet. Nog geen vars en andere dingen:

YAML:

- hosts: domiducus
  #become: true
  vars:
    compose_stack_name: "whoami"
    compose_stack_dir: "/home/stacks/whoami"
    compose_stacks_owner: "home"
    compose_stacks_group: "home"
    compose_recreate: true

  tasks:
    - name: Create directory
      file:
        path: "{{ compose_stack_dir }}"
        state: directory
        owner: "{{ compose_stacks_owner }}"
        group: "{{ compose_stacks_group }}"
        mode: "0755"

    - name: Copy compose file
      ansible.builtin.copy:
        src: docker-compose.yaml       # uit je Git repo
        dest: "{{ compose_stack_dir }}/docker-compose.yml"
        owner: "{{ compose_stacks_owner }}"
        group: "{{ compose_stacks_group }}"
        mode: "0644"

    - name: Copy .env
      ansible.builtin.copy:
        src: .env
        dest: "{{ compose_stack_dir }}/.env"
        mode: "0600"

    - name: Validate compose
      command: docker compose config
      args:
        chdir: "{{ compose_stack_dir }}"
      changed_when: false

    # Tijdelijk ff via shell commando, en niet via docker python module die blijkbaar op de host moet draaien hiervoor
#    - name: Compose up
#      community.docker.docker_compose:
#        project_src: "{{ compose_stack_dir }}"
#        project_name: "{{ compose_stack_name }}"
#        state: present
#        recreate: always
    - name: Compose up
      ansible.builtin.command:
        cmd: docker compose up -d
        chdir: "{{ compose_stack_dir }}"

Ik heb nu dus een werkende keten

Dat is al heel wat

Nu kan ik wat dingen gaan uitbouwen. Heb al wel een .env file, maar nog geen "secrets" in die .env file. Ik wil nog steeds SOPS gebruiken, Die kan ook met SSH keys werken, dus dan zou ik maar één key nodig hebben voor al dit gedoe, en kan ik ook vscode + sops plugin gebruiken om de .env bestanden te editen/wijzigen zonder dat ik handmatig hoef te en/decrypten

Gewoon een checkout van git, en gaan met die banaan.

---

De renovate-bot container heb ik ook met een Action weten te schedulen, en zou ook op een push event kunnen werken, dus ook die doet zijn werk op het moment dat ik een docker compose file toevoeg! Ik had expres een oude versie (v1.10.4) van WhoAmI gebruikt., terwijl 1.11.0 de laatste is...

Ik draai nog wel een aparte Renovate container: die herstart ik. Dus nog niet een container die binnen de runner gestart wordt. Stapje voor stapje



Een week geleden nog nooit gehoord van/gewerkt met Forgejo, Renovate en Ansible, en kiek nou!.

Toppie @alex3305

[alex3305]

Lekker bezig @Mars Warrior. Kleine stappen, maar wat mij betreft een groot resultaat. Ik vind dat je best even stil mag staan bij de technologie die je in deze korte periode bekeken, geëvalueerd, beoordeeld en ingezet hebt. Dat vind ik - bovenop Docker - echt prachtig .

Je hebt voor zover ik weet overigens de docker-python module niet nodig. Ik heb een Unraid systeem waar ik niets echt op kan installeren en daar heb ik dat ook niet. Wel installeer ik - via een eigen role - Docker Compose:

roles/docker_compose/tasks/main.yml

YAML:

- name: Assert required variables are set
  ansible.builtin.assert:
    that:
      - docker_compose_version is defined

- name: Uninstall Docker Compose from package manager
  ansible.builtin.package:
    name: "{{ docker_compose_package }}"
    state: absent
  when: >-
    docker_compose_package is defined and
    ansible_facts['pkg_mgr'] is defined and
    ansible_facts['pkg_mgr'] != 'unknown'
  become: true
  failed_when: false

- name: Create Docker plugins directory
  ansible.builtin.file:
    path: "/usr/local/lib/docker/cli-plugins/"
    state: directory
    owner: "{{ ansible_facts['user_id'] }}"
    group: "docker"
    mode: "0755"
  register: docker_plugins_dir
  become: true

- name: Install Docker Compose
  ansible.builtin.get_url:
    url: "{{ docker_compose_release_url }}"
    dest: "{{ [docker_plugins_dir.path, 'docker-compose'] | path_join }}"
    owner: "{{ ansible_facts['user_id'] }}"
    group: "docker"
    mode: "0755"
    checksum: "sha256:{{ docker_compose_release_url }}.sha256"
  notify: "Check Docker Compose Version"

roles/docker_compose/vars/main.yml

YAML:

# This should be fairly complete but probably isn't...
docker_compose_arch: >-
  {% if ansible_facts['architecture'] in ['x86-64', 'x86_64'] %}
    x86_64
  {% elif ansible_facts['architecture'] in ['armv6'] %}
    armv6
  {% elif ansible_facts['architecture'] in ['armv7'] %}
    armv7
  {% elif ansible_facts['architecture'] in ['armv8', 'armhf', 'aarch'] %}
    aarch64
  {% else %}
    {{ ansible_facts['architecture'] }}
  {% endif %}

docker_compose_package: >-
  {% if (ansible_facts['pkg_mgr'] | lower) in ['apt', 'rpm'] %}
    docker-compose-plugin
  {% elif (ansible_facts['pkg_mgr'] | lower) in ['pacman', 'dnf'] %}
    docker-compose
  {% elif (ansible_facts['pkg_mgr'] | lower) in ['apk'] %}
    docker-cli-compose
  {% endif %}

# yamllint disable-line rule:line-length
docker_compose_release_url: "https://github.com/docker/compose/releases/download/{{ docker_compose_version | trim }}/docker-compose-linux-{{ docker_compose_arch | trim }}"

roles/docker_compose/handlers/main.yml

YAML:

- name: Check Docker Compose Version
  ansible.builtin.command: docker compose version
  changed_when: false
  register: docker_compose_version
  failed_when: docker_compose_version.rc != 0

Voor de volgende stappen zou ik je verder sterk aanraden om Ansible te cachen. De Forgejo cache is met 1 node extreem simpel in te richten. Daarnaast heb je zeer waarschijnlijk ook alleen maar Ansible Core nodig. Volledige Ansible gebruik je o.a. voor integratie met externe systemen zoals Cisco. Dat scheelt al enorm met downloaden en installeren .

Je kunt Renovate natuurlijk ook met een Cron laten draaien hè. Dat heb ik eerder ook al een keer gepost.

[Mars Warrior]

alex3305 schreef op vrijdag 5 december 2025 @ 16:21:
Lekker bezig @Mars Warrior. Kleine stappen, maar wat mij betreft een groot resultaat. Ik vind dat je best even stil mag staan bij de technologie die je in deze korte periode bekeken, geëvalueerd, beoordeeld en ingezet hebt. Dat vind ik - bovenop Docker - echt prachtig .

Yep. Ben er ook blij mee. Het is nog wel relatief een eenvoudige opzet, maar het werkt, en uitbreiden kan altijd nog.

Voor de volgende stappen zou ik je verder sterk aanraden om Ansible te cachen. De Forgejo cache is met 1 node extreem simpel in te richten. Daarnaast heb je zeer waarschijnlijk ook alleen maar Ansible Core nodig. Volledige Ansible gebruik je o.a. voor integratie met externe systemen zoals Cisco. Dat scheelt al enorm met downloaden en installeren .

Daar ga ik naar kijken ja. Het grootste deel van de tijd is nu het installeren van Ansible

Je kunt Renovate natuurlijk ook met een Cron laten draaien hè. Dat heb ik eerder ook al een keer gepost.

Had ik gezien ja. Jij runt hem als Docker container in de Runner. Ik nog als aparte container in mijn GitOps stack.

---

Maar ik zat nog ff verder te denken. Behalve de docker stack moet je natuurlijk ook de omgeving van de docker services opzetten en configuratiebestanden enzo ook in forgejo zetten, en dus ook uitrollen met Ansible. Het zijn wat mapjes en wat bestanden. Meer niet.

Nu doe ik alles nog handmatig: Dus mappen aanmaken, en bestanden aanmaken die nodig zijn. Ik backup wel, waarbij ik de .env bestanden door GPG haal en zo in Github gooi als backup. Maar echt handig is dit niet natuurlijk.

Als ik de config bestanden die nodig zijn ook in de stack map in forgejo zou zetten, dan kan ik die eerst aanmaken en klaarzetten, en daarna de compose mappen en bestanden aanmaken en de compose stack starten. Enkel de stack zonder mappen gaat nooit werken.

Verder dan ook de vraag of je een volledige compose file voor die stack gebruikt (zoal ik nu doe), of aparte files die je dan bij de deplo samenneemt. Datzelfde kun je dan doen voor de .env files. Dan kun je ze zelfs nog apart deployen.

Keuzes, keuzes, en mogelijkheden

code:

/home/compose/<stack>/<service>/        ← compose + env + scripts

/home/data/<stack>/<service>/git/       ← config UIT GIT
/home/data/<stack>/<service>/runtime/   ← alles wat de service zelf maakt

[ Voor 4% gewijzigd door Mars Warrior op 05-12-2025 22:04 ]

[alex3305]

@Mars Warrior Dit is uiteraard ook weer een kwestie van smaak en het een hoeft niet beter te zijn dan het ander . Ik ben ook van mijn Unraid machine uitgegaan. Unraid is misschien niet de meest logische keuze voor iemand met een stack zoals de mijne, maar daar staat tegenover dat ik alles vanuit een UI kan bedienen. Ik heb een zicht van ~20% en een terminal op mijn telefoon met een voor mij leesbaar lettertype is dus een redelijke no-go. Elke keer mijn workstation moeten starten om een kleine aanpassing te maken of een container een schop te geven is ook niet zo handig. Vandaar.

Unraid draait volledig in geheugen. Disks worden alleen maar gebruikt voor (user) data. Ik heb daarom in Unraid een partitie op een van de SSD's aangemaakt o.a. voor Docker. Die heeft als mount point /mnt/applications/appdata gekregen. Applications is de naam van de disk en appdata de naam van de partitie. Op mijn Debian host heb ik /opt/appdata. Beide directories neem ik mee in mijn backup.

Bij een uitrol voer ik (kort door de bocht) een aantal stappen uit:

1. Controleren van ingevoerde variabelen
2. Aanmaken van mappen voor de uit te rollen applicatie
3. Templaten van configuratiebestanden (optioneel)
4. Aanmaken van Docker Compose directory
5. Templaten van Docker Compose
6. Docker Compose Up

Voor Stap 1 gebruik ik de assert module, maar ik kan bijvoorbeeld ook controleren of het ingevoerde Compose netwerk reeds bestaat:

YAML:

- name: Assert required variables
  ansible.builtin.assert:
    that:
      - ghost_domain is defined
      - ghost_domain is string

- name: Assert Docker ingress network
  community.docker.docker_network_info:
    name: "{{ ghost_ingress_network }}"
  register: _docker_ingress_network_output
  failed_when: not _docker_ingress_network_output.exists

Voor Stap 2 maak ik in de vars/main.yml variabelen aan die gebaseerd zijn op een application directory. In dit geval geef ik de role een ghost_dir variabele mee en baseer ik de overige variabelen daar bovenop. Daarna maak ik daarmee de benodigde mappen aan.

YAML:

- name: Create Ghost directories
  ansible.builtin.file:
    path: "{{ item }}"
    state: directory
    owner: "{{ ghost_user }}"
    group: "{{ ghost_group }}"
    mode: "0755"
  become: true
  loop:
    - "{{ ghost_dir }}"
    - "{{ ghost_uploads_dir }}"
    - "{{ ghost_database_dir }}"

Intern gebruik ik dan nog een leuk trucje. In de host variabele heb ik standaard een variabele genaamd appdata en dat is dus het eerder door mij genoemde pad. In de defaults van de roles combineer ik die dan met de naam van de role

YAML:

ghost_dir: "{{ [appdata, role_name] | path_join }}"

Dus alleen bij een afwijkend pad hoef ik deze variabelen daadwerkelijk te zetten / te wijzigen .

Tegelijkertijd is deze stap (wederom) idempotent, en wordt die dus niet uitgevoerd wanneer deze niet nodig is. Je zou eventueel zelfs deze stap recursive kunnen doen zodat je zeker bent dat de rechten altijd staan zoals je wilt.

In Stap 3 template of kopieer ik bestanden die ik nodig heb. Ik heb de voorkeur voor templating omdat ik dan variabelen kan gebruiken. Bij mijn Traefik role is dat bijvoorbeeld erg uitgebreid:


Nou weet ik dat deze bestanden eigenlijk buiten de role horen, maar soms ben ik liever iets pragmatischer en praktischer dan principieel.

Tot slot maak ik op eenzelfde manier de Compose Stack directory aan. Bij mij is dat dan in de dockge/stacks directory zodat ik Compose (wederom) via een UI kan bedienen. En template ik de Compose bestanden. Na een validatie wordt Docker Compose Up gedraaid.

In sommige gevallen doe ik nog een controle of de applicatie draait. Bijvoorbeeld bij de Mosquitto broker. Immers werken anders bepaalde applicaties niet.

Rome is niet in 1 dag gebouwd en deze repo ook niet hè. Maar wellicht dat het o.a. jou nog wat inzicht geeft

[blackd]

@alex3305 @Mars Warrior Erg interessant om jullie setup m.b.t. beheer van docker containers / compose projects te lezen.
Ik heb een vergelijkbare ansible setup draaien als @alex3305, gehost op GitHub (private repo), ik gebruik inmiddels uitsluitend GitHub Actions en heb een Self hosted runner draaien om mijn playbook lokaal uit te rollen.Voorheen gebruikte ik (ook) woodpecker maar daar ben ik vanaf gestapt.

Ik beheer met een Ansible Monorepo mijn router (edgerouter), mijn 2 pi-hole machines (high available), nog een losse rpi, mijn TrueNAS Scale server met daarbinnen een Jailmaker jail (hier draaien alle docker containers) en een 'Instance' (hier draait de Self hosted runner) Ik heb zoveel als mogelijk alle dependencies geversioneerd en draai Renovate om alle dependencies te updaten. Ik maak een nightly release en draai dan het playbook uit over mijn infrastructuur.

T.a.v. het cachen van Ansible nog een tip, ik heb een eigen docker container in beheer (gebaseerd op ansible-dev-tools container) die ik zowel als devcontainer in VSCode gebruik als base image voor mijn Self hosted runner. Hier heb ik de versies van Python, Ansible, Ansible Lint, mijn gebruikte Galaxy Collections en pip dependencies in gefixeerd. Ik onderhoud deze docker container in een aparte repository en bouw deze met Ansible Builder als een execution environment. Ik ben alleen niet heel gelukkig met Fedora als base os. Ik zou dit op termijn nog een keer willen omzetten naar een Debian based OS.
Je zou ervoor kunnen kiezen je runner (of dat nou Woodpecker is of een Github local runner) uit te laten voeren in een eigen container met daarin alle benodigde spullen al geïnstalleerd.

Ik zou het gebruik van Bitwarden voor secrets momenteel afraden. Ik heb dit een tijdje gedaan, maar merkte dat de service best wel intermittent werkt, waardoor je playbooks gaan falen bij uitvoer. Dus ik zou Ansible Vault aanraden om je secrets in je eigen repo vast te leggen. Sowieso probeer ik zelf ook de repo zo weinig mogelijk dependencies van de buitenwereld te geven. De Galaxy Collections zijn al geinstalleerd in de execution environment, de Roles heb ik in de repo ingecheckt. Een probleem waar je misschien tegenaan loopt is dat je niet weet welke variabelen je in je vault hebt, zonder hem telkens te decrypten. Een oplossing die ik ergens ben tegengekomen en zelf ook toepas is een tweetrapsraket: een secrets.yml waar je alle variabelen definieert (deze variabelen gebruik je in overige bestanden) en die verwijst naar een vault.yml (deze is encrypted).

secrets.yaml:

YAML:

secrets:
  healthchecks_api_token: "{{ vault_secrets.healtchecks_api_token }}"

vault.yaml

YAML:

vault_secrets:
  healthchecks_api_token: "<jouw token>"

En dan gebruik je deze bijvoorbeeld in group_vars/main.yml:

YAML:

healthchecksio:
  check_uuid: <<blabla>>
  api_token: "{{ secrets.healthchecksio_api_token }}"

Qua roles: ik heb voor elke docker compose stack een eigen role gemaakt. Maar ik merkte dat ik toch een aantal zaken generiek wilde trekken, zoals het plaatsen van de docker compose file, de .env file, het aanmaken van een dataset, het fixen van permissies, etc. Ik heb daartoe een docker_compose_base rol gemaakt met deze operaties in tasks. Die roep ik aan in mijn stack specifieke compose files. Ik draai nu 24 stacks (volgens dockge).

[Mars Warrior]

Haha @blackd , nog meer input voor mijn arme hersentjes

Vwb betreft je probleem of omweg om de keys te kunnen lezen in je .env file: daarvoor wil ik dus SOPS gebruiken. De keys blijven volledig leesbaar, enkel de values worden geencrypt.

Zo'n bestand kun je dus ook gewoon in Git gooien. Niemand kan er wat mee. Decrypten is met je SSH key, die je toch nodig hebt voor Ansible om te kunnen deployen. Dus onderdeel van de Action of een Playbook

Nergens dus een bestand met leesbare secrets, zeker niet als je met vscode edit: die en/decrypt automatisch vanuit de editor. Je kunt meerdere SSH Keys gebruiken, dus dat is ook nog een plus vind ik.

En het is nu Vroooeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeem tijd

[blackd]

@Mars Warrior Ja, dat kan natuurlijk ook. Maar dat kan met Ansible Vault ook.
Ik heb ervoor gekozen om alle secrets in 1 yaml bestand te zetten en die in zijn geheel te encrypten.

Houd er in de keuze van je oplossing wel rekening mee of je nog andere tooling gebruikt om je bestanden te verwerken. Je hebt al VSCode benoemd. Maar ik draai zelf Ansible Lint en Docker Compose Lint (ook als GitHub action) bij elke pull request om de repo te valideren. Ansible Lint ondersteunt ook Ansible Vault.
https://docs.ansible.com/projects/lint/
https://docs.ansible.com/projects/lint/usage/#vaults

[alex3305]

T.a.v. het cachen van Ansible nog een tip, ik heb een eigen docker container in beheer (gebaseerd op ansible-dev-tools container) die ik zowel als devcontainer in VSCode gebruik als base image voor mijn Self hosted runner. Hier heb ik de versies van Python, Ansible, Ansible Lint, mijn gebruikte Galaxy Collections en pip dependencies in gefixeerd. Ik onderhoud deze docker container in een aparte repository en bouw deze met Ansible Builder als een execution environment. Ik ben alleen niet heel gelukkig met Fedora als base os. Ik zou dit op termijn nog een keer willen omzetten naar een Debian based OS.
Je zou ervoor kunnen kiezen je runner (of dat nou Woodpecker is of een Github local runner) uit te laten voeren in een eigen container met daarin alle benodigde spullen al geïnstalleerd.

Dat heb ik ook een tijdje gehad, maar vond ik onhandig. Ik wil op mijn workstation niet per se afhankelijk zijn van Docker / devcontainers en/of Visual Studio Code. Ook wilde ik graag mijn Ansible requirements graag meenemen in de container. Daardoor had ik echter twee keer dezelfde dependencies in twee aparte repo's. Dat voelde niet zo lekker.

Ter referentie mijn Ansible Dockerfile

Docker:

FROM node:22.17-alpine

ADD requirements.txt requirements.yml /

RUN apk add --no-cache ca-certificates \
                       git \
                       python3 \
                       py3-pip \
                       openssh-client \
                       openssl \
                       rsync \
                       sshpass \
                       sudo \
    && \
    pip3 install --ignore-installed \
                 --break-system-packages \
                 -r /requirements.txt \
    && \
    ansible-galaxy install -r /requirements.yml \
    && \
    mkdir -p /ansible \
    && \
    rm -rf /root/.cache \
           /requirements.txt \
           /requirements.yml

WORKDIR /ansible

ENTRYPOINT ["ansible-playbook"]
CMD ["--version"]

De Node versie zou best geüpgraded mogen worden. In de requirements.txt had ik dan o.a. Ansible staan:

code:

ansible-core==2.18.6
ansible-lint==25.6.1

En in de requirements.yml stonden dan mijn (externe) roles en collections.

Ik regel dit dus nu in mijn Ansible / infra / Docker repo. Om toch repeatable builds te krijgen heb ik een aantal bestanden aangemaakt:

• .python-version
• requirements.txt
• requirements.yml

Bij het starten van de workflow gebruikt de Forgejo Act runner de generieke setup-python action. Die action gebruikt vervolgens het .python-version bestand om de Python versie te bepalen die geïnstalleerd wordt. Python wordt geïnstalleerd in de hosted tool cache die gedeeld wordt tussen builds. Dezelfde action zet direct ook een cache op voor Python requirements, waar Ansible ook in staat .

In dezelfde repo heb ik ook een setup.sh script staan voor op mijn workstation. Vanuit daar wordt, wanneer nodig, pyenv geïnstalleerd en geconfigureerd. Ik heb ook nog gekeken naar uv, maar dat project was nog niet volwassen genoeg om effectief te zijn. In datzelfde script installeer ik vervolgens wederom dependencies, maar dan dus in een virtualenv binnen pyenv. Ook controleert dit script op een vault pass en kan deze direct geconfigureerd worden. Afijn, alles om te starten.

[alex3305]

Mars Warrior schreef op zondag 7 december 2025 @ 13:59:
Zo'n [SOPS] bestand kun je dus ook gewoon in Git gooien. Niemand kan er wat mee. Decrypten is met je SSH key, die je toch nodig hebt voor Ansible om te kunnen deployen. Dus onderdeel van de Action of een Playbook

Dus hetzelfde als Ansible Vault, maar dan moet ik nog een extra tool hebben en integreert het niet lekker met Ansible .

Ik zou ook mijn SSH key kunnen gebruiken als vault pass. Dat is immers gewoon een string. Als je echter in een team werkt is dat onhandig. Bij mij is dit dus gewoon een shared secret die toevallig alleen ik gebruik.

blackd schreef op zondag 7 december 2025 @ 18:55:
@Mars Warrior Ja, dat kan natuurlijk ook. Maar dat kan met Ansible Vault ook.
Ik heb ervoor gekozen om alle secrets in 1 yaml bestand te zetten en die in zijn geheel te encrypten.

Ik heb per group en host vault bestanden. De setup die je eerder aangaf met mappings (bijv. vault.my_secret) gebruik ik expliciet niet. Ik heb liever expliciete variabelen, dus vault_my_secret. Dat komt omdat ik in het verleden wat nare ervaringen heb gehad met het samenvoegen van dergelijke objecten en onverwachte resultaten. Maar goed, dat is natuurlijk stijl .

Houd er in de keuze van je oplossing wel rekening mee of je nog andere tooling gebruikt om je bestanden te verwerken. Je hebt al VSCode benoemd. Maar ik draai zelf Ansible Lint en Docker Compose Lint (ook als GitHub action) bij elke pull request om de repo te valideren.

Bij elke push / PR draait Ansible Lint op mijn Git server:

YAML:

jobs:
  ansible-lint:
    name: Ansible Lint
    runs-on: ubuntu-latest

    steps:
      - name: ⤵️ Checkout repository
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6

      - name: 🏗️ Setup Ansible
        id: setup-ansible
        uses: ./.forgejo/actions/setup-ansible
        with:
          vault-pass: ${{ secrets.ANSIBLE_VAULT_KEY }}

      - name: 🕵️‍♀️ Run Ansible Lint
        run: ansible-lint
        env:
          ANSIBLE_VAULT_PASSWORD_FILE: >-
            ${{ steps.setup-ansible.outputs.vault-pass-file }}

ansible-lint zit namelijk in de requirements.txt en wordt standaard mee geïnstalleerd .

Ook gebruik ik pre-commit hooks om Ansible Lint te draaien voordat ik commit. Dat heeft ook al enkele oopsies voorkomen en was verrassend eenvoudig op te zetten. Tevens heb ik een eigen pre-commit hook gemaakt die controleert op Ansible Vault files en de commit abort wanneer ik dergelijke bestanden in plain text probeer te committen.

Docker Compose Lint lijkt me interessant, behalve dan dat ik dus mijn Compose bestanden maak met Jinja . Daar moet ik dus nog even vanaf zien. Anderzijds valideer ik Compose bestanden sowieso voor een Up.

[blackd]

alex3305 schreef op zondag 7 december 2025 @ 19:40:
Dat heb ik ook een tijdje gehad, maar vond ik onhandig. Ik wil op mijn workstation niet per se afhankelijk zijn van Docker / devcontainers en/of Visual Studio Code. Ook wilde ik graag mijn Ansible requirements graag meenemen in de container. Daardoor had ik echter twee keer dezelfde dependencies in twee aparte repo's. Dat voelde niet zo lekker.

Wat betreft het eerste, snap ik wat je zegt. Momenteel heb ik ook ansible gewoon nog 'lokaal' geinstalleerd staan.
Het had juist mijn voorkeur om overal exact dezelfde dependencies te hebben. Zowel in CI als lokaal in development.

Ik heb nu inderdaad requirements.yml dubbel geadministreerd staan, dat vind ik wel jammer aan deze setup. Ansible-Lint heeft 'm ook gewoon in de project dir nodig.
Mijn oplossing: een sync d.m.v. een github action van de ene repo naar de andere met deze action.

Ik had eerst de execution environment in dezelfde repo staan (geinspireerd door dbrennand op GitHub) maar dat werd een rommeltje met twee aparte releases in 1 project.

alex3305 schreef op zondag 7 december 2025 @ 19:48:
Ook gebruik ik pre-commit hooks om Ansible Lint te draaien voordat ik commit. Dat heeft ook al enkele oopsies voorkomen en was verrassend eenvoudig op te zetten. Tevens heb ik een eigen pre-commit hook gemaakt die controleert op Ansible Vault files en de commit abort wanneer ik dergelijke bestanden in plain text probeer te committen.

Dat staat nog op mijn wensenlijstje.

Docker Compose Lint lijkt me interessant, behalve dan dat ik dus mijn Compose bestanden maak met Jinja . Daar moet ik dus nog even vanaf zien. Anderzijds valideer ik Compose bestanden sowieso voor een Up.

Ik template ook mijn Compose bestanden maar het enige wat er eigenlijk gevuld wordt zijn de standaard variabelen (${}) en die worden weer gevoed door het .env bestand. En die template ik ook, die wordt gevoed door Ansible.

Voorbeeldje docker-compose.yml in jellyfin role (snippet):

YAML:

services:
  jellyfin:
    image: jellyfin/jellyfin:10.11.4@sha256:aab0b50a3ce43a41621fc7040a379cc57174059aec8f9c17a90176649a0c1ab1
    container_name: jellyfin
    volumes:
      - ${HOST_VOLUME_CONFIG}:/config
      - ${HOST_VOLUME_CACHE}:/cache
      - ${HOST_VOLUME_MEDIA}:/media

.env.j2

YAML:

HOST_VOLUME_CONFIG="{{ jellyfin__compose_volume_config }}"
HOST_VOLUME_CACHE="{{ jellyfin__compose_volume_cache }}"
HOST_VOLUME_MEDIA="{{ jellyfin__compose_volume_media }}"

[alex3305]

blackd schreef op zondag 7 december 2025 @ 20:29:
[...]

Wat betreft het eerste, snap ik wat je zegt. Momenteel heb ik ook ansible gewoon nog 'lokaal' geinstalleerd staan.
Het had juist mijn voorkeur om overal exact dezelfde dependencies te hebben. Zowel in CI als lokaal in development.

Yes. Maar dat heb ik dus . Want lokaal gebruik ik pyenv met een virtualenv die met pip de requirements.txt installeert met daarin o.a. Ansible Core en Ansible Lint. En de CI omgeving doet setup-python hetzelfde. Allebei maken ze gebruik van dezelfde python versie dmv het .python-version bestand. Renovate update hier (wederom) de dependencies.

Ik vind het overigens een voordeel om lokaal geen globale Ansible meer te hebben. Dan kan ik ook niet per abuis een verkeerde of oude versie gebruiken.

Dat staat nog op mijn wensenlijstje.

.pre-commit-config.yaml

YAML:

repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v6.0.0
    hooks:
      - id: check-shebang-scripts-are-executable
      - id: detect-private-key
      - id: end-of-file-fixer
      - id: trailing-whitespace

  - repo: https://github.com/ansible/ansible-lint
    rev: v25.12.0
    hooks:
      - id: ansible-lint

In de requirements.txt zit pre-commit==4.5.0 en activeren is dan niets meer dan pre-commit install.

Ik template ook mijn Compose bestanden maar het enige wat er eigenlijk gevuld wordt zijn de standaard variabelen (${}) en die worden weer gevoed door het .env bestand. En die template ik ook, die wordt gevoed door Ansible.

Ik template de Compose bestanden zelf ook. Best uitgebreid overigens . Recent ben ik wat met Ghost in de weer geweest en dan komt er zoiets uit. Dit is een snippet als voorbeeld:

YAML:

#jinja2: lstrip_blocks: True, trim_blocks: True
---
{{ ansible_managed | comment }}

name: {{ _compose_stack_name }}

services:
  ghost:
    container_name: ${COMPOSE_PROJECT_NAME}
    image: ghost:6.10.0-alpine
    environment:
      NODE_ENV: production
      url: ${GHOST_URL}
      database__client: mysql
      database__connection__host: database
      database__connection__user: ${DATABASE_USERNAME}
      database__connection__password: ${DATABASE_PASSWORD}
      database__connection__database: ${DATABASE_NAME}
    networks:
      ingress:
      internal:
    volumes:
      - {{ ghost_uploads_dir }}:/var/lib/ghost/content
    depends_on:
      database:
        condition: service_healthy
      {% if not ghost_use_hosted_activitypub %}
      activitypub:
        condition: service_started
        required: false
      {% endif %}
    {% if ghost_docker_options is defined %}
    {{ ghost_docker_options | to_nice_yaml | indent(4) }}
    {%- endif %}
    labels:
      traefik.enable: true
      traefik.http.routers.{{ _compose_stack_name }}.rule: "Host(`{{ ghost_domain }}`)"
      traefik.http.routers.{{ _compose_stack_name }}.middlewares: "anubis@docker"
      traefik.http.routers.{{ _compose_stack_name }}.service: "{{ _compose_stack_name }}"
      traefik.http.services.{{ _compose_stack_name }}.loadbalancer.server.port: "2368"
      {%- if _is_unraid +%}
      net.unraid.docker.icon: https://avatars.githubusercontent.com/u/2452804?s=200&v=4
      net.unraid.docker.managed: ansible
      net.unraid.docker.shell: /bin/bash
      {% endif %}

Secrets komen bij mij in de .env.j2 zodat deze niet direct zichtbaar zijn.

Conditionals zijn bij mij hier enorm belangrijk omdat ik afhankelijk van variabelen nog weleens het een of het andere uitrol. Bijvoorbeeld een adguard_home_sync op een secundaire node. Dan hoef ik geen twee Compose bestanden te onderhouden. Profielen zijn uiteraard ook nog een optie, maar dat vind ik niet heel transparent. Laatst heb ik daar wel meegespeeld in OpenCloud / OCIS, maar dan wordt het heel snel, heel complex. Met name als je geen of weinig ervaring in de desbetreffende repo hebt.

Bij de labels moet ik (helaas) de Jinja expressie gebruiken omdat Docker Compose ${COMPOSE_PROJECT_NAME} deze al literal neemt in de label naam . Volgens mij is dat niet zo bij de andere syntax, maar ik ga dat niet helemaal omgooien om zoiets doms.

Overigens is dit ook weer allemaal een kwestie van smaak en is het geheel uiteraard fluïde.

[Mars Warrior]

blackd schreef op zondag 7 december 2025 @ 20:29:
[...]
Voorbeeldje docker-compose.yml in jellyfin role (snippet):

YAML:

services:
  jellyfin:
    image: jellyfin/jellyfin:10.11.4@sha256:aab0b50a3ce43a41621fc7040a379cc57174059aec8f9c17a90176649a0c1ab1
    container_name: jellyfin
    volumes:
      - ${HOST_VOLUME_CONFIG}:/config
      - ${HOST_VOLUME_CACHE}:/cache
      - ${HOST_VOLUME_MEDIA}:/media

.env.j2

YAML:

HOST_VOLUME_CONFIG="{{ jellyfin__compose_volume_config }}"
HOST_VOLUME_CACHE="{{ jellyfin__compose_volume_cache }}"
HOST_VOLUME_MEDIA="{{ jellyfin__compose_volume_media }}"

W44r0m z0 dµßß13 0p?? W44r0m n13t m33t33n 1n d3 3nv f1l3 d3 ju1$t3 k3¥ v4|u3z?? Nu m00t j3 t0¢h 3 d1ng3n b1jh0µd3n!! D4t 0nt9a4t m1j 3v3n…

0ƒ h33ƒt d4t t3 m4k3n m3t d3 V4µ|t??

[blackd]

@alex3305 ja dat soort uitgebreidere jinja templating gebruik ik niet. Eigenlijk moet ik zeggen dat ik de template module gebruik, maar ik template niks, want ik kan net zo goed een copy doen. Anders snapt dclint het niet.

@Mars Warrior
In de .env file staan bij mij verschillende soorten waardes, bijv:
- secrets. Die staan zoals gezegd in een apart bestand bij mij.
- host afhankelijke waardes, die worden gevoed door group vars of host vars.

In dit voorbeeld staan absolute paden en die kunnen dus per host in theorie verschillend zijn. Dat wil je niet in je role vastleggen, die dient generiek te zijn.

Daarnaast kan ik de paden als het een variabele in ansible is, hergebruiken. Bijv voor aanmaken dataset, controleren permissies, dat soort zaken.

Ik ben overigens nog wel zoekende naar de juiste structuur qua variabelen. Ik heb laatst variabelen in playbooks gemigreerd naar group_vars. Maar e.e.a kan vast nog beter georganiseerd.

[alex3305]

blackd schreef op zondag 7 december 2025 @ 22:12:
@alex3305 ja dat soort uitgebreidere jinja templating gebruik ik niet. Eigenlijk moet ik zeggen dat ik de template module gebruik, maar ik template niks, want ik kan net zo goed een copy doen. Anders snapt dclint het niet.

Zo'n vermoeden had ik al . Daar is natuurlijk niets mis mee hè.

Ik gebruik de Jinja templates dus in Compose ook als feature toggles. Dat kan soms verdomde handig zijn. Alhoewel de andere kant van de medaille verbositeit is. Met andere woorden, meer code om hetzelfde of soms minder te bereiken . Komt er ook nog bij dat ik vanuit mijn werk enorm veel met Jinja heb gewerkt en er dus best aardig in ben, al zeg ik het zelf . En ik gebruik het veel in Home Assistant. Ik schrik er dus niet zo snel van.

Ik gebruik daarnaast in elke Compose _docker_options zodat ik CPUs en memory kan limiteren waar nodig. Dit doe ik o.a. voor stroombesparing.

Ik ben overigens nog wel zoekende naar de juiste structuur qua variabelen. Ik heb laatst variabelen in playbooks gemigreerd naar group_vars. Maar e.e.a kan vast nog beter georganiseerd.

Ik probeer variabelen zoveel mogelijk toe te passen waar ze horen. Serial numbers en keys horen IMHO niet bij een host, maar bij een groep. En dan eigenlijk zelfs de groep all. Immers veranderd de groepenstructuur in de inventory niets aan de toepasbaarheid van een dergelijke key. Mijn Maxmind GeoIP API sleutel gebruik ik dan zo:

YAML:

# group_vars/all/vault.yml
vault_maxmind_api_key: "secret string here..."

# group_vars/all/all.yml
maxmind_api_key: "{{ vault_maxmind_api_key }}"

# host_vars/leetower/maxmind_geoip.yml OF group_vars/docker/maxmind_geoip.yml
maxmind_geoip_api_key: "{{ maxmind_api_key }}"

De maxmind_geoip role op host leetower (of groep docker als je het op meerdere hosts gebruikt) vereist de API key geprefixed met de role_name. Maar die key hoort wat mij betreft niet bij de specifieke host of groep thuis, maar is algemeen voor mijn play(s).

Ook hier is het aardig verbose, maar zorgt het wat mij betreft wel voor de nodige duidelijkheid. En dat is met Ansible geen overbodige luxe .

[blackd]

alex3305 schreef op zondag 7 december 2025 @ 20:49:
Yes. Maar dat heb ik dus . Want lokaal gebruik ik pyenv met een virtualenv die met pip de requirements.txt installeert met daarin o.a. Ansible Core en Ansible Lint. En de CI omgeving doet setup-python hetzelfde. Allebei maken ze gebruik van dezelfde python versie dmv het .python-version bestand. Renovate update hier (wederom) de dependencies.

Ik wil de venv opzet toch nog wel een kans geven, ik had dat voorheen ook wel maar ik denk dat ik een paar stappen gemist heb om alle dependencies te fixeren en alle installaties te automatiseren. Bij de devcontainer loop ik ook wel tegen wat issues aan (vanwege het OS [Fedora] is feature/docker-outside-docker niet mogelijk en geknoei met permissies door verschillende gebruikers in de container vs op het host OS).
Misschien wil ik wel een hybride setup met lokaal een venv en op CI een docker container (met venv?).

Wat ik begrijp heb je dus Ansible-Core en Ansible-Lint in je requirements.txt staan en specificeer je de Python versie in .python-version.

Hoe zit dat dan met de Python versie? Van wat ik lees zul je de globale python versie (op je dev machine) dan in sync moeten houden met je CI build. Hoe pak je dat aan?

Edit:
Daarnaast heb ik ook nog andere dependencies die ik geinstalleerd moet hebben:
- GitHub CLI (via package manager)
- ACT (via GH CLI extension)
- Task (taskfile.dev) (via package manager)
- NPM
- DCLint (als NPM package)
- Renovate (als NPM package)

Voorheen heb ik een development playbook gemaakt waarin dit soort zaken geautomatiseerd geinstalleerd werden. Nu zit dat in mijn Execution Environment Docker image.

alex3305 schreef op maandag 8 december 2025 @ 11:54:
Ik probeer variabelen zoveel mogelijk toe te passen waar ze horen. Serial numbers en keys horen IMHO niet bij een host, maar bij een groep. En dan eigenlijk zelfs de groep all. Immers veranderd de groepenstructuur in de inventory niets aan de toepasbaarheid van een dergelijke key. Mijn Maxmind GeoIP API sleutel gebruik ik dan zo:

Ik heb API keys e.d. inderdaad in group_vars/all/main.yml en secrets in group_vars/all/secrets.yml en de encrypted versie in group_vars/all/vault.yml.

Daarnaast zoveel als mogelijk alle variabelen die nodig zijn voor de roles in group_vars/<groep>/<role>.yml.
De enige host_vars zijn ansible_host, ansible_user, ansible_password, ansible_connection en vergelijkbaar.

Qua inventory heb ik het ook geordend naar stage:

code:

inventories/
├── development
├── production
│   ├── group_vars
│   │   ├── all
│   │   └── <group>
│   └── host_vars
└── staging
    ├── group_vars
    │   ├── all
    │   └── <group>
    └── host_vars

Staging is voor mij een gevirtualiseerde evenknie van mijn productieomgeving.
Daar heb ik in VirtualBox een TrueNAS installatie draaien met dezelfde configuratie qua pools waarmee ik eenvoudig de Jail, Docker installatie en Docker Containers kan testen bij upgrades van TrueNAS.
Het liefst zou ik de group_vars op 1 plek hebben maar dat is me nog niet gelukt.

Maar stiekem heb ik nog wel wat variabelen in de roles/<role>/vars/main.yml zitten die ik een keer moet migreren naar de groep.
Zo heb ik sinds kort een docker groep gemaakt want ik had de Docker versies nog niet gefixeerd. Met de Traefik API compatibility issue liep ik daar snel tegenaan. Ik gebruik overigens de geerlingguy.docker role via Galaxy.

[ Voor 6% gewijzigd door blackd op 09-12-2025 10:47 ]

[alex3305]

blackd schreef op dinsdag 9 december 2025 @ 10:07:
[...]

Ik wil de venv opzet toch nog wel een kans geven, ik had dat voorheen ook wel maar ik denk dat ik een paar stappen gemist heb om alle dependencies te fixeren en alle installaties te automatiseren. Bij de devcontainer loop ik ook wel tegen wat issues aan (vanwege het OS [Fedora] is feature/docker-outside-docker niet mogelijk en geknoei met permissies door verschillende gebruikers in de container vs op het host OS).
Misschien wil ik wel een hybride setup met lokaal een venv en op CI een docker container (met venv?).

Wat ik begrijp heb je dus Ansible-Core en Ansible-Lint in je requirements.txt staan en specificeer je de Python versie in .python-version.

Yes .

requirements.txt

code:

ansible-core==2.20.0
ansible-dev-tools==25.12.0
ansible-lint==25.12.0
pre-commit==4.5.0
yamllint==1.37.1

.python-version

code:

3.14.2

En dit wordt wederom netjes bijgehouden met Renovate:

renovate.json

JSON:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "packageRules": [
    {
      "description": "Limit requirements to once a week",
      "matchFileNames": [
        "requirements.txt",
        "requirements.yml"
      ],
      "schedule": ["* * * * 3"]
    },
    {
      "description": "Update Python version",
      "matchFileNames": [".python-version"],
      "minimumReleaseAge": "30 days",
      "internalChecksFilter": "strict",
      "matchDatasources": ["python-version"]
    }
  ]
}

Waarbij ik dus afwachtend ben met het updaten van Python.

Hoe zit dat dan met de Python versie? Van wat ik lees zul je de globale python versie (op je dev machine) dan in sync moeten houden met je CI build. Hoe pak je dat aan?

Dat regel ik dus met pyenv. Die staat in mijn home directory en houdt net zoals bijvoorbeeld nvm voor Node een aparte Python environment bij. Installatie en configuratie is dood eenvouudig:

# Requirements installeren voor Debian
sudo apt update
sudo apt install build-essential gdb lcov \
                 pkg-config libbz2-dev libffi-dev libgdbm-dev \
                 libgdbm-compat-dev liblzma-dev libncurses5-dev \
                 libreadline6-dev libsqlite3-dev libssl-dev lzma lzma-dev \
                 tk-dev uuid-dev zlib1g-dev libmpdec-dev libzstd-dev

# pyenv automatic installer
curl -fsSL https://pyenv.run | bash

Waarna ik in mijn .zshrc pyenv configureer voor mijn shell:

Bash:

#!/bin/zsh
# shellcheck shell=zsh
#
# 3) .zshrc - Zsh file loaded for interactive shell sessions
#

ZDOTDIR="${ZDOTDIR:-$HOME}"

# Set the list of directories that zsh searches for commands.
path=(
  $HOME/{,s}bin(N)
  $HOME/.local/{,s}bin(N)
  $HOME/.pyenv/bin(N)
  $HOME/.dotnet/tools(N)
  /usr/local/{,s}bin(N)
  $path
)

# Pyenv
export PYENV_ROOT="$HOME/.pyenv"
eval "$(pyenv init --path)"

Mijn zsh configuratie heb ik in mijn dotfiles repo staan en de installatie van pyenv staat, zoals ik eerder al zei, in mijn infra repo. Ik heb daar een setup scriptje staan die alle benodigde dependencies automatisch kan installeren:


Op de CI omgeving zorgt de GitHub setup-python action voor de setup van de juiste Python versie op basis van het .python-version bestand:

quote: GitHub Setup Python Action

Basic usage
[...]
The python-version input is optional. If not supplied, the action will try to resolve the version from the default .python-version file. [...]

Python wordt hier in de hosted tool cache geïnstalleerd (en dus gecached), evenals de dependencies. Theoretisch is dat een security risico, maar dat neem ik voor lief.

Daarnaast heb ik ook nog andere dependencies die ik geinstalleerd moet hebben:
- GitHub CLI (via package manager)
- ACT (via GH CLI extension)
- Task (taskfile.dev) (via package manager)
- NPM
- DCLint (als NPM package)
- Renovate (als NPM package)

Ik beargumenteer niet dat alle packages verplicht in een venv moeten hè . Je mag best afhankelijk zijn van het OS of een externe package manager. Ik vind alleen de aanpak van een Docker container hier onnodig en onhandig. Evenals de afhankelijkheid van een devcontainer, aangezien dat weer redelijk afhankelijk is van VSCode. Ik vind een vendor lock-in van een editor namelijk nogal beroerd .

In mijn zsh omgeving heb ik sowieso nvm - en dus npm - geconfigureerd staan. De installatie van deze afhankelijkheden zou ik dus simpelweg meenemen in mijn setup script.

Voorheen heb ik een development playbook gemaakt waarin dit soort zaken geautomatiseerd geinstalleerd werden. Nu zit dat in mijn Execution Environment Docker image.

Staging is voor mij een gevirtualiseerde evenknie van mijn productieomgeving.
Daar heb ik in VirtualBox een TrueNAS installatie draaien met dezelfde configuratie qua pools waarmee ik eenvoudig de Jail, Docker installatie en Docker Containers kan testen bij upgrades van TrueNAS.
Het liefst zou ik de group_vars op 1 plek hebben maar dat is me nog niet gelukt.

Ja dat is leuk . Voor thuis heb ik alles fail-fast met één omgeving. Waarbij ik moet toegeven dat er over het algemeen bijzonder weinig kapot vliegt of langdurig kapot gaat. Door Renovate heb ik het vertrouwen om het op deze manier te doen. Rollbacks zijn namelijk triviaal geworden.

Ik gebruik overigens de geerlingguy.docker role via Galaxy.

Die kende ik niet. Mja, Jeff Geerling wel, maar niet zijn role. Wel grappig om te zien dat mijn role nagenoeg gelijk is aan zijn role .

[alex3305]

Even iets anders dan al het Ansible geweld . De laatste tijd krijg ik regelmatige vage foutmeldingen in mijn Forgejo Runner dind omgeving. Gisteren ben ik op speurtocht geweest en ben erachter gekomen dat het komt door cross compilen. Blijkbaar wordt de binfmt_misc kernel module niet meegenomen bij rootless dind . Ondanks een --privileged flag. Gek genoeg werkt het wel als ik een verse Alpine container maak met daarin bijv. Docker of podman.

Aan de hand daarvan was ik nog bezig gegaan met Docker Bake. Ik wil namelijk kijken of ik verschillende varianten van mijn container kan maken. In eerste instantie om mee te testen, maar daarna wellicht ook om uit te brengen.

Het ziet er allemaal leuk uit, maar eigenlijk vind ik het ook wel weer gedoe. Er wordt hcl gebruikt voor configuratie. Helemaal prima, behalve dan dat ik dat weer helemaal nergens anders gebruik .

Wel grappig want ik had op mijn persoonlijke issue lijst momenteel nog drie punten staan:

1. Docker bake uitproberen
2. Podman ipv dind uitproberen
3. ARM (qemu) builds fixen

En dat komt nu toevallig allemaal bij elkaar . Immers kan ik met een test met podman waarschijnlijk qemu oplossen of een workaround maken. En kan ik met Docker bake eenvoudig twee varianten bouwen zodat de oude versie niet breekt .

[blackd]

alex3305 schreef op dinsdag 9 december 2025 @ 12:10:
Dat regel ik dus met pyenv. Die staat in mijn home directory en houdt net zoals bijvoorbeeld nvm voor Node een aparte Python environment bij. Installatie en configuratie is dood eenvouudig:

Nice, pyenv had ik even gemist. Ik had in het verleden alleen een venv gemaakt met de standaard module in Python. Ik ga dit verder onderzoeken, bedankt!

Ik beargumenteer niet dat alle packages verplicht in een venv moeten hè . Je mag best afhankelijk zijn van het OS of een externe package manager.

Mijn doel is ook niet om het allemaal in een venv te proppen maar ik wil voor (mijzelf, haha) een eenvoudig en reproduceerbaar proces hebben om alles wat nodig is te installeren. Mag best global / system wide zijn, zolang ik maar dezelfde versies heb op mijn development laptop als op de CI omgeving.

Zoals ik zei heb ik Woodpecker gebruikt als CI tool, daarvoor wilde ik alles via Semaphore UI laten lopen. Dat was een drama wat betreft dependencies op de ansible control node, daar heb ik best e.e.a. voor moeten 'hacken'. Uiteindelijk draait je Ansible Playbook daar in een aparte container, waardoor je met een playbook getarget op 'local' ook de nodige dependencies kunt installeren. Alleen dat duurde op mijn machine allemaal best wel lang.

Hier komt ook mijn aversie tegen Bitwarden secrets terug, de installatie was een drama vanwege een bug die nog steeds open staat. En de oplossing? Een license file publiceren bij je volgende release. Door het ontbreken daarvan moest ik de SDK vanuit source installeren, waar weer de nodige dev dependencies voor nodig waren.

Ik vind alleen de aanpak van een Docker container hier onnodig en onhandig. Evenals de afhankelijkheid van een devcontainer, aangezien dat weer redelijk afhankelijk is van VSCode. Ik vind een vendor lock-in van een editor namelijk nogal beroerd .

Ik ben ook geen fan van vendor lock-in.
De container die ik heb ontwikkeld is wat dat betreft multi-purpose. Je kan hem als devcontainer gebruiken, je kan hem als container in GitHub Actions gebruiken en het is een execution environment voor Ansible Navigator. Voor dat laatste heb je nog steeds wel Python, Ansible-Navigator en Docker nodig.

Ja dat is leuk . Voor thuis heb ik alles fail-fast met één omgeving. Waarbij ik moet toegeven dat er over het algemeen bijzonder weinig kapot vliegt of langdurig kapot gaat. Door Renovate heb ik het vertrouwen om het op deze manier te doen. Rollbacks zijn namelijk triviaal geworden.

Ik ga ook niet elke wijziging via staging laten lopen, maar zoiets fundamenteels als het onderliggende OS updaten vind ik wel dusdanig dat ik dit eerst wat uitgebreider ga testen.
Door gebruik van Renovate is mijn update proces ook veel betrouwbaarder geworden. Ik auto merge alleen patch en digest updates, minor en hoger review ik altijd de release notes (door schade en schande wijs geworden). Met name de apps met databases is wat ingewikkelder updaten.

Ik kom van TrueNAS Scale in de tijd dat TrueCharts nog een ding was. Dit werd vrij rap niet meer ondersteund. Toen kwam jailmaker waarin ik docker kon draaien. Daarna ging TrueNAS scale ook naar docker bewegen voor ingebouwde apps (met hun eigen app-store). Ik kies er bewust voor dat niet meer te gebruiken maar alles in een aparte omgeving via Ansible te onderhouden om zo flexibel te blijven. Vooralsnog is 'Instances' in TrueNAS Scale experimenteel en werkt Jailmaker ook nog gewoon. Dus er zijn twee manieren om een omgeving te creëren op mijn TrueNAS machine waarin ik Docker + all mijn Compose projects kan uitrollen.

Die kende ik niet. Mja, Jeff Geerling wel, maar niet zijn role. Wel grappig om te zien dat mijn role nagenoeg gelijk is aan zijn role .

Hij heeft best handige roles en zijn content over Ansible vond ik erg leerzaam. Misschien nog een tip voor @Mars Warrior.

[alex3305]

blackd schreef op dinsdag 9 december 2025 @ 12:49:
Nice, pyenv had ik even gemist. Ik had in het verleden alleen een venv gemaakt met de standaard module in Python. Ik ga dit verder onderzoeken, bedankt!

Met standaard Python en venv is het inderdaad een groot drama. uv is the new kid on the block en daarmee dus ook fancy. Met mijn progressieve aanpak wilde ik die eigenlijk gebruiken. Vooral omdat ik dan een pyproject.toml of uv.toml kon toepassen. Dan zou ik ook geen extra requirements.txt meer hebben. Echter kreeg ik dat een paar maanden geleden niet lekker werkend met Ansible. Pyenv voldoet dan gewoon.

Mijn doel is ook niet om het allemaal in een venv te proppen maar ik wil voor (mijzelf, haha) een eenvoudig en reproduceerbaar proces hebben om alles wat nodig is te installeren. Mag best global / system wide zijn, zolang ik maar dezelfde versies heb op mijn development laptop als op de CI omgeving.

100%. Professioneel weet ik dat dat super waardevol is. Vandaar dat ik dat privé ook toepas. Het kost dan vooraf wellicht wat meer tijd om in te richten en op te zetten, dat verdien je op een later moment weer terug.

Ik kom van TrueNAS Scale in de tijd dat TrueCharts nog een ding was. Dit werd vrij rap niet meer ondersteund. Toen kwam jailmaker waarin ik docker kon draaien. Daarna ging TrueNAS scale ook naar docker bewegen voor ingebouwde apps (met hun eigen app-store). Ik kies er bewust voor dat niet meer te gebruiken maar alles in een aparte omgeving via Ansible te onderhouden om zo flexibel te blijven. Vooralsnog is 'Instances' in TrueNAS Scale experimenteel en werkt Jailmaker ook nog gewoon. Dus er zijn twee manieren om een omgeving te creëren op mijn TrueNAS machine waarin ik Docker + all mijn Compose projects kan uitrollen.

Ik heb dus destijds de Unraid afslag genomen. Met name omdat ik al enorm veel ervaring had met Docker, Docker Compose en Kubernetes. Daarom heeft TrueCharts mij dus nooit aangesproken en vond ik dat eigenlijk eerder een nadeel dan een voordeel . Dat is ook de reden dat ik Portainer niet (meer) gebruik. Portainer gebruikt namelijk ander jargon dan Docker en Compose. Dat stoort mij dan gigantisch.

[blackd]

alex3305 schreef op dinsdag 9 december 2025 @ 12:10:
.python-version

code:

3.14.2

[..]

Ik heb daar een setup scriptje staan die alle benodigde dependencies automatisch kan installeren:
[Afbeelding]

Op de CI omgeving zorgt de GitHub setup-python action voor de setup van de juiste Python versie op basis van het .python-version bestand:

Ik heb nu even als test .python-version toegevoegd in mijn repo en Renovate triggert daar op.
Ik gebruik het alleen nog niet in CI/lokaal om de Python versie gelijk te houden.

Hoe 'enforce' je dat je development machine ook dezelfde python versie gebruikt in jouw pyenv t.o.v. wat in de repo gedefinieerd staat? Want als Renovate triggert op een nieuwe Python versie zul je jouw pyenv virtualenv opnieuw moeten opbouwen neem ik aan?

[alex3305]

blackd schreef op woensdag 10 december 2025 @ 09:48:
Hoe 'enforce' je dat je development machine ook dezelfde python versie gebruikt in jouw pyenv t.o.v. wat in de repo gedefinieerd staat? Want als Renovate triggert op een nieuwe Python versie zul je jouw pyenv virtualenv opnieuw moeten opbouwen neem ik aan?

Dat klopt. Ik forceer het inderdaad niet, daar heb je helemaal gelijk in. Ik draai mijn setup script met enige regelmaat.

Je zou natuurlijk met Ansible pre_tasks kunnen controleren of de huidige Python versie gelijk is aan die in .python-version. Idem voor Ansible of andere pakketten.

Als alternatief zou je in zsh (waarschijnlijk ook in andere shells) een shell hook kunnen opzetten zodat bijv. pyenv geüpdatet wordt wanneer je in die directory komt. Dat doe ik al met oh-my-zsh en pyenv:

.oh-my-zsh/custom/python-venv.zsh

Bash:

#!/bin/zsh
# shellcheck shell=zsh
#
# python-venv.zsh - Automatically venv when possible!
# Source: https://dev.to/moniquelive/auto-activate-and-deactivate-python-venv-using-zsh-4dlm
#

python_venv() {
  MYVENV=./.venv

  # when you cd into a folder that contains $MYVENV
  [[ -d $MYVENV ]] && source $MYVENV/bin/activate > /dev/null 2>&1
  # when you cd into a folder that doesn't
  [[ ! -d $MYVENV ]] && deactivate > /dev/null 2>&1
}

autoload -U add-zsh-hook
add-zsh-hook chpwd python_venv

python_venv

En je zou dit ook in de editor (VSCode) kunnen regelen. Ik doe dat bijvoorbeeld voor mijn Home Assistant Configuration repository. Daar maak ik een aantal (mock) bestanden aan zodat de configuratie check in ieder geval werkt.

.vscode/tasks.json

JSON:

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "setup",
            "type": "shell",
            "command": "./setup.sh",
            "runOptions": {
              "runOn": "folderOpen"
            },
            "presentation": {
              "echo": false,
              "reveal": "silent",
              "focus": false,
              "panel": "shared",
              "close": true,
            }
        }
    ]
}

Het is dus een klein beetje behelpen op sommige vlakken. Mijn oplossing is ook verre van perfect. Aan de andere kant zijn veranderingen veelal incrementeel. Immers accepteer ik expliciet bepaalde minor's. Dan is het dus ook niet bijster erg als ik een keer een versie achterloop, mits ik niet tegen problemen aanloop.

[blackd]

alex3305 schreef op zondag 7 december 2025 @ 20:49:
.pre-commit-config.yaml

Ook maar even opgezet:

YAML:

# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v6.0.0
    hooks:
      - id: check-shebang-scripts-are-executable
      - id: detect-private-key
      - id: end-of-file-fixer
      - id: trailing-whitespace

  - repo: https://github.com/renovatebot/pre-commit-hooks
    rev: 42.52.4
    hooks:
      - id: renovate-config-validator

  - repo: https://github.com/docker-compose-linter/pre-commit-dclint
    rev: v3.1.0
    hooks:
      - id: dclint

  - repo: https://github.com/ansible/ansible-lint
    rev: v25.12.0
    hooks:
      - id: ansible-lint
        pass_filenames: true

  - repo: https://github.com/mpalmer/action-validator
    rev: v0.8.0
    hooks:
      - id: action-validator

Het meeste draait vrij snel (alleen changes). Over ansible-lint ben ik alleen nog niet heel tevreden..

Om vervolgens te gebruiken moet ik dat installeren, daarom in devcontainer.json:

YAML:

{
  [...]
  "postStartCommand": "pre-commit install"
}

NB: Mocht je een foutmelding krijgen over ontbrekende locale bij gebruik pre-commit, installeer dan glibc-langpack-en.

alex3305 schreef op woensdag 10 december 2025 @ 19:39:
Dat klopt. Ik forceer het inderdaad niet, daar heb je helemaal gelijk in. Ik draai mijn setup script met enige regelmaat.

Je zou natuurlijk met Ansible pre_tasks kunnen controleren of de huidige Python versie gelijk is aan die in .python-version. Idem voor Ansible of andere pakketten.

Heb ik ook aan zitten denken maar druist in tegen de manier waarop het bij mij nu werkt, ik laat de python en ansible versie in de docker container leidend zijn en verifieer of mijn playbook daarop runt.
Deze versies zijn embedded in de community-ansible-dev-tools docker image.

Ik heb geprobeerd om de dependencies geautomatiseerd te installeren maar kom dan vrij snel op het punt dat ik in mijn GitHub Self Hosted runner de workflow in een container wil runnen. Laat dat nou net mijn ansible-ee image kunnen zijn . Enige nadeel is zoals gezegd dat dit o.b.v. fedora is en niet debian/ubuntu.

Wat dat betreft kan een devcontainer wel snel een update van deze dependencies forceren. Zodra renovate een update ziet van een van de dependencies, wordt de PR gevalideerd en indien mogelijk automatisch gemerged. De nightly release produceert een nieuwe docker image. Deze wordt vervolgens in mijn playbook repo door Renovate getriggerd. Wanneer dit gemerged wordt naar main, wordt het ook doorgezet naar develop. Dan krijg ik gelijk van VSCode een melding of ik de container wil rebuilden.

Wat snippets van mijn ansible-ee repo:
execution-environment.yml

YAML:

--
version: 3

images:
  base_image:
    name: ghcr.io/ansible/community-ansible-dev-tools:v25.11.0@sha256:c3ee333e84517404d0940e9fd97b247b18cf60e957cbd1bb45e79ca84848beaa

dependencies:
  galaxy: requirements.yml
  python: requirements.txt

additional_build_steps:
  [..]

In de additional_build_steps installeer ik:

• glibc-langpack-en (via dnf)
• docker-ce-cli (via install script)
• nodejs npm (via dnf)
• gh-cli (via dnf)
• dclint (via npm)
• action-validator (via npm)

Sommige zaken zijn geversioneerd, nog niet alles.
Renovate pakt alleen de updates van base_image nog niet op dus ik moet nog even met de renovate config gaan stoeien.

Dit bouw ik dan met een GitHub Action. Daarin roep ik Ansible Builder aan. Ik gebruik daarbij wel docker/setup-buildx-action, docker/metadata-action en docker/build-push-action aangezien Ansible Builder onderwater gewoon docker build aanroept.

YAML:

[..]
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3
      id: docker_buildx
      with:
        platforms: linux/amd64,linux/arm64
[..]
    - name: Build Execution Environment image
      working-directory: .
      run: | 
        ansible-builder build \
          --container-runtime docker \
          --extra-build-cli-args "--load --builder ${{ steps.docker_buildx.outputs.name }} --platform linux/amd64"
[..]

De docker buildx builder wordt gebruikt bij het aanroepen van ansible-builder.
De output van deze stap wordt gecached in context/en wordt daarna opgepakt door o.a. docker/buld-push-action.

YAML:

    - name: Build and push
      uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6
      with:
        context: context/
        push: ${{ github.ref_type == 'tag' }}
        tags: ${{ steps.docker_meta.outputs.tags }}
        labels: ${{ steps.docker_meta.outputs.labels }}

Deze workflow draait bij elke pull request (zonder release) en bij elke tag (met release).

[blackd]

Sorry, nu weer wat meer Ansible en Python geweld.

alex3305 schreef op dinsdag 9 december 2025 @ 14:33:
Met standaard Python en venv is het inderdaad een groot drama. uv is the new kid on the block en daarmee dus ook fancy. Met mijn progressieve aanpak wilde ik die eigenlijk gebruiken. Vooral omdat ik dan een pyproject.toml of uv.toml kon toepassen. Dan zou ik ook geen extra requirements.txt meer hebben. Echter kreeg ik dat een paar maanden geleden niet lekker werkend met Ansible. Pyenv voldoet dan gewoon.

Ik las vandaag dat ansible-dev-environment onderwater uv gebruikt.
Het belooft met het commando ade Python, ansible en collections isolatie met venv support.
Wellicht is dat voor jou (nogmaals?) het onderzoeken waard?

alex3305 schreef op woensdag 10 december 2025 @ 19:39:
Je zou natuurlijk met Ansible pre_tasks kunnen controleren of de huidige Python versie gelijk is aan die in .python-version. Idem voor Ansible of andere pakketten.

Ik kwam vandaag een interessante pre-commit-hook tegen in bovengenoemde repo.
https://github.com/ansibl...in/.pre-commit-hooks.yaml

YAML:

---
- id: check-platform-constraints
  name: Check platform constraints and update renovate.json
  entry: check-platform-constraints
  language: python
  additional_dependencies: ["packaging>=23.2", "pyyaml"]
  files: ^pyproject\.toml$
  pass_filenames: false
  description: Validates dependencies against platform constraints and updates renovate.json

Het bijbehorende script: https://github.com/ansibl...k_platform_constraints.py

Python:

#!/usr/bin/env python3
"""Validate and enforce platform constraints.

This script:
1. Defines platform constraints as constants
2. Validates dependencies in pyproject.toml against these constraints
3. Updates renovate.json with allowedVersions rules to prevent automated bumps
"""

En de config met constraints:
https://github.com/ansibl.../platform-constraints.txt

code:

# Platform compatibility constraints for AAP and RHEL
# These represent the MAXIMUM versions we can use to remain compatible
# with downstream platform packages

# AAP 2.5/2.6 ships ansible-core 2.16.x
ansible-core<2.17

# RHEL 8/9 ships cffi 1.15.x
cffi<1.16

# RHEL 8/9 ships setuptools 65.5.1
setuptools<65.6

# galaxy-importer constraint
packaging<25.0

Een dergelijke aanpak is wellicht ook interessant.

[alex3305]

@blackd Zeker. Thanks voor je aanvullingen . Ik had je post eerder vandaag ook gelezen en met jouw aanpak is zeker niets mis. Alleen is het niet helemaal mijn smaak. Ik ben gewoon een beetje allergisch voor devcontainers (leuk om te noemen in het Docker topic ). Niet omdat het niet werkt of omdat het slecht is, maar vanwege het gedoe met containers op Windows al dan niet in combinatie met WSL(2). Ik wil mezelf die complexiteit liever niet meer op de hals halen. Althans niet nu.

blackd schreef op zondag 14 december 2025 @ 19:37:
Ik las vandaag dat ansible-dev-environment onderwater uv gebruikt.
Het belooft met het commando ade Python, ansible en collections isolatie met venv support.
Wellicht is dat voor jou (nogmaals?) het onderzoeken waard?

Misschien wel, maar voor nu werkt pyenv prima. Ik kan het issue zo 1-2-3 niet vinden...



Maar het ging er om dat tools niet zomaar geïnstalleerd konden worden vanuit een pyproject.toml. Wellicht is dat nu (een paar maanden later) wel het geval. Aangezien ik nu een degelijke setup heb laat ik het even zo .

Die pre-commit hook is nog wel een interessante. Dat zou je ook al quick and dirty kunnen doen

Bash:

$(python --version | awk '{print $2}') = $(cat .python-version) ] && echo "true" || echo "false"
# of 
$(python --version | awk '{print $2}') = $(cat .python-version) ] && exit 0 || exit 1

[Mars Warrior]

Mijn hoofd zit nog beetje vol van de afgelopen Forgejo/Ansible posts. Ik ga het voorlopig toch wat simpeler aanpakken. En pas daarna uitbouwen volgend jaar.

Daarom nog een wat info van CrowdSec, Alerts per dag en domein.
Des te roder, des te meer Alerts op dat domein op die dag. Groen is beter, en zwart is het beste, namelijk niks geen alerts!

Na de "massale" aanvallen van begin december (400-500 Alerts per dag) stapsgewijs wat maatregelen genomen:

• Handmatige block van het verre oosten (Japan, Singapore, Zuid-Korea, India, Australie, etc.) voor de MICROSOFT ASN en AMAZON-02 ASN. Het gros van de Alerts kwam uit deze ASNs namelijk
• Scripten - elke dag via cron - van de actuele Abuse Ip database richting CrowdSec. Deze lijst is actueel.

Het resultaat mag er zijn zou ik zeggen. Bijna niks meer op de domeinen (de regels onder <ip>).
Het aantal decisions/bans per dag is nu op een paar vingers te tellen



Dat wordt natuurlijk veroorzaakt doordat de firewall het overgrote deel van het verkeer blokkeert. En dan met name de cscli-import blocklist met ca 70.000 extra decisions bovenop de CAPI lijst van 15.000.

• De firewall laat een aardige toename richting 4.000 - 5.000 drops per dag zien
• Het cscli-import deel is sommige dagen voor 90-95% verantwoordelijk voor het aantal drops. Die actuele lijsten werken dus perfect!
• De CAPI lijst doet steeds minder. Het was ooit ca 30%, en laatste tijd rond de 5%. Vanaf laatste week november ben ik al zelf lijsten gaan toevoegen als test. Die overlappen blijkbaar enorm met de CAPI lijst.

Oftewel: ook met publiek verkrijgbare lijsten kun je een goede verdediging opbouwen.
Je hebt echt geen abbo van CrowdSec nodig. Het is natuurlijk wel extra werk, maar als het eenmaal draait, draait het. En ik update nu 1x per dag, terwijl die lijsten vaak 1x per uur of 30 minuten geactualiseerd worden. Het kan dus nog beter.

[DjoeC]

Ik ben met allerlei aanpassingsklusjes bezig zoals het optuigen van een nieuwe Docker omgeving. Tot heden gebruik ik voor de netwerking een user_bridge omdat die communicatie tussen containers mogelijk maakt. Ik kan die containers natuurlijk ook via <host>:<gemapte poort> bereiken, maar ik zou graag willen dat ik een flink aantal containers - zoals Mariadb - zowel vanuit de rest van het netwerk als onderling in Docker via een hostnaam mariradb1.mijn.lan kan bereiken.

Ik meen dat dit ook met userbridge ooit gewerkt heeft door in mijn lokale dns die hostnaam op te nemen met het IP adres van de Docker machine maar dat lijkt niet altijd te werken.... Pihole heb ik al heel lang draaien op een macvlan met eigen IP adres.

De vraag: Is het gebruik van macvlan een "slechte" gewoonte, zo ja waarom, zo nee waarom niet? Voor mij lijkt het voordeel dat de container met macvlan op elke willekeurige machine in de lucht kan komen terwijl dat met user_bridge niet zo is.... Zijn er simpele, werkbare alternatieven?

[Mars Warrior]

@DjoeC. Is Traefik een optie om als L4 proxy te laten fungeren?

Dat deed ik voorheen met de Caddy L4 plug-in met de nodige beperkingen. Nu met Traefik
Nog niet gebruikt.

Je hebt dan altijd een centraal toegangspunt en ook een URL.

[DjoeC]

Mars Warrior schreef op zondag 4 januari 2026 @ 17:06:
@DjoeC. Is Traefik een optie om als L4 proxy te laten fungeren?

Dat deed ik voorheen met de Caddy L4 plug-in met de nodige beperkingen. Nu met Traefik
Nog niet gebruikt.

Je hebt dan altijd een centraal toegangspunt en ook een URL.

Tja, ik gebruik nu NPM als reverse proxy. Die zal ook wel wat dingen kunnen (en gebruik ik ook af en toe wat truukerig) maar ik wilde dit eigenlijk in Docker zelf oplossen omdat het naar mijn idee ook een Docker uitdaging is. Een extra stap ertussen of erbij doe ik liever niet

Ik gebruik NPM o.a. om de verschillende webinterfaces van binnenuit en soms ook van buitenuit bereikbaar te maken. Maar om dat ook voor databases en MQTT etc in te zetten gaat me wel wat ver.

[ Voor 13% gewijzigd door DjoeC op 04-01-2026 17:31 ]

[Mars Warrior]

DjoeC schreef op zondag 4 januari 2026 @ 17:30:
[...]

Tja, ik gebruik nu NPM als reverse proxy. Die zal ook wel wat dingen kunnen (en gebruik ik ook af en toe wat truukerig) maar ik wilde dit eigenlijk in Docker zelf oplossen omdat het naar mijn idee ook een Docker uitdaging is. Een extra stap ertussen of erbij doe ik liever niet

Ik gebruik NPM o.a. om de verschillende webinterfaces van binnenuit en soms ook van buitenuit bereikbaar te maken. Maar om dat ook voor databases en MQTT etc in te zetten gaat me wel wat ver.

Aha. Het was maar een idee.

Voorheen gebruikte ik ook macvlan. Werkte goed. Maar ik wilde meer afscherming en eenvoud.

En de meeste databases die ik gebruik hebben een webconsole. Dus altijd via Traefik intern bereikbaar via een URL.

[DjoeC]

Mars Warrior schreef op zondag 4 januari 2026 @ 22:28:
[...]

Aha. Het was maar een idee.

Voorheen gebruikte ik ook macvlan. Werkte goed. Maar ik wilde meer afscherming en eenvoud.

En de meeste databases die ik gebruik hebben een webconsole. Dus altijd via Traefik intern bereikbaar via een URL.

Dan moet ik me echt wat meer in Traefik of Caddy gaan verdiepen. NPM vind ik heerlijk snel in te richten, lets encrypt werkt feilloos en ook de accesslijsten ben ik blij mee.. Maar misschien mis ik iets dat nog beter en toch simpel werkt.....

[CH4OS]

DjoeC schreef op zondag 4 januari 2026 @ 16:50:
Ik ben met allerlei aanpassingsklusjes bezig zoals het optuigen van een nieuwe Docker omgeving. Tot heden gebruik ik voor de netwerking een user_bridge omdat die communicatie tussen containers mogelijk maakt. Ik kan die containers natuurlijk ook via <host>:<gemapte poort> bereiken, maar ik zou graag willen dat ik een flink aantal containers - zoals Mariadb - zowel vanuit de rest van het netwerk als onderling in Docker via een hostnaam mariradb1.mijn.lan kan bereiken.

Ik meen dat dit ook met userbridge ooit gewerkt heeft door in mijn lokale dns die hostnaam op te nemen met het IP adres van de Docker machine maar dat lijkt niet altijd te werken.... Pihole heb ik al heel lang draaien op een macvlan met eigen IP adres.

De vraag: Is het gebruik van macvlan een "slechte" gewoonte, zo ja waarom, zo nee waarom niet? Voor mij lijkt het voordeel dat de container met macvlan op elke willekeurige machine in de lucht kan komen terwijl dat met user_bridge niet zo is.... Zijn er simpele, werkbare alternatieven?

Wat bedoel je met user_bridge? Je kunt, in combinatie met docker compose toch ook gewoon gemakkelijk werken met diverse interne en externe netwerken? Dan hoef je niet eens poorten te forwarden, containers op hetzelfde netwerk kunnen elkaar dan ook bereiken, zonder een port forward hoeven in te stellen, dat lijkt mij dus een veel minder complexe methode, ik gebruik het best veel. Met macvlan heb ik in elk geval nog nooit hoeven werken. Enige is af en toe network_mode: host (en dan moet je wel poorten forwarden), maar dat is het dan wel.

Ik begrijp niet helemaal waarom je direct wilt kunnen verbinden met een database in Docker, laat dat lekker aan de applicaties (waarvoor je de database nodig hebt) over...

[ Voor 3% gewijzigd door CH4OS op 05-01-2026 01:39 ]

[CH4OS]

Mars Warrior schreef op woensdag 17 december 2025 @ 14:22:
Mijn hoofd zit nog beetje vol van de afgelopen Forgejo/Ansible posts. Ik ga het voorlopig toch wat simpeler aanpakken. En pas daarna uitbouwen volgend jaar.

Daarom nog een wat info van CrowdSec, Alerts per dag en domein.
Des te roder, des te meer Alerts op dat domein op die dag. Groen is beter, en zwart is het beste, namelijk niks geen alerts!

Na de "massale" aanvallen van begin december (400-500 Alerts per dag) stapsgewijs wat maatregelen genomen:

• Handmatige block van het verre oosten (Japan, Singapore, Zuid-Korea, India, Australie, etc.) voor de MICROSOFT ASN en AMAZON-02 ASN. Het gros van de Alerts kwam uit deze ASNs namelijk
• Scripten - elke dag via cron - van de actuele Abuse Ip database richting CrowdSec. Deze lijst is actueel.

Het resultaat mag er zijn zou ik zeggen. Bijna niks meer op de domeinen (de regels onder <ip>).
Het aantal decisions/bans per dag is nu op een paar vingers te tellen

[Afbeelding]

Dat wordt natuurlijk veroorzaakt doordat de firewall het overgrote deel van het verkeer blokkeert. En dan met name de cscli-import blocklist met ca 70.000 extra decisions bovenop de CAPI lijst van 15.000.

• De firewall laat een aardige toename richting 4.000 - 5.000 drops per dag zien
• Het cscli-import deel is sommige dagen voor 90-95% verantwoordelijk voor het aantal drops. Die actuele lijsten werken dus perfect!
• De CAPI lijst doet steeds minder. Het was ooit ca 30%, en laatste tijd rond de 5%. Vanaf laatste week november ben ik al zelf lijsten gaan toevoegen als test. Die overlappen blijkbaar enorm met de CAPI lijst.

Oftewel: ook met publiek verkrijgbare lijsten kun je een goede verdediging opbouwen.
Je hebt echt geen abbo van CrowdSec nodig. Het is natuurlijk wel extra werk, maar als het eenmaal draait, draait het. En ik update nu 1x per dag, terwijl die lijsten vaak 1x per uur of 30 minuten geactualiseerd worden. Het kan dus nog beter.

[Afbeelding]

Ik ben wel benieuwd hoe je CrowdSec aan de praat hebt gekregen. Ik heb een poosje terug dit ook gebruikt, maar na verloop van tijd stopte het gewoon met werken, bleek de API key ongeldig of zo. Omdat ik het vervolgens niet 1 2 3 meer aan de praat kreeg, maar wel services had die ik wel bereikbaar wilde hebben, heb ik daarom de filtering nu anders opgelost. Maar voor de services die ik wel publiekelijk heb nog, wil ik wel CrowdSec nog tussen zetten. Ik zou CrowdSec dan als plug-in gebruiken voor Traefik, aangezien ik nog geen (dedicated) firewall (ik ben van plan een OpnSense doos neer te gaan zetten ergens dit jaar) heb.

[DjoeC]

CH4OS schreef op maandag 5 januari 2026 @ 01:33:
[...]

Wat bedoel je met user_bridge? Je kunt, in combinatie met docker compose toch ook gewoon gemakkelijk werken met diverse interne en externe netwerken? Dan hoef je niet eens poorten te forwarden, containers op hetzelfde netwerk kunnen elkaar dan ook bereiken, zonder een port forward hoeven in te stellen, dat lijkt mij dus een veel minder complexe methode, ik gebruik het best veel. Met macvlan heb ik in elk geval nog nooit hoeven werken. Enige is af en toe network_mode: host (en dan moet je wel poorten forwarden), maar dat is het dan wel.

Ik begrijp niet helemaal waarom je direct wilt kunnen verbinden met een database in Docker, laat dat lekker aan de applicaties (waarvoor je de database nodig hebt) over...

user_bridge is/was noodzakelijk omdat de "normale" docker bridge mode bij aanvang van mijn docker reis geen contacten tussen containers/services toeliet. Mogelijk is dat veranderd of heb ik nog steeds het hele docker netwerk geneuzel niet door

Netwerk mode Host ken ik (nog) niet. Zal me eens inlezen.

Database: Benaderen vanaf Windows machines, andere SBC's. Mosquitto idem en vanaf ESP bordjes, etc. Er is voor mij wel degelijk een reden om in containers draaiende applicaties vanaf extern, maar ook vanaf intern (andere containerized applicaties zoals Nextcloud, eigen domotica, weerstation, etc.) te kunnen benaderen. Ik wil gewoon 1 database (eventueel als failsafe over 2 instanties op 2 docker hosts), 1 Mosquitto gekoppeld over 2 of meer instanties (dat werkt best mooi) etc. Ofwel: ik weet eigenlijk wat ik wil maar nog niet altijd hoe het slim en eenvoudig onderhoudbaar op te zetten is. Linux, Docker en nog veel meer zijn mijn hobby en niet mijn vak. Vragen om tips en weer veel lezen en leren dus....

[Mars Warrior]

CH4OS schreef op maandag 5 januari 2026 @ 01:43:
[...]
Ik ben wel benieuwd hoe je CrowdSec aan de praat hebt gekregen. Ik heb een poosje terug dit ook gebruikt, maar na verloop van tijd stopte het gewoon met werken, bleek de API key ongeldig of zo. Omdat ik het vervolgens niet 1 2 3 meer aan de praat kreeg, maar wel services had die ik wel bereikbaar wilde hebben, heb ik daarom de filtering nu anders opgelost. Maar voor de services die ik wel publiekelijk heb nog, wil ik wel CrowdSec nog tussen zetten. Ik zou CrowdSec dan als plug-in gebruiken voor Traefik, aangezien ik nog geen (dedicated) firewall (ik ben van plan een OpnSense doos neer te gaan zetten ergens dit jaar) heb.

Er is een CrowdSec plugin/middleware voor Traefik die wordt aanbevolen. Die heb ik gewoon gebruikt. Dat werkt al probleemloos sinds vorig jaar oktober.

Ik ben daarnaast de firewall docker container (iptables) gaan gebruiken van CrowdSec en dat werkt ook probleemloos. Omdat bijna alles op één server draait heb ik ook geen behoefte aan een externe firewall. Alle bans en allowlists (voorheen whitelists) komen automagisch in de firewall terecht.

Door gebruik te maken van externe blocklists die je met een import decisions inleest (helaas geen ondersteuning voor eigen blocklists, zal wel een commerciële reden hebben) heb ik het aantal events/alerts/decisions van CrowdSec zelf drastisch kunnen verlagen: op sommige dagen met 100%



De effectiviteit van de firewall is dus uitstekend: gisteren had ik een flinke scan vanuit SECFIREWALLAS die ff ruim 3.000 drops liet zien in korte tijd voor een totaal van ca 5.000 drops. Die stond dus al op een ban lijst.



Ik ben er blij mee. Het scheelt aan de ene kant ca 0,5% CPU (en dus Wattjes), al neemt (helaas) aan de andere kant het syncen van op dit ogenblik 125.000 bans ook weer de nodige CPU cycles in beslag.

[CH4OS]

Mars Warrior schreef op maandag 5 januari 2026 @ 12:45:
Er is een CrowdSec plugin/middleware voor Traefik die wordt aanbevolen. Die heb ik gewoon gebruikt. Dat werkt al probleemloos sinds vorig jaar oktober.

Ja, volgens mij gebruikte ik deze middleware juist. Binnenkort maar weer eens proberen, al heb ik nu ook niet echt inzichtelijk wat er binnenkomt. Hoe maak je deze grafieken bijvoorbeeld?

[CH4OS]

DjoeC schreef op maandag 5 januari 2026 @ 11:44:
Database: Benaderen vanaf Windows machines, andere SBC's. Mosquitto idem en vanaf ESP bordjes, etc. Er is voor mij wel degelijk een reden om in containers draaiende applicaties vanaf extern, maar ook vanaf intern (andere containerized applicaties zoals Nextcloud, eigen domotica, weerstation, etc.) te kunnen benaderen. Ik wil gewoon 1 database (eventueel als failsafe over 2 instanties op 2 docker hosts), 1 Mosquitto gekoppeld over 2 of meer instanties (dat werkt best mooi) etc. Ofwel: ik weet eigenlijk wat ik wil maar nog niet altijd hoe het slim en eenvoudig onderhoudbaar op te zetten is. Linux, Docker en nog veel meer zijn mijn hobby en niet mijn vak. Vragen om tips en weer veel lezen en leren dus....

Ah, ik heb gewoon gescheiden stacks gemaakt. Daardoor kunnen versies van de databases ook verschillen. Bijvoorbeeld omdat het ene programma niet altijd support heeft voor de bleeding edge of laatste stabiele versies van een database. Dat heeft ook als voordeel dat men ook niet afhankelijk is van elkaar en stacks niet omvallen omdat een andere stack omvalt. Ik denk dat als je gerichter advies wilt (en ik moet zeggen, ik heb niet alles terug gelezen in dit topic) het wellicht ook handig is om te weten hoe je nu een en ander hebt en wat je gebruikt.

[ Voor 7% gewijzigd door CH4OS op 05-01-2026 15:18 ]

[Mars Warrior]

CH4OS schreef op maandag 5 januari 2026 @ 15:05:
[...]
Ja, volgens mij gebruikte ik deze middleware juist. Binnenkort maar weer eens proberen, al heb ik nu ook niet echt inzichtelijk wat er binnenkomt. Hoe maak je deze grafieken bijvoorbeeld?

De grafieken maak in in Metabase (gratis versie). Voorheen leverde CrowdSec een metabase container mee, maar dat doen ze niet meer omdat ze vinden dat hun console meer kan. Ach ja, keep dreaming

Ik heb wel bergen aan scripts om zaken te verwerken en binnen te halen, dus de grafieken zijn de resultaten van heel wat weekjes werk.

Overigens is data verwerking mijn werk, dus dan zijn dit soort dingen voor mij gewoon leuk werk!

[DjoeC]

CH4OS schreef op maandag 5 januari 2026 @ 15:13:
[...]
Ah, ik heb gewoon gescheiden stacks gemaakt. Daardoor kunnen versies van de databases ook verschillen. Bijvoorbeeld omdat het ene programma niet altijd support heeft voor de bleeding edge of laatste stabiele versies van een database. Dat heeft ook als voordeel dat men ook niet afhankelijk is van elkaar en stacks niet omvallen omdat een andere stack omvalt. Ik denk dat als je gerichter advies wilt (en ik moet zeggen, ik heb niet alles terug gelezen in dit topic) het wellicht ook handig is om te weten hoe je nu een en ander hebt en wat je gebruikt.

Ik heb even bijgelezen over "host" networking. Dat kan werken voor sommige containers maar als ik er tig heb die poort 80 of 3000 gebruiken gaat dat natuurlijk niet. Maar, ik ga eens kijken wat voor mij de beste optie is.

Effectief heb ik nu ~30 containers op 1 machine. De meesten daarvan hoeven niet naar buiten open te staan maar bijvoorbeeld alle Joomla instanties (nu poort 80) wel. Bij "sommige" containers is een aangepaste poort via configatie aan te passen maar niet bij allemaal, daar moet dus nog steeds poortmapping gebeuren. Geen probleem, die kan ik allemaal via NPM eenvoudig benaderen.

Stacks gebruik ik niet - minimale uitzonderingen daar gelaten. Ik heb me daar in het begin van mijn Docker inspanningen aan gebrand. Liever 1 losse database om te beheren dan 10 "embedded".... Ook vanuit andere overwegingen gebruik ik 1 MariaDB LTS voor alle generieke database dingen in mijn totale netwerk. Samen met "ghcr.io/tiredofit/docker-db-backup:latest" als container, phpmyadmin in een container en Navicat op de PC is beheer dan "simpel". Ook Mosquitto draai ik 1 keer (heb wat ervaring met zeer grootschalige MQ omgevingen), ook dat is prima beheersbaar met de paar honderd duizend berichten per dag. Op alle uitgangspunten zijn uitzonderingen mogelijk.

Pihole draait via macvlan opeen eigen (vast) ip adres. Dat is ook meteen de (lokale) DNS voor alles in het netwerk (samen met unbound).

Macvlan heeft voordelen want ik kan containers opstarten op (1 uit) meedere machines zonder dat ik de routering hoef aan te passen: De DNS naam veranderd niet, kwestie down brengen op machine 1, opstarten op machine 2.

Maar, zelf met deze (voor mij) uitgesproken manier van inrichten zal er best iets beters met minder inspanning mogelijk zijn, dat zoek ik dus, Alleen zie ik het, ondanks de goede inhoudelijke reacties van mensen hier, nog niet als eenvoudiger voor me - en dat ligt vast aan mij. Misschien lijdt ik aan tunnelvisie.

[CH4OS]

@DjoeC De Joomla installaties zet je dan toch achter Traefik / Caddy / Nginx Proxy Manager?

Met Traefik hoef je dan niet eens de poorten te openen / forwarden, zolang de Traefik container ze maar bereiken kan. Ik zie echt niet waarom de containers op het netwerk buiten Docker zouden moeten zitten, dat laat ik liever Docker regelen icm Traefik (ook via Docker). De back-end(s) voor Joomla kun je dan evenetueel op een intern netwerk (docker network create --insternal <naam>) zetten waardoor buitenaf er niet eens bij kan. De Joomla instanties zet je dan dus op 2 netwerken, zodat ze enerzijds intern de database kunnen bereiken en het andere netwerk is extern, zodat bepaalde resources die je remote ophaalt (afbeeldingen via een CDN bijvoorbeeld, of metadata van een film of serie) dan opgehaald kan worden. Als dat niet eens nodig is voor de Joomla instanties, kan je dus gewoon met 1 intern netwerk af, Traefik gaat dan voor je naar buiten.

Ik denk echt dat je een en ander onnodig complex hebt voor jezelf, als ik jouw bovenstaande reactie zo lees Ook Pi-Hole draai ik zonder macvlan (draait op een simpele Pi 3B in Docker, tezamen met DSMR reader om mijn slimme meter uit te lezen, verder doet de Pi niks), maar dan dus met portforward, voor Ad Guard Home (die ik op mijn homelab draai) idem dito. Voor het draaien van containers op een andere host zonder aanpassingen te hoeven doen, gebruik je dan toch gewoon Docker Swarm?

[ Voor 14% gewijzigd door CH4OS op 05-01-2026 16:40 ]

[DjoeC]

CH4OS schreef op maandag 5 januari 2026 @ 16:26:
@DjoeC De Joomla installaties zet je dan toch achter Traefik / Caddy / Nginx Proxy Manager?

Met Traefik hoef je dan niet eens de poorten te openen / forwarden, zolang de Traefik container ze maar bereiken kan. Ik zie echt niet waarom de containers op het netwerk buiten Docker zouden moeten zitten, dat laat ik liever Docker regelen icm Traefik (ook via Docker). De back-end(s) voor Joomla kun je dan evenetueel op een intern netwerk (docker network create --insternal <naam>) zetten waardoor buitenaf er niet eens bij kan. De Joomla instanties zet je dan dus op 2 netwerken, zodat ze enerzijds intern de database kunnen bereiken en het andere netwerk is extern, zodat bepaalde resources die je remote ophaalt (afbeeldingen via een CDN bijvoorbeeld, of metadata van een film of serie) dan opgehaald kan worden. Als dat niet eens nodig is voor de Joomla instanties, kan je dus gewoon met 1 intern netwerk af, Traefik gaat dan voor je naar buiten.

Ik denk echt dat je een en ander onnodig complex hebt voor jezelf, als ik jouw bovenstaande reactie zo lees Ook Pi-Hole draai ik zonder macvlan (draait op een simpele Pi 3B in Docker, tezamen met DSMR reader om mijn slimme meter uit te lezen, verder doet de Pi niks), maar dan dus met portforward, voor Ad Guard Home (die ik op mijn homelab draai) idem dito. Voor het draaien van containers op een andere host zonder aanpassingen te hoeven doen, gebruik je dan toch gewoon Docker Swarm?

Dank je. Ik ga me er echt nog eens goed in verdiepen want ik wil dit eenvoudiger krijgen. Gaat me wat tijd kosten maar goed

[CH4OS]

DjoeC schreef op maandag 5 januari 2026 @ 17:39:
Dank je. Ik ga me er echt nog eens goed in verdiepen want ik wil dit eenvoudiger krijgen. Gaat me wat tijd kosten maar goed

Graag gedaan! Ik zou toch eens overwegen om meer met stacks (en elimineren van afhankelijkheden zoals een enkele database instance) te gaan werken. In combinatie met docker compose bijvoorbeeld werkt dat echt goed anno nu.

[ Voor 8% gewijzigd door CH4OS op 05-01-2026 19:24 ]

[synoniem]

CH4OS schreef op maandag 5 januari 2026 @ 19:24:
[...]
Graag gedaan! Ik zou toch eens overwegen om meer met stacks (en elimineren van afhankelijkheden zoals een enkele database instance) te gaan werken. In combinatie met docker compose bijvoorbeeld werkt dat echt goed anno nu.

Het aantal mogelijkheden is wat dat betreft best groot. Omdat ik toch een webserver moet draaien en aan Apache2 gewend ben, heb ik een aantal docker compose scripts waarin Traefik alle services verbindt en de Let's Encrypt certificaten regelt. De Apache2 server stelt een aantal webservices beschikbaar maar is tegelijkertijd ook een proxy voor services die hun eigen webserver draaien.

Uiteraard kan Traefik ook het proxy werk doen maar de webserver met proxy had ik al dus het is min of meer zo organisch gegroeid. Het voordeel is wel dat er een service gewoon kan uitvallen. Zolang de webserver maar blijft draaien blijven de andere services bereikbaar. De volgende stap is het redundant maken met k3s en Longhorn.

[CH4OS]

@synoniem Traefik kan ook prima het Let's Encrypt deel doen, dus dat hoeft niet per se in aparte scripts gedaan te worden. Ook ververst het een certificaat dan automatisch voor je. Om daar dan nog een Apache2 als proxy achter te hangen voelt een beetje dubbel als ik jouw verhaal zo lees. Of ik begrijp het verhaal nu een beetje verkeerd.

[synoniem]

CH4OS schreef op maandag 5 januari 2026 @ 19:59:
@synoniem Traefik kan ook prima het Let's Encrypt deel doen, dus dat hoeft niet per se in aparte scripts gedaan te worden. Ook ververst het een certificaat dan automatisch voor je. Om daar dan nog een Apache2 als proxy achter te hangen voelt een beetje dubbel als ik jouw verhaal zo lees. Of ik begrijp het verhaal nu een beetje verkeerd.

Ja ik ben misschien niet duidelijk genoeg. Traefik regelt inderdaad de certificaten, om precies te zijn een wildcard certificaat dat ook mjin mailserver (in een container) gebruikt. De webserver zit in hetzelfde script om alle subdomeinen af te laten vangen door Traefik proxy. Ik heb gewoon mijn webservice maar ook een subdomein voor icecast/mpd, webmail, postfixadmin terwijl git+docker registry en Navidrome etc. ge-proxied worden.

[DjoeC]

CH4OS schreef op maandag 5 januari 2026 @ 19:24:
[...]
Graag gedaan! Ik zou toch eens overwegen om meer met stacks (en elimineren van afhankelijkheden zoals een enkele database instance) te gaan werken. In combinatie met docker compose bijvoorbeeld werkt dat echt goed anno nu.

Alles zit al in docker compose/yaml en dat werkt inderdaad prima!

[CH4OS]

DjoeC schreef op maandag 5 januari 2026 @ 22:11:
Alles zit al in docker compose/yaml en dat werkt inderdaad prima!

Ah, dat is althans wat ik bedoelde met stacks

Toch even een vraag: Hoe beheren jullie deze files/stacks? Ik doe dat 'simpel' met VS Code (al twijfel ik ook om over te stappen op een andere fork, maar weet nog niet welke, hoor ook veel goede verhalen over Google's Antigravity bijvoorbeeld) en docker doe ik gewoon old-school via de commandline. Maar hoe doen jullie dat? Gebruiken jullie bijvoorbeeld Portainer, Dockge, Arcane of een van de vele andere (webbased) beheertools? Lazydocker wellicht?

[ Voor 58% gewijzigd door CH4OS op 05-01-2026 22:20 ]

[DjoeC]

CH4OS schreef op maandag 5 januari 2026 @ 22:16:
[...]
Ah, dat is althans wat ik bedoelde met stacks

Yes, maar dan wel vzv mogelijk 1 service/1 container per yaml/compose/ok, stack Alleen immich wordt uitgebreider maar wel zonder de database, die wil ik echt centraal houden......

Aanvulljng: Ik heb Raspi lite met daaroverheen Openmediavault. Onderdeel daarvan is een steeds meer uitgebreid Docker nanagement, grofweg Portainer kloon maar werkt veel soepeler. Portainer gebruik ik alleen nog voor snel een container stoppen/starten en das alleen omdat omv geen multiselects kent. Daarbij zijn de omv ontwikkelaars ontzettend responsief bij vragen of issues.

[ Voor 35% gewijzigd door DjoeC op 05-01-2026 22:28 ]

[CH4OS]

Ah, ik heb een onderverdeling gemaakt in wat het doeleinde is. Mijn 'Arr stack' bijvoorbeeld heeft 20 services in totaal, waarvan 2 services dubbel draaien ivm limitaties en/of betere filtering en sorteringsopties voor anime. Dat is dan wel gelijk mijn grootste stack, andere stacks die ik heb, zijn dan weer kleiner, zoals mijn networking stack (waarin ik dus Traefik heb zitten en die ik vervolgens op bijna elk Docker netwerk heb zitten). immich is hier ook een aparte stack, net als OpenCloud zijn eigen stack heeft.

[ Voor 8% gewijzigd door CH4OS op 05-01-2026 22:29 ]

[synoniem]

CH4OS schreef op maandag 5 januari 2026 @ 22:16:
[...]
Ah, dat is althans wat ik bedoelde met stacks

Toch even een vraag: Hoe beheren jullie deze files/stacks? Ik doe dat 'simpel' met VS Code (al twijfel ik ook om over te stappen op een andere fork, maar weet nog niet welke, hoor ook veel goede verhalen over Google's Antigravity bijvoorbeeld) en docker doe ik gewoon old-school via de commandline. Maar hoe doen jullie dat? Gebruiken jullie bijvoorbeeld Portainer, Dockge, Arcane of een van de vele andere (webbased) beheertools? Lazydocker wellicht?

Ik gebruik gewoon de commandline en heb mijn yaml in git repos staan. Mijn servers zijn headless dus een mooie tool met grafische interface heeft weinig nut.

[CH4OS]

@synoniem Eigenlijk hebben alle genoemde tools een webinterface, een gui draaien is dus niet nodig... Enige die dat niet heeft is Lazydocker, dat is een commandline tool.

[ Voor 44% gewijzigd door CH4OS op 05-01-2026 22:48 ]

[blackd]

Voor de mensen die Uptime-Kuma gebruiken, ik las gisteren deze blogpost en leerde toen AutoKuma kennen.

Voorheen had ik een Ansible Task gemaakt die via deze Python library en deze ansible collection een web request deed naar Uptime Kuma om monitors aan te maken. Echter kreeg ik hier steeds meer problemen mee. Ik vermoed het gebruik van de SQLite database icm veel monitors en veel historische data, dus wil graag upgraden naar 2.x met MariaDB.

In plaats van bovenstaande aanpak kan ik met AutoKuma nu labels aanmaken in de Compose file zelf om AutoKuma te voeden met de juiste info om de monitors aan te maken.

Ik beheer op deze manier al mijn Traefik configuratie via labels, mijn Homepage configuratie via labels dus dit past mooi in dat straatje.

Ik ben nu bezig alle config als labels in te richten, daarna kan ik eenvoudig upgraden van 1.x naar 2.x in een nieuwe stack en met een schone lei beginnen.

YAML:

services:
  autokuma:
    image: ghcr.io/bigboot/autokuma:uptime-kuma-v1-2.0.0
    restart: unless-stopped
    environment:
      AUTOKUMA__KUMA__URL: http://uptime-kuma:3001
      AUTOKUMA__KUMA__USERNAME: ${KUMA_USERNAME}
      AUTOKUMA__KUMA__PASSWORD: ${KUMA_PASSWORD}
      AUTOKUMA__DOCKER__EXCLUDE_CONTAINER_PATTERNS: "^temp_;^[a-f0-9]{12}_.*_" # Excludes test containers and temporary stack containers.
      AUTOKUMA__DEFAULT_SETTINGS: |-
        docker.docker_container: {{ container_name }}
        http.max_redirects: 10
        *.max_retries: 3
      AUTOKUMA__DOCKER__LABEL_PREFIX: kuma
      AUTOKUMA__SNIPPETS__DOCKER: |-
         {{container_name}}_docker.docker.docker_container: {{container_name}}
         {{container_name}}_docker.docker.docker_host_name: local
         {{container_name}}_docker.docker.name: docker_{{container_name}}
         {{container_name}}_docker.docker.notification_name_list: ["pushbullet"]
      AUTOKUMA__SNIPPETS__WEB: |-
         {{container_name}}_http.http.name: web_{{container_name}}
         {{container_name}}_http.http.url: https://{{container_name}}.domain.tld
         {{container_name}}_http.http.notification_name_list: ["pushbullet"]
    labels:
      kuma.local.docker_host.name: 'Local Docker Socket'
      kuma.local.docker_host.connection_type: 'socket'
      kuma.local.docker_host.path: '/var/run/docker.sock'
      kuma.pushbullet.notification.name: 'Pushbullet'
      kuma.pushbullet.notification.active: 'true'
      kuma.pushbullet.notification.config: |
        {   [ .. config in JSON ..]
        }
     [..]
   [ ook een uptime-kuma container gedefinieerd op poort 3001]

En dan als voorbeeld:

YAML:

name: sabnzbd
services:
  sabnzbd:
    image: ghcr.io/home-operations/sabnzbd:4.5.5@sha256:da57e01cdebc547852b6df85c8df8c0e4d87792742c7608c5590dc653b184e8c
    container_name: sabnzbd
   [..]
    labels:
      - traefik.enable=true
      - traefik.docker.network=traefik-net
      - traefik.http.routers.sabnzbd.rule=Host(`sabnzbd.domain.tld`)
      - traefik.http.routers.sabnzbd.entrypoints=websecure
      - traefik.http.routers.sabnzbd.tls.certresolver=cfdns
      - traefik.http.services.sabnzbd.loadbalancer.server.port=8080
      - kuma.__web
      - kuma.__docker
 [..]

De labels kuma.__web en kuma.__docker zijn snippets die via de labels AUTOKUMA__SNIPPETS__* geconfigureerd worden.

CH4OS schreef op maandag 5 januari 2026 @ 22:16:
[...]
Ah, dat is althans wat ik bedoelde met stacks

Toch even een vraag: Hoe beheren jullie deze files/stacks? Ik doe dat 'simpel' met VS Code (al twijfel ik ook om over te stappen op een andere fork, maar weet nog niet welke, hoor ook veel goede verhalen over Google's Antigravity bijvoorbeeld) en docker doe ik gewoon old-school via de commandline. Maar hoe doen jullie dat? Gebruiken jullie bijvoorbeeld Portainer, Dockge, Arcane of een van de vele andere (webbased) beheertools? Lazydocker wellicht?

Zoveel mogelijk geautomatiseerd met Ansible, elke stack als Ansible Role in een Github project. Ik doe het beheer met VSCode lokaal en het deployen doe ik via Ansible met een Github self hosted runner.

Als het nodig is containers restarten via Dockge of debuggen via Portainer en worst-case via de CLI via SSH.

[ Voor 33% gewijzigd door blackd op 06-01-2026 09:30 ]

[synoniem]

CH4OS schreef op maandag 5 januari 2026 @ 22:45:
@synoniem Eigenlijk hebben alle genoemde tools een webinterface, een gui draaien is dus niet nodig... Enige die dat niet heeft is Lazydocker, dat is een commandline tool.

Tja, ik ben old skool wat dat betreft dus geen beheerinterface aan het net hangen. Een headless server (vps) is bij mij alleen bereikbaar op port 443 en 22 (en eventueel imap en smtp). Ik zou eventueel een beheerinterface aan localhost kunnen hangen en dan via ssh forwarden maar dat is net zoveel werk als met ssh inloggen en het zelf doen.

[ThinkPad]

Ik meen ooit eens een container te hebben gezien voor het bijhouden van verzekeringspolissen, energiecontracten e.d. Kan het alleen niet vinden, ik kom dan uit bij document management systemen zoals Paperless, of warranty trackers waarin ik kan registreren dat de garantie van m'n TV verloopt op 5 nov. 2027 bijv. Of inventarissystemen, om bij te houden hoeveel boodschappen ik nog in huis heb, of hoeveel dozen schroefjes. Niet wat ik zoek

Ik zoek meer een Excel-achtig overzicht waarin ik kan invoeren dat ik m'n auto verzekerd heb bij BedrijfX, dat ik een energiecontract heb bij LeverancierXYZ wat loopt tot dd-mm-yyyy en een internetcontract heb wat loopt tot dd-mm-yyyy

Iemand een idee?

[ Voor 9% gewijzigd door ThinkPad op 06-01-2026 09:21 ]

[synoniem]

ThinkPad schreef op dinsdag 6 januari 2026 @ 09:19:
Ik meen ooit eens een container te hebben gezien voor het bijhouden van verzekeringspolissen, energiecontracten e.d. Kan het alleen niet vinden, ik kom dan uit bij document management systemen zoals Paperless, of warranty trackers waarin ik kan registreren dat de garantie van m'n TV verloopt op 5 nov. 2027 bijv. Of inventarissystemen, om bij te houden hoeveel boodschappen ik nog in huis heb, of hoeveel dozen schroefjes. Niet wat ik zoek

Ik zoek meer een Excel-achtig overzicht waarin ik kan invoeren dat ik m'n auto verzekerd heb bij BedrijfX, dat ik een energiecontract heb bij LeverancierXYZ wat loopt tot dd-mm-yyyy en een internetcontract heb wat loopt tot dd-mm-yyyy

Iemand een idee?

Zoiets als Wallos?

[ThinkPad]

synoniem schreef op dinsdag 6 januari 2026 @ 09:37:
[...]

Zoiets als Wallos?

Yes perfect!

Ik zat al te kijken naar een Excel-template zoals deze, maar die Wallos is precies wat ik zoek zo te zien. Kan ook notificaties sturen als iets bijna verloopt zo te zien.

[Ben.Hahlen]

@DjoeC (en anderen):
Interessante discussie over "de inrichting"
Mijn 2 centen:

Ik heb een hele tijd MACVLan gedraaid en was daar best tevreden over, maar het management is wel "ingewikkeld", want je moet goed bijhouden wat waar draait, in PiHole regeltjes bijhouden voor routing etc.

Ondertussen ben ik al een hele tijd over naar "normale" netwerken, maar ik draai ook nog "generieke" services, dus geen stack per applicatie.
Mijn folder structuur ziet er nu zo uit:

code:

.
├── 01-critical
├── 02-databases
├── 03-middleware
├── 04-management
├── 05-home
├── 06-personal
├── 07-finance
├── 08-travel
├── 09-tools
├── 10-media
├── 11-games
├── 12-websites
├── 13-ai

In the eerste stack zitten bijvoorbeeld Authentik, Traefik, PiHole en Postgres (speciaal voor die stack). Dat is de enige die volledig zelf-contained is.

Voor het managen van de files gebruik ik VSCode en de Compose Stacks starten/stoppen doe ik met dc, een tooltje dat ik voor mezelf geschreven heb.

[DjoeC]

Ben.Hahlen schreef op dinsdag 6 januari 2026 @ 14:30:
@DjoeC (en anderen):
Interessante discussie over "de inrichting"
Mijn 2 centen:

Ik heb een hele tijd MACVLan gedraaid en was daar best tevreden over, maar het management is wel "ingewikkeld", want je moet goed bijhouden wat waar draait, in PiHole regeltjes bijhouden voor routing etc.

Ondertussen ben ik al een hele tijd over naar "normale" netwerken, maar ik draai ook nog "generieke" services, dus geen stack per applicatie.
Mijn folder structuur ziet er nu zo uit:

code:

.
├── 01-critical
├── 02-databases
├── 03-middleware
├── 04-management
├── 05-home
├── 06-personal
├── 07-finance
├── 08-travel
├── 09-tools
├── 10-media
├── 11-games
├── 12-websites
├── 13-ai

In the eerste stack zitten bijvoorbeeld Authentik, Traefik, PiHole en Postgres (speciaal voor die stack). Dat is de enige die volledig zelf-contained is.

Voor het managen van de files gebruik ik VSCode en de Compose Stacks starten/stoppen doe ik met dc, een tooltje dat ik voor mezelf geschreven heb.

Interessant..... Voor mij is het voordeel van MACVLAN nou juist dat ik na de eerste keer geen routering meer hoef aan te passen. Pihole krijgt ip 10.1.1.2 en houd dat, ongeacht op welke docker instantie die draait.... Ben dus wel benieuwd waarom jij routering zou moeten aanpassen. Gewoon elke service z'n eigen hostname in de pihole locale DNS - die ik trouwens op de Fritzbox router ook als overall DNS heb ingesteld.

[Ben.Hahlen]

DjoeC schreef op dinsdag 6 januari 2026 @ 16:41:
[...]
Interessant..... Voor mij is het voordeel van MACVLAN nou juist dat ik na de eerste keer geen routering meer hoef aan te passen. Pihole krijgt ip 10.1.1.2 en houd dat, ongeacht op welke docker instantie die draait.... Ben dus wel benieuwd waarom jij routering zou moeten aanpassen. Gewoon elke service z'n eigen hostname in de pihole locale DNS - die ik trouwens op de Fritzbox router ook als overall DNS heb ingesteld.

Ik zat in die tijd nogal in de "speelfase", dus heel vaak containers weg en nieuwe er voor in de plaats.
Dan gaat het hard met de administratie

PiHole heeft een WildCard verwijzing naar mijn Traefik, zodat intern alles ook op hostname resolved kan worden.

Mijn USG en PiHole wlke ook samen.

[Greatsword]

Ik heb docker op mijn (Ugreen) NAS draaien, voornamelijk voor zaken als Plex, Sonarr, Radarr etc.

Deze applicaties maken netjes wekelijks geautomatiseerde backups in Zip bestanden, maar hoe maak ik nu eigenlijk het beste een backup van Docker? Stel de NAS houdt er mee op dan wil ik dus zo snel mogelijk alles weer terug kunnen zetten.

Is het dan voldoende om de zip bestanden (backups) ergens anders op te slaan of moet ik dan echt de hele Docker / appdata map overzetten.

De NAS staat 24/7 aan en in deze applicaties worden ook continue logs geschreven, dus ben benieuwd of dat nog conflicten met zich kan meebrengen.

[DjoeC]

Ben.Hahlen schreef op woensdag 7 januari 2026 @ 10:16:
[...]

Ik zat in die tijd nogal in de "speelfase", dus heel vaak containers weg en nieuwe er voor in de plaats.
Dan gaat het hard met de administratie

PiHole heeft een WildCard verwijzing naar mijn Traefik, zodat intern alles ook op hostname resolved kan worden.

Mijn USG en PiHole wlke ook samen.

Ik heb me alvast een beetje verder ingelezen. In de revrvse proxy opties is voorlopig Caddy afgevallen. Traefik moet ik me nog meer in verdiepen dus nog geen uiteindelijke selectie gemaakt voor de nieuwe omgeving.

Daarnaast me nog eens opnieuw ingelezen over macvlan in de docker docs. Daar lijken wat nadelen aan te zitten die door gebruik van ipvlan kunnen worden ondervangen. Dan is er nog het onderscheid in ipvlan L2 en L3, daar moet ik eerst ook wat meer van gaan snappen (en wat mee experimenteren)..... Leuk!

[DjoeC]

Greatsword schreef op donderdag 8 januari 2026 @ 15:24:
Ik heb docker op mijn (Ugreen) NAS draaien, voornamelijk voor zaken als Plex, Sonarr, Radarr etc.

Deze applicaties maken netjes wekelijks geautomatiseerde backups in Zip bestanden, maar hoe maak ik nu eigenlijk het beste een backup van Docker? Stel de NAS houdt er mee op dan wil ik dus zo snel mogelijk alles weer terug kunnen zetten.

Is het dan voldoende om de zip bestanden (backups) ergens anders op te slaan of moet ik dan echt de hele Docker / appdata map overzetten.

De NAS staat 24/7 aan en in deze applicaties worden ook continue logs geschreven, dus ben benieuwd of dat nog conflicten met zich kan meebrengen.

Ik maak 2 soorten "backup's" van docker spul. Databases dagelijks middels https://github.com/tiredofit/docker-db-backup , die komen in een shared backup folder die "zodra ze er staan" en Windows beschikbaar is naar Windows worden overgehaald en daar in de Windows backup cyclus meelopen. Daarnaast wordt alle "permanente" docker data (docker-config en docker-data) middels een simpel script naar die backup folder gekopieerd en loopt op dezelfde manier mee. Al het andere is een herstel kwestie van: configatie, datafolders terug zetten, containers opnieuw uitrollen mbv de bewaarde yml's en gaan met die banaan. De databases (mariadb): Eerst kale Mariadb starten en dan alles (behalve system) restoren.

En ja, er zijn meer en veel meer sophisticated manieren, dit werkt voor mij zonder omkijken. O ja, en van pihole draai ik elke nacht een automatische teleporter job. Dan heeft ie ook mijn lokale DNS altijd compleet. 1 dag verlies kan ik mij veroorloven. Als je dat niet kunt: andere maatregelen treffen

[Satom]

Greatsword schreef op donderdag 8 januari 2026 @ 15:24:
Ik heb docker op mijn (Ugreen) NAS draaien, voornamelijk voor zaken als Plex, Sonarr, Radarr etc.

Deze applicaties maken netjes wekelijks geautomatiseerde backups in Zip bestanden, maar hoe maak ik nu eigenlijk het beste een backup van Docker? Stel de NAS houdt er mee op dan wil ik dus zo snel mogelijk alles weer terug kunnen zetten.

Is het dan voldoende om de zip bestanden (backups) ergens anders op te slaan of moet ik dan echt de hele Docker / appdata map overzetten.

De NAS staat 24/7 aan en in deze applicaties worden ook continue logs geschreven, dus ben benieuwd of dat nog conflicten met zich kan meebrengen.

Toen ik nog gebruik maakte van een Intel NUC, gebruikte ik een script + rsync om elke nacht alle docker-compose projecten te stoppen, te kopiëren naar een specifieke te back-uppen map en daarna een-voor-een de docker-compose projecten weer op te starten. De te back-uppen map werd dan op een later tijdstip (geloof een uur later) door Duplicati verwerkt naar de cloud. De downtime die het met zich mee bracht, maakte mij niets uit. Het gehele proces liep als ik lag te slapen.

Op dit moment draai ik een Raspberry Pi 3B+, daarvan hanteer ik bijna dezelfde werkwijze, behalve het kopiëren. Middels scripting worden de docker-compose projecten gestopt, vervolgens gaat Duplicati de boel uploaden naar de cloud, om uiteindelijk de projecten weer te starten. De downtime is hier iets langer, maar ook nu heb ik er geen last van (het proces loopt diep in de nacht).

Zolang als ik self-host (10+ jaar), heb ik altijd downtime verkozen boven, mogelijk, incomplete backups, omdat het spul nog draaiende is. Ik geloof wel dat de tooling tegenwoordig beter is geworden, maar goed

[DjoeC]

Satom schreef op donderdag 8 januari 2026 @ 15:59:
[...]
De downtime is hier iets langer, maar ook nu heb ik er geen last van (het proces loopt diep in de nacht).

Hmm, ik zou toch liever doordraaien, zeker als zoiets hier 1 alle DNS verzorgd wordt (pihole, unbound) en er ook (beschermd via Cloudflare) een paar publieke websites draaien. Ik kan niet voorspellen wie wanneer wel of niet slaapt. Daarnaast vind ik (maar goed, wie ben ik) unattended stops en starts onwenselijk. Maar goed, YMMV.

[DjoeC]

Vraag: ik gebruik momenteel Mosquitto als MQTT broker (bron voor HA en eigen proggies), gevoed vanuit sensoren en ESP's (eigen proggies). Ik gebruik zoveel mogelijk MQTT V5 maar V3 wordt ook nog wel gebruikt.

Nu mis ik een grafische (management) interface waar statistieken, timestamp laatste bericht in een queue, oid te zien zijn. Ik denk NIET aan prometheus achtige oplossingen. Blijkbaar is er een commercieele versie van Mosquitto die dit heeft maar ik zoek eigenlijk gewoon open-source.

Is er een betere MQTT broker met iets meer opties (docker gebaseerd). Ik kom HiveMQ, RabbitMQ, emqx tegen. Heeft iemand ervaring met 1 van die alternatieven?

[Ben.Hahlen]

DjoeC schreef op zaterdag 17 januari 2026 @ 15:21:
Vraag: ik gebruik momenteel Mosquitto als MQTT broker (bron voor HA en eigen proggies), gevoed vanuit sensoren en ESP's (eigen proggies). Ik gebruik zoveel mogelijk MQTT V5 maar V3 wordt ook nog wel gebruikt.

Nu mis ik een grafische (management) interface waar statistieken, timestamp laatste bericht in een queue, oid te zien zijn. Ik denk NIET aan prometheus achtige oplossingen. Blijkbaar is er een commercieele versie van Mosquitto die dit heeft maar ik zoek eigenlijk gewoon open-source.

Is er een betere MQTT broker met iets meer opties (docker gebaseerd). Ik kom HiveMQ, RabbitMQ, emqx tegen. Heeft iemand ervaring met 1 van die alternatieven?

Ik gebruik MQTT Explorer.
Deze connect naar Mosquitto, misschien is dat wat?

[DjoeC]

Ben.Hahlen schreef op maandag 19 januari 2026 @ 15:28:
[...]

Ik gebruik MQTT Explorer.
Deze connect naar Mosquitto, misschien is dat wat?

Ja, die gebruik ik al op Windows maar liefst zou ik iets hebben dat direct onder docker draait - of zou dit zo in een container te "verpakken" kunnen zijn?

Vanochtend heb ik EMQX uitgeprobeerd, dat leip eigenlijk best wel als alternatief voor Mosquitto. Het grote verschil: Mosquitto kan maar 100.000 connecties aan en EMQX wel 1.000.000. Duhhh....

Daar zit een "soort van" combinatie in van MQTT Explorer en https://github.com/sanjeshpathak/Mosquitto-Dashboard maar ik vraag me af of dat pakket niet veel te zwaar is voor een Raspi. Daarbij moet je met EMQX bij een "cluster" al meteen een betaalde licentie aanschaffen, ik neem aan dat dat bij bridgen ook geldt - terwijl bringen van mosquitto gewoon een paar config regels zijn....

Maar goed, als er echt niks is maak ik misschien wel een Python containertje dat statistics naar Home Assistant kan sturen en maak ik daar wel een dashboardje. Werk waar ik niet op zit te wachten - maar dat kan natuurlijk wel.....

[Mars Warrior]

DjoeC schreef op maandag 19 januari 2026 @ 15:37:
[...]

Ja, die gebruik ik al op Windows maar liefst zou ik iets hebben dat direct onder docker draait - of zou dit zo in een container te "verpakken" kunnen zijn?

Vanochtend heb ik EMQX uitgeprobeerd, dat leip eigenlijk best wel als alternatief voor Mosquitto. Het grote verschil: Mosquitto kan maar 100.000 connecties aan en EMQX wel 1.000.000. Duhhh....

Daar zit een "soort van" combinatie in van MQTT Explorer en https://github.com/sanjeshpathak/Mosquitto-Dashboard maar ik vraag me af of dat pakket niet veel te zwaar is voor een Raspi. Daarbij moet je met EMQX bij een "cluster" al meteen een betaalde licentie aanschaffen, ik neem aan dat dat bij bridgen ook geldt - terwijl bringen van mosquitto gewoon een paar config regels zijn....

Maar goed, als er echt niks is maak ik misschien wel een Python containertje dat statistics naar Home Assistant kan sturen en maak ik daar wel een dashboardje. Werk waar ik niet op zit te wachten - maar dat kan natuurlijk wel.....

Dat clusteren van EMQS geld kost wist ik niet. Voorheen draaide ik dat namelijk op een netwerk van RPIs...

Maar EMQX is mooi en informatief als optie voor een GUI.

Daarnaast heb je nog RabbitMQ. Kan wat bewerkelijker zijn omdat je een MQTT plugin moet gebruiken, immers RabbitMQ doet standaard AMQP.

En wat dacht je van deze, MQTTUI?
Dit is een aparte GUI voor een willekeurige broker en draait vanzelfsprekend in Docker.

[Ben.Hahlen]

DjoeC schreef op maandag 19 januari 2026 @ 15:37:
[...]

Ja, die gebruik ik al op Windows maar liefst zou ik iets hebben dat direct onder docker draait - of zou dit zo in een container te "verpakken" kunnen zijn?

Jazeker, dat is de enige manier dat ik hem heb:

YAML:

  mqtt-explorer:
    extends:
      file: ../shared.yml
      service: pubnet-shared
    image: smeagolworms4/mqtt-explorer:latest
    container_name: mqtt-explorer
    hostname: mqtt-explorer
    env_file: mqtt-explorer.env
    volumes:
      - ./mqtt-explorer/config:/mqtt-explorer/config
 

[DjoeC]

Mars Warrior schreef op maandag 19 januari 2026 @ 16:06:
[...]

Dat clusteren van EMQS geld kost wist ik niet. Voorheen draaide ik dat namelijk op een netwerk van RPIs...

Maar EMQX is mooi en informatief als optie voor een GUI.

Daarnaast heb je nog RabbitMQ. Kan wat bewerkelijker zijn omdat je een MQTT plugin moet gebruiken, immers RabbitMQ doet standaard AMQP.

En wat dacht je van deze, MQTTUI?
Dit is een aparte GUI voor een willekeurige broker en draait vanzelfsprekend in Docker.

[Afbeelding]

EMQX heeft de licentie afgelopen jaar aangepast. Multi-node kan nog wel voor eigen gebruik/hobby maar je moet wel een (en daar zat ik waarschijnlijk fout) vzv ik kan zien gratis licentie voor aanvragen. Daar houdt ik niet zo van

RabbitMQ heb ik in het verleden al eens naar gekeken maar toen was hun MQTT ondersteuning er niet/in een pril statium. Misschien ook maar weer eens proberen.

Met Terdia MQTUI ben ik gosteren aan t kloten geweest. Ik kreeg t niet leek aan de gang. Maar als chatgpt t aanbeveelt zal het toch wel goed moeten zijn

En anders wordt t toch weer het vertrouwde Mosquitto, dan maar geen interface - in de huidige "produktie"omgeving doet die ook gewoon wat ie doen moet. Alleen, een mens wil soms wat extra franje..

[DjoeC]

Ben.Hahlen schreef op maandag 19 januari 2026 @ 16:15:
[...]

Jazeker, dat is de enige manier dat ik hem heb:

YAML:

  mqtt-explorer:
    extends:
      file: ../shared.yml
      service: pubnet-shared
    image: smeagolworms4/mqtt-explorer:latest
    container_name: mqtt-explorer
    hostname: mqtt-explorer
    env_file: mqtt-explorer.env
    volumes:
      - ./mqtt-explorer/config:/mqtt-explorer/config
 

Ik ga die zometeen eens uitrollen, die heb ik over t hoofd gezien - zal vast wel verkeerd gezocht hebben. Nou dat dashboard nog, om de stats snel in beeld te hebben, dan ben ik klaar en kan ik gewoon op Mosquitto blijven.

<aanvulling>
MQTT-explorer draait al en net zoals lokaal Top!

[ Voor 4% gewijzigd door DjoeC op 19-01-2026 16:48 ]

[DjoeC]

Is er een "goede" reden om Python scripts via een Dockerfile uit te rollen naar een "eigen" image ipv een script vanuit de (een) standaard Pyhton image via command vanuit de compose te starten? Als vrijwel iedereen eigen images bakt zal daar best een (door mij niet kunnen vinden) hele goede onderbouwing voor zijn...

Nee, ik gebruik voor eigen images (nog) geen repository en heb dus ook geen automatische bewaking (zoals Watchtower) of er voor een onderdeel van het image updates uitgekomen zijn....