makepkg (Français)

État de la traduction:
Cet article est la version francophone de
makepkg
. Date de la dernière traduction: 2022-04-30. Vous pouvez aider à synchroniser la traduction s'il y a eu des
changements
dans la version anglaise.
Related articles
Creating packages
PKGBUILD (Français)
.SRCINFO
Arch User Repository (Français)
pacman (Français)
Official repositories (Français)
Arch Build System (Français)
makepkg
est un script pour automatiser la construction de paquets. Les conditions requises pour utiliser ce script sont une plate-forme Unix capable de compiler et un
PKGBUILD
.
makepkg est fourni par le paquet
pacman
.
Configuration
Consultez
makepkg.conf(5)
pour plus de détails sur les options de configuration de
makepkg
.
La configuration du système est disponible dans
/etc/makepkg.conf
, mais les changements spécifiques à l'utilisateur peuvent être effectués dans
$XDG_CONFIG_HOME/pacman/makepkg.conf
ou
~/.makepkg.conf
. Il est recommandé de vérifier la configuration avant de construire des paquets.
Informations sur le paquet
Chaque paquet est étiqueté avec des métadonnées identifiant entre autres le
packager
. Par défaut, les paquets compilés par l'utilisateur sont marqués avec
Unknown Packager
. Si plusieurs utilisateurs compilent des paquets sur un système, ou si l'un d'entre eux distribue des paquets à d'autres utilisateurs, il est utile de fournir un contact réel. Ceci peut être fait en définissant la variable
PACKAGER
dans
makepkg.conf
.
Pour vérifier cela sur un paquet installé :
$ pacman -Qi
package
...
Packager : John Doe <john@doe.com>
...
Pour générer automatiquement des paquets signés, définissez également la variable
GPGKEY
dans
makepkg.conf
.
Résultat du paquet
Par défaut,
makepkg
crée les archives du paquet dans le répertoire de travail et télécharge les données sources directement dans le répertoire
src/
. Des chemins personnalisés peuvent être configurés, par exemple pour conserver tous les paquets construits dans
~/build/packages/
et toutes les sources dans
~/build/sources/
.
Configurez les variables suivantes
makepkg.conf
si nécessaire :
PKGDEST
- répertoire pour le stockage des paquets résultants
SRCDEST
- répertoire pour le stockage des données
source
(des liens symboliques seront placés vers
src/
s'il pointe ailleurs)
Répertoire
SRCPKGDEST
- répertoire pour stocker les paquets sources résultants (construits avec
makepkg -S
)
Astuce
Le répertoire
PKGDEST
peut être nettoyé avec par exemple
paccache -c ~/build/packages/
comme décrit dans
Pacman (Français)#Nettoyage du cache des paquets
.
Vérification des signatures
Note
La vérification des signatures implémentée dans
makepkg
n'utilise pas le trousseau de clés de pacman, mais celui de l'utilisateur.
[1]
Si un fichier de signature sous la forme
.sig
ou
.asc
fait partie du tableau source de
PKGBUILD
,
makepkg
tente automatiquement de
vérifier
ce fichier. Si le trousseau de l'utilisateur ne contient pas la clé publique nécessaire à la vérification de la signature,
makepkg
interrompra l'installation avec un message indiquant que la clé PGP n'a pas pu être vérifiée.
Si une clé publique nécessaire pour un paquet est manquante, le
PKGBUILD
contiendra très probablement une entrée
validpgpkeys
avec les ID de clé requis.
Importez
-la manuellement ou trouvez-la
sur un serveur de clés
et importez-la à partir de là.
Utilisation
Avant de continuer,
installez
le groupe
base-devel
. Les paquets appartenant à ce groupe n'ont pas besoin d'être listés comme dépendances au moment de la construction (
makedepends
) dans les fichiers
PKGBUILD
.
Note
Assurez-vous que
Sudo
est configuré correctement pour les commandes passées à
pacman
.
L'exécution de
makepkg
en tant que root est
interdite
.
[2]
Outre le fait qu'un
PKGBUILD
peut contenir des commandes arbitraires, la construction en tant que root est généralement considérée comme dangereuse.
[3]
Les utilisateurs qui n'ont pas accès à un compte utilisateur normal devraient exécuter makepkg avec l'utilisateur
nobody
.
Pour construire un paquet, il faut d'abord créer un
PKGBUILD
, ou script de construction, comme décrit dans
Création de paquets (en)
. Les scripts existants sont disponibles dans l'arbre
Arch Build System
(ABS)
ou de l'
Arch User Repository
(AUR)
. Une fois en possession d'un
PKGBUILD
, allez dans le répertoire où il est enregistré et exécutez la commande suivante pour construire le paquet :
$ makepkg
Si les dépendances requises sont manquantes,
makepkg
émettra un avertissement avant d'échouer. Pour construire le paquet et installer les dépendances nécessaires, ajoutez le paramètre
-s
/
--syncdeps
:
$ makepkg --syncdeps
L'ajout du paramètre
-r
/
--rmdeps
fait que
makepkg
supprime les dépendances make plus tard, qui ne sont plus nécessaires. Si vous construisez constamment des paquets, pensez à utiliser
Pacman (Français)/Tips and tricks (Français)#Suppression des paquets inutilisés (orphelins)
de temps en temps à la place.
Note
Ces dépendances doivent être disponibles dans les dépôts configurés ; consultez
Pacman (Français)#Dépôts et miroirs
pour plus de détails. Alternativement, on peut installer manuellement les dépendances avant la construction (
pacman -S --asdeps
dep1
dep2
).
Seules les valeurs globales sont utilisées lors de l'installation des dépendances, c'est-à-dire que toute modification effectuée dans la fonction d'empaquetage d'un paquet divisé ne sera pas utilisée.
Une fois que toutes les dépendances sont satisfaites et que le paquet se construit avec succès, un fichier paquet (
pkgname
-
pkgver
.pkg.tar.zst
) sera créé dans le répertoire de travail. Pour l'installer, utilisez
-i
/
--install
. (comme
pacman -U
pkgname
-
pkgver
.pkg.tar.zst
) :
$ makepkg --install
Pour nettoyer les fichiers et répertoires restants, comme les fichiers extraits dans le
$srcdir
, ajoutez l'option
-c
/
--clean
. Cette option est utile pour les constructions multiples du même paquet ou la mise à jour de la version du paquet, tout en utilisant le même répertoire de construction. Elle empêche les fichiers obsolètes et résiduels d'être reportés dans les nouvelles constructions :
$ makepkg --clean
Pour en savoir plus, consultez
makepkg(8)
.
Trucs et astuces
Réduire les temps de téléchargement et d'extraction des sources
Utilisez
SRCDEST
, en particulier lors de la construction de
paquets récupérant les sources par un logiciel de contrôle de version
, pour gagner du temps lors de la récupération et de la décompression des sources lors des reconstructions ultérieures.
Construction de binaires optimisés
Une amélioration des performances du logiciel empaqueté peut être obtenue en activant les optimisations du compilateur pour la machine hôte. L'inconvénient est que les binaires compilés pour une architecture de processeur spécifique ne fonctionneront pas correctement sur d'autres machines. Sur les machines x86_64, il y a rarement des gains de performances réels assez significatifs pour justifier d'investir du temps dans la reconstruction des paquets officiels.
Cependant, il est très facile de réduire les performances en utilisant des paramètres de compilation "non standard". De nombreuses optimisations du compilateur ne sont utiles que dans certaines situations et ne devraient pas être appliquées sans discernement à tous les paquets. À moins que des tests de référence ne soient disponibles pour prouver que quelque chose est plus rapide, il y a de fortes chances que ce ne soit pas le cas ! Les articles du wiki Gentoo
GCC optimization
et
Safe CFLAGS
fournissent des informations plus détaillées sur l'optimisation des compilateurs.
Les options passées à un compilateur C/C++ (par exemple
gcc
ou
clang
) sont contrôlées par les variables d'environnement
CFLAGS
,
CXXFLAGS
, et
CPPFLAGS
. Pour une utilisation dans le système de construction Arch,
makepkg
expose ces variables d'environnement comme options de configuration dans
makepkg.conf
. Les valeurs par défaut sont configurées pour produire des binaires génériques qui peuvent être installés sur une large gamme de machines.
Note
Gardez à l'esprit que tous les systèmes de compilation n'utilisent pas les variables configurées dans
makepkg.conf
. Par exemple,
cmake
ne tient pas compte de la variable d'environnement des options du préprocesseur,
CPPFLAGS
. Par conséquent, de nombreux
PKGBUILDs
contiennent des solutions de contournement avec des options spécifiques au système de construction utilisé par le logiciel paqueté.
La configuration fournie avec le code source dans le
Makefile
ou un argument spécifique dans la ligne de commande de compilation est prioritaire et peut potentiellement remplacer celle dans
makepkg.conf
.
GCC peut détecter et activer automatiquement des optimisations sûres spécifiques à l'architecture. Pour utiliser cette fonctionnalité, supprimez d'abord les paramètres
-march
et
-mtune
, puis ajoutez
-march=native
. Par exemple :
/etc/makepkg.conf
CFLAGS="
-march=native
-O2 -pipe -fno-plt"
CXXFLAGS="${CFLAGS}"
Pour consulter les paramètres activés, exécutez :
$ gcc -march=native -v -Q --help=target
Note
Spécifier des valeurs différentes au lieu de
-march=native
, alors
-Q --help=target
ne fonctionnera pas comme prévu.
[4]
Pour savoir quelles options sont réellement activées, effectuez une compilation. Consultez
Gentoo:Safe CFLAGS#Manual
pour obtenir des instructions.
À partir de la version 5.2.2 de
pacman
,
makepkg.conf
inclut également des dérogations pour la variable d'environnement
RUSTFLAGS
, pour les paramètres donnés au compilateur Rust. Le compilateur Rust peut également détecter et activer des optimisations spécifiques à l'architecture en ajoutant
-C target-cpu=native
à la valeur
RUSTFLAGS
donnée :
/etc/makepkg.conf
RUSTFLAGS="-C opt-level=2
-C target-cpu=native
"
Pour consulter les fonctionnalités du CPU que cela va activer, exécutez :
$ rustc -C target-cpu=native --print cfg
L'exécution de
--print cfg
sans
-C target-cpu=native
affichera la configuration par défaut. Le paramètre
opt-level
peut être changé en
3
,
s
, ou
z
selon les besoins. Consultez
La documentation du compilateur Rust
pour plus de détails.
Améliorer les temps de compilation
Compilation parallèle
Le système de compilation
make
utilise la
variable d'environnement
MAKEFLAGS
pour spécifier des options supplémentaires à
make
. La variable peut également être définie dans le fichier
makepkg.conf
.
Les utilisateurs de systèmes multi-core/multi-processeurs peuvent spécifier le nombre de tâches à exécuter simultanément. Ceci peut être accompli avec l'utilisation de
nproc
pour déterminer le nombre de processeurs disponibles, par exemple
MAKEFLAGS="-j$(nproc)"
. Certains
PKGBUILDs
remplacent spécifiquement cela par
-j1
, à cause de conditions de concurrence critique dans certaines versions ou simplement parce que cela n'est pas pris en charge en premier lieu. Les paquets qui ne se construisent pas à cause de cela devraient être
signalés
sur le suivi des bogues (ou dans le cas des paquets
AUR
, au mainteneur du paquet) après s'être assuré que l'erreur est bien causée par
MAKEFLAGS
.
Consultez
make(1)
pour une liste complète des options disponibles.
Construction à partir de fichiers en mémoire
Comme la compilation nécessite de nombreuses opérations d'E/S et la manipulation de petits fichiers, le déplacement du répertoire de travail vers un
tmpfs
peut améliorer les temps de construction.
La variable
BUILDDIR
peut être temporairement exportée vers
makepkg
pour définir le répertoire de construction vers un tmpfs existant. Par exemple :
$ BUILDDIR=/tmp/makepkg makepkg
La configuration persistante peut être faite dans
makepkg.conf
en décommentant l'option
BUILDDIR
, qui se trouve à la fin de la section
BUILD ENVIRONMENT
dans le fichier par défaut
/etc/makepkg.conf
. En donnant à cette option la valeur
BUILDDIR=/tmp/makepkg
, on utilisera le système de fichiers temporaires
/tmp
par défaut de l'Arch.
Note
Évitez de compiler les paquets les plus volumineux dans tmpfs pour ne pas manquer de mémoire.
Le répertoire tmpfs doit être monté sans l'option
noexec
, sinon il empêchera l'exécution des binaires construits.
Gardez à l'esprit que les paquets compilés dans tmpfs ne persisteront pas après un redémarrage. Envisagez de définir l'option
PKGDEST
de manière appropriée pour déplacer le paquet construit automatiquement dans un répertoire persistant.
Utilisation d'un cache de compilation
L'utilisation de
ccache
peut améliorer les temps de construction en mettant en cache les résultats des compilations pour une utilisation successive.
Générer de nouvelles sommes de contrôle
Installez
pacman-contrib
et exécutez la commande suivante dans le même répertoire que le fichier PKGBUILD pour générer de nouvelles sommes de contrôle :
$ updpkgsums
updpkgsums
utilise
makepkg --geninteg
pour générer les sommes de contrôle. Consultez
cette discussion du forum
pour plus de détails.
Les sommes de contrôle peuvent également être obtenues avec, par exemple,
sha256sum
et ajoutées au tableau
sha256sums
à la main.
Utiliser d'autres algorithmes de compression
Pour accélérer à la fois l'empaquetage et l'installation, avec pour contrepartie des archives de paquets plus volumineuses, modifiez
PKGEXT
.
Par exemple, l'exemple suivant ne compresse pas le fichier du paquet, qui n'aura pas besoin d'être décompressé lors de l'
installation
:
$ PKGEXT='.pkg.tar' makepkg
Comme autre exemple, ce qui suit utilise l'algorithme lzop, avec le paquet
lzop
requis :
$ PKGEXT='.pkg.tar.lzo' makepkg
Pour rendre l'un de ces paramètres permanent, définissez
PKGEXT
dans
/etc/makepkg.conf
.
Utilisation de plusieurs cœurs pour la compression
xz
prend en charge
plusieurs processeurs en simultané
via le paramètre
--threads
pour accélérer la compression. Par exemple, pour laisser makepkg utiliser autant de cœurs de CPU que possible pour compresser les paquets, éditez le tableau
COMPRESSXZ
dans
/etc/makepkg.conf
:
COMPRESSXZ=(xz -c -z
--threads=0
-)
pigz
est une implémentation parallèle qui remplace sans autres modifications
gzip
et utilise par défaut tous les cœurs disponibles du CPU (le paramètre
-p/--processes
peut être utilisé pour utiliser moins de cœurs) :
COMPRESSGZ=('
pigz
-c -f -n)
pbzip2
est une implémentation parallèle qui remplace sans autres modifications
bzip2
et utilise également tous les cœurs de processeur disponibles par défaut. Le paramètre
-p#
peut être utilisé pour utiliser moins de cœurs (note : pas d'espace entre le
-p
et le nombre de cœurs).
COMPRESSBZ2=(
pbzip2
-c -f)
zstd
prend en charge
plusieurs processeurs en simultané
via le paramètre
--threads
pour accélérer la compression. Par exemple, pour laisser makepkg utiliser autant de cœurs de CPU que possible pour compresser les paquets, éditez le tableau
COMPRESSZST
dans
/etc/makepkg.conf
:
COMPRESSZST=(zstd -c -z -q
--threads=0
-)
Afficher les paquets avec un empaqueteur spécifique
expac
est un utilitaire d'extraction de base de données de pacman. Cette commande affiche tous les paquets installés sur le système avec le packager nommé
nomdupaquet
:
$ expac "%n %p" | grep "
packagername
" | colonne -t
Cette commande affiche tous les paquets installés sur le système avec l'empaqueteur défini dans la variable
/etc/makepkg
PACKAGER
et montre seulement les paquets qui sont dans un dépôt défini dans
/etc/pacman.conf
.
$ . /etc/makepkg.conf ; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1)
Construire des paquets 32 bits sur un système 64 bits
Attention
Des erreurs ont été signalées lors de l'utilisation de cette méthode pour construire le paquet
linux
.
Tout d'abord, activez le dépôt
multilib
et
installez
multilib-devel
.
Créez ensuite un fichier de configuration 32 bits
~/.makepkg.i686.conf
CARCH="i686"
CHOST="i686-unknown-linux-gnu"
CFLAGS="-m32 -march=i686 -mtune=generic -O2 -pipe"
CXXFLAGS="${CFLAGS}"
LDFLAGS="-m32 -Wl,-O1,--sort-common,--as-needed,-z,relro"
et invoquez makepkg comme suit
$ linux32 makepkg --config ~/.makepkg.i686.conf
Dépannage
Spécification du répertoire d'installation pour les paquets basés sur QMAKE
Le fichier makefile généré par
qmake
utilise la variable d'environnement
INSTALL_ROOT
pour spécifier où le programme doit être installé. Ainsi, cette fonction d'empaquetage devrait fonctionner :
PKGBUILD
...
package() {
	cd "$srcdir/${pkgname%-git}" ($srcdir/${pkgname%-git})
	make INSTALL_ROOT="$pkgdir" install
}
...
Notez que qmake doit également être configuré de manière appropriée. Par exemple, mettez ceci dans le fichier
.pro
correspondant :
VotreProjet.pro
...
target.path = /usr/local/bin
INSTALLATIONS += cible
...
WARNING: Package contains reference to $srcdir
D'une manière ou d'une autre, les chaînes littérales contenues dans les variables
$srcdir
ou
$pkgdir
se sont retrouvées dans l'un des fichiers installés dans le paquet.
Pour identifier ces fichiers, exécutez la commande suivante depuis le répertoire de construction de
makepkg
:
$ grep -R "$PWD/src" pkg/
Une cause possible serait l'utilisation de la macro
__FILE__
dans le code C/C++ avec le chemin complet passé au compilateur.
Makepkg ne parvient pas à télécharger les dépendances lorsqu'il est derrière un proxy
Lorsque
makepkg
appelle les dépendances, il appelle pacman pour installer les paquets, ce qui nécessite des privilèges administratifs via
sudo
. Cependant,
sudo
ne passe aucune
variable d'environnement
à l'environnement privilégié, et inclut les variables liées au proxy
ftp_proxy
,
http_proxy
,
https_proxy
, et
no_proxy
.
Afin de faire fonctionner
makepkg
derrière un proxy, invoquez l'une des méthodes suivantes.
Activer le proxy en définissant son URL dans la XferCommand
La XferCommand peut être configurée pour utiliser l'URL du proxy souhaité dans
/etc/pacman.conf
.  Ajoutez ou décommentez la ligne suivante dans
pacman.conf
[5]
:
/etc/pacman.conf
...
XferCommand = /usr/bin/curl -x http://username:password@proxy.proxyhost.com:80 -L -C - -f -o %o %u
...
Activer le proxy via env_keep de sudo
Alternativement, on peut vouloir utiliser l'option
env_keep
de sudo, qui permet de préserver des variables données l'environnement privilégié. Consultez
Sudo#Environment variables
pour plus d'informations.
Makepkg échoue, mais make aboutit
Si quelque chose se compile avec succès avec
make
, mais échoue avec
makepkg
, c'est presque certainement parce que
/etc/makepkg.conf
définit une variable de compilation incompatible.  Essayez d'ajouter ces paramètres au tableau PKGBUILD
options
:
!buildflags
, pour empêcher ses
CPPFLAGS
,
CFLAGS
,
CXXFLAGS
, et
LDFLAGS
} par défaut.
!makeflags
, pour empêcher sa valeur par défaut
MAKEFLAGS
.
!debug
, pour empêcher son défaut
DEBUG_CFLAGS
, et
DEBUG_CXXFLAGS
, au cas où le PKGBUILD est un build de débogage.
Si l'un d'entre eux résout le problème, cela pourrait justifier un rapport de bogue en amont en supposant que le paramètre incriminé a été identifié.
Voir aussi
makepkg(8)
makepkg.conf(5)
Un bref tour du processus Makepkg
code source de makepkg