Így használd a Gitet a Drupal projekted verziókezelésére

Üdv a modern webfejlesztés világában, ahol a Drupal robosztus keretrendszere találkozik a Git elengedhetetlen verziókezelő rendszerével! Ha valaha is dolgoztál már projekten egyedül vagy csapatban, tudod, milyen könnyű elveszni a fájlok különböző verziói között. „Melyik volt az a működő változat? Hova tűnt az a kód? Ki írta át ezt a sort?” – ismerős kérdések, ugye? A jó hír az, hogy a Git segítségével ezek a dilemmák a múlté lesznek, és a Drupal fejlesztés sokkal átláthatóbbá, hatékonyabbá és stresszmentesebbé válik. Ez az átfogó útmutató segít eligazodni abban, hogyan integráld a Gitet a Drupal munkafolyamataidba, a kezdetektől a fejlett stratégiákig.

Miért éppen Git és Drupal?

A verziókezelés nem luxus, hanem alapvető szükséglet minden szoftverfejlesztési projektben. A Git, a világ legnépszerűbb elosztott verziókezelő rendszere, tökéletes választás a Drupalhoz. Elosztott mivolta azt jelenti, hogy minden fejlesztő rendelkezik a teljes kód történetével, ami növeli a redundanciát és lehetővé teszi a zökkenőmentes offline munkát. A Drupal, mint komplex CMS, folyamatos fejlesztést, frissítést és konfigurációkezelést igényel. A Git segít nyomon követni minden egyes változást, lehetővé teszi a hibák könnyű visszavonását, és támogatja a párhuzamos munkát anélkül, hogy a csapattagok felülírnák egymás módosításait. Röviden: a Git megóv a katasztrófától, felgyorsítja a fejlesztést és elősegíti a csapatmunkát.

Git Alapok: Induljunk El!

Mi az a Git és hogyan működik?

A Git egy olyan rendszer, amely nyomon követi a fájljaidban bekövetkező változásokat. Nem csak az aktuális állapotot menti el, hanem rögzíti a módosítások történetét is. Minden egyes elmentett állapotot commit-nak nevezünk. Ezek a commitok összefüggő láncot alkotnak, ami lehetővé teszi, hogy bármikor visszatérj egy korábbi verzióhoz. A Git alapvető elemei:

Repository (Tárhely): A projekt teljes történetét és fájljait tartalmazó mappa. Lehet lokális (a gépeden) vagy távoli (pl. GitHub, GitLab).
Commit (Véglegesítés): Egy adott pillanatfelvétel a projekt fájljairól. Minden commit egy üzenettel rendelkezik, ami leírja a változásokat.
Branch (Ág): Egy független fejlesztési vonal a fő kódbázison belül. Lehetővé teszi, hogy új funkciókat fejlessz, vagy hibákat javíts anélkül, hogy befolyásolnád a fő vonalat.
Merge (Egyesítés): Két vagy több branch változásainak összevonása egyetlen branch-be.
Clone (Klónozás): Egy távoli repository lemásolása a helyi gépedre.
Push (Feltöltés): A helyi commitok feltöltése a távoli repository-ba.
Pull (Letöltés): A távoli repository-ból származó új változások letöltése és integrálása a helyi repository-ba.

Git telepítése

Mielőtt belevágnánk a Drupal specifikus teendőkbe, győződj meg róla, hogy a Git telepítve van a rendszereden. A legtöbb operációs rendszerre könnyen telepíthető. Látogass el a git-scm.com/downloads oldalra a részletes utasításokért.

Git és Drupal: A kezdetek

A projekt inicializálása

Tegyük fel, hogy van egy új vagy már meglévő Drupal projekted. Első lépésként inicializálnod kell a Git repository-t a projekt gyökérkönyvtárában. Nyisd meg a terminált/parancssort, navigálj a projekt mappájába, és futtasd a következő parancsot:

git init

Ezzel létrejön egy rejtett .git mappa, ami a projekt összes verziókezelési információját tárolja.

A .gitignore fájl fontossága

A Drupal projektek sok olyan fájlt és mappát tartalmaznak, amelyeket nem kell (sőt, nem is szabad!) Git-tel verziókezelni. Ilyenek például a generált fájlok, ideiglenes cache, a felhasználók által feltöltött médiafájlok, vagy a biztonsági szempontból érzékeny konfigurációs adatok. Itt jön képbe a .gitignore fájl. Hozd létre ezt a fájlt a projekt gyökérkönyvtárában, és add hozzá a következő sorokat (ez egy tipikus példa, de a projektedtől függően eltérhet):

# Drupal core
/core/
/vendor/
/web/core/
/web/modules/contrib/
/web/themes/contrib/
/web/profiles/contrib/
/web/libraries/

# Composer managed files
/composer.lock

# Sites specific files
/web/sites/*/files/
/web/sites/*/settings.php
/web/sites/*/settings.local.php
/web/sites/*/services.yml
/web/sites/*/sync/
/web/sites/*/translations/

# Other common ignore patterns
*.log
*.sql
*.sqlite
.env
.DS_Store
Thumbs.db
/node_modules/
/tmp/
/private/
/drush-backups/
/backup/
/assets/build/ # if using custom build process

Ez a lista biztosítja, hogy csak a ténylegesen szükséges kód és konfiguráció kerüljön be a repository-ba. Különösen fontos a /web/sites/*/files/ és a /web/sites/*/settings.php figyelmen kívül hagyása, mivel ezek felhasználóspecifikus adatokat és érzékeny információkat tartalmazhatnak.

Az első commit

Miután inicializáltad a repository-t és beállítottad a .gitignore-t, ideje elkészíteni az első commit-ot. Ez a projekt kezdeti állapotának pillanatfelvétele.

git add .
git commit -m "Initial commit of the Drupal project structure"

A git add . paranccsal hozzáadod az összes változást (kivéve azokat, amiket a .gitignore figyelmen kívül hagy) a „staging area”-hoz. A git commit -m "Üzenet" paranccsal pedig véglegesíted ezeket a változásokat egy új commit-ként a megadott üzenettel.

Fejlesztési munkafolyamatok: Branch-ek ereje

A branch-ek a Git egyik legerősebb funkciói. Lehetővé teszik a párhuzamos fejlesztést anélkül, hogy a fő (általában main vagy master nevű) kódbázis stabilitását veszélyeztetnéd. Minden új funkciót, hibajavítást vagy kísérletezést egy külön branch-en érdemes végezni.

Feature branch-ek és munkafolyamat

Képzeld el, hogy egy új kapcsolati űrlapot kell fejlesztened a Drupal oldaladra. Ehelyett, hogy közvetlenül a main branch-en dolgoznál, hozz létre egy új feature branch-et:

git checkout -b feature/kapcsolati-urlap

Mostantól ezen az ágon dolgozol. Végezd el a módosításokat (modul telepítés, konfiguráció, sablonfájlok). Amikor egy logikai egységet befejeztél, készíts egy commit-ot:

git add .
git commit -m "Implementáltuk az új kapcsolati űrlapot."

Ismételd ezt a folyamatot, amíg a funkció teljesen el nem készül. Ha végeztél, válts vissza a main branch-re, és egyesítsd a feature branch-et:

git checkout main
git merge feature/kapcsolati-urlap

Konfliktus esetén a Git jelezni fogja, és kézzel kell feloldanod az eltéréseket. Miután sikeresen egyesítetted, törölheted a feature branch-et (ha már nincs rá szükséged):

git branch -d feature/kapcsolati-urlap

Merge vs. Rebase

