Hogyan készíts saját csomagot az Arch Linux AUR számára

Üdvözöllek, Arch Linux rajongó! Ha valaha is elgondolkodtál azon, hogyan kerülnek a kedvenc, nem hivatalos szoftvereid a rendszeredre, vagy ha egyedi igényeid vannak a programok fordítását illetően, akkor jó helyen jársz. Ez a cikk egy átfogó útmutatót kínál a saját csomagok készítéséhez az Arch User Repository (AUR) számára. Készülj fel, hogy mélyebbre áss az Arch csomagkezelésének világában, és válj igazi „csomagmesterré”!

Mi az AUR és Miért Fontos?

Az Arch Linux az egyszerűségéről, a minimalizmusáról és a „rolláló kiadás” modelljéről híres. A hivatalos tárolók kiválóan ellátnak minket stabil és naprakész szoftverekkel, de mi van, ha egy specifikus alkalmazásra van szükségünk, amely nem található meg ezekben a repókban? Itt jön képbe az Arch User Repository (AUR).

Az AUR egy hatalmas, közösség által fenntartott tároló, ahol a felhasználók által készített PKGBUILD fájlok gyűjteménye található. Ezek a szkriptek tartalmazzák az utasításokat a szoftverek forráskódjából történő fordításához és becsomagolásához, vagy már lefordított binárisok telepítéséhez. Az AUR az Arch Linux egyik legfontosabb erőssége, mivel lehetővé teszi szinte bármilyen szoftver egyszerű telepítését, legyen szó béta verziókról, egyedi programokról, vagy olyan alkalmazásokról, amelyek licencük miatt nem kerülhetnek a hivatalos tárolókba.

A saját csomag készítésének számos oka lehet:

Egy olyan szoftver csomagolása, ami még nincs az AUR-ban.
Egy meglévő szoftver egyedi fordítási opciókkal való telepítése.
Saját programod vagy szkripted megosztása a közösséggel.
Hozzájárulás az Arch ökoszisztémájához és a közösség segítése.

Ez az útmutató végigvezet a PKGBUILD fájl felépítésén, a csomag elkészítésének lépésein, és azon, hogyan töltsd fel azt az AUR-ra.

Előfeltételek

Mielőtt belevágnánk, győződj meg róla, hogy rendelkezel a szükséges eszközökkel és ismeretekkel:

Alapszintű Arch Linux ismeretek és a parancssor magabiztos használata.
Telepített base-devel csomagcsoport: Ez tartalmazza a fordításhoz szükséges alapvető eszközöket (pl. gcc, make, binutils). Telepítsd a következő paranccsal: sudo pacman -S --needed base-devel git
Git telepítése: Az AUR-ral való interakcióhoz szükség lesz rá. Ha még nincs telepítve, a fenti paranccsal azonnal felkerül.
Egy szövegszerkesztő (pl. Vim, Nano, VS Code).

A PKGBUILD Titka – Lépésről Lépésre

A PKGBUILD egy shell szkript, amely a bash szintaxisát használja. Ez a szkript mondja meg a makepkg eszköznek, hogyan fordítsa le és csomagolja be a szoftvert. Nézzük meg a legfontosabb részeit:

Alapvető Változók

Minden PKGBUILD-nek tartalmaznia kell ezeket a kulcsfontosságú változókat:

pkgname: A csomag neve (pl. myprogram). Kicsi betűkkel, nem tartalmazhat -git, -svn stb. utótagot, kivéve ha az egy VCS csomag.
pkgver: A szoftver verziószáma (pl. 1.0.0).
pkgrel: A csomagkiadás száma, ami a PKGBUILD verzióját jelöli (pl. 1). Növeld, ha frissíted a PKGBUILD-et a szoftver verziójának változása nélkül.
pkgdesc: A csomag rövid leírása.
arch: Milyen architektúrákon fut a csomag (pl. ('x86_64') vagy ('any')).
url: A szoftver honlapja vagy forráskódjának linkje.
license: A szoftver licenc típusa (pl. ('GPL'), ('MIT'), ('custom')).
depends: A futásidejű függőségek listája, amikre a szoftvernek szüksége van (pl. ('glibc' 'openssl')).
makedepends: A fordítási függőségek listája (pl. ('gcc' 'make')). Ezeket a makepkg telepíti, majd törli a fordítás után.
optdepends: Opcionális függőségek, amelyek extra funkcionalitást biztosítanak.
source: A forrásfájlok URL-jei, vagy helyi fájlnevek. Ide kell tenni a forráskód archívumát, patcheket stb. (pl. ("https://example.com/software-${pkgver}.tar.gz")).
sha256sums (vagy md5sums, sha512sums): A source fájlok ellenőrzőösszegei. Nagyon fontos a biztonság és az integritás szempontjából! Ezt a makepkg -g parancs generálja.

