🟡 Intermediate

Renovate a Dependabot — automatizovaná správa závislostí

Závislosť, ktorú ste nainštalovali pred rokom, je dnes bezpečnostné riziko. Nie preto, že by ste urobili chybu — ale preto, že ekosystém sa nezastavil. Každý mesiac pribúdajú nové CVE, breaking changes a opravy. Manuálny npm update raz za kvartál nestačí. Potrebujete systém, ktorý za vás sleduje závislosti, otvára PRy a integruje sa s vašimi CI testami.

Dnes existujú dva nástroje, ktoré sa stali de-facto štandardom: Renovate (open-source, Mend) a Dependabot (GitHub-native). Oba riešia rovnaký problém, ale odlišným spôsobom — a rozhodnutie medzi nimi závisí od vašej infraštruktúry, ekosystému a tolerancie ku konfigurácii.

Problém — prečo manuálne npm update nestačí

Supply chain riziká

Softvérový supply chain útok nie je teória. Log4Shell (CVE-2021-44228) zasiahol tisíce aplikácií, pretože mali v tranzitívnych závislostiach starú verziu log4j-core. Útočníci to vedeli. Organizácie, ktoré mali aktuálne závislosti a aktívne scannovanie, opravili problém za hodiny. Ostatní za týždne.

Tranzitívne závislosti sú najväčší problém. Vaša package.json môže mať 40 priamych závislostí, ale celkový strom môže obsahovať 800+ balíkov. Každý z nich je potenciálny vektor útoku. Manuálne sledovanie je ilúzia.

CVE reakcia

CVSS skóre 9.8 (Critical) znamená, že máte hodiny, nie týždne. Bez automatizácie sa na vás vulnerability alert dostane buď cez GitHub Security Advisories (ak to niekto číta), alebo — v horšom prípade — cez incidentové hlásenie od zákazníka.

Automatizovaný systém otvorí PR do 24 hodín od publikácie CVE v OSV databáze. Váš CI pipeline overí, že fix nebreakuje nič. Vy mergujete.

Drift a tech debt

Aktualizácie, ktoré odkladáte mesiac, sa stávajú aktualizáciami s breaking changes. Skočiť z react@17 na react@18 po roku nečinnosti je migration project — nie PR. Malé pravidelné aktualizácie sú podstatne lacnejšie ako veľké catch-up projekty.

Cena aktualizácie (zjednodušené):
┌───────────────────────────────────────────────────────┐
│  Patch update (1.2.3 → 1.2.4):   5 minút              │
│  Minor update (1.2.x → 1.3.0):   30 minút             │
│  Major update (1.x → 2.0):       2–8 hodín            │
│  Major update po 2 rokoch drift:  2–4 dni + testy      │
└───────────────────────────────────────────────────────┘

Záver: automatizovaná správa závislostí nie je komfort — je to bezpečnostná požiadavka a technický dlh prevencia.

Renovate — open-source riešenie od Mend

Renovate (pôvodne od Renovatebot, teraz pod Mend — predtým WhiteSource) je open-source nástroj pre automatizovanú správu závislostí. Je dostupný ako:

  • GitHub App (github.com/apps/renovate) — najjednoduchšia inštalácia pre GitHub.
  • GitLab App — integrovaný do GitLab marketplace.
  • Bitbucket Cloud — vlastná integrácia.
  • Self-hosted — vlastný runner (cron alebo CI pipeline), plná kontrola.
  • Mend-hosted — SaaS verzia s rozšírenou podporou pre enterprise.

Renovate podporuje viac ako 90 package managerov — od npm, pip, maven, cargo, cez Docker images a Kubernetes Helm charty, až po GitHub Actions verzie a Terraform moduly. Toto je jeho najväčšia silná stránka oproti Dependabotu.

Konfigurácia Renovate je deklaratívna — renovate.json alebo .renovaterc.json v root repozitára. Preset systém umožňuje zdieľať konfiguráciu naprieč repozitármi organizácie cez tzv. shareable configs.

Dependabot — GitHub-native riešenie

Dependabot bol akvírovaný GitHubom v roku 2019 (pôvodne startup z Londýna). Dnes je hlboko integrovaný do GitHub platformy — nielen ako nástroj pre version updates, ale aj ako súčasť GitHub Security Advisories systému.

Dependabot je zadarmo pre všetky GitHub repozitáre vrátane public. Pre private repozitáre v GitHub Free tier funguje s limitmi.

Typy Dependabot funkcií:

  • Version updates — pravidelné PR pre nové verzie balíkov (konfigurácia v .github/dependabot.yml).
  • Security updates — automatické PR pri detectovaní CVE vo vašich závislostiach, nezávisle od version updates schedule.
  • Dependabot alerts — notifikácie (bez PR) pri vulnerabilitách.

