makepkg (Magyar) - ArchWiki

Jump to content

# makepkg (Magyar)

From ArchWiki

Fordítás állapota: Ez az oldal az angol Makepkg című oldal magyar nyelvre lefordított változata. Utolsó fordítás dátuma: 2026.05.15. Amennyiben a lefordítás időpontja óta az angol nyelvű oldalon történtek újabb módosítások, akkor Ön segíthet hozzászinkronizálni az angolhoz ezt a magyar nyelvű fordítást.

További oldalak az adott témakörben

- Arch build system (Magyar)
- Arch User Repository (Magyar)
- Creating packages (Magyar)
- GnuPG (Magyar)
- Official repositories (Magyar)
- OpenPGP (Magyar)
- pacman (Magyar)
- .SRCINFO (Magyar)

A makepkg egy olyan szkriptfájl, amely automatizálja a szoftvercsomagok létrehozását. A szkriptfájl használatához szükség van egy szoftvercsomag létrehozásra alkalmas Unix platformra és egy PKGBUILD szkriptfájlra.

A makepkg szkriptfájlt a pacman szoftvercsomag tartalmazza.

## Beállítás

A rendszerbeállítás elérhető a `/etc/makepkg.conf` fájlban, de felhasználóspecifikus módosításokat lehet elvégezni a `$XDG_CONFIG_HOME/pacman/makepkg.conf` vagy a `~/.makepkg.conf` fájlban. Emellett, rendszerszintű változtatások is elvégezhetőek egy `/etc/makepkg.conf.d/makepkg.conf` drop-in fájl segítségével. A szoftvercsomagok létrehozása előtt ajánlott a beállítás áttekintése.

További információkért tekintse meg a makepkg.conf(5) man súgót.

Megjegyzés Tiszta chroot környezetben a devtools segédszkriptek a szoftvercsomagok létrehozásához ehelyett a `/usr/share/devtools/makepkg.conf.d/arch.conf` beállításfájlt használják.

### Szoftvercsomaglétrehozási információk

Minden szoftvercsomag metaadatokkal van ellátva, amelyek többek között a szoftvercsomag-készítőt is azonosítják. Alapértelmezés szerint a felhasználó által létrehozott szoftvercsomagok `Unknown Packager` megjelölést kapnak. Ha egy operációs rendszeren több felhasználó fog szoftvercsomagokat létrehozni, vagy ha a felhasználó más felhasználóknak terjeszt szoftvercsomagokat, akkor célszerű valódi elérhetőséget megadni. Ez megtehető a `makepkg.conf` fájlban a `PACKAGER` változó beállításával.

Egy szoftvercsomagon a szoftvercsomaglétrehozási információt az alábbi módon lehet ellenőrizni:

    $ pacman -Qi szoftvercsomag

    ...
    Packager       : Jézus Krisztus <jezus@krisztus.hu>
    ...

Az aláírt szoftvercsomagok automatikus úton történő létrehozása érdekében állítsa be a `GPGKEY` változót is a `makepkg.conf` fájlban.

### Szoftvercsomag-kimenet

Alapértelmezés szerint a makepkg a betömörített tar szoftvercsomagfájlokat a munkakönyvtárban hozza létre, és a forrásadatokat közvetlenül a `src/` könyvtárba tölti le. Beállíthatók egyéni elérési utak. Például beállítható az összes létrehozott szoftvercsomag tárolására a `~/build/packages/` könyvtár, vagy az összes forrásadat tárolására a `~/build/sources/` könyvtár.

Amennyiben szükséges, állítsa be a következő `makepkg.conf` változókat:

- `PKGDEST` — Könyvtár a létrejött szoftvercsomagok tárolására.
- `SRCDEST` — Könyvtár a forrásadatok tárolására. (Ha más helyre mutat, akkor szimbolikus linkek kerülnek az `src/` könyvtárba.)
- `SRCPKGDEST` — Könyvtár a létrejött forrásszoftvercsomagok tárolására. (`makepkg -S` paranccsal elkészítve.)

Tipp A `PKGDEST` könyvtár például a `paccache -c ~/build/packages/` paranccsal tisztítható, ahogyan az a pacman#Szoftvercsomag-gyorsítótár kitakarítása című részben le van írva.

Ön használhatja a relatív elérési utakat az egyes szoftvercsomagkönyvtárakon belül.

### Szoftvercsomag aláírásának az ellenőrzése

Megjegyzés A makepkg által implementált szoftvercsomagaláírás-ellenőrzés nem a pacman kulcstartóját használja, hanem a felhasználó kulcstartójára támaszkodik.[1]