Kulcsfontosságú Függvények

Ezek a funkciók határozzák meg a csomag elkészítésének folyamatát:

prepare(): (Opcionális) Itt végezhetők el a forráskódon módosítások, pl. patchek alkalmazása, konfigurációs fájlok szerkesztése.
build(): Itt történik a szoftver fordítása. Általában ./configure, make parancsokat tartalmaz, de lehet python setup.py build vagy bármi más.
check(): (Opcionális) Itt futtathatók a szoftver tesztjei (pl. make check).
package(): Ez a legfontosabb lépés! Itt telepítjük a lefordított fájlokat egy ideiglenes könyvtárba ($pkgdir), amely a későbbi csomag alapjául szolgál. Ebben a fázisban nem szabad sudo-t használni, a makepkg gondoskodik a megfelelő jogosultságokról. Például: install -Dm755 myprogram "$pkgdir/usr/bin/myprogram".

Gyakorlati Példa: Egy Egyszerű C Program Csomagolása

Készítsünk egy nagyon egyszerű C programot, és csomagoljuk be az AUR számára.

Hozz létre egy munkakönyvtárat:
```
mkdir myapp-aur
cd myapp-aur
```

Hozd létre a forrásfájlt (myapp.c):

// myapp.c
#include <stdio.h>

int main() {
    printf("Hello from AUR package!n");
    return 0;
}

Csomagold be a forráskódot (opcionális, de jó gyakorlat):

Bár a PKGBUILD tud helyi fájlokat is kezelni, a közösség elvárja, hogy a forráskód egy URL-ről legyen letölthető. Egyszerűség kedvéért most tegyük ezt a lokális fájlt egy tar.gz-be, mintha egy letöltött archívum lenne. Valós esetben egy GitHub release vagy egy saját szerver lenne a forrás.
```
tar -czvf myapp-1.0.tar.gz myapp.c
```
Ekkor a myapp-1.0.tar.gz fájl lesz a source.

Írd meg a PKGBUILD fájlt:

Hozd létre a PKGBUILD fájlt a myapp-aur könyvtárban a következő tartalommal:

# Maintainer: Your Name <[email protected]>
pkgname=myapp
pkgver=1.0
pkgrel=1
pkgdesc="A simple 'Hello from AUR package!' program."
arch=('x86_64')
url="https://example.com/myapp-project" # Cseréld le a valódi URL-re
license=('GPL') # Változtasd meg a valós licencre
depends=('glibc')
makedepends=('gcc')
source=("${pkgname}-${pkgver}.tar.gz") # Ezt a fájlt fogja keresni
# A sha256sums-ot a makepkg -g paranccsal generáljuk majd
# sha256sums=()

build() {
  cd "${srcdir}"
  # Fordítás
  gcc myapp.c -o myapp
}

package() {
  cd "${srcdir}"
  # Telepítés a $pkgdir-be. A -Dm755 létrehozza a könyvtárat és beállítja a jogosultságokat.
  install -Dm755 myapp "${pkgdir}/usr/bin/myapp"
}

Generáld az ellenőrzőösszeget:

A PKGBUILD-ben a sha256sums még üres. Futtasd a következő parancsot a myapp-aur könyvtárból:

makepkg -g >> PKGBUILD

Ez hozzáadja a sha256sums=('...') sort a PKGBUILD végéhez. Helyezd át a megfelelő helyre (a source sor alá).

A PKGBUILD most így fog kinézni:

# Maintainer: Your Name <[email protected]>
pkgname=myapp
pkgver=1.0
pkgrel=1
pkgdesc="A simple 'Hello from AUR package!' program."
arch=('x86_64')
url="https://example.com/myapp-project"
license=('GPL')
depends=('glibc')
makedepends=('gcc')
source=("${pkgname}-${pkgver}.tar.gz")
sha256sums=('a1b2c3d4e5f67890...') # Ez a sor a te rendszereden generált értékkel lesz tele

build() {
  cd "${srcdir}"
  gcc myapp.c -o myapp
}

package() {
  cd "${srcdir}"
  install -Dm755 myapp "${pkgdir}/usr/bin/myapp"
}

Teszteld a csomagot:

Most már készen állsz a csomag elkészítésére a makepkg-gel. Futtasd a következő parancsot a myapp-aur könyvtárból:
```
makepkg -s
```
Ez letölti a függőségeket (ha szükséges), lefordítja a programot, és létrehoz egy myapp-1.0-1-x86_64.pkg.tar.zst (vagy hasonló nevű) fájlt. Ha hibát kapsz, olvasd el figyelmesen a kimenetet, és javítsd a PKGBUILD-et.

Telepítsd a csomagot (helyileg):

sudo pacman -U myapp-1.0-1-x86_64.pkg.tar.zst

Teszteld a telepített programot:
```
myapp
```
Ha a "Hello from AUR package!" üzenetet látod, sikeresen elkészítetted és telepítetted a csomagot!
Takarítás:

A makepkg által generált fordítási fájlokat és függőségeket törölheted:
```
makepkg --clean --rmdeps
```
A csomagot eltávolíthatod a pacman-nel:
```
sudo pacman -R myapp
```

Haladó PKGBUILD Koncepciók és Tippek

VCS Csomagok (Git, SVN, Mercurial)

Ha egy szoftver verziókezelő rendszerből (pl. Git) származik, a pkgver dinamikusan generálható. A pkgname általában -git utótagot kap (pl. myapp-git). A source változó a VCS URL-jét tartalmazza, és a sha256sums helyére SKIP kerül, mivel a forráskód változhat.

Példa pkgver() függvényre:

pkgver() {
  cd "${srcdir}/${pkgname}"
  git describe --long --tags | sed 's/([^-]*-)g/1r/' | sed 's/([^-]*)-([0-9]*)-g(.*)/1.r2.g3/' | sed 's/^v//'
}

Split Csomagok

Egyetlen PKGBUILD-ből több csomagot is generálhatsz, ha a forráskód több független komponenst tartalmaz. Ekkor a PKGBUILD-ben több pkgname, pkgdesc, depends stb. változó lesz, és minden alkalommal package_<pkgname>() függvényeket kell használni.

Fontos Tippek és Legjobb Gyakorlatok

Arch Packaging Guidelines: Mindenképpen olvasd el az Arch Wiki hivatalos csomagolási irányelveit! Ez a legfontosabb forrás.
Nincs sudo a PKGBUILD-ben: A build() és prepare() funkciók normál felhasználóként futnak, míg a package() gyökérjogosultságokkal. Soha ne használj sudo-t a PKGBUILD-en belül! Az install parancsot használd a fájlok másolására a $pkgdir-be.
Függőségek: Légy precíz a depends és makedepends listáknál. Csak azokat add hozzá, amikre tényleg szükség van.
Licencelés: Győződj meg róla, hogy a licenc helyes, és ha egyedi, akkor helyezd el a $pkgdir/usr/share/licenses/$pkgname/ útvonalon.
Forrás Integritás: Mindig generálj ellenőrzőösszegeket (sha256sums) a forrásfájlokhoz. Ha a source egy VCS repository, használhatsz SKIP-et, de ez csak akkor ajánlott, ha nincs statikus forrásfájl, amit letöltenél.
Hivatalos Tárolók Előnyben: Ha egy függőség elérhető a hivatalos Arch tárolókban, mindig azt használd az AUR verziója helyett.

Feltöltés az AUR-ra

Miután a PKGBUILD-ed tökéletes, és a csomag sikeresen elkészült helyileg, ideje megosztani a közösséggel!

Regisztrálj AUR Fiókot:

Látogass el az AUR weboldalára és regisztrálj egy fiókot. Szükséged lesz egy SSH kulcsra is, amit feltölthetsz a profilodba.
Klónozz egy már létező csomagot (opcionális, de jó gyakorlat):

