Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Eigene Abhängigkeiten

Ziel: Du bringst Renovate Versionen bei, die kein Manager kennt: in Dockerfile-ARGs, Makefiles, eigenen YAML-Dateien und hinter einer hauseigenen Versionsliste. · Dauer: ca. 120 min · Voraussetzung: Tag 3

Briefing

  • Viele Versionen stehen in Dateien, die kein Manager versteht: ARG KUBECTL_VERSION=… vor einem curl, HELM_VERSION ?= … im Makefile, eine Tool-Liste in YAML.
  • customManagers mit customType: regex holt sie per Regex mit benannten Gruppen heraus. customType: jsonata fragt JSON, YAML oder TOML strukturiert ab.
  • Jede gefundene Abhängigkeit braucht mindestens depName, currentValue und datasource, entweder als Gruppe im Regex oder als …Template.
  • Die Konvention # renovate: datasource=… depName=… über der Zeile plus fertige Presets (customManagers:dockerfileVersions u. a.) ersparen dir eigene Regexe.
  • customDatasources liefert Versionen aus einer eigenen JSON-Quelle.
 Datei ──managerFilePatterns──► matchStrings (Regex/JSONata)
                                   │ depName, currentValue, datasource, …
                                   ▼
                               Datasource ──► Versionen ──► PR ersetzt currentValue

Drill 1: Was Renovate nicht sieht

Das neue Repo shop/shop-tools ist die Werkzeugkiste des Teams. Es bringt eine renovate.json mit config:recommended mit. Forgejo meldet ein frisch gepushtes Repo für ein, zwei Sekunden noch als leer, die until-Schleife wartet das ab (sonst: „Repository is empty - skipping”).

source ~/renovate-lab/setup/env.sh && ~/renovate-lab/setup/check.sh
export RENOVATE_GITHUB_COM_TOKEN=$(gh auth token)   # hier fast Pflicht, s. u.
mkdir -p ~/renovate-lab/tag07 && cd ~/renovate-lab/tag07
~/renovate-lab/setup/mkrepo.sh shop/shop-tools ~/renovate-lab/code/tag07/shop-tools
until curl -sf -u "$ADMIN" "$FORGEJO/api/v1/repos/shop/shop-tools" \
  | jq -e '.empty == false' > /dev/null; do sleep 1; done
source ~/renovate-lab/code/tag03/report.sh
source ~/renovate-lab/code/tag07/vals.sh
renovate --dry-run=extract --report-type=file --report-path=extract.json \
  shop/shop-tools > extract.log 2>&1
deps extract.json
(cd ~/renovate-lab/code/tag07/shop-tools && grep -H -E '_VERSION|version:|_TAG' \
  Dockerfile Makefile tools.yaml deploy.env | grep -v '\$')

Erwartet:

✔ shop/shop-tools angelegt (http://127.0.0.1:3000/shop/shop-tools)
shop-tools  asdf        terraform  1.6.6   -
shop-tools  asdf        golang     1.21.5  -
shop-tools  dockerfile  alpine     3.19.1  -
shop-tools  dockerfile  curl       -
Dockerfile:ARG KUBECTL_VERSION=v1.29.0
Dockerfile:ARG KUSTOMIZE_VERSION=5.3.0
Makefile:HELM_VERSION ?= 3.14.0
Makefile:GOLANGCI_LINT_VERSION ?= v1.55.2
tools.yaml:    version: v4.40.5
tools.yaml:    version: v0.9.0
deploy.env:DB_TAG=15.4

Renovate findet das Basis-Image, sogar das apk-Paket curl (ohne Version, also übersprungen), und .tool-versions über den Manager asdf. Die unteren sieben Versionen aber fasst nie ein PR an. Das sind die Stellen, an denen in echten Repos die ältesten Werkzeuge mit den meisten CVEs liegen.

Achtung: Fast alle Datasources dieses Tages sind github-releases oder github-tags. Ohne RENOVATE_GITHUB_COM_TOKEN läufst du nach rund 60 Anfragen pro Stunde in das anonyme Rate-Limit der GitHub-API, und Lookups scheitern.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der erste Regex-Manager

Ein Custom Manager besteht aus Dateimuster, Regex und den Angaben, die der Regex nicht liefert. Hier kommt nur currentValue aus der Datei, Name und Datasource sind fest.

git clone -q http://lab-admin:[email protected]:3000/shop/shop-tools.git
cd shop-tools
git config user.name "Lab Admin" && git config user.email [email protected]
cat > renovate.json <<'EOF'
{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": ["config:recommended"],
  "customManagers": [
    {
      "customType": "regex",
      "description": "kubectl im Tool-Image",
      "managerFilePatterns": ["/(^|/)Dockerfile$/"],
      "matchStrings": ["ARG KUBECTL_VERSION=(?<currentValue>\\S+)"],
      "depNameTemplate": "kubernetes/kubernetes",
      "datasourceTemplate": "github-releases"
    }
  ]
}
EOF
renovate-config-validator
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../local.json > ../local.log 2>&1
vals ../local.json
jq '.repositories[].packageFiles.regex[0].deps[0]
  | {depName, currentValue, datasource, versioning, replaceString}' ../local.json

Erwartet:

 INFO: Validating renovate.json
 INFO: Config validated successfully against 1 file(s)
Dockerfile  kubernetes/kubernetes  v1.29.0  v1.37.1
{
  "depName": "kubernetes/kubernetes",
  "currentValue": "v1.29.0",
  "datasource": "github-releases",
  "versioning": "semver-coerced",
  "replaceString": "ARG KUBECTL_VERSION=v1.29.0"
}

Drei Dinge zum Merken:

  • Der Regex läuft gegen den ganzen Dateiinhalt, nicht zeilenweise. Renovate nutzt RE2, Lookbehind und Rückverweise gibt es also nicht.
  • Im JSON wird jeder Backslash verdoppelt: \S heißt \\S. Ein vergessener Backslash ist der häufigste Grund für „matcht nicht”.
  • replaceString ist der gesamte Treffer. Beim Update ersetzt Renovate darin nur currentValue. Ohne Angabe gilt das Versioning semver-coerced.

Jede Gruppe hat ein Template-Gegenstück für feste Werte:

Gruppe im Regex Template Zweck
depName depNameTemplate Name im PR-Titel und für packageRules
packageName packageNameTemplate Name für die Datasource, falls anders
datasource datasourceTemplate woher die Versionen kommen
versioning versioningTemplate wie verglichen wird (semver, loose, …)
extractVersion extractVersionTemplate Version aus dem Tag schälen (Drill 4)
registryUrl registryUrlTemplate andere Registry/API-URL

currentValue ist Pflicht und hat kein Template. Templates sind Handlebars und dürfen Gruppen verwenden, etwa "depNameTemplate": "{{{depName}}}-cli".

Fortschritt speichern? Kostenlos registrieren

Drill 3: Kommentarkonvention und Presets

Für jede Variable einen eigenen Manager zu schreiben skaliert nicht. Renovate bringt Presets mit, die eine Kommentarzeile über der Variablen auswerten. Lies das Original:

P=~/renovate-lab/tools/node_modules/renovate/dist/config/presets/internal
grep -o '^\t[a-zA-Z]*Versions' $P/custom-managers.preset.js | tr -d '\t' \
  | paste -sd' ' - | fold -s -w 80
grep -A12 '^\tdockerfileVersions' $P/custom-managers.preset.js \
  | grep -o '"# renovate.*' | fold -w 80

Erwartet:

azurePipelinesVersions biomeVersions bitbucketPipelinesVersions
dockerfileVersions githubActionsVersions gitlabPipelineVersions
helmChartYamlAppVersions makefileVersions mavenPropertyVersions tfvarsVersions
tsconfigNodeVersions valeVersions
"# renovate: datasource=(?<datasource>[a-zA-Z0-9-._]+?) depName=(?<depName>[^\\s
]+?)(?: (lookupName|packageName)=(?<packageName>[^\\s]+?))?(?: versioning=(?<ver
sioning>[^\\s]+?))?(?: extractVersion=(?<extractVersion>[^\\s]+?))?(?: registryU
rl=(?<registryUrl>[^\\s]+?))?\\s(?:ENV|ARG)\\s+[A-Za-z0-9_]+?_VERSION[ =][\"']?(
?<currentValue>.+?)[\"']?\\s"]