Ha egy .sig vagy .asc formátumú aláírásfájl része a PKGBUILD forrástömbnek, akkor a makepkg automatikusan megpróbálja ellenőrizni a fájlt. Amennyiben a felhasználó kulcstartója nem tartalmazza az szoftvercsomag-aláírás ellenőrzéséhez szükséges nyilvános kulcsot, akkor a makepkg megszakítja a szoftvercsomag feltelepítését azzal az üzenettel, hogy a szoftvercsomaghoz tartozó PGP kulcs nem ellenőrizhető.

Ha hiányzik egy szoftvercsomaghoz tartozó nyilvános kulcs, akkor a PKGBUILD nagy valószínűséggel tartalmaz egy validpgpkeys bejegyzést a szükséges kulcsazonosítókkal. Importálja manuális úton, vagy keresse meg egy kulcsszerveren, és importálja onnan. Az aláírás-ellenőrzés ideiglenes kikapcsolása érdekében futtassa a makepkg parancsot a `--skippgpcheck` opcióval.

## Használat

Mielőtt folytatná, telepítse a base-devel meta szoftvercsomagot. Ennek a szoftvercsomagnak a szoftvercsomag-függőségeit a PKGBUILD fájlokban nem szükséges úgy feltüntetni mintha azok a szoftvercsomag létrehozása alatt szükséges szoftvercsomag-függőségek (makedepends) lennének.

Megjegyzés

- Győződjön meg arról, hogy a pacman szoftvercsomag-kezelőnek átadott parancsok számára a sudo megfelelően be van állítva. Alternatívaként más engedélyezési parancs is megadható a `PACMAN_AUTH` változóval a makepkg.conf(5) beállításfájlban.
- A `makepkg` root felhasználóként történő futtatása le van tiltva.[2] Amellett, hogy egy `PKGBUILD` tetszőleges parancsokat tartalmazhat, a root felhasználóként történő kódfordítás általában nem tekinthető biztonságosnak.[3] Azoknak a felhasználóknak, akiknek nincs hozzáférésük egy normál felhasználói fiókhoz, a `makepkg` szkriptet a nobody felhasználóként kell futtatniuk, például a `runuser -u nobody makepkg` parancs használatával.

Egy szoftvercsomag létrehozása érdekében először létre kell hozni egy PKGBUILD fájlt, vagyis egy build szkriptet, ahogyan az a Szoftvercsomagok létrehozása című oldalon le van írva. Létező szkriptek elérhetők az Arch build system (ABS) fában vagy az AUR szoftvercsomag-tárolóban. Miután Ön rendelkezik egy `PKGBUILD` fájllal, váltson át abba a könyvtárba, ahol el van mentve a fájl, és futtassa a következő parancsot a szoftvercsomag létrehozása érdekében:

    $ makepkg

Ha hiányoznak a szükséges szoftvercsomag-függőségek, akkor a makepkg figyelmeztetést fog megjeleníteni, mielőtt hibával leállna. A szoftvercsomag létrehozása érdekében és a szükséges szoftvercsomag-függőségek telepítése érdekében adja hozzá a makepkg parancshoz a `-s`/`--syncdeps` kapcsolót:

    $ makepkg --syncdeps

A `-r`/`--rmdeps` kapcsoló hozzáadásával a makepkg később eltávolítja azokat a build-függőségeket, amelyekre már nincs szükség. Ha Ön folyamatosan szokott szoftvercsomagokat létrehozni, akkor inkább időnként használja a Pacman/Tippek és trükkök#Nem használt (elárvult) szoftvercsomagok eltávolítása lehetőséget.

Megjegyzés

- Ezeknek a szoftvercsomag-függőségeknek elérhetőknek kell lenniük a beállított szoftvercsomag-tárolókban. Részletekért tekintse meg a pacman#Repositories and mirrors című leírást. Alternatívaként a függőségeket kézzel is telepítheti a fordítás előtt (`pacman -S --asdeps dep1 dep2`).
- Kizárólag globális értékek kerülnek felhasználásra a szoftvercsomag-függőségek számítógépre történő feltelepítésekor. Tehát például a split szoftvercsomag csomagolási függvényében végzett bármilyen felülírás nem kerül alkalmazásra.

Miután minden szoftvercsomag-függőség teljesült és a szoftvercsomag sikeresen létre lett hozva, egy szoftvercsomagfájl (`pkgname-pkgver.pkg.tar.zst`) jön létre a munkakönyvtárban. A feltelepítés érdekében használja a `-i`/`--install` kapcsolót (ugyanaz, mint a `pacman -U pkgname-pkgver.pkg.tar.zst`):

    $ makepkg --install

A megmaradt fájlok és könyvtárak, például a `$srcdir` könyvtárba kibontott fájlok eltávolítása érdekében adja hozzá a `-c`/`--clean` kapcsolót. Ez hasznos ugyanazon szoftvercsomag többszöri létrehozásakor, vagy a szoftvercsomag verziójának frissítésekor, miközben Ön ugyanazt a build könyvtárat használja. Megakadályozza, hogy elavult és maradvány fájlok átkerüljenek az új build fájlokba:

    $ makepkg --clean