Dependabot je jednoduchší na nastavenie, ale má menej konfiguračných možností. Pre GitHub-only tímy je to prirodzená voľba. Pre multi-platform organizácie alebo komplexné monorepo scenáre naráža na limity.

Porovnanie funkcií

Funkcia Renovate Dependabot
Package managers 90+ (npm, pip, cargo, maven, Go, Docker, Helm, TF...) ~20 hlavných ekosystémov
Git platformy GitHub, GitLab, Bitbucket, Gitea, Azure DevOps Len GitHub
Monorepo podpora ✅ Natívna (matchFileNames, packageRules) ⚠️ Viacero package-ecosystem blokov
Group rules ✅ Silná, flexibilná ⚠️ Základná (pridané 2023)
Auto-merge ✅ Konfigurovateľné (patch, minor, dev deps) ✅ Konfigurovateľné
Rebase stratégia rebaseWhen: conflicted/behind-base/never Automatický rebase
Vulnerability updates ✅ vulnerabilityAlerts blok + OSV ✅ Natívna integrácia (Security Advisories)
Dashboard ✅ Dependency Dashboard issue ❌ Len PR list
Shareable config ✅ Presets a extends ❌
Self-hosted ✅ Plná podpora ❌ (iba GitHub Actions, nie vlastný runner)
Config formát JSON/JSONC/JSON5, JavaScript YAML
Schedule Cron-like, timezone-aware Denný/týždenný/mesačný
Cena Open-source (self-hosted zadarmo) Zadarmo pre GitHub
PR limit per run Konfigurovateľný Max 5 open PRs (default)

Inštalácia Renovate

GitHub App (najrýchlejší štart)

  1. Prejdite na github.com/apps/renovate.
  2. Kliknite Install a zvoľte repozitáre (alebo všetky v organizácii).
  3. Renovate otvorí onboarding PR s renovate.json — review a merge.
  4. Hotovo. Renovate beží na Mend infraštruktúre.

Nevýhody GitHub App (Mend-hosted):

  • Kód prechádza Mend servermi (relevanté pre regulated industries).
  • Menej kontroly nad schedulingom.
  • Enterprise features sú platené.

Self-hosted na GitHub Actions

Pre organizácie, ktoré chcú plnú kontrolu — vlastný runner, žiadne externé závislosti:

# .github/workflows/renovate.yml
name: Renovate

on:
  schedule:
    # Spúšťaj každú noc o 3:00 UTC
    - cron: "0 3 * * *"
  workflow_dispatch:
    # Umožni manuálne spustenie

jobs:
  renovate:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Self-hosted Renovate
        uses: renovatebot/github-action@v41
        with:
          # Renovate konfiguracia je v renovate.json v repozitari
          configurationFile: renovate.json
        env:
          # PAT alebo GitHub App token s prístupom na vytváranie PRs
          RENOVATE_TOKEN: ${{ secrets.RENOVATE_TOKEN }}
          # Voliteľné: log level
          LOG_LEVEL: info

Pre organizačný level — jeden workflow, viacero repozitárov:

# .github/workflows/renovate-org.yml
name: Renovate (org-wide)

on:
  schedule:
    - cron: "0 3 * * 1-5"  # len pracovné dni
  workflow_dispatch:

jobs:
  renovate:
    runs-on: ubuntu-latest
    steps:
      - name: Self-hosted Renovate
        uses: renovatebot/github-action@v41
        env:
          RENOVATE_TOKEN: ${{ secrets.RENOVATE_GH_TOKEN }}
          # Renovate autodiscover — nájde všetky repozitáre, kde je nainštalovaný
          RENOVATE_AUTODISCOVER: "true"
          RENOVATE_AUTODISCOVER_FILTER: "my-org/*"
          # Organizačná konfigurácia (override pre každý repo)
          RENOVATE_CONFIG_FILE: org-renovate-config.json
          LOG_LEVEL: warn

Konfigurácia Renovate — renovate.json

Presets — zdieľaná konfigurácia

Renovate má systém presets — predpripravené konfiguračné bloky, ktoré môžete extendsovať:

  • config:recommended — štandardný set pravidiel (odporúčané pre začiatok).
  • config:best-practices — prísnejšia verzia s viacerými bezpečnostnými pravidlami.
  • :automergeMinor — auto-merge minor updates ak CI prejde.
  • :separatePatchReleases — separátne PR pre patch vs minor.
  • group:monorepos — grupuje príbuzné balíky z monorepos.
  • security:openssf-scorecard — OpenSSF Scorecard integrácia.

Jednoduchý štart

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:recommended"
  ]
}

To je doslov všetko, čo potrebujete pre základnú funkčnosť. Renovate pridá renovate.json cez onboarding PR a začne otvárať PRy.

Pokročilá konfigurácia — monorepo + groups + schedule + auto-merge

Nasledujúci príklad je pre Node.js monorepo s viacerými appkami a Docker images:

{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:recommended",
    "group:monorepos",
    ":separatePatchReleases",
    ":ignoreModulesAndTests"
  ],

  "schedule": ["after 3am and before 6am on Monday"],
  "timezone": "Europe/Bratislava",

  "labels": ["dependencies", "renovate"],
  "reviewers": ["team:platform"],
  "assignees": ["platform-bot"],

  "prConcurrentLimit": 10,
  "prHourlyLimit": 4,
  "branchConcurrentLimit": 20,

  "rebaseWhen": "conflicted",

  "packageRules": [
    {
      "description": "Auto-merge patch updates pre všetky dev závislosti",
      "matchDepTypes": ["devDependencies"],
      "matchUpdateTypes": ["patch"],
      "automerge": true,
      "automergeType": "pr",
      "automergeStrategy": "squash"
    },
    {
      "description": "Auto-merge patch updates trusted scopes (len ak CI prejde)",
      "matchPackageNames": ["typescript", "eslint", "prettier"],
      "matchUpdateTypes": ["patch"],
      "automerge": true
    },
    {
      "description": "Grupuj všetky @aws-sdk/* do jedného PR",
      "matchPackageNames": ["^@aws-sdk/"],
      "groupName": "AWS SDK",
      "groupSlug": "aws-sdk",
      "matchUpdateTypes": ["major", "minor", "patch"]
    },
    {
      "description": "Grupuj @types/* do jedného PR (nízka priorita)",
      "matchPackageNames": ["^@types/"],
      "groupName": "TypeScript type definitions",
      "schedule": ["after 3am and before 6am on Sunday"],
      "automerge": true
    },
    {
      "description": "Frontend app — monorepo path filter",
      "matchFileNames": ["apps/frontend/**"],
      "addLabels": ["app:frontend"],
      "reviewers": ["team:frontend"]
    },
    {
      "description": "Backend API — monorepo path filter",
      "matchFileNames": ["apps/api/**"],
      "addLabels": ["app:api"],
      "reviewers": ["team:backend"]
    },
    {
      "description": "Docker base images — weekly, no automerge",
      "matchManagers": ["dockerfile"],
      "schedule": ["after 3am and before 6am on Sunday"],
      "automerge": false
    },
    {
      "description": "Helm chart dependencies",
      "matchManagers": ["helmv3"],
      "groupName": "Helm charts",
      "schedule": ["after 3am and before 6am on Monday"]
    },
    {
      "description": "Major updates — nikdy auto-merge, vyžaduj 2 reviews",
      "matchUpdateTypes": ["major"],
      "automerge": false,
      "minimumReleaseAge": "7 days",
      "reviewers": ["team:platform", "team:security"],
      "labels": ["breaking-change", "dependencies"]
    },
    {
      "description": "Ignoruj beta a RC verzie v produkcii",
      "matchPackageNames": ["*"],
      "ignoreUnstable": true,
      "minimumReleaseAge": 3
    }
  ],

  "vulnerabilityAlerts": {
    "labels": ["security", "vulnerability"],
    "assignees": ["security-team"],
    "prPriority": 5,
    "schedule": "at any time"
  },

  "osvVulnerabilityAlerts": true,

  "dependencyDashboard": true,
  "dependencyDashboardTitle": "Renovate Dependency Dashboard",
  "dependencyDashboardAutoclose": true
}

Kľúčové konfiguračné kľúče

Kľúč Popis
extends Presets — zdieľaná konfigurácia
schedule Kedy otvárať PRy (cron-like, human-readable)
timezone Timezone pre schedule
prConcurrentLimit Max súbežných Renovate PRs
rebaseWhen conflicted / behind-base / never
automerge Auto-merge ak CI zelená
minimumReleaseAge Čakaj X dní pred PR (ochrana proti typosquatting)
minimumReleaseAge Čakaj X dní od publikácie verzie
matchFileNames Filtrovanie podľa cesty v monorepe
matchManagers Filtrovanie podľa package managera
groupName Zlúči viacero dep updates do jedného PR
vulnerabilityAlerts Konfigurácia pre security PRy

Dependabot — .github/dependabot.yml

Základná konfigurácia

# .github/dependabot.yml
version: 2

updates:
  # npm / Node.js
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "03:00"
      timezone: "Europe/Bratislava"
    labels:
      - "dependencies"
    reviewers:
      - "team/platform"
    open-pull-requests-limit: 10

Konfigurácia pre viacero ekosystémov + groups

# .github/dependabot.yml
version: 2

updates:
  # Frontend — root package.json
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "03:00"
      timezone: "Europe/Bratislava"
    labels:
      - "dependencies"
      - "npm"
    open-pull-requests-limit: 15
    groups:
      # Grupuj AWS SDK do jedného PR
      aws-sdk:
        patterns:
          - "@aws-sdk/*"
      # Grupuj @types/* do jedného PR
      typescript-types:
        patterns:
          - "@types/*"
      # Grupuj testing nástoje
      testing:
        patterns:
          - "jest*"
          - "@testing-library/*"
          - "vitest*"

  # Backend API — iný adresár v monorepe
  - package-ecosystem: "npm"
    directory: "/apps/api"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "03:00"
      timezone: "Europe/Bratislava"
    labels:
      - "dependencies"
      - "app:api"
    reviewers:
      - "team/backend"
    open-pull-requests-limit: 10

  # Python závislosti
  - package-ecosystem: "pip"
    directory: "/scripts"
    schedule:
      interval: "monthly"
    labels:
      - "dependencies"
      - "python"
    open-pull-requests-limit: 5

  # Docker base images
  - package-ecosystem: "docker"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "sunday"
    labels:
      - "dependencies"
      - "docker"
    open-pull-requests-limit: 3

  # GitHub Actions
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
    labels:
      - "dependencies"
      - "github-actions"
    groups:
      actions:
        patterns:
          - "*"

  # Terraform / OpenTofu
  - package-ecosystem: "terraform"
    directory: "/infra"
    schedule:
      interval: "weekly"
    labels:
      - "dependencies"
      - "terraform"
    open-pull-requests-limit: 5

Security updates — vulnerability alerting

Security updates v Dependabote fungujú automaticky — nie je potrebná žiadna konfigurácia. Dependabot sleduje GitHub Security Advisories (GHSA) a OSV databázu. Keď sa detekuje CVE vo vašich závislostiach:

  1. Dependabot otvorí PR s fixom.
  2. PR je označený ako Dependabot security update.
  3. PR je blokovaný pre merge kým CI neprejde.

Ak chcete security updates vypnúť (napríklad máte vlastný patch management proces):

# .github/dependabot.yml
version: 2

updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"

# Separátna sekcia pre security updates nie je v YAML —
# security updates sa konfigurujú cez GitHub UI:
# Settings → Security → Dependabot → Dependabot security updates

Vulnerability alert config — Renovate vs Dependabot

Renovate:

{
  "vulnerabilityAlerts": {
    "enabled": true,
    "labels": ["security", "vulnerability"],
    "assignees": ["security-team"],
    "prPriority": 5,
    "schedule": "at any time",
    "automerge": false
  },
  "osvVulnerabilityAlerts": true
}

Dependabot — konfigurácia je minimálna (väčšina je automatická):

# .github/dependabot.yml
version: 2

updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    # Security updates su vzdy zapnute nezavisle od schedule
    # Ignorovanie konkretnych CVE:
    ignore:
      # Ignoruj konkretnu verziu (napr. false positive)
      - dependency-name: "lodash"
        versions: ["4.17.20"]
      # Ignoruj patch updates pre specificky balik
      - dependency-name: "axios"
        update-types: ["version-update:semver-patch"]

Auto-merge stratégie

Auto-merge je mocná funkcia, ktorá môže znásobiť výhody automatizácie — alebo spôsobiť production incident. Pravidlo je jednoduché: auto-merge funguje len vtedy, keď máte dostatočné testové pokrytie.

Kedy auto-merge zapnúť

