DevOps nástroje

Proč právě Jenkins, GitLab CI a Terraform

DevOps praxe propojuje vývoj, testování a provoz do automatizovaného, měřitelného a opakovatelného procesu. Jenkins a GitLab CI jsou nástroje pro Continuous Integration/Continuous Delivery (CI/CD), zatímco Terraform je standardem pro Infrastructure as Code (IaC). Společně tvoří osu moderního softwarového dodavatelského řetězce: od změny v repozitáři přes build a testy až po deterministické nasazení infrastruktury a aplikací.

Srovnání: silné a slabé stránky nástrojů

Architektura Jenkins: controllery, agenty a pluginy

• Controller orchestruje buildy, plánuje joby, spravuje frontu a napojuje pluginy (SCM, notifikace, credential store).
• Build agenty (dříve „slaves“) provádějí kroky pipeline; lze provozovat jako VM, kontejnery nebo ephemerální podů v Kubernetes.
• Pipeline as Code přes Jenkinsfile (deklarativní nebo skriptovaný styl) – verzování v repozitáři, recenze přes MR/PR.
• Bezpečnost: minimální množství pluginů, pravidelné aktualizace LTS, Credentials Binding, oddělené identity pro SCM a registry.

GitLab CI: runners, executory a YAML pipeline

• GitLab Runner je exekuční agent; režimy shell, Docker, Kubernetes, custom. Sdílené vs. specifické runnery.
• .gitlab-ci.yml definuje fáze (stages) a joby s rules, needs, artifacts, cache, environment a manual gates.
• Integrovaný ekosystém: MR pipeline, code quality, SAST/DAST, dependency scanning, release evidence, container registry.
• Multi-project pipelines a child/parent pipeline pro rozpad monolitů na doménové celky.

Terraform: moduly, providery, state a workspaces

• Moduly: znovupoužitelné balíčky zdrojů s proměnnými a výstupy; vytvářejte „platformové“ moduly (síť, databáze, observabilita).
• State: zdroj pravdy pro existující prostředky; ukládat do vzdáleného backendu (S3/GCS + zamykání DynamoDB/Cloud SQL) s verzováním.
• Workspaces: separace stavů pro prostředí (dev/stage/prod); alternativou jsou samostatné adresáře/repa.
• Policy-as-Code: OPA/Rego nebo Sentinel pro zásady (např. zákaz veřejných S3, limity velikosti instancí).

Vzorový CI/CD tok: build → test → security → image → infra → deploy

1. Build a test: kompilace/instalace závislostí, unit/integration testy, generování artefaktů.
2. Security gates: SAST, dependency audit, container image scan – pipeline padá při nalezení kritických CVE.
3. Image: build Docker image s multi-stage, tagování app:commit-sha + app:semver, push do registry.
4. Infra: Terraform plan (review, schválení), následně apply s uzamčeným state a auditním logem.
5. Deploy: rollout na cílové prostředí (Kubernetes/VM), smoke a health-checks, případně canary/blue-green.

Jenkinsfile: doporučené konstrukce

• Declarative pipeline s bloky agent, options, environment, stages, post – čitelnější a bezpečnější než skriptovaný styl.
• Shared Libraries pro společné kroky (lint/test/build/publish), centralizace do jednoho repozitáře.
• Parallel pro testovací matice, when a post pro podmínky a notifikace.
• Credential binding a withDockerRegistry pro práci s registry bez ukládání tajemství v kódu.

GitLab CI YAML: patterns a anti-patterns

• Rules místo only/except, needs pro DAG a rychlejší start downstream jobů.
• Include pro import sdílených šablon, extends pro DRY a deduplikaci.
• Artifacts a cache: artefakty pro předání binárek/reportů, cache pro závislosti (s klíčem podle hashe lockfile).
• Environment & deployment: mapování jobů na prostředí, stop/review apps, manual brány pro produkci.

Terraform v CI: bezpečný life-cycle

• Init s definovaným backendem a poskytovateli verze-locknutými v required_providers a required_version.
• Validate → fmt → tflint: rychlé statické kontroly před plan.
• Plan jako artefakt ke schválení (MR/MR comment), Apply pouze na chráněných branchech s approval a lock.
• State management: povinné uzamykání a šifrování, rotace přístupů, oddělené identity pro prostředí.

Škálování a spolehlivost: orchestrace agentů a runnerů