További részletekért tekintse meg a makepkg(8) man súgót.

## Optimalizálás

Az alapértelmezett beállítások megegyeznek azokkal a beállításokkal, amelyeket a devtools a hivatalos szoftvercsomag-tárolók számára használ a szoftvercsomagok létrehozásához.[4] Ennek következtében a végfelhasználók kisebb-nagyobb mértékű teljesítménynövekedést érhetnek el az alábbi beállítások finomhangolásával annak érdekében, hogy a beállítások jobban illeszkedjenek a végfelhasználók helyi környezetéhez.

### Optimalizált binárisok készítése

A szoftvercsomag teljesítménye javítható, amennyiben Ön a gazdagép számára engedélyezi a programkódfordító optimalizálásait. Ennek az a hátránya, hogy az adott processzorarchitektúrára lefordított bináris programok más architektúrájú számítógépeken nem fognak helyesen futni. Az x86_64 architektúrájú számítógépeken ritkán érhetők el olyan mértékű valós teljesítménynövekedések, amelyek indokolnák a hivatalos szoftvercsomagok újbóli lefordításába belefektetett időt.

Ugyanakkor nagyon könnyű a teljesítményt lecsökkenteni a "nem szabványos" programkódfordítási jelölőzászlók használatával. Sok kódfordító optimalizálás csak bizonyos helyzetekben hasznos, és nem szabad válogatás nélkül minden szoftvercsomagra alkalmazni. Amíg nincs rendelkezésre álló benchmark adat, amely bizonyítja, hogy valami gyorsabb, addig nagyon nagy az esélye annak, hogy nem gyorsabb! A Gentoo GCC optimalizálás és Biztonságos CFLAGS wiki cikkek részletesebb információt nyújtanak a programkódfordítási optimalizálásról.

#### C és C++

A C/C++ programkódfordítónak (például gcc vagy clang) átadott opciókat a `CFLAGS`, `CXXFLAGS` és `CPPFLAGS` környezeti változók szabályozzák. A makepkg ezeket a környezeti változókat az Arch build rendszerben (Arch build system) beállításopcióként teszi elérhetővé a `makepkg.conf` fájlban. Az alapértelmezett értékek úgy vannak beállítva, hogy általános binárisan futtatható programokat állítsanak elő, amelyek széleskörűen telepíthetőek a számítógépekre.

Megjegyzés

- Tartsa szem előtt, hogy nem minden build rendszer használja a `makepkg.conf` fájlban beállított változókat. Például a cmake figyelmen kívül hagyja az előfeldolgozó opciók környezeti változóját, tehát a `CPPFLAGS` változót. Ennek következtében sok PKGBUILD szkriptfájl kerülőmegoldásokat tartalmaz specifikus opciókkal, amely opciók a csomagolt szoftver által használt build rendszerhez tartoznak.
- Elsőbbséget élvez a forráskóddal együtt biztosított beállítás a `Makefile` fájlban. Ugyanígy elsőbbséget élvez egy konkrét argumentum a kódfordítási parancssorban. Ezek felülírhatják a `makepkg.conf` fájlban szereplő beállítást.

A GCC képes automatikusan felismerni és engedélyezni a biztonságos, architektúraspecifikus optimalizálásokat. Ennek használatához először távolítsa el az összes `-march` és `-mtune` jelölőzászlót, majd adja hozzá a `-march=native` opciót. Például:

    /etc/makepkg.conf

    CFLAGS="-march=native -O2 -pipe ..."
    CXXFLAGS="${CFLAGS} ..."

A megadott jelölőzászlók által engedélyezett beállítások megtekintéséhez futtassa:

    $ gcc -march=native -v -Q --help=target

Megjegyzés Ha eltérő értékeket ad meg a `-march=native` helyett, akkor a `-Q --help=target` nem fog a vártnak megfelelően működni.[5] Annak megállapításához, hogy mely opciók vannak valóban engedélyezve, menjen végig egy programkódfordítási folyamaton. Az utasításokért tekintse meg a Gentoo:Safe CFLAGS#Manual útmutatót.

A binárisok további optimalizálása elérhető olyan optimalizálások engedélyezésével, amelyek memóriahasználat és programkódfordítási idő szempontjából költségesnek számítanak. Ez megvalósítható az optimalizációsszint-jelölőzászló `-O2` értékről `-O3` értékre történő megváltoztatásával. Ennek a jelölőzászlónak a használata a legtöbb esetben javítja a bináris programkódra lefordított program teljesítményét, bár a teljesítményjavulás nem garantált, és bizonyos esetekben kontraproduktívnak bizonyulhat. Részletekért tekintse meg a Gentoo:GCC optimization/hu#-O és a GCC optimalizációs opciók oldalát.

#### Rust