Ha szeretnél példát látni, vagy egy létező AUR csomagot frissítenél, klónozd le a Git repóját:
```
git clone https://aur.archlinux.org/example-package.git
```
Hozd létre az új Git Repozitóriumot:

A myapp-aur könyvtárban inicializálj egy Git repót, add hozzá a PKGBUILD-et, és kövesd el az első commitot:
```
git init
git add PKGBUILD
git commit -m "Initial PKGBUILD for myapp"
```
Ha vannak kiegészítő fájlok (pl. .install szkript, patchek, licence fájlok), azokat is add hozzá a git add paranccsal.
Töltsd fel az AUR-ra:

Most jön a lényeg! Add hozzá az AUR távoli repóját, és pushold fel a master (vagy main) ágat:
```
git remote add aur ssh://[email protected]/myapp.git
git push aur master
```
Fontos: A myapp.git helyére a pkgname kerül, ahogy azt a PKGBUILD-ben definiáltad.
Várj a felülvizsgálatra:

Az első feltöltés után a csomagod az „Out-of-date” listára kerül, és várja a közösség vagy egy Megbízható Felhasználó (Trusted User) felülvizsgálatát. Ellenőrizd rendszeresen a csomagod oldalát az AUR weboldalán a megjegyzésekért. Légy nyitott a visszajelzésekre és javítsd a PKGBUILD-et, ha szükséges.
Karbantartás:

A sikeres feltöltés után te vagy a csomag fenntartója. Ez azt jelenti, hogy figyelemmel kell kísérned a szoftver új verzióit, frissítened kell a PKGBUILD-et (pkgver és pkgrel növelésével, valamint az ellenőrzőösszegek frissítésével), és válaszolnod kell a felhasználók kommentjeire az AUR oldalon.

A frissítés menete hasonló a feltöltéshez: módosítod a PKGBUILD-et, generálsz új ellenőrzőösszegeket, commitolsz, majd git push aur master.

Gyakori Hibák és Hibaelhárítás

Hiányzó Függőségek: Ha a makepkg „could not resolve dependencies” hibaüzenettel leáll, valószínűleg hiányzik egy depends vagy makedepends.
Ellenőrzőösszeg Hiba: „One or more files did not pass the validity check.” Ez azt jelenti, hogy a letöltött forrásfájl nem egyezik a PKGBUILD-ben szereplő sha256sums értékkel. Futtasd újra a makepkg -g >> PKGBUILD parancsot, és cseréld ki az elavult értékeket.
Fordítási Hiba: A build() fázisban lévő hibák általában a szoftver fordításával kapcsolatosak. Olvasd el a hibaüzenetet, keress rá a problémára online, vagy ellenőrizd a szoftver hivatalos fordítási útmutatóját.
Telepítési Hiba (package() funkció): Győződj meg róla, hogy a fájlokat a $pkgdir alkönyvtáraiba telepíted. Soha ne próbálj meg root könyvtárba írni (pl. /usr/bin helyett $pkgdir/usr/bin).
Hibás Fájlrendszer Hierarchia: Kövesd az Arch FHS (Filesystem Hierarchy Standard) ajánlásait. Például végrehajtható binárisok az /usr/bin-be, könyvtárak az /usr/lib-be, konfigurációs fájlok az /etc-be.

Konklúzió

Gratulálok! Most már rendelkezel a tudással és eszközökkel ahhoz, hogy saját csomagokat hozz létre és tölts fel az Arch Linux AUR-ra. Ez nem csupán technikai képesség, hanem egy nagyszerű módja annak, hogy hozzájárulj az Arch közösségéhez, és megoszd tudásodat és erőforrásaidat másokkal.

Ne feledd, a gyakorlat teszi a mestert. Kezdd egyszerű csomagokkal, tanulj a meglévő PKGBUILD fájlokból, és mindig tartsd be az Arch hivatalos irányelveit. Hamarosan te is profi „csomagmesterré” válsz, és büszkén nézheted, ahogy a szoftvereid elérhetővé válnak az Arch felhasználók számára világszerte!

További jó munkát és sikeres csomagolást kívánok!