A git merge egy új commit-ot hoz létre az egyesítéshez, megtartva a branch-ek teljes történetét. A git rebase ezzel szemben „átírja” a történetet, úgy tűnik, mintha a branch-ed változásai a cél branch-en felülre kerültek volna, tisztább, lineárisabb történetet eredményezve. Kezdőknek a merge javasolt, mivel kevésbé hajlamos hibákra, de csapatban érdemes megbeszélni, melyik stratégiát követitek.

A Drupal kódstruktúrájának kezelése Gittel

A modern Drupal projektek (különösen a Drupal 8/9/10+) szinte kivétel nélkül Composerrel épülnek fel. Ez a függőségkezelő eszköz alapjaiban változtatta meg a Drupal fájlstruktúráját és a verziókezelési gyakorlatot.

Composer és Git

A Composer kezeli a Drupal core, a hozzájáruló (contrib) modulok, témák és könyvtárak letöltését és frissítését. A legjobb gyakorlat az, hogy a Composer által kezelt fájlokat (beleértve a /vendor/ mappát is) **nem commitoljuk** a Git repository-ba. Ehelyett a composer.json és composer.lock fájlokat verziókezeljük.

composer.json: Leírja a projekt függőségeit (melyik Drupal core verzió, milyen modulok stb.).
composer.lock: Pontosan rögzíti az egyes függőségek telepített verzióit, ezzel biztosítva, hogy mindenki (és a deployment is) ugyanazokat a verziókat használja.

Amikor egy új fejlesztő klónozza a repository-t, vagy egy új környezetbe deploy-olunk, csak futtatni kell a composer install parancsot, és a Composer letölti az összes szükséges függőséget a composer.lock alapján.

A Drupal konfiguráció menedzsment (CM)

A Drupal 8+ bevezette a konfiguráció menedzsmentet, ami lehetővé teszi a site beállításainak (nézetek, tartalomtípusok, modulbeállítások) exportálását YAML fájlokba. Ezek a fájlok a /web/sites/default/sync/ mappába kerülnek (vagy egy custom útvonalra). Ez a mappa _kulcsfontosságú_ a Git verziókezelés szempontjából, mivel ezeket a YAML fájlokat **mindig commitolni kell**!

Munkafolyamat:

Végezz el konfigurációs változtatásokat az admin felületen (pl. hozz létre egy új tartalomtípust).
Exportáld a konfigurációt a fájlrendszerbe: drush cim -y vagy drush cex -y (a drush cex exportálja, a drush cim importálja).

Add hozzá és commitold a megváltozott YAML fájlokat:

git add web/sites/default/sync/
git commit -m "Új tartalomtípus hozzáadva: Esemény"

Amikor egy másik fejlesztő letölti a változtatásokat, importálnia kell a konfigurációt: drush cim -y.

Több fejlesztővel való munka és távoli repository-k

A Git ereje igazán csapatmunkában mutatkozik meg. Ehhez szükséged lesz egy távoli (remote) repository-ra, amit olyan szolgáltatók nyújtanak, mint a GitHub, GitLab vagy Bitbucket.

A távoli repository hozzáadása

Miután létrehoztál egy üres repository-t a választott szolgáltatónál, add hozzá a helyi projektedhez:

git remote add origin https://github.com/felhasznalonev/projektnev.git
git push -u origin main

Ezzel feltöltöd a helyi main branch-edet az „origin” nevű távoli repository-ra.

Pull Requests (PR) / Merge Requests (MR)

Amikor egy feature branch-en befejezted a munkát, és szeretnéd, hogy a változásaid bekerüljenek a main branch-be, hozz létre egy Pull Requestet (GitHub, Bitbucket) vagy Merge Requestet (GitLab). Ez egy formális javaslat a kód egyesítésére. Lehetővé teszi más csapattagoknak, hogy:

Átnézzék (code review) a kódodat.
Kommenteket fűzzenek hozzá.
Javaslatokat tegyenek módosításokra.
Futtassanak automatizált teszteket.