A `pacman` 5.2.2 verziójától kezdve a `makepkg.conf` fájl tartalmazza a `RUSTFLAGS` környezeti változó felülírásait is, amelyeket a Rust programkódfordító kap. A Rust programkódfordító képes felismerni és engedélyezni az architektúraspecifikus optimalizálásokat is, amennyiben a megadott `RUSTFLAGS` értékhez Ön hozzáadja a `-C target-cpu=native` beállítást:

    /etc/makepkg.conf.d/rust.conf

    RUSTFLAGS="-C force-frame-pointers=yes -C target-cpu=native"

A következő CPU-funkciók megtekintéséhez futtassa a következő parancsot:

    $ rustc -C target-cpu=native --print cfg

A `--print cfg` futtatása `-C target-cpu=native` nélkül az alapértelmezett beállítást fogja kiírni.

További optimalizálással kapcsolatos beállítások, amelyek hozzáadhatók a `RUSTFLAGS` értékhez:

- `-C opt-level=3`: Az érték tetszés szerint módosítható `3`, `s`, vagy `z` értékre. A `opt-level=3` a kiadási build alapértelmezett beállítása.
- `-C codegen-units=n`: Amennyiben Ön az `n` értéket `16` alá állítja, akkor az optimalizálni fogja a bináris kódot, de növeli a programkódfordítás idejét.
- `-C link-arg=-z -C link-arg=pack-relative-relocs` csökkenti a lefordított bináris kódnak a méretét.

Részletekért tekintse meg a Rust compiler's documentation című leírást.

### Szoftvercsomag létrehozási idejének feljavítása

#### Párhuzamos programkódfordítás

A make létrehozási rendszer a make számára a `MAKEFLAGS` környezeti változót használja a további beállítások megadására. A változó beállítható a `makepkg.conf` fájlban is.

A többmagos/többprocesszoros számítógépet használó felhasználók megadhatják, hogy hány feladat fusson párhuzamosan. Ez megvalósítható a nproc(1) használatával, amely meghatározza az elérhető processzorok számát, például: `MAKEFLAGS="--jobs=$(nproc)"`.

Néhány `PKGBUILD` kifejezetten felülírja ezt a `-j1` beállítással, bizonyos verziókban előforduló versenyhelyzetek miatt, vagy egyszerűen azért, mert eleve nem támogatott. Azok a szoftvercsomagok, amelyek emiatt nem fordíthatók le, a hibakövetőben (vagy AUR szoftvercsomagok esetén a szoftvercsomag karbantartójának) kell jelenteni, miután Ön megbizonyosodott arról, hogy a hibát valóban a `MAKEFLAGS` okozza.

Tekintse meg a make(1) man súgót a rendelkezésre álló beállítások teljes listájáért.

#### Fájlokból szoftvercsomag létrehozása a számítógép memóriájában

Mivel a programkód lefordítása számos I/O műveletet és számos kis fájlok kezelését igényli, a munkakönyvtár áthelyezése egy tmpfs könyvtárba (tehát a számítógép memóriájába) feljavíthatja az szoftvercsomag létrehozásának az idejét.

A `BUILDDIR` változó ideiglenesen exportálható a makepkg számára annak érdekében, hogy a programkódfordítási könyvtárat Ön egy meglévő tmpfs fájlrendszerre állítsa rá. Például:

    $ BUILDDIR=/tmp/makepkg makepkg

Az állandósult beállítás elvégezhető a `makepkg.conf` fájlban a `BUILDDIR` opció kikommentelésével, amely az alapértelmezett `/etc/makepkg.conf` fájl `BUILD ENVIRONMENT` szakaszának végén található. Például az érték beállítása `BUILDDIR=/tmp/makepkg` elérési útvonalra azt eredményezi, hogy az Arch alapértelmezett `/tmp` ideiglenes fájlrendszere lesz használva a forráskód lefordításakor.

Megjegyzés

- Kerülje a nagyobb szoftvercsomagok kódfordítását tmpfs elérési útvonalon annak érdekében, hogy ezáltal el lehessen kerülni a számítógép memóriájának a telítődését.
- A tmpfs könyvtárat a `noexec` opció nélkül kell felcsatolni, máskülönben a lefordított binárisok futtatása meg lesz akadályozva.
- Tartsa szem előtt, hogy a tmpfs könyvtárban lefordított szoftvercsomagok nem maradnak meg a számítógép újraindítása után. Fontolja meg a PKGDEST opció megfelelő beállítását annak érdekében, hogy a lefordított szoftvercsomag automatikusan egy állandó könyvtárba kerüljön át.

#### Fordítási gyorsítótár használata

A ccache használata javíthatja az szoftvercsomagok létrehozásának az idejét azáltal, hogy gyorsítótárazza a fordítások eredményeit későbbi felhasználásra.

#### Mold linker használata

