Les systèmes d'exploitation (OS) sont un sujet approfondi. Pendant des décennies, une approche a dominé ici: Unix. En effet, la plupart des systèmes modernes, y compris la plupart des distributions GNU / Linux, * BSD et macOS, adhèrent à l'architecture Unix. (Il n'y a pas de Windows, mais il n'y a presque rien d'intéressant sur ce sujet).
En 2000, Rob Pike a fait un exposé sur les raisons pour lesquelles la
recherche sur les logiciels système n'est pas pertinente . En raison du pessimisme ou de la négligence de la communauté, il semble avoir complètement ignoré les plaintes recueillies par de nombreux utilisateurs d'Unix dans
The Unix-Haters Handbook (1994). Le livre est délibérément sarcastique, mais souligne certains problèmes critiques avec les systèmes Unix - et ils n'ont pas encore été résolus.
En 2006, Elko Dositra a publié sa thèse,
«Un modèle de déploiement de logiciel entièrement fonctionnel», qui décrit le gestionnaire de packages Nix fonctionnel. En 2008, l'auteur a publié
NixOS: une distribution Linux entièrement fonctionnelle . Alors que NixOS réutilise beaucoup de logiciels gratuits pour les systèmes Unix, il est si loin de la conception et de la philosophie Unix qu'il peut difficilement être appelé un «système Unix».
Nix est un grand pas en avant dans l'ingénierie des systèmes. Cet OS a non seulement résolu de nombreux problèmes Unix (y compris les critiques de la collection susmentionnée), mais a également ouvert la voie à de nombreuses autres fonctions et études qui peuvent jouer un rôle très important à notre époque, lorsque la fiabilité et la sécurité sont devenues le sujet principal de nombreux travaux scientifiques, publics et politiques. débat.
Pike avait tort. Et cela prouve un autre point plus général: il est probablement plus sage de s’abstenir de déclarer toute recherche non pertinente si vous ne pouvez pas prouver l’impossibilité de poursuivre le développement. Et le rapport mentionné peut difficilement être considéré comme une preuve mathématique. Il n'a fait que renforcer l'idée qu'Unix est «assez bon» et que vous devez accepter ses fonctionnalités et ses problèmes.
Heureusement, ce pessimisme inutile était myope et n'a pas duré longtemps: quelques années plus tard, le système Nix l'a prouvé.
Apparence de Guix
Guix est le gestionnaire de paquets sur Nix, et GuixSD est le système d'exploitation, l'équivalent de NixOS, qui vise à être un «OS entièrement programmable». En effet, presque tout ici est écrit et configuré dans le
schéma Guile : de la gestion des paquets Guix au système d'initialisation de
GNU Shepherd.
Guix est très différent des systèmes d'exploitation Unix. Vous pouvez consulter la documentation et évaluer le degré de changement:
Avantages sociaux chez Guix
Les avantages de Guix sont révolutionnaires au point où le reste du système d'exploitation ressemble à des systèmes hérités par rapport à lui.
Mes fonctionnalités préférées personnelles:
- Invulnérabilité du système: Guix conserve un historique de tous les changements au niveau du système et de l'utilisateur. Si la mise à jour casse quelque chose, vous pouvez toujours revenir en arrière. Cela rend le système pratiquement invulnérable .
- Intégrité: puisque la configuration est déclarative, elle donne à l'utilisateur ou à l'administrateur système un contrôle complet. Sur les autres variantes Unix, il est beaucoup plus difficile de dire quand un fichier de configuration aléatoire change.
- Système d'exploitation entièrement programmable: programmez les configurations du système et utilisez un système de contrôle de version. De nombreux services système peuvent être configurés dans le Guile Scheme: des règles udev à Xorg, PAM, etc. Grâce à Guile, la configuration peut être conditionnée par le matériel ou même le nom d'hôte!
- Remplacement direct d'autres gestionnaires de packages (pas si bons): pourquoi gérer séparément les packages Emacs, Python ou TeXlive s'il y a une seule interface pour tout le monde (voir ci - dessous )! Il est plus facile d'écrire et de gérer des déclarations pour les profils utilisateur.
- Définitions de packages Guile: il est beaucoup plus efficace de développer des définitions de packages en vrac . Il remplace avantageusement des concepts tels que les indicateurs Portage USE (voir ci - dessous ).
- Plusieurs modes d'émission de packages: Un package Guix peut avoir plusieurs «modes d'émission» qui servent à séparer les différents composants (bibliothèques, outils supplémentaires, documentation, etc.). Sur d'autres systèmes d'exploitation (généralement Debian), il est plus difficile de deviner quels paquets s'emboîtent.
- Entrées non multiplicatives: dans la terminologie Guix, les «entrées» sont des dépendances de paquet. Le profil utilisateur et l'environnement ne contiennent que des packages installés explicitement par l'utilisateur et pas nécessairement leurs dépendances. Par exemple, voir inxi , un outil de génération de rapports sur les informations système: si je ne suis intéressé que par les rapports sur le système / équipement inxi, il n'est pas nécessaire d'ajouter deux à trois douzaines d'outils de ligne de commande supplémentaires à
PATH . Guix vous permet d'afficher dans le profil de l'utilisateur uniquement ce dont il a vraiment besoin.
- Environnements Guix: Lorsque vous exécutez un
guix environment SOME-PACKAGES Guix guix environment SOME-PACKAGES Guix met en place un environnement temporaire où toutes les exigences pour SOME-PACKAGES . Cela peut être utilisé pour configurer facilement l'environnement de construction pour le projet, ainsi qu'à d'autres fins (voir ci-dessous). Une grande qualité - ils vous permettent d'exécuter des programmes sans les installer dans le profil utilisateur.
- Mises à jour partielles: 100% pris en charge. C'est probablement la principale cause de pannes dans les versions flottantes comme Arch Linux et Gentoo: comme seules plusieurs versions y sont prises en charge en même temps (généralement une seule), l'ensemble du système doit être mis à jour dans son ensemble. Cela signifie plus de trafic à chaque mise à jour. Avec Guix, tout package est mis à jour individuellement.
- Intégration continue ou pourquoi Guix peut fonctionner sans mainteneurs de packages: grâce à des versions reproductibles et à la prise en charge des mises à jour partielles, si le package fonctionne sur Guix, il fonctionnera "toujours" et certaines dépendances ne se briseront pas lors de la prochaine mise à jour (plus précisément, si la dépendance rompt le package, alors cela est trivialement corrigé pour utiliser la bonne version de la bibliothèque). Ainsi, le travail avec les packages peut être transféré vers des «fermes d'assemblage» (l'une sur Hydra du projet Nix, l'autre sur Cuirass ). Comparez cela à la plupart des autres communautés GNU / Linux, qui nécessitent des dizaines de mainteneurs pour mettre à niveau des milliers de packages. Cette approche n'est pas évolutive: au final, ces distributions stagnent sur quelques milliers de packages. À Guix, le nombre de colis peut augmenter tranquillement sans crainte de s'effondrer. Dans le même temps, les contributeurs peuvent être utilisés plus efficacement.
À Guix, la construction à partir des sources est tout aussi simple. En fait, ce n'est pas si important pour l'utilisateur final: Guix peut facilement retourner à l'assemblage depuis les sources si le paquet fini n'est pas disponible.
guix import et guix refresh : créez ou mettez à jour automatiquement et récursivement les définitions de package. Des centaines de définitions sont traitées simultanément. Ces fonctionnalités soulignent les avantages d'un véritable langage de programmation dans le système d'exploitation. Ce qui est une tâche difficile sur la plupart des systèmes d'exploitation, elle est relativement facile à implémenter dans Guix.
- Chaînes Guix: une de mes fonctionnalités préférées! Arch Linux ou Gentoo vous oblige à créer un référentiel local. Comme ils ne prennent pas en charge les mises à jour partielles, l'utilisateur doit effectuer une maintenance de temps en temps (c'est-à-dire s'assurer que les mises à jour des dépendances ne cassent pas les packages). Les canaux Guix remplacent avantageusement les superpositions AUR d'Arch Linux et Gentoo, permettant à quiconque de distribuer leurs définitions de packages, par exemple, à partir des référentiels Git. Encore une fois, cela garantit une transparence totale (pots-de-vin, historique, etc.).
- Emacs-Guix : Pour autant que je sache, Guix est la seule distribution à être livrée avec l'interface utilisateur Emacs la plus puissante!
- Packs Guix : une véritable alternative aux conteneurs comme Docker. La plupart des systèmes de conteneurs souffrent de problèmes critiques: ils ne peuvent pas être lus et en réalité ce sont des binaires opaques, ce qui est catégoriquement inacceptable pour les utilisateurs qui se soucient de la confiance, de la sécurité et de la confidentialité. Au contraire, les packs Guix sont absolument clairs, reproductibles et transparents.
guix system vm et guix system disk-image : Guix simplifie la lecture de l'intégralité du système actuel en tant qu'USB en direct, à l'intérieur de la machine virtuelle ou sur une machine distante.
Guix en comparaison avec ses concurrents
Debian, Arch Linux et la plupart des autres distributions GNU / Linux
Les distributions GNU / Linux n'ont généralement pas les avantages susmentionnés de Guix. Les lacunes les plus critiques:
- Manque de support pour plusieurs versions de packages ou «enfer des dépendances». Supposons que le dernier mpv nécessite un nouveau ffmpeg, mais la mise à jour de ffmpeg interrompt la plupart des autres programmes. Nous sommes coincés dans un dilemme: soit casser des paquets, soit sauvegarder les anciennes versions. Pire encore, il peut ne pas y avoir de package approprié ou il n'y a pas de prise en charge du système d'exploitation. Ce problème est inhérent à la plupart des distributions qui ne peuvent garantir l'accomplissement de leur tâche principale: un package pour n'importe quel programme.
- Dépendance critique envers les mainteneurs. La gestion des packages non fonctionnels signifie que tous les packages doivent être constamment testés pour la compatibilité. C'est beaucoup de travail acharné pour ceux sur les épaules desquels cette tâche a été confiée. En pratique, cela signifie que la qualité de la gestion des packages dépend fortement des personnes. Une distribution sans un nombre suffisant de mainteneurs souffrira inévitablement et pourrait même mourir. Cette exigence de main-d'œuvre n'est pas normalement mise à l'échelle et, à mesure que le nombre de paquets augmente, elle entraîne une augmentation de la complexité (à la fois dans la base de code et dans la gestion).
Gentoo, * BSD
Gentoo et d'autres distributions avec le gestionnaire de paquets
Portage ont une caractéristique célèbre:
UTILISER des drapeaux pour activer des fonctions dans tout le système (par exemple, couper le son, activer le support de l'interface graphique, etc.).
Les indicateurs USE rendent trivial l'activation ou la désactivation des fonctions de l'auteur du package (et l'avantage est qu'elles sont testées). En revanche, Portage ne vous permet pas de configurer des fonctionnalités qui ne sont pas pensées à l'avance. Par exemple, si un package a un son supplémentaire, mais que l'auteur n'a pas défini l'indicateur correspondant, l'utilisateur ne pourra rien y faire (sauf pour créer une nouvelle définition de package).
Par comparaison, Guix vous permet de tout personnaliser, mais avec un peu plus de code Scheme. En pseudo code, cela ressemble à ceci:
(loop-over (TARGET-PACKAGES) (package (inherit TARGET) (changes-here... including patches, build options, etc.))
Ce lot de code définit les définitions des
TARGET-PACKAGES avec vos modifications. Aucune des modifications ne doit être apportée à la définition du package. À tout moment, l'utilisateur conserve un contrôle total sur les modifications qui peuvent être apportées aux packages.
J'ai adoré Gentoo, mais après être passé à Guix, les limites de Portage sont devenues apparentes.
- Le système de drapeau USE ne permet pas la personnalisation de fonctions arbitraires non planifiées.
- L'utilisation de drapeaux ajoute une classe entière de complexité (voir la sémantique des atomes plutôt compliquée) pour décrire et gérer la relation des fonctions entre les packages. Guix supprime complètement ce niveau de complexité en utilisant Guile Scheme pour programmer les relations.
De plus, Portage souffre du même problème avec le manque de prise en charge appropriée pour plusieurs versions, et les indicateurs augmentent considérablement l'ampleur du problème (une plainte fréquente à propos de Portage): lorsque des indicateurs USE incompatibles s'appliquent à certaines dépendances, l'utilisateur doit rechercher manuellement une solution. Parfois, cela signifie que la fonction requise n'est pas applicable (du moins sans travail important sur les définitions de package).
En pratique, Guix fournit des packages pré-compilés - un énorme gain de temps par rapport à Gentoo (bien que Portage supporte la distribution de packages binaires).
* Les systèmes BSD (par exemple FreeBSD) souffrent de problèmes similaires dans la
make config .
Nix
Nix a été une percée historique dans la recherche de systèmes d'exploitation, et Guix a emprunté presque toutes ses idées à partir de là. Aujourd'hui, Nix est toujours l'un des meilleurs systèmes d'exploitation actifs. Guix n'aurait probablement pas existé sans un défaut.
À mon avis, Guix résout le problème principal de Nix: au lieu de son propre
langage spécifique au domaine (DSL), un langage de programmation complet basé sur Lisp Guile Scheme est utilisé ici.
«Mettre en œuvre votre propre langage de programmation» est une idée fausse très courante dans le développement de logiciels. Cela a touché de nombreux projets où le langage de configuration ou de programmation souffrait des inconvénients suivants:
- expressivité et capacités limitées;
- Une autre langue d'apprentissage (mais pas quelque chose de très utile et universel), qui nécessite un certain effort de la part de l'utilisateur et crée ainsi une barrière à l'entrée;
- code moins lisible (au moins au début);
- performances souvent médiocres.
Il y a tellement de projets dans des langues locales ou trop limitées:
- XML, HTML (encore mieux: S-XML )
- Make, Autoconf, Automake, Cmake, etc.
- Bash, Zsh, Fish (encore mieux: Eshell ou scsh )
- JSON, TOML, YAML
- Portage vers Nix Ebuild et de nombreuses autres règles de syntaxe pour les définitions de packages OS
- Firefox lorsqu'il est utilisé XUL (Mozilla l'a depuis abandonné) et la plupart des autres langues locales pour les extensions
- SQL
- Octave, R, PARI / GP, la plupart des programmes scientifiques (par exemple Common Lisp, Racket et autres schémas)
- Expressions régulières ( rx dans Emacs , PEG dans Racket , etc.)
- sed, AWK, etc.
- La plupart des configurations init, y compris systemd (encore mieux: GNU Shepherd )
- cron (encore mieux: mcron )
- conky (pas entièrement programmable, bien que cela devrait être la caractéristique la plus attendue d'un programme similaire)
- TeX, LaTeX (et tous les dérivés), Asymptote (encore mieux: scribble , skribilo - toujours en développement; depuis janvier 2019, TeX / LaTeX est toujours utilisé comme étape intermédiaire dans la préparation du PDF)
- La plupart des programmes avec des configurations qui n'utilisent pas de langage de programmation à usage général.
Réinventer la roue n'est généralement pas une bonne idée. Quand il s'agit d'outils aussi importants que les langages de programmation, cela a des conséquences très dramatiques. Des efforts supplémentaires inutiles sont nécessaires, des erreurs se produisent. La communauté se disperse. Des communautés plus consolidées sont plus efficaces et utilisent mieux leur temps si elles améliorent les langages de programmation existants et bien développés.
Pas seulement pour le bureau
Guix prend en charge plusieurs architectures (i686, x86_64, ARMv7 et AArch64 à partir de janvier 2019) et prévoit de prendre en charge davantage de cœurs en dehors de l'écosystème Linux (disons * BSD,
GNU Hurd ou peut-être votre propre système!).
Cela fait de Guix un excellent outil pour déployer des serveurs (reproductibles) et d'autres systèmes spécialisés. Je pense que dans les systèmes embarqués, Guix peut très bien rivaliser avec
OpenWRT (bien qu'il faudra un certain travail pour porter sur des systèmes embarqués).
USB live auto-reproductible
Ci-dessus, j'ai mentionné
guix system disk-image : par exemple, il vous permet de recréer le système actuel sur une clé USB.
Ainsi, un clone du système actuel est facile à connecter n'importe où et à reproduire l'environnement actuel exact (moins le matériel). Vous pouvez y inclure des données utilisateur: clés PGP, e-mail. Tout est disponible immédiatement après le téléchargement.
De toute évidence, le clonage fonctionne plus loin de la machine sur laquelle le clone est installé: au lieu du Guix «nu», un système d'exploitation à part entière est déployé, prêt à fonctionner.
Remplacement d'autres gestionnaires de packages
Emacs, Python, Ruby ... et la puissance de l' guix environment
Guix peut remplacer n'importe quel gestionnaire de packages, y compris les gestionnaires de packages de langages de programmation. Il présente plusieurs avantages:
- Reproductibilité omniprésente.
- Rollbacks omniprésents.
- Pas besoin d'apprendre un autre gestionnaire de paquets.
À ce stade, vous devez mentionner l'
guix environment . Cette commande configure un environnement temporaire avec uniquement un ensemble spécifique de packages, comme
virtualenv . La particularité est qu'il est universel pour toutes les langues et leurs combinaisons.
Texlive
(Avertissement: à partir de janvier 2019, le système de build TeXlive pour Guix est en cours de refonte).
TeXlive a reçu une mention spéciale car c'est particulièrement terrible :), ce qui confirme une fois de plus le rôle salvateur de Guix!
La plupart des systèmes d'exploitation basés sur Unix distribuent généralement TeXlive dans le cadre d'une suite de packages. Par exemple, Arch Linux en possède une douzaine. Si vous avez besoin de packages TeX de différents ensembles, Arch Linux ne laisse d'autre choix que d'installer des milliers de packages (éventuellement inutiles), et TeXlive prend
beaucoup de place: des centaines de mégaoctets.
Alternativement, vous pouvez installer TeXlive manuellement, mais
tlmgr :
tlmgr est juste un mauvais gestionnaire de paquets, et il nécessite un travail supplémentaire fastidieux.
À l'aide de Guix, les packages TeXlive sont installés séparément, comme tout le reste, ce qui vous aide à maintenir votre propre ensemble de packages TeXlive ou même à créer des spécifications d'environnement virtuel pour la compilation de documents spécifiques.
Le noyau
De nombreux systèmes d'exploitation n'offrent qu'une prise en charge limitée des noyaux personnalisés. Si les utilisateurs souhaitent s'éloigner du noyau par défaut, le noyau non standard doit être géré manuellement.
Gentoo est connu pour «exiger» le noyau de l'utilisateur comme étape d'installation recommandée (obligatoire?). Cependant, ce n'est guère une condition préalable, et les utilisateurs eux-mêmes doivent prendre en charge la configuration du noyau.
Dans Guix, le noyau est un package régulier entièrement personnalisable, comme tout autre. Vous pouvez tout configurer et passer le fichier de configuration du noyau à la définition du package.
Par exemple, voici les définitions d'un noyau Linux non libre avec le pilote
iwlwifi (avertissement: je déconseille fortement d'utiliser des pilotes propriétaires, car ils constituent une menace sérieuse pour votre vie privée et votre liberté):
(define-module (ambrevar linux-custom) #:use-module (guix gexp) #:use-module (guix packages) #:use-module (guix download) #:use-module (guix git-download) #:use-module (guix build-system trivial) #:use-module ((guix licenses) #:prefix license:) #:use-module (gnu packages linux) #:use-module (srfi srfi-1)) (define-public linux-nonfree (package (inherit linux-libre) (name "linux-nonfree") (version (package-version linux-libre)) (source (origin (method url-fetch) (uri (string-append "https://www.kernel.org/pub/linux/kernel/v4.x/" "linux-" version ".tar.xz")) (sha256 (base32 "1lm2s9yhzyqra1f16jrjwd66m3jl43n5k7av2r9hns8hdr1smmw4")))) (native-inputs `(("kconfig" ,(local-file "./linux-custom.conf")) ,@(alist-delete "kconfig" (package-native-inputs linux-libre)))))) (define (linux-firmware-version) "9d40a17beaf271e6ad47a5e714a296100eef4692") (define (linux-firmware-source version) (origin (method git-fetch) (uri (git-reference (url (string-append "https://git.kernel.org/pub/scm/linux/kernel" "/git/firmware/linux-firmware.git")) (commit version))) (file-name (string-append "linux-firmware-" version "-checkout")) (sha256 (base32 "099kll2n1zvps5qawnbm6c75khgn81j8ns0widiw0lnwm8s9q6ch")))) (define-public linux-firmware-iwlwifi (package (name "linux-firmware-iwlwifi") (version (linux-firmware-version)) (source (linux-firmware-source version)) (build-system trivial-build-system) (arguments `(#:modules ((guix build utils)) #:builder (begin (use-modules (guix build utils)) (let ((source (assoc-ref %build-inputs "source")) (fw-dir (string-append %output "/lib/firmware/"))) (mkdir-p fw-dir) (for-each (lambda (file) (copy-file file (string-append fw-dir (basename file)))) (find-files source "iwlwifi-.*\\.ucode$|LICENSE\\.iwlwifi_firmware$")) #t)))) (home-page "https://wireless.wiki.kernel.org/en/users/drivers/iwlwifi") (synopsis "Non-free firmware for Intel wifi chips") (description "Non-free iwlwifi firmware") (license (license:non-copyleft "https://git.kernel.org/cgit/linux/kernel/git/firmware/linux-firmware.git/tree/LICENCE.iwlwifi_firmware?id=HEAD"))))
Le noyau et le firmware personnalisés peuvent être conditionnellement inclus dans la configuration actuelle du système (certains fichiers
config.scm ):
(define *lspci* (let* ((port (open-pipe* OPEN_READ "lspci")) (str (get-string-all port))) (close-pipe port) str)) (operating-system (host-name "...")
Suivez ensuite ces étapes pour installer une nouvelle configuration système:
sudo -E guix system reconfigure config.scm
Sans même installer un nouveau noyau, vous pouvez créer directement une image prête à démarrer à partir d'une clé USB.
Les jeux
Étant donné que les packages Guix utilisent des technologies avancées (par exemple, les dernières versions de Mesa) et permettent un réglage complet du noyau, c'est une plate-forme idéale pour les jeux et, en particulier, pour
empaqueter les jeux!
Malheureusement, l'industrie du jeu est loin d'être une philosophie du logiciel libre, et très peu de jeux sont emballés dans le cadre du projet officiel Guix.
Bien que Guix soit synonyme de logiciel libre et n'accepte aucune propriété dans son référentiel, ironiquement, de nombreuses fonctionnalités avancées font de Guix un gestionnaire de packages idéal pour les programmes non libres.
Quelques avantages:
guix environment vous permet d'exécuter n'importe quelle application dans un conteneur isolé qui restreint l'accès au réseau, masque le système de fichiers (il n'y a aucun risque que le programme propriétaire vole certains de vos fichiers, disons, portefeuille Bitcoin ou clés PGP) et même des informations au niveau du système telles comme nom d'utilisateur. Cela est nécessaire pour exécuter tout programme source fermé non fiable.
- Gestion des packages fonctionnels: les programmes à source fermée ne résistent généralement pas à l'épreuve du temps et ne fonctionnent pas lorsqu'une dépendance de bibliothèque change son API. Étant donné que Guix définit des packages au-dessus de n'importe quelle version de n'importe quelle dépendance (sans conflit avec le système actuel), Guix vous permet de créer des packages pour des jeux avec du code source fermé qui fonctionneront pour toujours.
- Environnement reproductible: les programmes à source fermée sont généralement mal portés et peuvent se comporter différemment sur des systèmes avec des dépendances légèrement différentes. La propriété de reproductibilité de Guix implique que si nous faisons fonctionner le package Guix une fois, il fonctionnera toujours (sauf pour une panne matérielle ou un changement de configuration matérielle).
Pour ces raisons, Guix est un outil idéal pour emballer et distribuer des jeux en source fermée.
Cependant, il s'agit d'un grand sujet distinct, qu'il vaut mieux laisser pour un autre article.
Trucs et astuces
Emacs-guix
L'un des avantages incroyables de Guix est l'
interface Emacs-Guix , qui vous permet d'installer et de supprimer des packages, de mettre à jour de manière sélective, de rechercher, de passer à la définition de package, de gérer les générations, d'imprimer les «différences» entre eux, et bien plus encore.
Il a des modes de développement pour l'assemblage et la programmation, ainsi qu'un environnement interactif spécial appelé Scheme
REPL . Il s'agit d'une interface utilisateur unique pour le système d'exploitation.
Il y a aussi l'interface
Helm System Packages , qui chevauche partiellement Emacs-Guix, mais il me semble plus agréable pour des recherches de paquets rapides et des opérations rapides.
Stockage de données
Étant donné que Guix stocke plusieurs générations de configurations système (y compris l'historique complet des packages), il nécessite plus d'espace disque que les autres systèmes d'exploitation.
D'après mon expérience, en 2018, la partition de 25 Go a dû être nettoyée environ une fois par mois (compte tenu du fait que j'ai de grandes demandes concernant le nombre de packages), et la partition de 50 Go peut être laissée sans surveillance pendant une année entière.Il est pratique d'utiliser la commande pour nettoyer le stockage guix gc, mais elle peut supprimer «trop de packages», c'est-à-dire les packages qui seront nécessaires immédiatement lors de la prochaine mise à jour.Emacs-Guix a une commande mx guix-store-dead-itemqui trie les paquets morts par taille et vous permet de les supprimer individuellement.Si vous devez analyser les dépendances, regardez guix gc --referenceset guix gc --requisites. Ceci peut être combiné avec la sortie guix build ...pour voir les différents éléments du graphe de dépendances.Par exemple, pour afficher le code de l'un des scripts de génération, ouvrez le fichier renvoyé par la commande suivante: $ guix gc --references $(guix build -d coreutils) | grep builder /gnu/store/v02xky6f5rvjywd7ficzi5pyibbmk6cq-coreutils-8.29-guile-builder
Génération de manifeste
Il est souvent utile de générer un manifeste de tous les packages installés dans un profil.Cela peut être fait en utilisant le script Guile suivant: (use-modules (guix profiles) (ice-9 match) (ice-9 pretty-print)) (match (command-line) ((_ where) (pretty-print `(specifications->manifest ',(map manifest-entry-name (manifest-entries (profile-manifest where)))))) (_ (error "Please provide the path to a Guix profile.")))
Par exemple, exécutez-le sur votre profil ~/.guix-profile: $ guile -s manifest-to-manifest.scm ~/.guix-profile
Mes fichiers dot suivent l'historique des packages installés. Comme je garde également la version de Guix, je peux revenir à l'état exact de mon système à tout moment dans le passé.Les références
Quelques interfaces web:Documents:Paquets non officiels: