Git alapok üzemeltetőknek: a git parancsok, amelyeket tényleg használsz

Sok üzemeltető akkor találkozik először a Gittel, amikor egy fejlesztő átad neki egy repót. Pedig a verziókezelés legalább annyira az üzemeltetés eszköze: ha a szerverkonfigurációk, a karbantartó szkriptek, az Ansible-playbookok és a Terraform-kód Gitben vannak, mindig látod, ki, mikor és miért változtatott, és egy rossz módosítást percek alatt visszavonsz. Ebben a cikkben a legfontosabb git parancsok következnek – az a nagyjából tizenöt, amelyet a napi munkában tényleg használunk –, és megmutatjuk, hogyan indulhat el egy kis csapat.

A Git legfrissebb verziója a július 29-én megjelent 2.46. A disztribúciók ennél régebbit szállítanak – az Ubuntu 24.04 LTS a 2.43-at, a Debian 12 a 2.39-et –, de az alábbiak mindegyikkel működnek.

Mi kerüljön Gitbe, és mi ne?

Gitbe való minden, ami szöveges, és amit kézzel írsz:

  • Ansible-playbookok, szerepkörök (roles) és az inventory,
  • Terraform-kód és modulok,
  • shell- és Python-szkriptek, systemd unitok,
  • konfigurációs sablonok (nginx, Postfix, a Zabbix-sablonok exportja),
  • runbookok és dokumentáció Markdownban.

Nem való bele: jelszó, privát kulcs, API-token, a Terraform state fájlja, mentés, nagy bináris fájl. Erről lent külön is szó lesz.

Az első lépések

Egyszer, gépenként állítsd be, kinek a nevében készülnek a commitok, és hogy az új repók alapértelmezett ága main legyen:

git config --global user.name "Kovács Péter"
git config --global user.email "ops@example.hu"
git config --global init.defaultBranch main

A 2.46-tól a git config alparancsokat is kapott (git config get, git config set), de a fenti, régi forma továbbra is működik, a régebbi Git-verziókon pedig csak ez.

Új repót a git init hoz létre, meglévőt a git clone tölt le:

git init ansible
git clone git@gitlab.example.hu:ops/ansible.git

A git parancsok, amelyeket naponta használsz

Parancs Mire való?
git status Mi változott, mi van előkészítve (staged) a commitra
git diff / git diff --staged A még nem előkészített, illetve az előkészített változások soronként
git add <fájl> / git add -p Változás előkészítése; a -p darabonként kérdez rá
git commit -m "…" Az előkészített változások rögzítése
git log --oneline --graph Az előzmények tömören, az ágakkal együtt
git branch Ágak listázása, törlése (-d)
git switch <ág> / git switch -c <ág> Váltás meglévő ágra, illetve új ág létrehozása
git merge <ág> Egy ág beolvasztása az aktuálisba
git pull / git push Szinkronizálás a távoli repóval (GitLab)
git stash / git stash pop Félkész munka félretétele, majd visszavétele
git revert <commit> Egy commit hatásának visszavonása új commitként
git reset Az ág visszaállítása egy korábbi állapotra (óvatosan!)
git tag Egy állapot elnevezése, például egy élesítésé

A git switch a 2.23-as verzió óta létezik; régi leírásokban ugyanez git checkout néven szerepel.

Egy tipikus módosítás elejétől a végéig így néz ki:

git switch main
git pull
git switch -c nginx-body-limit
# ... szerkesztés ...
git status
git diff
git add roles/nginx/templates/site.conf.j2
git commit -m "nginx: client_max_body_size 50 MB-ra emelése"
git push -u origin nginx-body-limit

revert vagy reset?

Ez a két parancs okozza a legtöbb bajt, ezért érdemes tisztán látni a különbséget:

  • A git revert új commitot készít, amely pontosan visszacsinálja egy korábbi commit változásait. Az előzmény megmarad, mindenki látja, mi történt. Ha egy már pusholt változás okozott hibát élesben, ezt használd.
  • A git reset az ágat egy korábbi commitra állítja vissza, a későbbieket „eldobja” az ágról. A --soft megtartja a változásokat előkészítve, a --hard a munkakönyvtárat is visszaállítja, a nem rögzített változásokkal együtt. Csak olyan commitokra használd, amelyeket még nem pusholtál.
