TOC

Comment configurer un système de construction Poudriere pour créer des paquetages pour vos serveurs FreeBSD

introduction

Le système de ports est l’un des atouts majeurs de FreeBSD pour les utilisateurs qui recherchent la flexibilité et le contrôle de leurs logiciels. Il permet aux administrateurs de créer et de gérer facilement des installations basées sur des sources en utilisant un système conçu pour être robuste et prévisible.

Bien que les avantages de cette fonctionnalité soient importants, certaines des plaintes les plus courantes contre l’administration basée dans les ports concernent le temps et les ressources nécessaires pour compiler chaque logiciel. Cela devient encore plus problématique si vous gérez un grand nombre de serveurs, chacun compilant ses propres ports. Alors que les paquets FreeBSD offrent une alternative qui accélère l’installation, ils sacrifient le contrôle accordé par les ports.

Pour atténuer ce problème, les administrateurs peuvent utiliser une application appelée * poudriere * pour créer et gérer des packages personnalisés. Bien que techniquement créé pour construire des paquets pour diverses architectures, + poudriere + est souvent utilisé comme environnement de construction de paquets pour créer et héberger des paquets pour toute une infrastructure de serveurs FreeBSD.

En tirant parti de + poudriere +, les administrateurs peuvent personnaliser les logiciels à l’aide du système de ports et compiler des packages pour faciliter l’installation et la gestion des logiciels. Un nombre quelconque de serveurs FreeBSD peuvent utiliser un hôte avec + poudriere + installé comme source de paquet, leur permettant de télécharger et d’installer rapidement et facilement des exécutables pré-compilés et personnalisés.

Dans ce guide, nous montrerons comment configurer un serveur avec + poudriere + en tant que machine de construction. Nous pouvons ensuite utiliser ce serveur comme référentiel pour les packages de serveurs supplémentaires. Bien que cette configuration puisse être bénéfique pour un seul serveur, les gains d’efficacité réels sont visibles lorsque des serveurs supplémentaires commencent à utiliser le même hôte + poudriere + en tant que source de package.

La construction de ports étant un processus gourmand en ressources, il peut être intéressant de l’installer sur un système plus puissant que d’habitude.

Installer le logiciel de gestion des ports nécessaires

Pour commencer, nous allons installer tous les ports dont nous avons besoin.

Comme toujours, avant de commencer toute tâche liée aux ports, nous mettrons à jour notre arborescence de ports pour nous assurer que les références sur le système de fichiers sont récentes:

sudo portsnap fetch update

Une fois l’arborescence des ports mise à jour, nous pouvons commencer à installer le logiciel. Premièrement, nous devons installer + poudriere + lui-même. Cela se trouve dans la catégorie + ports-mgmt + de l’arborescence des ports. Pour construire et installer, allez dans ce répertoire et utilisez + make + pour compiler et installer:

cd /usr/ports/ports-mgmt/poudriere
sudo make install clean

N’hésitez pas à choisir l’une des options présentées. Pour une construction standard, aucune n’est essentielle.

Ensuite, si vous ne l’avez pas déjà installé, nous devrons installer le port + portmaster +. Nous allons utiliser cela pour générer facilement une liste de logiciels sur notre machine que nous voulons que + poudriere + construise. C’est également dans la catégorie + ports-mgmt +:

cd /usr/ports/ports-mgmt/portmaster
sudo make install clean

Enfin, nous voudrons également installer un serveur Web. Cela servira à deux fins. Premièrement, ce sera la méthode par laquelle nos machines pourront télécharger les paquets que nous allons compiler. Deuxièmement, + poudriere + fournit une interface Web permettant de suivre le processus de construction et de surveiller les journaux.

Pour ce guide, nous utiliserons + nginx + en tant que serveur Web. Cela se trouve dans la catégorie + www + de l’arborescence des ports:

cd /usr/ports/www/nginx
sudo make install clean

Vous pouvez accepter les valeurs par défaut ou personnaliser si vous avez des besoins spécifiques dans un autre but.

Lorsque vous avez terminé la compilation et l’installation du logiciel, veillez à réévaluer votre CHEMIN si vous utilisez les shells + tcsh + ou + csh + par défaut:

rehash

Maintenant que notre logiciel est installé, nous pouvons commencer à configurer chacun de nos composants.

Créer un certificat SSL et une clé

Lorsque nous construisons des paquets avec + poudriere +, nous voulons pouvoir les signer avec une clé privée. Cela garantira à toutes nos machines que les packages créés sont légitimes et que personne n’intercepte la connexion à la machine de construction pour servir des packages malveillants.

