Faire ses paquets sur son système OpenBSD comporte plusieurs avantages :
L’installation et la désinstallation avec ses dépendances, des programmes sont mieux maîtriser.
On a un seul outils pour gérer toutes les bibliothéques et système de paquets pour les programmes
On peut bénéficier et faire bénéficier aux autres d’un programme sur son système
On peut gérer les options et les fonctionnalités d’un programme
Quand on réalise un paquet pour un programme on dit qu’on fait un portage d’une application sur son système. Le système BSD en général travaille avec ce qu’on appelle un arbre de ports. En gros, c’est un ensemble de dossiers et sous dossiers où sont classés les programmes par catégories qui contienennt non pas les programmes mais toutes les recettes pour générer les paquets des programmes pour son système.
Cela permet de simplifier et d’automatiser l’installation des logiciels ou programme c’est pareil, car souvent les logiciels dépendent d’autres programmes pour fonctionner et se taper l’installation de chacun des programmes à la main ça peut très vite être chiant.
Cela permet aussi de montrer les modifications faîtes sur un programme pour l’adapter à son système. Enfin on peut générer tout les paquets à partir de cette arbre et les faire bénéficier aux utilisateurs du système.
En gros c’est ce qui vous permet de faire :
pkg_add firefox
Quand vous faîtes ça, ça vous installe le programme firefox avec tous les autres programmes dont il a besoin pour fonctionner. On indique au gestionnaire de paquets (pkg_add dans ce cas) un dossier souvent sur le web mais pas que, où se trouve tous les paquets et il se débrouille ensuite à piocher dedans, tous les autres paquets des programmes dont il a besoin pour que le logiciel que vous avez demandé s’installe et fonctionne correctement chez vous. Si un programme manque et qu’il n’a pas de paquet pour ce programme il vous signalera le programme qu’il vous faut pour pouvoir installé votre logiciels afin qu’il puisse fonctionner.
Comment il sait qu’il a tout les programmes nécessaires pour fontionner ?
C’est indiqué dans les recettes pour générer les paquets et quand vous générer le paquets il met ces informations dans ce dernier pour que le gestionnaire de paquets sache quoi installé quand il installera votre programme.
Et donc nous on va apprendre à faire cette recette ?
Ouaip c’est ça, on va apprendre à faire une, c’est ce qu’on appelle un ports. Et pour ne pas refaire toutes les recettes des programmes pour le notre aura besoin on va déjà télécharger le dossier des recettes déjà faîtes fourni par OpenBSD.
Pour cela on va télécharger les ports dans le dossier /tmp pour les fichiers temporaire vérifier que le transfert c’est bien passé et l’extraire dans un dossier de notre choix comme ceci :
cd /tmp
ftp https://cdn.openbsd.org/pub/OpenBSD/$(uname -r)/{ports.tar.gz,SHA256.sig}
signify -Cp /etc/signify/openbsd-$(uname -r | cut -c 1,3)-base.pub -x SHA256.sig ports.tar.gz
cd /usr
su # il faut être root pour pouvoir extraire l'archive dans /usr
# tar xzvf /tmp/ports.tar.gz
# chown votre_user -R /usr/ports
La dernière commande sert à donné les droits à votre utilisateur de travailler sur le dossier car il est déconseillé de générer ses paquets en root. Il y a un risque de péter un peu tout les programmes quand on fait des tests.
Création du dossier mystuff
Donc on a nos ports d’installer mais on ne va pas travaillé directement dessus on va un repertoire nommé mystuff où nous allons mettre nos ports à nous :
cd /usr/ports
mkdir mystuff
cd mystuff
Création de tous les dossiers et fichers nécéssaires
Là on est dans notre répertoire de travail, c’est dans celui-ci qu’on va créer nos ports. Nous dans notre exemple, on va créé un port pour le programme args-count. Chaques programmes étant classés dans des catégories, il faut faire pareil dans notre repertoire de travail notre programme concerne le web donc on va le mettre dans la catégorie www et comme c’est du python et plus particulièrement un librairie python on va créer le dossier qui va accueillir notre recette py-flask-bcrypt
mkdir -p misc/args_count
cd misc/args_count
Ça y est on peut créer la recette
HAAA enfin ! On va passer aux choses serieuses ! Ben oui mon ami, c’est un peu long mais on ne construit quoi que ce soit sur une mauvaise base sinon soit ça s’écroule soit ça ne ressemble à rien. Pour cela
Une cuisine suréquipée
Il y a tout un tas d’outils pour aider à ne pas tout taper à la main donc du coup notre recette va ressembler à ça :
COMMENT= Program who count arguments
PKGNAME= args_count-${V}
V= 1.0
CATEGORIES= misc
MASTER_SITES= https://kitoy.me/git/kitoy/args_count/archive/
EXTRACT_SUFX = tar.gz
DISTFILES= ${V}.${EXTRACT_SUFX}
WRKSRC= ${WRKDIST}/args_count
MAINTAINER= Kitoy <Votre mail>
# Licence WFTPL
PERMIT_PACKAGE= Yes
WANTLIB += c
.include <bsd.port.mk>
Quelques petites explications : Même si les différentes variables à remplir parle d’elles mêmes voici quelques petites explications pour certaines d’entres elles. Toutes ces variables sont le strict minimum a compléter pour faire son ports. Là j’ai fais un petit programme d’exemple pour illustrer le fait que c’est assé simple d’écrire un simple programme et de le packager ensuite.
Dans la variables MASTER_SITES on met met juste l’adresse web du dossier où se trouve l’archive du programme, ensuite, on spécifie le format de l’archive et enfin, avec l’aide de toutes ces variables on peut construire le nom comlet de notre archive qu’on veut télécharger, on peut le voir avec la variable DISTFILES
Ensuite comme l’archive contient un dossier dans où sont placées les sources du programme je l’inqdique dans la variable WRKSRC.
Bon ensuite on met des informations pour être joins si jamais quelqu’un réutilise notre ports afin de signaler un problème ou une fonctionnalité.
Et je signale aussi en précisant la licence juste au dessus que mon programme peut-être redistribuer en spécifiant la licence en commentaire juste au dessus.
Mon programme est en C donc je lui demande l’outil de compilations et les outils pour le C. C’est ici(WANTLIB) qu’on déclare toutes les librairies dont on a besoin et lui il se demerdera à aller les chercher au bon endroit. Si j’avais un programme en python ben j’appellerai python et ainsi dessuite. Pour avoir un description assé exhautive de ce que l’on peut renseigner vous pouvez consulter le fichier
/usr/ports/infrastructure/templates/Makefile.template
Donc là on a notre liste d’ingredients maintenant on appelle le robotcooking !
Et enfin on appelle un programme qui va s’occuper de faire notre paquets à partir des informations qu’on lui aura donné précédement. bsd.port.mk
C’est là que ca devient intérréssant car ça nous donne accès a plein de fonctionnalités à l’aide d’un seul programme “make” qui veut dire faire en français et du coup tout devient super explicite dans les commandes que l’on tape.
Premièrement et en cas de problèmes ça permet de contrôler ce que contiennent nos différentes variables. Pour ça on va faire par exemple :
make show=DISTFILE
Et ça nous montre ce que contient la variable DISTFILE. Vous pouvez faire ça pour toutes les variables.
Ça y est tu es prêt·e on générer le paquet !
Pour s’assure que l’on travaille bien sur la même archive à chaque fois, on génére une somme de contôle des fichiers à télécharger. Comme ça si il y a une modification du contenue de l’archive ou un problème dans le téléchargement de l’archive vous êtes au courant dessuite et vous ne cherchez pas des heures sans savoir c’est quoi le problème. On fait comme ceci:
$ make makesum
Ensuite on peut lancer un simple make pour voir si ça compile:
$ make
Et pour finir on génére la liste des fichiers qui seront installés :
$ make plist
Cette commandes va créé un dossier pkg dans lequel sera stocké la liste de fichiers contenue dans votre paquets
Il faudra ajouté une description dans ce paquet :
echo “Programme qui compte les arguments” > pkg/DESCR
Et à partir de là on peut enfin générer le paquet:
make package
Ensuite on signe ses paquets pour les partager entre ses machines
Ouais, alors pourquoi on signe ces paquets ?
Bien déjà pour une raison simple prouver à celui(ou la machine) qui les télécharges que c’est bien les nôtres qu’il a télécharger et pas des paquets qui lui ressemble mais ne viennent pas de nous.
Du coup on va devoir générer deux clefs:
Pour cela on va d’abord se créer une paires de clefs comme ceci :
# mkdir /etc/signify/private
# signify -G -p /etc/signify/my-pkg.pub -s /etc/signify/private/my-pkg.sec
# chmod 400 /etc/signify/private/my-pkg.sec
Enfin on pourra signé le paquet généré précédement et le mettre dans le dossier signed:
# cd /usr/ports/packages/$(uname -p)
# pkg_sign -s signify2 -s /etc/signify/my-pkg.sec -o signed -S all
Ainsi sur vos autres systèmes où vous voudrez installer vos paquets vous n’aurez plus qu’à importer la clé publique dans le dossier /etc/signify et hop les paquets s’installeront sans problème car il y a bien une preuve que c’est vous qui avait généré ce paquet et du coup de risques d’installer n’importe quoi avec un paquet vérolé ;).