git revert a1b2c3d          # a hibás commit visszavonása új commitként
git reset --soft HEAD~1     # az utolsó, még helyi commit visszavonása, a változások megmaradnak

Ha mégis elvesztettél valamit, a git reflog megmutatja, hol állt korábban az ág, és onnan általában vissza lehet hozni.

Címkék az élesítésekhez

Egy címke (tag) megmondja, pontosan melyik állapot ment ki élesre. Hibakereséskor aranyat ér:

git tag -a v2024.08.1 -m "Postfix relay csere, élesítve 08.22."
git push origin v2024.08.1

.gitignore: a titkok maradjanak kint

A .gitignore fájlban felsorolt minták nem kerülnek be véletlenül sem a repóba. Egy üzemeltetési repó jó kiindulópontja:

# Terraform
.terraform/
*.tfstate
*.tfstate.*
crash.log

# Ansible
*.retry
.vault_pass*

# Általános
.env
*.pem
*.key

Néhány szabály, amelyet mi mindig betartunk:

  • A titkok titkosítva kerülnek a repóba, például Ansible Vaulttal. A vault jelszava soha.
  • A Terraform state távoli tárolóba megy, például a GitLab beépített Terraform state tárolójába, nem a repóba; a state-ben jelszavak és kulcsok is lehetnek.
  • A .gitignore csak az új fájlokra hat. Ami már bekerült, azt a git rm --cached <fájl> veszi ki a követésből.
  • Ha egy titok már pusholva lett, cseréld le. Az előzmények átírása (például git filter-repo) is segít, de a repó addigra több gépre is letöltődhetett, ezért a jelszó- vagy kulcscsere az elsődleges.

Commitüzenetek, amelyek fél év múlva is érthetők

A „javítás” és az „update” üzenetű commitok fél év múlva semmit nem mondanak. Pár egyszerű szokás:

  • Az első sor rövid (nagyjából 50 karakter), és megmondja, mi változott; elöl a komponens neve.
  • Üres sor után jön, hogy miért: ez az, ami a kódból nem derül ki.
  • Egy commit egy logikai változás. A nginx-beállítás és a felhasználói lista módosítása két commit.
  • Ha van jegyrendszer, hivatkozz a jegyre.
postfix: relayhost cseréje az új smarthostra

A régi szolgáltató szeptember végén megszünteti a relay-t,
az új szerver már élesben fogadja a leveleinket.

Jegy: OPS-142

Egyszerű munkafolyamat GitLab merge requesttel

Kis csapatnak nem kell bonyolult elágazási modell. Ez a felállás nálunk évek óta működik:

  1. A main ág védett (protected branch): közvetlenül senki nem pushol rá, és mindig azt tartalmazza, ami élesben fut.
  2. Minden változás külön ágon készül, beszédes névvel (zabbix-uj-szerverek, nginx-body-limit).
  3. Push után merge request nyílik. A GitLab ezt push opcióval is elintézi: git push -o merge_request.create -o merge_request.target=main.
  4. A CI ellenőriz: ansible-lint, terraform fmt -check, terraform validate, és a terraform plan kimenete a merge requestbe kerül.
  5. Egy kolléga átnézi a diffet, és csak jóváhagyás után kerül a változás a main-be.
  6. Élesíteni a main-ből lehet, utána jöhet a címke.

A második szem és az automatikus ellenőrzés nem bürokrácia: a júliusi CrowdStrike-leállás is megmutatta, mennyit ér, ha egy változás nem egyszerre, ellenőrzés nélkül jut ki mindenhová.

Hogyan kezdj hozzá?

Nem kell egyszerre mindent Gitbe tenni. Kezdd a szkriptekkel és a legtöbbet módosított konfigurációkkal, egy GitLab-projektben, védett main ággal. Pár hét után a csapat magától kezdi a merge requestet használni, mert kényelmesebb, mint e-mailben egyeztetni, ki mit írt át a szerveren.

Ha segítség kell a GitLab beállításában, az Ansible- vagy Terraform-kód rendbetételében vagy egy CI-folyamat felépítésében, keress minket; erről a Felhő és DevOps oldalon olvashatsz bővebben.

Beszéljünk a projektedről

Írd le röviden, miben segíthetünk, és a lehető leghamarabb válaszolunk.

Kapcsolatfelvétel