• Kubernetes: ephemerální build pod pro každý job (Jenkins Kubernetes plugin / GitLab Kubernetes executor) – izolace, čistota prostředí, autoscaling.
• Auto-scaling runnerů: horizontální škálování podle fronty jobů, limity paralelismu pro ochranu závislých služeb (DB, registry).
• Build cache: per-branch cache, sdílené registry pro základní image, lokální mirror závislostí (Composer/NPM/PyPI) pro stabilitu.

Bezpečnost a compliance v DevOps

• Least privilege: oddělené identity pro CI, registry, cloud; krátkodobé tokeny a OIDC federace místo statických klíčů.
• Secret management: integrované trezory (HashiCorp Vault, cloud KMS/Secrets), nikdy neukládat tajemství v repo ani v artefaktech.
• Supply-chain: podepisování artefaktů (Sigstore/Cosign), SBOM (CycloneDX/SPDX), verifikace v deploy fázi.
• Audit: auditní logy přístupů a apply operací, politika approvalů, povinné MR recenze.

GitOps a propojení s Terraformem

• Git jako zdroj pravdy: veškeré změny (aplikace, k8s manifesty, Terraform kód) přes MR s recenzí a CI kontrolami.
• Argo CD/Flux pro deklarativní synchronizaci aplikací; Terraform spravuje základní zdroje, GitOps vrstvu pro aplikační manifesty.
• Oddělení domén: repo platform-infra, repo app-infra a repo apps – jasné hranice odpovědností a oprávnění.

Měření a observabilita CI/CD

• DORA metriky: frekvence nasazení, lead time pro změnu, MTTR, míra chyb nasazení.
• Pipeline metriky: p50/p95 doba jobů, úspěšnost, flakiness testů, velikost artefaktů, vytížení runnerů.
• Tracing: OpenTelemetry v build stepch pro korelaci s runtime metrikami aplikací.

Kvalita a testování v pipeline

• Shift-left: lintery, statická analýza, unit testy dříve než build image.
• Contract testing a e2e smoke na dočasném prostředí (Review Apps) před nasazením.
• Perf testy (k6/JMeter) jako gate pro kritické služby, s baseline a automatickým porovnáním.

Náklady a efektivita

• Ephemerální běhy v Kubernetes/spot instancích s limity CPU/RAM a cost allocation tagy.
• Cache a registry: minimalizace přenosů, vrstvení image, sdílené základní image per tým/stack.
• Paralelizace vs. saturace: nastavte stropy tak, aby neovlivnily externí služby (rate-limit API, databáze).

Časté anti-patterny a jak se jim vyhnout

• Monolitický Jenkins s desítkami pluginů: udržujte minimum pluginů, oddělte controllery, používejte Shared Libraries.
• Globální sdílené účty: vždy individuální identity a audit; rotace klíčů, krátká TTL tokenů.
• Terraform bez remote state/locku: riziko kolize a ztráty konzistence; vždy remote backend a zamykání.
• Manuální zásahy do infrastruktury: vznik drifů; pravidelné terraform plan v cron pipeline, drift detekce.
• Flaky testy: odstraňte z pipeline nebo stabilizujte; jiné je flake než legitimní selhání.

Migrační strategie: z ad-hoc skriptů k DevOps platformě

1. Inventarizace buildů, skriptů a prostředí; mapování tajemství a přístupů.
2. Pilotní repo s čistým CI a Terraform modulem; definice standardů (lint, test, scan).
3. Šablony (.gitlab-ci.yml / Jenkins Shared Lib / Terraform module) publikujte jako produkt pro týmy.
4. Postupný onboarding aplikací, měření DORA metrik a nákladů, vyhodnocení.

Best practices v kostce

• Pipeline as Code a Infrastructure as Code všude; vše verzovat, recenzovat a auditovat.
• Ephemerální exekuce jobů a reproducibilní prostředí (pinované image, lockfile závislostí).
• Bezpečnost: OIDC federace CI → cloud, minimální role, trezor tajemství, zásady jako kód.
• Měřit a zlepšovat: DORA, p95 doby buildů, flake rate, MTTR; automatizované reporty do týmových dashboardů.
• Modularita: Terraform moduly, sdílené pipeline kroky, opakovatelné šablony pro projekty.

Závěr

Kombinace Jenkins/GitLab CI a Terraform umožňuje vybudovat robustní, bezpečný a škálovatelný DevOps řetězec. Jenkins se hodí pro vysoce přizpůsobené scénáře a heterogenní integrace, GitLab CI exceluje v jednoduchosti a integraci s verzováním a code review, Terraform přináší deterministickou správu infrastruktury. Klíčem k úspěchu je disciplína v návrhu pipeline, bezpečnosti a správě stavu, důsledné měření a standardizace formou šablon a modulů.