Miután a kód átnézése sikeres volt, és minden teszt lefutott, a PR/MR elfogadható és egyesíthető a cél branch-be.

Konfliktuskezelés

Előfordulhat, hogy két fejlesztő ugyanazon a fájlon vagy akár ugyanazon a kódsoron dolgozik. Amikor megpróbálják egyesíteni a változásaikat, a Git **konfliktust** jelez. Ezt kézzel kell feloldani. A Git egyértelműen megjelöli a konfliktusos részeket a fájlokban (pl. <<<<<<< HEAD, =======, >>>>>>> feature-branch). Gondosan döntsd el, melyik változatot szeretnéd megtartani, majd távolítsd el a Git által beszúrt jelzőket, és commitold a feloldott fájlt.

Deployment és CI/CD

A Git nem csak a fejlesztés során nyújt segítséget, hanem a deployment, azaz a kód éles szerverre történő telepítésének alapja is.

Egyszerű Git push alapú deployment

Egy egyszerűbb setup esetén beállíthatod, hogy a szervered automatikusan frissüljön, amikor pusholsz a main branch-re. Ez lehet egy Git hook, vagy egy egyszerű szkript, ami a szerveren lehúzza a legfrissebb kódot a repository-ból. Ezt követően futtatni kell a Drupal frissítési parancsait:

drush deploy:hook
drush updb -y
drush cim -y
drush cr

CI/CD (Continuous Integration / Continuous Delivery)

A professzionális Drupal fejlesztés elengedhetetlen része a CI/CD (Folyamatos Integráció / Folyamatos Szállítás). A CI/CD rendszerek (pl. GitLab CI/CD, GitHub Actions, Jenkins, CircleCI) automatizálják a kód buildelését, tesztelését és deploymentjét minden egyes commit vagy pull request esetén. Ennek előnyei:

**Automatizált tesztelés**: Egységtesztek, funkcionális tesztek, linting azonnali visszajelzést adnak a kód minőségéről.
**Gyorsabb hibafelderítés**: A problémák korán kiderülnek, mielőtt a fő branch-be kerülnének.
**Konzisztens deployment**: Minden telepítés azonos módon történik, csökkentve az emberi hiba lehetőségét.
**Gyorsabb piacra jutás**: A kód gyorsabban és megbízhatóbban kerülhet élesítésre.

Gyakori hibák és tippek

Soha ne commitolj érzékeny adatokat! Jelszavak, API kulcsok, adatbázis hozzáférések soha ne kerüljenek a Git repository-ba. Használj környezeti változókat (pl. a .env fájlban, amit a .gitignore figyelmen kívül hagy) vagy Drupal Secret modult.
Commitolj gyakran és apránként! Egy-egy commit egyetlen logikai változást takarjon. Ez megkönnyíti a hibakeresést és a revertelést.
Írj jó commit üzeneteket! Az üzenet első sora legyen tömör (max. 50-70 karakter), utána hagyj egy üres sort, majd részletesebben írd le a változásokat. Ez a kódkezelés alapja.
Használj branch stratégiát! A Gitflow vagy a GitHub Flow népszerű stratégiák, amelyek segítenek a csapatoknak egységesen kezelni a branch-eket és a kiadásokat.
Frissítsd rendszeresen a helyi kódodat! A git pull parancs futtatása előtt, hogy elkerüld a konfliktusokat.

Összefoglalás

A Git elsajátítása és a Drupal projektekbe való integrálása elengedhetetlen lépés a modern webfejlesztés során. Növeli a csapat hatékonyságát, biztosítja a kód integritását, és lehetővé teszi a biztonságos, kontrollált fejlesztést és deploymentet. Az elején talán ijesztőnek tűnhet, de a Git adta szabadság és kontroll, amit a Drupal projekt felett nyersz, hamarosan nélkülözhetetlenné teszi számodra. Kezdd el még ma, és fedezd fel, milyen professzionális szintre emelheti a verziókezelés a munkádat!