A mold egy ld/lld linkerek helyettesítésére szolgáló linker, amely jelentősen gyorsabb működést ígér.

A mold használata érdekében Ön adja hozzá a `-fuse-ld=mold` kapcsolót az `LDFLAGS` változóhoz. Például:

    /etc/makepkg.conf

    LDFLAGS="... -fuse-ld=mold"

Amennyiben Ön további beállításokat szeretne átadni a mold linkernek, akkor adja hozzá ezeket is az `LDFLAGS` változóhoz. Például:

    /etc/makepkg.conf

    LDFLAGS="... -fuse-ld=mold -Wl,--separate-debug-file"

Rust szoftvercsomagok számára történő mold felhasználás esetén adja hozzá a `-C link-arg=-fuse-ld=mold` kapcsolót a `RUSTFLAGS` változóhoz. Például:

    /etc/makepkg.conf.d/rust.conf

    RUSTFLAGS="... -C link-arg=-fuse-ld=mold"

#### Hibakereső szoftvercsomagok és LTO letiltása

A 2024 februárjában kiadott 6.0.2-9 verziószámú pacman szoftvercsomag-kezelőben található 90bf367e számú commit alapértelmezés szerint engedélyezte a `debug` és `lto` opciókat.

A hibakereső szoftvercsomagok fordítása lehetővé teszi, hogy a hivatalos szoftvercsomag-tárolók több programot biztosítsanak a felhasználók számára a problémák elhárítása érdekében (archlinux/packaging/packages/pacman#23#note_173528), de saját szoftvercsomagok fordításakor nem szükséges, és lassítja a fordítási folyamatot. Tekintse meg az archlinux/packaging/packages/pacman#23#note_173782 hibabejegyzést.

A link-idő optimalizáció optimalizáltabb bináris programokat eredményez, de jelentősen meghosszabbítja a forráskód fordításának folyamatát (archlinux/packaging/packages/pacman#23#note_173678), ami nem biztos, hogy kívánatos kompromisszum.

Az opciók letiltása érdekében adjon egy `!` karaktert közvetlenül eléjük a `OPTIONS=()` tömbben, például `OPTIONS=(...!debug !lto...)`.

### Tömörítés

#### Más tömörítési algoritmusok használata

A szoftverek csomagolása és a telepítés felgyorsítása érdekében – azzal a kompromisszummal, hogy a szoftvercsomagok archívumfájljai nagyobbak lesznek – módosítsa a `PKGEXT` változót.

Például a következő parancs kihagyja a szoftvercsomagfájl betömörítését, így telepítéskor nem kell azt kicsomagolni:

    $ PKGEXT='.pkg.tar' makepkg

A következő példa az LZ4 algoritmust használja, amely a sebességre összpontosít:

    $ PKGEXT='.pkg.tar.lz4' makepkg

Amennyiben Ön azt szeretné, hogy ezek közül valamelyik beállítás állandó legyen, állítsa be a `PKGEXT` változót a `/etc/makepkg.conf` fájlban.

#### Több processzormag használata tömörítésnél

A tömörítés felgyorsítása érdekében a zstd támogatja a szimmetrikus multiprocesszálást (SMP) a `-T`/`--threads` kapcsolón keresztül. A `-T0` kapcsoló alapértelmezetten szerepel a `COMPRESSZST` tömbben a `/etc/makepkg.conf` fájlban, amely lehetővé teszi azt, hogy a zstd annyi szálat használjon, amennyi fizikai CPU mag rendelkezésre áll a szoftvercsomagok tömörítéséhez. A használt szálak száma tovább növelhető, amennyiben Ön a zstd parancsot a `--auto-threads=logical` kapcsoló használatával a logikai CPU-számra utasítja:

    COMPRESSZST=(zstd -c -T0 --auto-threads=logical -)

Az lz4 és az xz alapértelmezetten több szálon futnak, így nincs szükség változtatásra a `/etc/makepkg.conf` fájlban.

A pigz egy közvetlenül használható, párhuzamos implementáció a gzip számára, amely alapértelmezetten az összes elérhető CPU magot használja. (A `-p`/`--processes` kapcsolóval kevesebb mag is megadható.):

    COMPRESSGZ=(pigz -c -f -n)

A pbzip2 egy közvetlenül használható, párhuzamos implementáció a bzip2 számára, amely alapértelmezetten az összes elérhető CPU magot használja. A `-p#` kapcsolóval kevesebb processzormag is megadható. (Megjegyzés: nincs szóköz a `-p` és a processzormagok száma között).

    COMPRESSBZ2=(pbzip2 -c -f)

Az lbzip2 egy másik közvetlenül használható, párhuzamos implementáció a bzip2 számára, amely alapértelmezetten az összes elérhető CPU magot használja. A `-n` kapcsolóval kevesebb mag is megadható.

    COMPRESSBZ2=(lbzip2 -c -f)

A plzipAUR egy több szálon futó implementáció az lzip számára, amely alapértelmezetten az összes elérhető CPU magot használja. A `-n`/`--threads` kapcsolóval kevesebb mag is megadható.

    COMPRESSLZ=(plzip -c -f)

#### Tömörítési szint módosítása

Számos tömörítési algoritmus (beleértve a zstd és az xz algoritmust is) támogatja a tömörítési szint beállítását, amely a sebesség, a memóriahasználat és a tömörítési hatékonyság közötti kompromisszumot határozza meg.

## Tippek és trükkök

### Források letöltési és kicsomagolási idejének csökkentése

#### Források helyének meghatározása

Használja az `SRCDEST` változót, különösen VCS szoftvercsomagok létrehozásakor annak érdekében, hogy időt takarítson meg a források beszerzésénél és kicsomagolásánál az ismételt újrafordítások során.

#### Egyedi DLAGENTS

Ön használhat olyan letöltőprogramot (például az axel szoftvercsomagot), amely támogatja a párhuzamos letöltést:

    /etc/makepkg.conf

    DLAGENTS=('file::/bin/curl -gqC - -o %o %u'
              'ftp::/bin/axel -n 2 -o %o %u'
              'http::/bin/axel -n 2 -o %o %u'
              'https::/bin/axel -n 2 -o %o %u')

Tekintse meg a Nonfree applications package guidelines#Custom DLAGENTS című leírást.

### Új ellenőrzőösszegek létrehozása

Telepítse fel a számítógépre a pacman-contrib szoftvercsomagot, majd futtassa a következő parancsot ugyanabban a könyvtárban ahol a PKGBUILD fájl található annak érdekében, hogy Ön ezáltal új ellenőrzőösszegeket hozzon létre:

    $ updpkgsums

Az `updpkgsums` parancs a `makepkg --geninteg` parancsot használja az ellenőrzőösszegek létrehozásához. További részletekért tekintse meg ezt a fórumbejegyzést.

Az ellenőrzőösszegek például az `sha256sum` parancs segítségével is előállíthatók. Ezután manuális úton, kézzel hozzáadhatók az `sha256sums` tömbhöz.

### Helyben eltárolt forrásfájlokból szoftvercsomag létrehozása

Amennyiben Ön módosítani szeretné a forráskódot, akkor letöltheti a forráskódot anélkül, hogy a szoftvercsomagot a letöltődés után rögtön létre is hozná. Ezt a műveletet a -o, --nobuild Csak fájlok letöltése és kibontása opció használatával teheti meg.

    $ makepkg -o

A szóban forgó program forráskódjának letöltését követően Ön most már módosíthatja a forráskódot, majd a módosított kódból létrehozhatja a szoftvercsomagot a -e, --noextract Ne bontsa ki a forrásfájlokat (használja a meglévő $srcdir/ könyvtárat) opcióval. Használja a -f opciót a már létrehozott és meglévő szoftvercsomagok felülírása érdekében.

    $ makepkg -ef

### Telepített szoftvercsomagok kilistázása a szoftvercsomag-karbantartó szerint

Az expac egy pacman adatbázis‑kivonatoló segédprogram. A következő parancs megmutatja az összes olyan szoftvercsomagot, amely az operációs rendszerre fel van telepítve, és amely szoftvercsomagnak a készítője szoftvercsomagkészítőneve:

    $ expac "%n %p" | grep "szoftvercsomagkészítőneve" | column -t

A következő parancs megmutatja az összes olyan szoftvercsomagot, amely az operációs rendszerre fel van telepítve, és amely szoftvercsomagnak a készítője a `/etc/makepkg` változóban megadott `PACKAGER`. Ez csak azokat a szoftvercsomagokat mutatja meg, amelyek a `/etc/pacman.conf` fájlban meghatározott szoftvercsomag-tárolóban találhatók meg.

    $ . /etc/makepkg.conf; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1)

### 32 bites szoftvercsomagok létrehozása 64 bites rendszeren

Tekintse meg a 32 bites szoftvercsomagok irányelvei című oldalt.

### Felügyelet nélküli szoftvercsomag-aláírás

This article or section is a candidate for merging with GnuPG#Unattended_passphrase.

Notes: This is not specific to makepkg. (Discuss in Talk:Makepkg (Magyar))

This article or section needs expansion.

Reason: Another option is gpg-preset-passphrase(1) (Discuss in Talk:Makepkg (Magyar))

Előfordulhat olyan helyzet, hogy nincs elérhető személy, aki megadja a jelszót ahhoz a gpg privát kulcshoz, amelyet az automatikus build környezetekben, például a Jenkins használatakor alkalmaznak az aláírás számára. Erősen ellenjavallt privát gpg kulcsot jelszó nélkül tárolni egy rendszeren.

Az makepkg segítségével létrehozott zst szoftvercsomag a létrehozás után továbbra is aláírható:

    $ gpg --detach-sign --pinentry-mode loopback --passphrase --passphrase-fd 0 --output NewlyBuilt.pkg.tar.zst.sig --sign NewlyBuilt.pkg.tar.zst

A fenti parancsban a GPG jelszó meg van adva biztonságosan, és az Ön által választott automatizációs rendszer elfedi azt.

A létrejött `zst` és `sig` fájlra hivatkozhatnak a pacman kliensprogramok, amelyek érvényes aláírást várnak, valamint azok a szoftvercsomag-tárolók, amelyek `repo-add --sign` paranccsal lettek létrehozva a saját szoftvercsomag-tároló üzemeltetésekor.

### Magnet URI linkek

A magnet URI linkek (`magnet://` előtaggal) támogatása a `source` mezőben hozzáadható a transmission-dlagentAUR letöltési ügynök használatával.

### makepkg futtatása systemd vezérlőcsoportban

Ha az Ön által elkészített szoftvercsomag túl sok erőforrást igényel az alapértelmezett make zászlókkal történő kódfordítás számára, amelyek egyébként a legtöbb szoftvercsomaghoz megfelelően vannak beállítva, akkor megpróbálhatja saját vezérlőcsoportban futtatni a kódfordítást. A makepkg-cgAUR egy makepkg burkoló (wrapper), amely ezt a systemd vezérlőcsoportok segítségével valósítja meg. (Tekintse meg a systemd.resource-control(5) man súgót).

### Futás tétlen ütemezési házirenddel

A szoftvercsomag létrehozásának a folyamata magas CPU‑kihasználtsághoz vezethet, különösen a #Párhuzamos programkódfordítás esetében. Nagy CPU‑terhelés alatt még a legmagasabb nice(1) érték mellett is a rendszer jelentősen lelassulhat, akár használhatatlanná is válhat. A számítógépen a felhasználói felület, és az előtérben futó alkalmazások akadozhatnak, vagy akár teljesen válaszképtelenné válhatnak.

Ez a helyzet megkerülhető azzal, hogy az ütemezési házirendet Ön `SCHED_IDLE` értékre állítja be, mielőtt futtatná a makepkg parancsot. Ez biztosítja, hogy a szoftvercsomagok létrehozásának folyamata ne zavarja a szokásos feladatokat, és csak a fennmaradó, fel nem használt CPU‑időt használja fel.

A következő szöveg a sched(7) § SCHED_IDLE: Scheduling very low priority jobs súgóból származik:

  Ez a házirend arra szolgál, hogy a feladatokat Ön rendkívül alacsony prioritással futtassa (még alacsonyabbal, mint a +19 nice érték a `SCHED_OTHER` vagy a `SCHED_BATCH` házirendek esetében).

A `SCHED_IDLE` házirend beállítható a chrt(1) parancs futtatásával a `-i` kapcsolóval, 0 prioritás megadásával (ez az egyetlen érvényes lehetőség a `SCHED_IDLE` esetében), valamint az aktuális shell PID azonosítójának a megadásával.

A legtöbb shell esetében:

    $ chrt -iap 0 $$

Tipp Amennyiben Ön a fenti parancsot elhelyezi a `makepkg.conf` fájlban, akkor az minden szoftvercsomag létrehozásához alkalmazható.

A fish shell esetében, ahol a `$$` nincs beállítva:

    $ chrt -iap 0 %self

### Relatív elérési utak az egyes szoftvercsomagkönyvtárakon belül

A szoftvercsomagkimenet-beállítások esetében az abszolút elérési utak használata helyett Ön beállíthat relatív elérési utakat is minden egyes szoftvercsomagkönyvtáron belül.

Megjegyzés A következő beállítások problémát okozhatnak bizonyos AUR segédprogramok esetében, mivel előfordulhat, hogy a `makepkg.conf` fájlt olyan környezetben használják, ahol a `$startdir` nincs definiálva. Legyen ezért óvatos.

Például a célútvonalakat a `makepkg.conf` fájlban az alábbi módon definiálhatja. A `$startdir` változó arra a könyvtárra utal, ahol a `PKGBUILD` található, amikor egy szoftvercsomagot Ön létrehoz.

    PKGDEST="$startdir/build/packages/"
    SRCDEST="$startdir/build/sources/"
    SRCPKGDEST="$startdir/build/srcpackages/"
    LOGDEST="$startdir/logs/"

Ez az alábbi eredményt adja:

- Az elkészült szoftvercsomagok a következő könyvtárban lesznek eltárolva: `"szoftvercsomagkönyvtár"/build/packages/`
- Minden letöltött forrásfájl a következő könyvtárban lesz eltárolva: `"szoftvercsomagkönyvtár"/build/sources/`
- Az elkészült forráscsomagok a következő könyvtárban lesznek eltárolva: `"szoftvercsomagkönyvtár"/build/srcpackages/`
- Minden naplófájl a következő könyvtárba lesz eltárolva: `"szoftvercsomagkönyvtár"/logs/`

A makepkg továbbra is létrehozza az `src/` és `pkg/` könyvtárakat a szokásos módon, így ez a várt működés.

## Hibaelhárítás

### Telepítési könyvtár megadása QMAKE alapú szoftvercsomagok számára

A qmake által generált makefile az `INSTALL_ROOT` környezeti változót használja annak meghatározására, hogy a program hová legyen telepítve. Ezért a következő szoftvercsomagfüggvénynek működnie kell:

    PKGBUILD

    ...
    package() {
    	cd "$srcdir/${pkgname%-git}"
    	make INSTALL_ROOT="$pkgdir" install
    }
    ...

Megjegyezendő, hogy a qmake parancsot is megfelelően be kell állítani. Például tegye bele a következőt a megfelelő .pro fájlba:

    YourProject.pro

    ...
    target.path = /usr/local/bin
    INSTALLS += target
    ...

### WARNING: Package contains reference to $srcdir

Valamilyen módon a `$srcdir` vagy `$pkgdir` változókban lévő szöveges értékek bekerültek a szoftvercsomag egyik telepített fájljába. [6]

A telepített fájlok azonosítása érdekében futtassa a következő parancsot a makepkg build könyvtárból:

    $ grep -R "$PWD/src" pkg/

Az egyik lehetséges ok az, hogy `__FILE__` makró van használva C/C++ kódban, amikor a teljes elérési út átadásra kerül a programkód lefordítónak.

A dotnet bináris programok alapértelmezett beállításában néha benne van a teljes elérési út a `.pdb` fájlokhoz.

### A makepkg nem tudja proxy mögött letölteni a függőségeket

Amikor a makepkg meghívja a függőségeket, akkor a pacman parancsot használja a szoftvercsomagok feltelepítése érdekében, amihez rendszergazdai jogosultság szükséges a sudo segítségével. Azonban a sudo nem adja át az környezeti változókat a privilégizált környezetnek, és így nem tartalmazza a proxyval kapcsolatos `ftp_proxy`, `http_proxy`, `https_proxy`, valamint `no_proxy` változókat.

A makepkg proxy mögötti működéséhez az alábbi módszerek egyikét kell alkalmazni.

#### Engedélyezze a proxy használatát az URL beállításával az XferCommand sorban

Az XferCommand beállítható úgy, hogy a kívánt proxy URL címet használja a `/etc/pacman.conf` fájlban. Adja hozzá vagy kommentezze ki az alábbi sort a `pacman.conf` fájlban:

    /etc/pacman.conf

    ...
    XferCommand = /usr/bin/curl --proxy http://username:password@proxy.proxyhost.com:80 --location --continue-at - --fail --output %o %u
    ...

#### Engedélyezze a proxy használatát a sudoers fájlban az env_keep beállítással

Alternatív megoldásként használható a sudoers `env_keep` opciója, amely lehetővé teszi bizonyos változók megőrzését a privilégizált környezetben. További részletekért tekintse meg a Pacman#Nem veszi figyelembe a proxybeállításokat a pacman című leírást.

### A makepkg hibát jelez, de a make sikeresen lefut

Amennyiben valami sikeresen lefordul a make használatával, de a makepkg során a programkódfordítás hibát jelez, akkor az szinte biztosan azért van, mert a `/etc/makepkg.conf` fájlban inkompatibilis programkódfordítási változó van beállítva. Próbálja meg hozzáadni ezeket a zászlókat a PKGBUILD `options` tömbjéhez:

`!buildflags` annak érdekében, hogy megakadályozza az alapértelmezett `CPPFLAGS`, `CFLAGS`, `CXXFLAGS` és `LDFLAGS` használatát.

`!makeflags`, hogy megakadályozza az alapértelmezett `MAKEFLAGS` használatát.

`!debug`, hogy megakadályozza az alapértelmezett `DEBUG_CFLAGS` és `DEBUG_CXXFLAGS` használatát, abban az esetben, ha a PKGBUILD egy hibakereső (debug) build.

Ha bármelyik fenti beállítás megoldja a problémát, akkor ez indokolhat egy hibajelentést az upstream fejlesztő felé, feltéve hogy sikerült azonosítani a hibát okozó zászlót.

## További olvasnivaló a témában

- makepkg(8)
- makepkg.conf(5)
- A Brief Tour of the Makepkg Process
- makepkg source code

Categories:

- Package development (Magyar)
- About Arch (Magyar)
- Commands (Magyar)
- OpenPGP (Magyar)

Hidden categories:

- Pages or sections flagged with Template:Merge
- Pages or sections flagged with Template:Expansion

makepkg (Magyar)
Add topic