Der Kommentar liefert datasource und depName, optional packageName, versioning, extractVersion und registryUrl, in genau dieser Reihenfolge, getrennt durch je ein Leerzeichen. Direkt danach muss ein ARG oder ENV mit …_VERSION folgen. Du ersetzt deinen eigenen Manager durch zwei Presets und kommentierst die Dateien:

cat > renovate.json <<'EOF'
{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:recommended",
    "customManagers:dockerfileVersions",
    "customManagers:makefileVersions"
  ]
}
EOF
c='# renovate: datasource=github-releases depName='
perl -pi -e "s|^(ARG KUBECTL_VERSION)|${c}kubernetes/kubernetes\n\$1|" Dockerfile
perl -pi -e "s|^(ARG KUSTOMIZE_VERSION)|${c}kubernetes-sigs/kustomize\n\$1|" Dockerfile
perl -pi -e "s|^(HELM_VERSION)|${c}helm/helm\n\$1|" Makefile
perl -pi -e "s|^(GOLANGCI_LINT_VERSION)|${c}golangci/golangci-lint\n\$1|" Makefile
sed -n 3,6p Dockerfile; sed -n 1,4p Makefile
renovate-config-validator > /dev/null && echo "✔ Config gültig"
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../local.json > ../local.log 2>&1
vals ../local.json

Erwartet:

# renovate: datasource=github-releases depName=kubernetes/kubernetes
ARG KUBECTL_VERSION=v1.29.0
# renovate: datasource=github-releases depName=kubernetes-sigs/kustomize
ARG KUSTOMIZE_VERSION=5.3.0
# renovate: datasource=github-releases depName=helm/helm
HELM_VERSION ?= 3.14.0
# renovate: datasource=github-releases depName=golangci/golangci-lint
GOLANGCI_LINT_VERSION ?= v1.55.2
✔ Config gültig
Dockerfile  kubernetes/kubernetes      v1.29.0  v1.37.1
Dockerfile  kubernetes-sigs/kustomize  5.3.0    -
Makefile    helm/helm                  3.14.0   3.22.0,4.3.0
Makefile    golangci/golangci-lint     v1.55.2  v1.64.8,v2.14.0

Die Zielversionen sind bei dir neuer. Helm liefert Tags mit v (v3.22.0), im Makefile steht die Version ohne. Renovate findet 3.14.0 als Release v3.14.0 und übernimmt das Format des aktuellen Werts. helm-v$(HELM_VERSION) in der Download-URL bleibt also heil (wann das schiefgeht, zeigt die Challenge). Zwei Ziele bei Helm und golangci-lint heißen wie gewohnt: Minor-PR und Major-PR (Tag 4).

Tipp: --platform=local liest nur Dateien, die Git kennt. Neue Dateien musst du vorher mit git add vormerken, sonst sieht Renovate sie nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 4: extractVersion für krumme Tags

Warum bekommt kustomize kein Update? Das Projekt veröffentlicht mehrere Module aus einem Repo, die Tags tragen ein Präfix:

curl -s "https://api.github.com/repos/kubernetes-sigs/kustomize/releases?per_page=4" \
  | jq -r '.[].tag_name'
jq -r '.repositories[].packageFiles.regex[].deps[]
  | select(.depName | test("kustomize")) | .currentVersion' ../local.json

Erwartet:

kyaml/v0.21.3
kustomize/v5.8.3
cmd/config/v0.21.3
api/v0.21.3
kustomize/v5.3.0

Renovate ordnet 5.3.0 zwar dem Tag kustomize/v5.3.0 zu, aus den gemischten Tags (api/v0.21.3, kyaml/v0.21.3, …) bildet es aber keinen Nachfolger. extractVersion ist ein Regex mit der Gruppe version: Nur Tags, die passen, zählen, und nur die Gruppe gilt als Version.

export ev='extractVersion=^kustomize/v(?<version>.+)$'
perl -pi -e 's|(depName=kubernetes-sigs/kustomize)$|$1 $ENV{ev}|' Dockerfile
grep -o 'kustomize extractVersion=.*' Dockerfile
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../local.json > ../local.log 2>&1
vals ../local.json | grep kustomize

Erwartet:

kustomize extractVersion=^kustomize/v(?<version>.+)$
Dockerfile  kubernetes-sigs/kustomize  5.3.0    5.8.3

$ENV{ev} liest die exportierte Variable, so muss perl die Sonderzeichen des Regex nicht auswerten. Derselbe Trick steckt übrigens in eingebauten Managern. asdf schält bei Terraform und Go das Präfix genauso ab:

jq -r '.repositories[].packageFiles.asdf[0].deps[]
  | [.depName, .packageName, .datasource, .extractVersion] | @tsv' ../local.json \
  | column -t

Erwartet:

terraform  hashicorp/terraform  github-releases  ^v(?<version>\\S+)
golang     golang/go            github-tags      ^go(?<version>\\S+)

Für .tool-versions (und mise.toml über den Manager mise) brauchst du also keinen Custom Manager. Prüfe immer erst unter docs.renovatebot.com/modules/manager/, ob es schon einen Manager gibt.

Fortschritt speichern? Kostenlos registrieren

Drill 5: JSONata für tools.yaml

tools.yaml hat Struktur. Statt sie per Regex zu zerlegen, fragt customType: jsonata die geparste Datei ab. fileFormat ist json, yaml oder toml. Der Ausdruck muss Objekte mit denselben Feldern wie die Regex-Gruppen liefern.

sed -n 2,5p tools.yaml
jq '.customManagers = [{
  "customType": "jsonata",
  "description": "CI-Werkzeuge in tools.yaml",
  "fileFormat": "yaml",
  "managerFilePatterns": ["tools.yaml"],
  "matchStrings": ["tools.{ \"depName\": repo, \"currentValue\": version }"],
  "datasourceTemplate": "github-releases"
}]' renovate.json > tmp.json && mv tmp.json renovate.json
renovate-config-validator > /dev/null && echo "✔ Config gültig"
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../local.json > ../local.log 2>&1
vals ../local.json | grep tools.yaml

Erwartet:

tools:
  - name: yq
    repo: mikefarah/yq
    version: v4.40.5
✔ Config gültig
tools.yaml  mikefarah/yq               v4.40.5  v4.54.1
tools.yaml  koalaman/shellcheck        v0.9.0   v0.11.0

tools.{…} läuft über jedes Element der Liste und baut daraus ein Objekt. Den Ausdruck testest du ohne Renovate auf try.jsonata.org (YAML vorher nach JSON wandeln). Beim Update sucht Renovate den alten Wert in der Datei und ersetzt ihn, Kommentare und Formatierung bleiben erhalten.

Achtung: JSONata-Ausdrücke stehen in einem JSON-String. Jedes " darin wird zu \". Mit jq wie oben musst du darüber nicht nachdenken.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Zwei Zeilen, eine Abhängigkeit

In deploy.env stehen Image (DB_IMAGE=postgres) und Tag (DB_TAG=15.4) in getrennten Zeilen. matchStringsStrategy regelt, wie mehrere matchStrings zusammenspielen: any (Default, jeder Regex liefert eigene Abhängigkeiten), recursive (jeder Regex sucht im Treffer des vorigen weiter) und combination (alle Treffer werden zu einer Abhängigkeit zusammengelegt).

cp renovate.json ../base.json
for s in any combination; do
  jq --arg s "$s" '.customManagers += [{
    "customType": "regex",
    "description": "Test-Datenbank in deploy.env",
    "managerFilePatterns": ["deploy.env"],
    "matchStringsStrategy": $s,
    "matchStrings": ["DB_IMAGE=(?<depName>\\S+)", "DB_TAG=(?<currentValue>\\S+)"],
    "datasourceTemplate": "docker"
  }]' ../base.json > renovate.json
  renovate --platform=local --dry-run=lookup --report-type=file \
    --report-path=../local.json > ../local.log 2>&1
  echo "$s: $(vals ../local.json | grep deploy.env || echo 'nichts gefunden')"
done

Erwartet:

any: nichts gefunden
combination: deploy.env  postgres                   15.4     15.19,18.6

Mit any liefert jeder Regex nur eine halbe Abhängigkeit, Renovate verwirft beide still. combination passt nur, wenn es pro Datei genau eine Abhängigkeit gibt. recursive brauchst du für verschachtelte Blöcke, etwa „finde den Abschnitt db: und darin tag:“.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Eine eigene Datasource

Das hauseigene shop-cli steht in keiner öffentlichen Registry. Das Release-Team pflegt eine JSON-Datei im Repo shop/releases. Renovate liest sie über customDatasources.

~/renovate-lab/setup/mkrepo.sh shop/releases ~/renovate-lab/code/tag07/releases
U="$FORGEJO/api/v1/repos/shop/releases/raw/shop-cli.json"
until curl -sf "$U" > /dev/null; do sleep 1; done   # Forgejo braucht einen Moment
curl -s "$U" | jq -c .versions

Erwartet:

✔ shop/releases angelegt (http://127.0.0.1:3000/shop/releases)
["1.2.0","1.3.0","1.4.1","2.0.0-rc.1"]

Renovate erwartet {"releases": [{"version": "…"}, …]}. Passt die Quelle nicht, formt transformTemplates (JSONata) sie um. Der Name hinter custom. verbindet Datasource und Abhängigkeit.

d='# renovate: datasource=custom.shop-cli depName=shop-cli'
perl -pi -e "s|^(RUN apk)|$d\nARG SHOP_CLI_VERSION=1.2.0\n\n\$1|" Dockerfile
jq --arg u "$U" '.customDatasources = {"shop-cli": {
  "defaultRegistryUrlTemplate": $u,
  "transformTemplates": ["{ \"releases\": [versions.{ \"version\": $ }] }"]
}}' renovate.json > tmp.json && mv tmp.json renovate.json
renovate-config-validator > /dev/null && echo "✔ Config gültig"
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../local.json > ../local.log 2>&1
vals ../local.json | grep shop-cli
grep -o 'WARN: HTTP request to an internal host[^,]*' ../local.log | head -1

Erwartet:

✔ Config gültig
Dockerfile  shop-cli                   1.2.0    1.4.1
WARN: HTTP request to an internal host

2.0.0-rc.1 ist eine Vorabversion und zählt nicht. Die Warnung ist neu in Renovate 44: Anfragen an Loopback- und private Adressen protokolliert Renovate (globale Option internalHostAccess, Default warn, später block). Erlaubt sind ohne Weiteres nur Anfragen an die Plattform selbst, also gleiches Schema, gleicher Host, gleicher Port wie RENOVATE_ENDPOINT. --platform=local hat keinen Endpoint, darum die Warnung. Im echten Lauf ist sie weg:

git add -A && git commit -qm "Eigene Abhängigkeiten erfassen" && git push -q
LOG_LEVEL=debug renovate --dry-run=lookup shop/shop-tools 2>&1 \
  | grep -E "Internal host|internal host|no authentication for" | sort -u | cut -c1-80

Erwartet:

 INFO: Internal host 127.0.0.1 permitted by configuration
 INFO: Internal host 127.0.0.1 permitted by configuration (repository=shop/shop-
DEBUG: hostRules: no authentication for 127.0.0.1:3000 (repository=shop/shop-too

Die Zeile „no authentication” zeigt: Renovate schickt den Bot-Token nicht mit. Das geht hier gut, weil shop/releases öffentlich ist. Für eine private Quelle brauchst du einen hostRules-Eintrag (Tag 8).

Fortschritt speichern? Kostenlos registrieren

Drill 8: Echter Lauf und Fehlersuche

Jetzt mit PRs. --pr-hourly-limit=0 hebt das Stundenlimit für diesen Lauf auf.

cd ~/renovate-lab/tag07
renovate --pr-hourly-limit=0 shop/shop-tools > run.log 2>&1
R="$FORGEJO/api/v1/repos/shop/shop-tools"
curl -s -u "$ADMIN" "$R/pulls?state=open&limit=50" \
  | jq -r '.[] | "#\(.number) \(.title)"'
for t in helm/helm kustomize yq shop-cli; do
  n=$(curl -s -u "$ADMIN" "$R/pulls?state=open&limit=50" | jq --arg t "$t" \
    '[.[] | select(.title | contains($t))][0].number')
  curl -s -u "$ADMIN" "$R/pulls/$n.diff" | grep -E '^[-+][^-+]'
done

Erwartet:

#10 Update dependency terraform to v1.16.5
#9 Update dependency shop-cli to v1.4.1
#8 Update dependency mikefarah/yq to v4.54.1
#7 Update dependency kubernetes/kubernetes to v1.37.1
#6 Update dependency kubernetes-sigs/kustomize to v5.8.3
#5 Update dependency koalaman/shellcheck to v0.11.0
#4 Update dependency helm/helm to v3.22.0
#3 Update dependency golangci/golangci-lint to v1.64.8
#2 Update dependency golang to v1.27.2
#1 Update alpine Docker tag to v3.24.2
-HELM_VERSION ?= 3.14.0
+HELM_VERSION ?= 3.22.0
-ARG KUSTOMIZE_VERSION=5.3.0
+ARG KUSTOMIZE_VERSION=5.8.3
-    version: v4.40.5
+    version: v4.54.1
-ARG SHOP_CLI_VERSION=1.2.0
+ARG SHOP_CLI_VERSION=1.4.1

Zehn PRs, dann ist Schluss: prConcurrentLimit steht per Default auf 10, der Rest (postgres, die Majors von Helm und golangci-lint) wartet im Dependency Dashboard unter „Rate-Limited”. Jeder Diff ändert genau den Wert, Kommentare bleiben stehen.

Und wenn ein Eintrag nicht erkannt wird? Ein typischer Fehler ist eine Leerzeile zwischen Kommentar und Variable. Die INFO-Meldung „Dependency extraction complete” zählt pro Manager, was gefunden wurde:

cd shop-tools && git pull -q
c='# renovate: datasource=github-releases depName='
h='ARG HELMFILE_VERSION=0.160.0'
perl -pi -e "s|^(RUN apk)|${c}helmfile/helmfile\n\n$h\n\n\$1|" Dockerfile
stats() { renovate --platform=local --dry-run=extract 2>&1 \
  | grep -A8 '"stats"' | grep -E '"regex"'; }
stats
perl -0pi -e 's|(depName=helmfile/helmfile)\n\n|$1\n|' Dockerfile
stats

Erwartet:

           "regex": {"fileCount": 3, "depCount": 6},
           "regex": {"fileCount": 3, "depCount": 7},

Der Preset-Regex erlaubt zwischen Kommentar und ARG genau ein Whitespace-Zeichen. Bei Problemen gehst du so vor:

  • Erkennt Renovate die Datei? LOG_LEVEL=debug zeigt „Using file pattern … for manager regex” und „Matched N file(s) for manager regex”.
  • Erkennt es die Abhängigkeit? depCount oder der Report von --dry-run=extract. Ein Regex, der nicht passt, erzeugt keine Fehlermeldung, nur weniger Treffer.
  • Stimmt der Lookup? --dry-run=lookup und im Debug-Log der Block „packageFiles with updates” mit currentVersion, updates und warnings je Abhängigkeit.
git checkout -q Dockerfile

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/renovate-lab/tag07
R="$FORGEJO/api/v1/repos/shop"
CFG=$(curl -sf -u "$ADMIN" "$R/shop-tools/raw/renovate.json")
jq -e '.extends | index("customManagers:dockerfileVersions")' <<<"$CFG" >/dev/null \
  && echo "✔ Preset dockerfileVersions aktiv" || echo "✘ Preset fehlt"
jq -e '.customManagers[] | select(.customType == "jsonata")' <<<"$CFG" >/dev/null \
  && echo "✔ JSONata-Manager für tools.yaml" || echo "✘ JSONata-Manager fehlt"
jq -e '.customDatasources["shop-cli"]' <<<"$CFG" >/dev/null \
  && echo "✔ customDatasource shop-cli" || echo "✘ customDatasource fehlt"
n=$(curl -sf -u "$ADMIN" "$R/shop-tools/pulls?state=open&limit=50" \
  | jq '[.[] | select(.title | test("kustomize|shop-cli|yq|postgres"))] | length')
[ "$n" -ge 3 ] && echo "✔ $n PRs aus eigenen Managern" || echo "✘ nur $n PRs"

Erwartet:

✔ Preset dockerfileVersions aktiv
✔ JSONata-Manager für tools.yaml
✔ customDatasource shop-cli
✔ 3 PRs aus eigenen Managern

Challenge

Das Security-Team scannt mit Trivy in GitLab CI. Die Version steht in .gitlab-ci.yml als TRIVY_VERSION: "0.48.0" unter variables:. Sorge dafür, dass Renovate sie aktualisiert, ohne einen eigenen Regex zu schreiben. Die Datei liegt im Begleitcode unter challenge/.

Hinweis: Schau dir die Liste der Presets aus Drill 3 noch einmal genau an.

Lösung

Datei übernehmen (für --platform=local per git add vormerken), Kommentar ergänzen und das Preset customManagers:gitlabPipelineVersions einbinden. In YAML darf der Kommentar eingerückt sein, der Regex erlaubt beliebigen Whitespace vor dem Variablennamen.

cd ~/renovate-lab/tag07/shop-tools
cp ~/renovate-lab/code/tag07/challenge/.gitlab-ci.yml . && git add .gitlab-ci.yml
c='# renovate: datasource=github-releases depName='
perl -pi -e "s|^(  TRIVY_VERSION)|  ${c}aquasecurity/trivy\n\$1|" .gitlab-ci.yml
sed -n 1,3p .gitlab-ci.yml
jq '.extends += ["customManagers:gitlabPipelineVersions"]' renovate.json > tmp.json \
  && mv tmp.json renovate.json
renovate-config-validator > /dev/null && echo "✔ Config gültig"
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../ch.json > ../ch.log 2>&1
vals ../ch.json | grep gitlab

Erwartet:

variables:
  # renovate: datasource=github-releases depName=aquasecurity/trivy
  TRIVY_VERSION: "0.48.0"
✔ Config gültig
.gitlab-ci.yml  aquasecurity/trivy         0.48.0   v0.75.0

Gefunden, aber Vorsicht: v0.75.0 mit v. Bei Helm (Drill 3) blieb das Format erhalten, weil Renovate 3.14.0 dem Release v3.14.0 zuordnen konnte. Das Release v0.48.0 gibt es bei Trivy nicht (mehr), die GitHub-API antwortet mit 404 auf repos/aquasecurity/trivy/releases/tags/v0.48.0. Ohne Bezugspunkt übernimmt Renovate den Tag wörtlich, und aus v${TRIVY_VERSION} in der Download-URL würde vv0.75.0. extractVersion macht das robust:

export ev='extractVersion=^v(?<version>.*)$'
perl -pi -e 's|(depName=aquasecurity/trivy)$|$1 $ENV{ev}|' .gitlab-ci.yml
grep -o 'depName=.*' .gitlab-ci.yml
renovate --platform=local --dry-run=lookup --report-type=file \
  --report-path=../ch.json > ../ch.log 2>&1
vals ../ch.json | grep gitlab
git add -A && git commit -qm "Trivy-Version erfassen" && git push -q

Erwartet:

depName=aquasecurity/trivy extractVersion=^v(?<version>.*)$
.gitlab-ci.yml  aquasecurity/trivy         0.48.0   0.75.0

Im nächsten echten Lauf ändert der PR genau "0.48.0" in "0.75.0", die Anführungszeichen stehen außerhalb von currentValue. Das Preset greift auf **/*.gitlab-ci.{yml,yaml} und damit auch auf die .gitlab-ci.yml im Wurzelverzeichnis. Setz extractVersion am besten immer, wenn Tags ein Präfix haben und dein Wert keins.

Den Endstand aller geänderten Dateien findest du unter ~/renovate-lab/code/tag07/loesung/.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Lege die Kommentarkonvention im Org-Preset fest (Tag 11): die passenden customManagers:*Versions-Presets plus eigene Manager für hausinterne Formate. Teams schreiben dann nur noch Kommentare, keine Regexe.
  • Bevorzuge eingebaute Manager (asdf, mise, gitlabci, terraform) vor Custom Managern. Sie kennen Sonderfälle wie Präfixe und Lockfiles.
  • Für hauseigene Werkzeuge ist customDatasources der saubere Weg. Liegt die Quelle intern, plane hostRules mit Token und allowInternal für internalHostAccess=block ein.
  • Betreibe Renovate nie ohne GitHub-Token (RENOVATE_GITHUB_COM_TOKEN, ein Read-only-Token ohne Scopes reicht), sobald github-releases oder github-tags im Spiel sind.
  • Ein Custom Manager, der still nichts mehr findet, fällt niemandem auf. Prüfe depCount in den Logs (Tag 14) oder per Report im CI.