Bezpečné pre auto-merge:
✅ Patch updates (1.2.3 → 1.2.4) — bugfixy, žiadne API zmeny
✅ Dev závislosti (devDependencies) — nepôjdu do produkcie
✅ @types/* — len TypeScript typy, žiadny runtime kód
✅ GitHub Actions — len CI zlepšenia
✅ Dôveryhodné balíky s históriou (typescript, eslint, prettier)

Nebezpečné bez robustného test suite:
❌ Minor updates s potenciálnymi behavior changes
❌ Major updates — breaking changes
❌ Runtime production dependencies (express, fastapi, Django)
❌ Security updates (paradoxne — vyžadujú ľudský review)
❌ Docker base images — zmeny v OS vrstvách

Podmienky pre bezpečný auto-merge

  1. CI pipeline musí byť povinný — branch protection rules s required status checks.
  2. Testy musia pokrývať kritické cesty — nielen unit testy, ale aj integration testy.
  3. Monitoring po merge — alerting na anomálie v produkcii.
  4. Rýchla rollback schopnosť — ak auto-merge rozbije produkciu, musíte vedieť rollbacknúť do minút.

Renovate auto-merge konfigurácia

{
  "packageRules": [
    {
      "description": "Auto-merge patch updates pre dev deps",
      "matchDepTypes": ["devDependencies"],
      "matchUpdateTypes": ["patch"],
      "automerge": true,
      "automergeType": "pr",
      "automergeStrategy": "squash",
      "platformAutomerge": true
    },
    {
      "description": "NIKDY auto-merge major updates",
      "matchUpdateTypes": ["major"],
      "automerge": false
    }
  ]
}

Dependabot auto-merge (cez GitHub Actions)

Dependabot nemá vlastný auto-merge — použite GitHub Actions:

# .github/workflows/dependabot-auto-merge.yml
name: Dependabot auto-merge

on: pull_request

permissions:
  contents: write
  pull-requests: write

jobs:
  auto-merge:
    runs-on: ubuntu-latest
    if: github.actor == 'dependabot[bot]'
    steps:
      - name: Dependabot metadata
        id: metadata
        uses: dependabot/fetch-metadata@v2
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"

      - name: Auto-merge patch updates pre dev deps
        if: |
          steps.metadata.outputs.update-type == 'version-update:semver-patch' &&
          steps.metadata.outputs.dependency-type == 'direct:development'
        run: gh pr merge --auto --squash "$PR_URL"
        env:
          PR_URL: ${{ github.event.pull_request.html_url }}
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Group rules — jeden PR pre príbuzné závislosti

PR noise je reálny problém. Bez groupovania môže Renovate alebo Dependabot otvoriť 30 PRov denne v aktívnom repozitári. Groupovanie je kľúčová funkcia pre škálovateľnosť.

Renovate — silné groupovanie

Renovate má najflexibilnejšie groupovanie — môžete kombinovať matchPackageNames, matchManagers, matchUpdateTypes a matchFileNames:

{
  "packageRules": [
    {
      "groupName": "React ekosystém",
      "matchPackageNames": ["react", "react-dom"],
      "matchPackageNames": ["^@types/react"],
      "matchUpdateTypes": ["major", "minor", "patch"]
    },
    {
      "groupName": "Linting a formátovanie",
      "matchPackageNames": [
        "eslint",
        "prettier",
        "@typescript-eslint/eslint-plugin",
        "@typescript-eslint/parser"
      ],
      "matchPackageNames": ["^eslint-"],
      "automerge": true,
      "automergeType": "pr"
    },
    {
      "groupName": "OpenTelemetry",
      "matchPackageNames": ["^@opentelemetry/"],
      "groupSlug": "opentelemetry"
    },
    {
      "groupName": "Infrastructure (Terraform providers)",
      "matchManagers": ["terraform"],
      "matchUpdateTypes": ["minor", "patch"]
    }
  ]
}

Dependabot — groupovanie (od 2023)

Dependabot pridal skupiny v roku 2023. Je jednoduchší, ale menej flexibilný:

updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    groups:
      react-ecosystem:
        patterns:
          - "react"
          - "react-dom"
          - "@types/react*"
      linting:
        patterns:
          - "eslint*"
          - "prettier*"
          - "@typescript-eslint/*"
        update-types:
          - "minor"
          - "patch"

Dependabot groups nepodporujú matchManagers — skupiny fungujú len v rámci jedného package-ecosystem. Pre cross-ecosystem grouping potrebujete Renovate.

Monorepo handling

Monorepa sú najkomplexnejší scenár pre dependency management. Renovate je tu výrazne silnejší.

Renovate — matchFileNames a packageRules

{
  "extends": ["config:recommended", "group:monorepos"],

  "packageRules": [
    {
      "description": "Frontend app — React, Vite, CSS",
      "matchFileNames": ["apps/frontend/**", "packages/ui/**"],
      "addLabels": ["app:frontend"],
      "reviewers": ["team:frontend"],
      "schedule": ["after 3am and before 6am on Monday"]
    },
    {
      "description": "API server — Express, Prisma, DB drivers",
      "matchFileNames": ["apps/api/**", "packages/db/**"],
      "addLabels": ["app:api"],
      "reviewers": ["team:backend"]
    },
    {
      "description": "Shared utilities — strict semver, no automerge",
      "matchFileNames": ["packages/shared/**"],
      "automerge": false,
      "reviewers": ["team:platform", "team:frontend", "team:backend"]
    },
    {
      "description": "Infrastructure kód — Terraform, Helm",
      "matchFileNames": ["infra/**", "k8s/**"],
      "matchManagers": ["terraform", "helmv3"],
      "addLabels": ["infrastructure"],
      "schedule": ["after 3am and before 6am on Sunday"]
    }
  ],

  "ignorePaths": [
    "**/node_modules/**",
    "**/dist/**",
    "**/.next/**"
  ]
}

Renovate automaticky detekuje package.json v každom adresári monorepa a vie ich individuálne konfigurovať. Jedna renovate.json v root riadi celý monorepo.

Dependabot — viacero package-ecosystem blokov

Dependabot vyžaduje explicitný záznam pre každý adresár:

version: 2

updates:
  - package-ecosystem: "npm"
    directory: "/apps/frontend"
    schedule:
      interval: "weekly"
    labels: ["app:frontend"]

  - package-ecosystem: "npm"
    directory: "/apps/api"
    schedule:
      interval: "weekly"
    labels: ["app:api"]

  - package-ecosystem: "npm"
    directory: "/packages/shared"
    schedule:
      interval: "weekly"
    labels: ["shared"]

  - package-ecosystem: "npm"
    directory: "/packages/ui"
    schedule:
      interval: "weekly"
    labels: ["ui"]

Nevýhoda: každý nový package.json musíte manuálne pridať do dependabot.yml. Renovate ho nájde automaticky.

Security vulnerability handling

OSV a GitHub Security Advisories

Oba nástroje sú integrované s:

  • OSV (Open Source Vulnerabilities) — databáza od Google, aggreguje CVE, GHSA, PyPI, npm advisories.
  • GitHub Security Advisories (GHSA) — GitHub vlastná databáza, rozšírená o community reports.
  • NVD (National Vulnerability Database) — americá NIST databáza.

Dependabot má hlbšiu integráciu s GHSA (GitHub vlastní oba). Renovate má osvVulnerabilityAlerts: true pre OSV integráciu.

Renovate — vulnerabilityAlerts

{
  "vulnerabilityAlerts": {
    "enabled": true,
    "labels": ["security", "vulnerability", "urgent"],
    "assignees": ["security-lead"],
    "reviewers": ["team:security"],
    "prPriority": 10,
    "schedule": "at any time",
    "automerge": false,
    "minimumReleaseAge": "0 days"
  },
  "osvVulnerabilityAlerts": true,
  "transitiveRemediation": true
}

transitiveRemediation: true — Renovate sa pokúsi opraviť tranzitívne závislosti aj keď priama závislosť nevydala nový release. Toto je kľúčové pre scenáre ako Log4Shell, kde tranzitívna závislosť bola zraniteľná.

Dependabot — security updates

Dependabot security updates sú vždy aktívne a nemôžete ich vypnúť cez dependabot.yml. Konfigurácia je v:

GitHub repository → Settings → Security → Dependabot
→ Dependabot alerts: Enable
→ Dependabot security updates: Enable
→ Grouped security updates: Enable (beta)

Dependabot security updates ignorujú open-pull-requests-limit — security PRy sa vždy otvoria. Je to zámerné správanie.

Rebase stratégia

Keď sa PR zaostáva za main branchom, musí sa rebasovať. Neaktuálne PRy môžu spôsobiť merge konflikty alebo skryť regresie.

Renovate — rebaseWhen

{
  "rebaseWhen": "conflicted",
  "rebaseLabel": "rebase",
  "recreateWhen": "auto"
}

Možnosti rebaseWhen:

  • "conflicted" (default) — rebase len ak sú merge konflikty.
  • "behind-base-branch" — rebase vždy, keď je PR za main branchom.
  • "never" — nikdy automaticky nerebasuj.

"behind-base-branch" je agresívne — generuje veľa CI runov. Pre veľké repozitáre s aktívnou main branchom je "conflicted" rozumnejší výber.

Dependabot — automatický rebase

Dependabot vždy automaticky rebasuje PRy keď sú za main branchom. Toto správanie nie je konfigurovateľné — Dependabot rebasuje, keď detekuje, že PR zaostáva.

Dashboard a viditeľnosť

Renovate Dependency Dashboard

Renovate vytvára GitHub Issue s prehľadom všetkých závislostí a čakajúcich aktualizácií:

## Dependency Dashboard

This issue lists Renovate updates and detected dependencies.

### Awaiting Schedule
- [ ] Update dependency typescript to v5.5.0
- [ ] Update AWS SDK (group) to v3.620.0

### Open
- [x] Update dependency react to v18.3.0 (PR #42)

### Ignored or Blocked
- [ ] Update dependency webpack to v6 (major — manual review required)

Dashboard umožňuje:

  • Vidieť všetky čakajúce aktualizácie na jednom mieste.
  • Manuálne triggernúť PR zaškrtnutím checkboxu.
  • Ignorovať konkrétne aktualizácie pridaním <!--renovate-ignore--> komentára.
{
  "dependencyDashboard": true,
  "dependencyDashboardTitle": "🔄 Dependency Dashboard",
  "dependencyDashboardAutoclose": true,
  "dependencyDashboardApproval": false
}

dependencyDashboardApproval: true — Renovate neotvorí PR kým nezaškrtnete checkbox v dashboarde. Užitočné pre major updates.

Dependabot — PR list

Dependabot nemá ekvivalent dashboardu. Prehľad je dostupný cez:

  • github.com/[org]/[repo]/network/updates — stav Dependabot runov.
  • Pull requests tab s filtrom is:pr author:app/dependabot.
  • GitHub Security tab → Dependabot alerts.

Pre veľké organizácie je absencia dashboardu citeľná nevýhoda — musíte prechádzať každý repozitár samostatne.

Scaling — PR noise a CI load

Problém

Bez rate limiting môže Renovate alebo Dependabot otvoriť desiatky PRov denne. V organizácii s 50 repozitármi a 100 závislosťami to znamená stovky PRov týždenne. CI load sa znásobí.

Riešenia

1. Schedule — zoskupte aktualizácie do konkrétnych okien

{
  "schedule": ["after 3am and before 6am on Monday"],
  "timezone": "Europe/Bratislava"
}

Výsledok: všetky PRy prídu v pondelok ráno. Tím ich review v pondelok dopoludnia. CI load je predvídateľný.

2. PR limity

{
  "prConcurrentLimit": 5,
  "prHourlyLimit": 2,
  "branchConcurrentLimit": 10
}

3. Skupiny — menej PRov, viac zmien v jednom

{
  "packageRules": [
    {
      "groupName": "všetky minor a patch",
      "matchUpdateTypes": ["minor", "patch"],
      "automerge": true
    }
  ]
}

Riziko: jeden veľký PR je ťažší na rollback ako viacero malých. Nájdite rovnováhu.

4. minimumReleaseAge — filter čerstvých verzií

{
  "minimumReleaseAge": "3 days",
  "minimumReleaseAge": 3
}

Nové verzie balíkov sa niekedy stiahnu alebo opravia v prvých 24–72 hodinách. Čakanie 3 dni filtruje tieto "hot fix" situácie.

5. Separácia security vs version updates

{
  "vulnerabilityAlerts": {
    "schedule": "at any time"
  },
  "schedule": ["after 3am and before 6am on Monday"]
}

Security PRy prídu okamžite. Verziovacie aktualizácie prídu v naplánovanom okne.

Integrácia so Supply Chain Security

SBOM generovanie

Software Bill of Materials (SBOM) je inventár všetkých závislostí. GitHub generuje SBOM automaticky pre repozitáre s Dependabotom:

# GitHub CLI — stiahnutie SBOM pre repozitár
gh api repos/[owner]/[repo]/dependency-graph/sbom \
  --jq '.sbom' > sbom.json

Renovate nevytvára SBOM priamo, ale kombinuje sa s nástrojmi ako syft alebo trivy:

# GitHub Actions — SBOM generovanie po Renovate merge
- name: Generate SBOM
  uses: anchore/sbom-action@v0
  with:
    format: spdx-json
    output-file: sbom.spdx.json

- name: Upload SBOM as artifact
  uses: actions/upload-artifact@v4
  with:
    name: sbom
    path: sbom.spdx.json

Sigstore — podpisovanie

Sigstore umožňuje verifikovať, že PR bol mergnutý po prejdení CI a je podpísaný. Pre container images:

# GitHub Actions — podpisovanie Docker image po Renovate/Dependabot merge
- name: Sign container image
  uses: sigstore/cosign-installer@v3

- name: Sign image
  run: |
    cosign sign --yes \
      ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}@${{ steps.build.outputs.digest }}
  env:
    COSIGN_EXPERIMENTAL: 1

OpenSSF Scorecard integrácia (Renovate)

{
  "extends": [
    "config:recommended",
    "security:openssf-scorecard"
  ]
}

Renovate môže brať do úvahy OpenSSF Scorecard skóre balíkov pri rozhodovaní o auto-merge. Balíky s nízkym scorecard skóre (< 5) dostanú extra review requirement.

Rozhodovací strom — Renovate vs Dependabot

Používate len GitHub?
├── Áno
│   ├── Máte len 1-3 ekosystémy (npm, pip, Docker)?
│   │   ├── Áno → Dependabot (jednoduchší setup)
│   │   └── Nie → Renovate (viac managerov)
│   ├── Máte monorepo?
│   │   ├── Áno, jednoduché → Dependabot (viacero entries)
│   │   └── Áno, komplexné → Renovate (matchFileNames)
│   └── Potrebujete shareable config naprieč 10+ repozitármi?
│       └── Áno → Renovate (extends a presets)
└── Nie (GitLab, Bitbucket, Azure DevOps)
    └── Renovate (Dependabot = len GitHub)

Vyberte Renovate ak:

  • Máte viac ako 5 package managerov.
  • Máte komplexný monorepo s rôznymi tímami na rôznych paths.
  • Potrebujete shareable konfiguráciu naprieč organizáciou.
  • Používate GitLab, Bitbucket alebo Azure DevOps.
  • Chcete Dependency Dashboard pre prehľad.
  • Potrebujete self-hosted riešenie bez závislosti na externých službách.
  • Máte Terraform, Helm, Dockerfile a GitHub Actions v jednom repozitári.

Vyberte Dependabot ak:

  • Ste GitHub-only tím.
  • Máte jednoduchý stack (npm + Docker alebo npm + GitHub Actions).
  • Chcete zero-configuration štart.
  • Oceňujete hlbokú integráciu s GitHub Security Advisories.
  • Nepotrebujete Dependency Dashboard.
  • Malý tím, menej ako 10 repozitárov.

Môžete používať oba súčasne:

  • Dependabot pre security updates (GitHub-native, vždy aktívny).
  • Renovate pre version updates (viac flexibilný).
  • Toto je legitímna konfigurácia — mnohé organizácie ju používajú.

Anti-patterns

1. Auto-merge bez testového pokrytia

Najnebezpečnejší anti-pattern. Ak nemáte integration testy, auto-merge patch aktualizácií môže rozbil produkciu — patch verzia môže opraviť bug, ktorý ste omylom využívali (broken-by-design behavior).

{
  "WRONG": "automerge: true pre všetky updates bez CI requirements"
}

Branch protection musí vyžadovať CI pred merge — inak je automerge: true herné pole pre problémy.

2. Ignorovanie alertov

# Toto je ZLÉ — ignorujete všetky major updates natrvalo
ignore:
  - dependency-name: "*"
    update-types: ["version-update:semver-major"]

Major updates sú bolestivé, ale nevyhnutné. Ignorovanie = akumulácia technického dlhu. Lepší prístup: groupujte major updates, pridajte minimumReleaseAge: "30 days" a naplánujte pravidelný review.

3. Beh len na stable branchoch bez dev/main aktualizácií

{
  "WRONG": "baseBranches: ['release']"
}

Závislosti treba aktualizovať na main/develop branchi, nie až na release branchi. Release branch by mal byť pokojným miestom bez unexpected zmien.

4. Nepravidelné mergí — PR hromadenie

Otvárate PRy, ale ich nemergeujete. Po 2 týždňoch máte 40 otvorených Renovate PRov, každý s merge konfliktom. Riešenie: nastavte prConcurrentLimit na rozumnú hodnotu a mergujte pravidelne, alebo nastavte automerge: true pre bezpečné kategórie.

5. Chýbajúci minimumReleaseAge

Bez minimumReleaseAge môžete mergujúť verzie, ktoré boli za hodinu stiahnuté (supply chain útok, broken release). Nastavte aspoň "3 days" pre production závislosit.

6. Self-hosted Renovate bez monitoringu

Self-hosted Renovate runner, ktorý prestane fungovať, ticho prestane otvárať PRy. Nikto si to nevšimne. Monitorujte, že Renovate skutočne beží:

# Alerting — ak Dependency Dashboard issue nebol updatovaný > 7 dní
# implementujte cez GitHub Actions scheduled check
- name: Check Renovate last run
  run: |
    LAST_UPDATE=$(gh issue list \
      --label "renovate" \
      --json updatedAt \
      --jq '.[0].updatedAt')
    
    DAYS_SINCE=$(( ($(date +%s) - $(date -d "$LAST_UPDATE" +%s)) / 86400 ))
    
    if [ "$DAYS_SINCE" -gt 7 ]; then
      echo "WARNING: Renovate nebol spustený $DAYS_SINCE dní!"
      exit 1
    fi

Zhrnutie

Automatizovaná správa závislostí nie je optional — je to hygienická požiadavka pre každý produkčný projekt. Manuálne npm update raz za štvrťrok vedie k akumulácii CVE, technického dlhu a migration projektom, ktoré stoja viac ako celoročná automatizácia.

Dependabot je správna voľba pre GitHub-only tímy, ktoré chcú nulový setup. Funguje out-of-the-box, je zadarmo a hlboko integrovaný s GitHub Security.

Renovate je správna voľba pre každú organizáciu s komplexným ekosystémom — viac managerov, monorepa, GitLab/Bitbucket, shareable konfigurácia, Dependency Dashboard. Investícia do renovate.json konfigurácie sa vráti v ušetrenom čase a bezpečnejšom kóde.

Bez ohľadu na voľbu: nastavte schedule, groupujte príbuzné závislosti, auto-merge len pre overené kategórie s CI testami, a security updates nechajte vždy aktívne.

Ďalšie čítanie