Pour commencer, nous allons créer une structure de répertoire pour notre clé et notre certificat. Étant donné que toute notre configuration logicielle facultative a lieu dans le répertoire + / usr / local / etc + et que d’autres logiciels utilisent l’emplacement + / usr / local / etc / ssl +, nous allons placer nos fichiers.

Nous allons nous assurer que nous avons un répertoire + ssl qui contient deux sous-répertoires appelés` + keys` et + certs +. Nous pouvons le faire en une seule commande en tapant:

sudo mkdir -p /usr/local/etc/ssl/{keys,certs}

Notre clé privée, qui doit rester secrète, sera placée dans le répertoire + keys +. Ceci sera utilisé pour signer les paquets que nous allons créer. Maintenir cette sécurité est essentiel pour nous assurer que nos colis ne sont pas altérés. Nous pouvons verrouiller le répertoire afin que les utilisateurs sans privilèges root ou + sudo + ne puissent pas interagir avec le répertoire ou son contenu:

sudo chmod 0600 /usr/local/etc/ssl/keys

Le répertoire + certs + contiendra notre certificat accessible au public créé avec la clé. En tant que tel, nous pouvons laisser les autorisations par défaut sur ce répertoire.

Ensuite, nous allons générer une clé de 4096 bits appelée + poudriere.key +, et la placer dans notre répertoire + keys + en tapant:

sudo openssl genrsa -out /usr/local/etc/ssl/keys/poudriere.key 4096

Une fois la clé générée, nous pouvons créer un certificat public en tapant:

sudo openssl rsa -in /usr/local/etc/ssl/keys/poudriere.key -pubout -out /usr/local/etc/ssl/certs/poudriere.cert

Nous avons maintenant les composants SSL dont nous avons besoin pour signer les packages et vérifier les signatures. Plus tard, nous allons configurer nos clients pour qu’ils utilisent le certificat généré pour la vérification du paquet.

Configuration de Poudrière

Maintenant que nous avons notre certificat SSL et notre clé, nous pouvons commencer à configurer lui-même + poudriere +.

Le fichier de configuration principal se trouve dans + / usr / local / etc / poudriere.conf +. Ouvrez ce fichier avec les privilèges + sudo + dans votre éditeur de texte:

sudo vi /usr/local/etc/poudriere.conf

Le fichier de configuration + poudriere + est très bien commenté et contient la plupart des paramètres dont nous avons besoin prédéfinis. Nous allons apporter quelques modifications spécifiques, mais en laissant la majorité de celles-ci intactes.

Si votre serveur FreeBSD s’exécute sur DigitalOcean, le système de fichiers sera UFS. Il y a des options spécifiques à ZFS dans + poudriere + que nous ne devrions pas définir. Pour indiquer que nous utilisons UFS, nous devons définir le drapeau + NO_ZFS + sur «yes». Recherchez et décommentez cette option dans le fichier:

NO_ZFS=yes

Si, par contre, votre serveur utilise ZFS, vous pouvez configurer + poudriere + pour utiliser un pool spécifique en définissant l’option + ZPOOL +. Dans ce pool, vous pouvez spécifier la racine que + poudriere + utilisera pour les paquets, les journaux, etc. avec l’option + ZROOTFS +. Notez que ces deux options * ne doivent pas * être définies si l’option + NO_ZFS + est définie sur «yes:

NO_ZFS=yes
ZPOOL=
ZROOTFS=

Lors de la construction du logiciel, + poudriere + utilise un type de jail afin de séparer le système de compilation du système d’exploitation principal. Ensuite, nous devons renseigner un hôte valide sur lequel la machine de génération peut télécharger le logiciel nécessaire aux jails. Ceci est configuré via l’option + FREEBSD_HOST +.

Cette option devrait déjà être présente, bien qu’elle ne soit pas actuellement définie sur un hôte valide. Vous pouvez changer ceci à l’emplacement par défaut + ftp: // ftp.freebsd.org + ou utiliser un miroir plus étroit si vous en connaissez un:

FREEBSD_HOST=

Ensuite, nous voulons nous assurer que votre répertoire de données dans la racine + poudriere est correctement défini. Ceci est contrôlé avec l’option + POUDRIERE_DATA + et devrait être utilisé par défaut, mais nous décommenterons l’option juste pour être sûr:

POUDRIERE_DATA=${BASEFS}/data

Les options suivantes que nous devrions supprimer sont les options + CHECK_CHANGED_OPTIONS + et + CHECK_CHANGED_DEPS +. La première option indique à + ​​poudriere + de reconstruire les paquets lorsque leurs options ont changé. La deuxième option indique à + ​​poudriere + de reconstruire les paquetages lorsque les dépendances ont changé depuis la dernière compilation.

Ces deux options existent sous la forme souhaitée dans le fichier de configuration. Il suffit de les décommenter:

CHECK_CHANGED_OPTIONS=verbose
CHECK_CHANGED_DEPS=yes

Ensuite, nous allons pointer + poudriere + sur la clé SSL que nous avons créée afin qu’elle puisse signer les paquets au fur et à mesure de leur construction. L’option utilisée pour spécifier ceci s’appelle + PKG_REPO_SIGNING_KEY +. Décommentez cette option et changez le chemin pour refléter l’emplacement de la clé SSL créée précédemment:

PKG_REPO_SIGNING_KEY=

Enfin, nous pouvons définir la chaîne + URL_BASE + sur le nom de domaine ou l’adresse IP où votre serveur peut être atteint. + Poudriere + l’utilisera pour construire des liens dans sa sortie sur lesquels il est possible de cliquer. Vous devez inclure le protocole et terminer la valeur par une barre oblique:

URL_BASE=http:///

Lorsque vous avez terminé vos modifications, enregistrez et fermez le fichier.

Création de l’environnement de construction

Ensuite, nous devons réellement construire notre environnement de construction. Comme mentionné précédemment, + poudriere + construira des ports dans un environnement isolé en utilisant des jails.

Nous devrons créer votre prison et faire installer FreeBSD par + poudriere à l’intérieur. Il est possible d’avoir plusieurs jails, chacun avec une version différente de FreeBSD. Les versions FreeBSD emprisonnées doivent être identiques ou antérieures à la version exécutée par le serveur lui-même. Pour ce guide, nous allons nous concentrer sur une seule prison qui reflète l’architecture et la version FreeBSD du système hôte.

Nous devrions choisir un nom descriptif pour la prison que nous créons. Ceci est important car il sera utilisé dans la configuration de notre référentiel sur les clients, ce qui peut être très important lors de la compilation pour différentes versions de FreeBSD. Les pages + man + vous demandent également d’éviter d’utiliser des points dans le nom en raison de certaines interactions avec d’autres outils. Par exemple, dans ce guide, nous fonctionnons sous FreeBSD 10.1 sur une architecture 64 bits, nous allons donc appeler cela "freebsd_10-1x64".

Nous spécifions le nom de notre prison avec + -j + et nous indiquons la version de FreeBSD à installer en utilisant l’option + -v +. Vous pouvez trouver le format des versions prises en charge dans la colonne «Communiqués» du tableau à la page this. Si vous suivez + -CURRENT + ou + -STABLE + au lieu de la version, vous pouvez utiliser le format trouvé sur la page this (comme `+ 11- ACTUEL + `).

Pour nos besoins, notre commande de construction de prison ressemblera à ceci:

sudo poudriere jail -c -j freebsd_10-1x64 -v 10.1-RELEASE

Cela prendra un certain temps, alors soyez patient. Lorsque vous avez terminé, vous pouvez voir la prison installée en tapant:

poudriere jail -l
JAILNAME        VERSION         ARCH  METHOD TIMESTAMP           PATH
freebsd_10-1x64 10.1-RELEASE-p3 amd64 ftp    2015-01-06 20:43:48 /usr/local/poudriere/jails/freebsd_10-1x64

Une fois que vous avez créé une prison, nous devrons installer une arborescence de ports. Il est possible de gérer plusieurs arborescences de ports afin de répondre à différents besoins de développement. Nous allons installer une arborescence de ports unique que notre prison peut utiliser.

Nous pouvons utiliser l’indicateur + -p + pour nommer notre arborescence de ports. Nous appellerons notre arbre "HEAD" car il résume avec précision l’utilisation de cet arbre (la "tête" ou le point le plus récent de l’arbre). Nous le mettrons à jour régulièrement pour correspondre à la version la plus récente de l’arbre des ports disponible:

sudo poudriere ports -c -p HEAD

Encore une fois, cette procédure prendra un certain temps car toute l’arbre des ports doit être récupéré et extrait. Quand c’est fini, nous pouvons voir notre arborescence de ports en tapant:

poudriere ports -l

Une fois cette étape terminée, nous avons maintenant les structures en place pour compiler nos ports et créer des packages. Ensuite, nous pouvons commencer à assembler notre liste de ports pour créer et configurer les options souhaitées pour chaque logiciel.

Création d’une liste de construction de port et définition des options de port

Lors de la compilation avec + poudriere +, nous indiquons les ports que nous souhaitons construire lors de l’appel de la commande build. Il est possible de spécifier les ports individuellement, mais ce n’est pas une bonne solution pour la gestion à long terme. Au lieu de cela, nous allons créer une liste de ports que nous pouvons transmettre directement à la commande.

Le fichier create devrait lister la catégorie de port suivie d’une barre oblique et du nom du port afin de refléter son emplacement dans l’arborescence des ports, comme ceci:

/
/
/

. . .

Toutes les dépendances nécessaires seront également automatiquement construites. Ne vous inquiétez donc pas de la traçabilité complète de l’arborescence des dépendances des ports que vous souhaitez installer. Vous pouvez créer ce fichier manuellement, mais si la plupart des logiciels que vous souhaitez créer sont déjà installés sur votre système de base, vous pouvez utiliser + portmaster + pour créer cette liste pour vous.

Avant de faire cela, il est généralement préférable de supprimer toutes les dépendances inutiles de votre système afin de garder la liste de ports aussi propre que possible. Vous pouvez le faire en tapant:

sudo pkg autoremove

Ensuite, nous pouvons obtenir une liste des logiciels que nous avons explicitement installés sur notre système de compilation en utilisant + portmaster +. La commande + portmaster + peut générer une liste de ports explicitement installés (pas de dépendances) au format correct en utilisant l’option + - list-origins +.

Nous pouvons diriger cette sortie dans + sort + pour alphabétiser la liste afin de faciliter la recherche d’éléments. Nous pouvons exporter les résultats dans un fichier du répertoire + / usr / local / etc / poudriere.d +. Nous appellerons ce fichier + port-list:

portmaster --list-origins | sort -d | sudo tee /usr/local/etc/poudriere.d/port-list

Passez en revue la liste. Si vous ne souhaitez pas inclure de ports, supprimez la ligne qui leur est associée. C’est également l’occasion d’ajouter des ports supplémentaires dont vous pourriez avoir besoin.

Si vous utilisez des options spécifiques + make.conf pour construire vos ports, vous pouvez créer un fichier` + cmake.conf` pour chaque jail de votre répertoire + / usr / local / etc / poudriere.d +. Par exemple, pour notre prison, nous pouvons créer un fichier + make.conf + avec ce nom:

sudo vi /usr/local/etc/poudriere.d/-make.conf

A l’intérieur, vous pouvez définir toutes les options que vous souhaitez utiliser lors de la construction de vos ports. Par exemple, si vous ne souhaitez pas créer de documentation, d’exemples, de prise en charge de langue native ou de X11, vous pouvez définir:

OPTIONS_UNSET+= DOCS NLS X11 EXAMPLES

Ensuite, nous pouvons configurer chacun de nos ports, ce qui créera des fichiers avec les options que nous avons sélectionnées.

Si vous avez personnalisé vos ports sur votre système hôte, vous pouvez copier les configurations sur + poudriere + pour utiliser ces paramètres. Pour ce faire, créez un nouveau répertoire dans le répertoire + / usr / local / etc / poudriere.d + nommé en fonction de votre jail avec + -options + ajouté à la fin. Pour notre guide, nous pouvons accomplir cela en tapant:

sudo mkdir /usr/local/etc/poudriere.d/-options

Maintenant, vous pouvez copier les options que vous avez déjà utilisées sur votre système hôte en tapant:

sudo cp -r /var/db/ports/* /usr/local/etc/poudriere.d/-options

Si vous terminez l’étape ci-dessus, vous disposerez d’une base de référence pour les options que nous allons configurer, mais bon nombre de vos dépendances devront encore être configurées.

Vous pouvez configurer tout ce qui n’a pas déjà été configuré à l’aide de la commande + options +. Nous devrions transmettre à la fois l’arbre de ports que nous avons créé (en utilisant l’option + -p +) et la prison pour laquelle nous définissons ces options (en utilisant l’option + -j +). Nous devons également spécifier la liste des ports que nous voulons configurer en utilisant l’option + -f +.

Notre commande ressemblera à ceci:

sudo poudriere options -j freebsd_10-1x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Vous verrez une boîte de dialogue pour chacun des ports de la liste et toutes les dépendances pour lesquelles aucune option correspondante n’est définie dans le répertoire + -options +. Les spécifications de votre fichier + make.conf + seront présélectionnées dans les écrans de sélection. Sélectionnez toutes les options que vous souhaitez utiliser.

Si vous souhaitez reconfigurer les options de vos ports à l’avenir, vous pouvez réexécuter la commande ci-dessus avec l’option + -c +. Cela vous montrera toutes les options de configuration disponibles, que vous ayez déjà effectué une sélection ou non:

sudo poudriere options -c -j freebsd_10-1x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Construire les ports

Nous sommes enfin prêts à commencer à construire des ports.

La dernière chose à faire est de veiller à ce que notre prison et notre arborescence de ports soient à jour. Ce ne sera probablement pas un problème la première fois que vous construirez des ports car nous venons de créer l’arbre des ports et la prison, mais il est bon de prendre l’habitude de le faire chaque fois que vous exécutez une construction.

Pour mettre à jour votre prison, tapez:

sudo poudriere jail -u -j freebsd_10-1x64

Pour mettre à jour votre arborescence de ports, tapez:

sudo poudriere ports -u -p HEAD

Une fois que cela est terminé, nous pouvons lancer le processus de construction en bloc.

  • Note *: Cela peut être un processus très long. Si vous êtes connecté à votre serveur via SSH, nous vous recommandons d’installer + screen + et de démarrer une session:

cd /usr/ports/sysutils/screen
sudo make install clean

rehash
screen

Pour commencer la construction, il suffit d’utiliser la commande + bulk + et de pointer sur toutes les pièces individuelles que nous avons configurées. Si vous utilisez les valeurs de ce guide, la commande ressemblera à ceci:

sudo poudriere bulk -j freebsd_10-1x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Cela démarrera un certain nombre de travailleurs (en fonction de votre fichier + poudriere.conf + ou du nombre de processeurs disponibles) et commencera à construire les ports.

À tout moment du processus de construction, vous pouvez obtenir des informations sur la progression en maintenant la touche + CTRL + enfoncée et en appuyant sur + t +:

CTRL-t

Certaines parties du processus produiront plus de résultats que d’autres.

Si vous devez vous retirer, vous pouvez détacher la session screen en appuyant sur + CTRL + avec + a + pour déplacer le contrôle sur + screen +, suivi de la touche + d + pour détacher la session:

CTRL-a d

Lorsque vous souhaitez revenir à la session, vous pouvez taper:

screen -x

Configuration de Nginx pour servir le serveur frontal et le référentiel

Pendant que vos paquets se construisent, nous pouvons en profiter pour configurer Nginx. Ouvrez un autre terminal, détachez votre session + screen comme indiqué ci-dessus ou ouvrez une nouvelle fenêtre` + screen` en tapant + CTRL-a c + (vous pouvez basculer entre les fenêtres en tapant + CTRL-a n + et ` + CTRL-a p + `).

Le serveur Web sera utilisé à deux fins distinctes:

  • Il servira le référentiel de paquets réel que d’autres hôtes peuvent utiliser pour télécharger vos paquets compilés personnalisés.

  • Il servira le web frontal + poudriere + qui peut être utilisé pour surveiller le processus de construction

Nous avons installé Nginx au début de ce guide, mais nous ne l’avons pas configuré.

Pour commencer, activez le service en ajoutant la ligne + nginx_enable =" YES "+ au fichier + / etc / rc.conf +. Cela démarrera le serveur au démarrage et nous permettra d’utiliser les commandes classiques + service + pour gérer le processus:

sudo sh -c "echo 'nginx_enable="YES"' >> /etc/rc.conf"

Nous pouvons maintenant ajuster le fichier de configuration par défaut. Ouvrez-le avec les privilèges + sudo + dans votre éditeur de texte:

sudo vi /usr/local/etc/nginx/nginx.conf

Dans ce fichier, nous allons tout supprimer du bloc + server {} + et le remplacer par notre propre configuration. Assurez-vous de laisser intactes les accolades ("\ {" et "}") pour vous assurer que votre fichier est valide.

Dans le contexte + serveur +, nous pouvons définir des directives de base pour permettre à notre serveur Web de répondre au trafic HTTP conventionnel sur le port 80 et au nom de domaine ou à l’adresse IP de notre serveur. Nous allons également définir la racine du document du serveur sur le répertoire Web + poudriere + situé dans + / usr / local / share / poudriere / html +. Modifiez la valeur de la directive + nom_serveur + ci-dessous pour qu’elle corresponde au nom de domaine ou à l’adresse IP de votre serveur:

# http context

. . .

   server {
       listen 80 default;
       server_name ;
       root /usr/local/share/poudriere/html;
   }

}

Ensuite, nous ajouterons deux blocs + location.

Bien que la directive de base + racine + définie plus haut gère la majorité de l’interface Web, nous devons indiquer à Nginx le répertoire dans lequel nous stockons les journaux et les données réelles. Poudriere utilisera le point de terminaison + / data + pour cela. Nos journaux sont tous écrits dans un répertoire spécifique. Nous pouvons donc activer la directive + autoindex + pour cet emplacement afin d’afficher la liste des journaux.

En fin de compte, notre premier bloc + emplacement + ressemblera à ceci:

# http context

. . .

   server {
       listen 80 default;
       server_name ;
       root /usr/local/share/poudriere/html;

       location /data {
           alias /usr/local/poudriere/data/logs/bulk;
           autoindex on;
       }
   }
}

Cela devrait permettre à notre interface Web de fonctionner correctement (après une modification supplémentaire du fichier + mime.types + que nous effectuerons dans un instant). Ensuite, nous devons ajouter notre deuxième bloc d’emplacement qui sera utilisé pour servir les paquets réels que nous avons construits.

Les paquets seront stockés dans un répertoire sous + / usr / local / poudriere +, cette fois sous + data / packages +. Nous pouvons le rendre disponible à l’emplacement + / packages +. De nouveau, nous pouvons activer + autoindex + pour afficher le contenu du répertoire, ce qui nous permet également d’afficher les fichiers dans un navigateur Web.

Une fois cette dernière modification terminée, le bloc + serveur + devrait ressembler à ceci:

#http context

. . .

   server {
       listen 80 default;
       server_name ;
       root /usr/local/share/poudriere/html;

       location /data {
           alias /usr/local/poudriere/data/logs/bulk;
           autoindex on;
       }

       location /packages {
           root /usr/local/poudriere/data;
           autoindex on;
       }
   }
}

Enregistrez et fermez le fichier lorsque vous avez terminé.

Ensuite, nous allons apporter une petite modification à notre fichier + mime.types +. Avec les paramètres actuels, si vous cliquez sur un journal dans le navigateur Web, le fichier sera téléchargé au lieu de l’afficher sous forme de texte brut. Nous pouvons changer ce comportement en marquant les fichiers se terminant par + .log + en tant que fichiers texte brut.

Ouvrez le fichier Nginx + mime.types + avec les privilèges sudo dans votre éditeur de texte:

sudo vi /usr/local/etc/nginx/mime.types

Recherchez l’entrée qui spécifie le type de contenu + text / plain + et ajoutez + log + à la fin de la liste actuelle des types de fichiers, séparés par un espace:

. . .

text/mathml                         mml;
text/plain                          txt ;
text/vnd.sun.j2me.app-descriptor    jad;

. . .

Enregistrez et fermez le fichier lorsque vous avez terminé.

Maintenant, vérifiez la syntaxe de vos fichiers de configuration en tapant:

sudo service nginx configtest

Si vous avez des erreurs, corrigez-les avant de continuer. Si votre test de configuration ne signale aucune erreur de syntaxe, démarrez Nginx en tapant:

sudo service nginx start

Si un pare-feu est activé, pensez à configurer vos règles pour autoriser le trafic sur le port 80 et redémarrer le service.

Maintenant, vous pouvez voir l’interface web + poudriere + en allant dans le nom de domaine ou l’adresse IP de votre serveur dans votre navigateur web:

http://

Vous devriez voir la page principale + poudriere +:

image: https: //assets.digitalocean.com/articles/freebsd_poudriere/main.png [Page principale de Poudriere]

Si vous cliquez dessus, vous devriez pouvoir visualiser le processus ou les résultats de la construction de votre port. Vous devriez également pouvoir cliquer sur les journaux de toutes les constructions terminées.

Si vous souhaitez afficher vos packages compilés dans le navigateur, ceux-ci doivent être disponibles via une hiérarchie commençant par + / packages +:

image: https: //assets.digitalocean.com/articles/freebsd_poudriere/packages.png [Repo des packages Poudriere]

Vous devrez peut-être attendre la fin de la construction pour pouvoir voir les paquetages. En cliquant sur les liens, vous verrez les paquetages compilés que vous avez produits avec votre commande + poudriere + build.

Configuration des clients de package

Maintenant que les packages sont construits et qu’un référentiel est configuré pour servir vos packages, vous pouvez configurer vos clients pour qu’ils utilisent le serveur comme source de leurs packages.

Configuration du serveur de construction pour utiliser son propre référentiel de paquet

Nous pouvons commencer par configurer le serveur de construction de manière à utiliser les packages qu’il a créés.

Premièrement, nous devons créer un répertoire pour contenir nos fichiers de configuration du référentiel:

sudo mkdir -p /usr/local/etc/pkg/repos

Dans ce répertoire, nous pouvons créer notre fichier de configuration du référentiel. Il doit se terminer par + .conf +, nous l’appellerons donc + poudriere.conf + pour refléter son objectif:

sudo vi /usr/local/etc/pkg/repos/poudriere.conf

Nous allons définir le nom du référentiel comme + poudriere + encore une fois. Dans la définition, nous indiquerons l’emplacement sur le disque où nos packages sont stockés. Cela devrait être un répertoire qui combine votre nom de prison et le nom de l’arborescence du port avec un tiret. Vérifiez votre système de fichiers pour en être certain. Nous allons également configurer la validation de la signature de nos paquets en pointant sur le certificat que nous avons créé.

En fin de compte, votre fichier devrait ressembler à ceci:

poudriere: {
   url: "file:///usr/local/poudriere/data/packages/",
   mirror_type: "srv",
   signature_type: "pubkey",
   pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
   enabled: yes
}

À ce stade, vous devez prendre une décision. Si vous voulez ferfer vos paquets compilés et vous baser sur les paquets fournis par les principaux référentiels FreeBSD, vous pouvez définir une priorité ici, en lui indiquant de préférer les paquets en dehors de ce référentiel. Cela fera que notre référentiel local aura la priorité sur les référentiels officiels.

Gardez à l’esprit que le mélange de paquets de cette manière peut avoir des conséquences compliquées. Si les référentiels officiels ont une version de package supérieure à celle de votre référentiel local, votre package compilé peut être remplacé par le générique des référentiels officiels (jusqu’à ce que vous reconstruisiez avec + poudriere + et que vous le réinstalliez avec + pkg +). En outre, les packages officiels peuvent supposer que les packages dépendants sont construits d’une certaine manière et peuvent ne pas fonctionner lorsqu’ils sont mélangés avec vos packages personnalisés.

Si vous choisissez de mélanger ces deux sources de paquet, soyez prêt à vérifier soigneusement chaque installation pour vous assurer que vous ne causez pas accidentellement un comportement indésirable.

Pour mélanger des packages, ajoutez un paramètre + priority + à votre définition de référentiel, en spécifiant que le référentiel local a une priorité plus élevée:

poudriere: {
   url: "file:///usr/local/poudriere/data/packages/",
   mirror_type: "srv",
   signature_type: "pubkey",
   pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
   enabled: yes,
   priority: 100
}

Enregistrez et fermez le fichier lorsque vous avez terminé.

Si vous avez choisi * uniquement * d’installer des packages personnalisés (la route la plus sûre), vous pouvez omettre le paramètre de priorité, mais vous souhaitez désactiver les référentiels par défaut. Vous pouvez le faire en créant un fichier de référentiel différent qui remplace le fichier de référentiel par défaut et le désactive:

sudo vi /usr/local/etc/pkg/repos/freebsd.conf

À l’intérieur, utilisez le nom + FreeBSD + afin de correspondre à la définition du référentiel par défaut. Désactivez le référentiel en le définissant comme suit:

FreeBSD: {
   enabled: no
}

Enregistrez et fermez le fichier lorsque vous avez terminé.

Quel que soit votre choix de configuration, vous devriez maintenant être prêt à utiliser votre référentiel. Mettez à jour votre liste de paquets en tapant:

sudo pkg update

Votre serveur peut maintenant utiliser la commande + pkg + pour installer les paquetages à partir de votre référentiel local.

Configuration des clients distants pour utiliser le référentiel de votre machine de compilation

Une des raisons les plus convaincantes de configurer + poudriere + sur une machine de construction est d’utiliser cet hôte comme référentiel pour de nombreuses autres machines. Tout ce que nous avons à faire pour que cela fonctionne est de télécharger le certificat SSL public à partir de notre machine de compilation et de configurer une définition de référentiel similaire.

Pour vous connecter à notre hôte de génération à partir de nos ordinateurs clients, vous devez démarrer un agent SSH sur votre * ordinateur local * pour stocker vos informations d’identification de clé SSH.

OpenSSL est livré avec un agent SSH qui peut être démarré en tapant ceci sur votre ordinateur domestique:

eval $(ssh-agent)

Ensuite, vous devrez y ajouter votre clé SSH en tapant:

ssh-add

Ensuite, vous pouvez transférer vos informations d’identification SSH locales sur vos ordinateurs clients lorsque vous vous connectez à l’aide de l’indicateur + -A +. Cela vous permettra d’accéder à n’importe quel ordinateur depuis votre ordinateur client comme si vous y accédiez depuis votre ordinateur personnel:

ssh -A @

Une fois que vous êtes sur votre ordinateur client distant, la première étape consiste à créer la structure de répertoires (si elle n’existe pas) pour que vous puissiez stocker le certificat. Nous allons également créer un répertoire pour les clés afin de pouvoir l’utiliser pour les tâches futures:

sudo mkdir -p /usr/local/etc/ssl/{keys,certs}

Maintenant, nous pouvons nous connecter à notre machine de compilation avec SSH et rediriger le fichier de certificat vers notre machine cliente. Depuis que nous avons transmis nos informations d’identification SSH, nous devrions pouvoir le faire sans être invité à entrer un mot de passe:

ssh freebsd@ 'cat /usr/local/etc/ssl/certs/poudriere.cert' | sudo tee /usr/local/etc/ssl/certs/poudriere.cert

Cette commande se connectera à la machine de construction à partir de votre ordinateur client à l’aide de vos informations d’identification SSH locales. Une fois connecté, il affiche le contenu de votre fichier de certificat et le redirige vers le poste client distant via le tunnel SSH. À partir de là, nous utilisons la combinaison + sudo tee + pour écrire le certificat dans notre répertoire.

Une fois cette opération terminée, nous pouvons créer la structure de répertoire de notre référentiel, comme nous l’avons fait sur la machine de construction elle-même:

sudo mkdir -p /usr/local/etc/pkg/repos

Nous pouvons maintenant créer un fichier de référentiel très similaire à celui que nous avons utilisé sur la machine de construction:

sudo vi /usr/local/etc/pkg/repos/poudriere.conf

Les différences sont l’emplacement de l’URL et le type de miroir. Là encore, nous pouvons choisir de mélanger des packages ou d’utiliser only nos packages personnalisés compilés. Les mêmes avertissements s’appliquent en ce qui concerne le mélange de sources de paquet.

Si vous souhaitez mélanger vos packages personnalisés avec ceux des référentiels officiels, votre fichier doit ressembler à ceci:

poudriere: {
   url: "http:///packages//",
   mirror_type: "http",
   signature_type: "pubkey",
   pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
   enabled: yes,
   priority: 100
}

Si vous souhaitez utiliser uniquement vos packages compilés, votre fichier doit ressembler à ceci:

poudriere: {
   url: "http:///packages//",
   mirror_type: "http",
   signature_type: "pubkey",
   pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
   enabled: yes

De plus, si vous utilisez uniquement vos propres packages, pensez à créer un autre fichier de configuration de référentiel pour remplacer la configuration de référentiel FreeBSD par défaut:

sudo vi /usr/local/etc/pkg/repos/freebsd.conf

Placez le contenu suivant dans le fichier pour désactiver les référentiels officiels:

FreeBSD: {
   enabled: no
}

Une fois que vous avez terminé, mettez à jour votre base de données + pkg + pour commencer à utiliser vos packages compilés personnalisés:

sudo pkg update

Cette procédure peut être répétée sur autant de machines clientes FreeBSD que vous le souhaitez.

Reconstruire vos paquets lorsque des mises à jour sont disponibles

Vous devriez maintenant avoir toute votre installation + poudriere + en cours d’exécution. Cependant, vous devrez reconstruire vos packages de temps en temps lorsque de nouvelles mises à jour deviennent disponibles, notamment si elles sont liées à la sécurité.

Heureusement, la procédure de reconstruction des packages est assez simple. Tout d’abord, vous devez mettre à jour votre prison FreeBSD afin que vos packages soient construits sur le système d’exploitation à jour. Vous pouvez le faire en tapant:

sudo poudriere jail -u -j freebsd_10-1x64

Ensuite, vous devriez mettre à jour votre arborescence de ports afin que la dernière version de chaque port soit disponible pour votre prison. Vous pouvez le faire en tapant:

sudo poudriere ports -u -p HEAD

Après la mise à jour de l’arborescence jail et des ports, vous pouvez modifier votre liste de ports si vous souhaitez apporter des modifications:

sudo vi /usr/local/etc/poudriere.d/port-list

Si vous devez ajuster les options + make.conf +, vous pouvez le faire en modifiant le fichier associé à votre construction:

sudo vi /usr/local/etc/poudriere.d/-make.conf

Vous pouvez rechercher de nouvelles options pour vos ports en tapant ceci:

sudo poudriere options -j freebsd_10-1x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Si vous souhaitez plutôt examiner all des options de vos ports, vous pouvez ajouter l’indicateur + -c +. Cela peut être utile lors du dépannage de problèmes de construction ou d’exécution:

sudo poudriere options -c -j freebsd_10-1x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Lorsque vous avez terminé les étapes préparatoires ci-dessus, vous pouvez recompiler tous les ports modifiés ou mis à jour en tapant:

sudo poudriere bulk -j freebsd_10-1x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

N’hésitez pas à surveiller les progrès dans l’interface Web. Une fois les nouveaux packages compilés, vous pouvez les mettre à jour sur chaque machine en tapant:

sudo pkg upgrade

Cela vous permettra de mettre à jour vos paquets personnalisés sur l’ensemble de votre infrastructure FreeBSD assez facilement.

Conclusion

Dans ce guide, nous avons expliqué comment configurer + poudriere + pour compiler et conditionner un ensemble de ports personnalisé pour notre machine de construction et nos clients externes. Le processus peut sembler long à première vue, mais il est assez simple de le gérer une fois que vous l’avez installé.

En utilisant + poudriere +, vous pourrez tirer parti des deux systèmes de gestion de logiciels optionnels de FreeBSD. Pour de nombreux utilisateurs, cela constitue le meilleur des deux mondes. Un système de compilation + poudriere + vous permet de personnaliser le logiciel à votre guise sur une seule machine tout en utilisant le système rapide + pkg + pour l’installation et la gestion effectives.

Related