Créer des logiciels Linux à partir de la source en 3 étapes faciles

Sommaire

Toggle

Résumé

• La plupart des logiciels suivent un processus en 3 étapes à construire à partir de la source: ./configure && make && faire l'installation.

• Le script de configuration vérifie les dépendances, tandis que Make génère un exécutable; AutoConf / Automake aide à automatiser cela.

• L'installation est généralement facultative, et principalement une commodité, vous permettant d'exécuter des commandes copiées dans un répertoire de chemin.

L'installation à partir de la source peut sembler un peu plus intimidante que l'utilisation de votre gestionnaire de packages. Mais trois commandes simples aident à garantir que le processus est toujours sans tracas.

Qu'est-ce que la construction de Source?

Les programmes que vous exécutez sur votre ordinateur sont interprétés ou compilés. Les premiers sont des fichiers texte contenant le code qu'un autre programme – un interprète – lira et exécutera lorsque vous les exécutez. Ces derniers sont des fichiers binaires autonomes qui contiennent du code machine et s'exécutent directement.

Les exécutables compilés sont très courants, en particulier pour les plus grands programmes. Lorsque vous construisez à partir de Source, vous utilisez un compilateur – comme GCC – pour générer un exécutable à partir du code source de l'application, qui peut être distribué sur de nombreux fichiers individuels.

Étant donné que la construction de Source peut être un processus complexe et long, il est généralement automatisé via un autre programme, le plus souvent. Vous pouvez écrire des makefiles pour contrôler comment un projet construit son programme exécutable final.

Dans les projets plus compliqués, les makefiles eux-mêmes deviennent grands et lourds. Cela est particulièrement vrai pour les applications portables qui doivent fonctionner sur différentes architectures et environnements. Pour répondre à ces situations, de nombreux projets génèrent automatiquement leurs marques à l'aide d'un outil appelé AutoConf / Automake.

Le processus de construction en 3 étapes: configurer, faire, installer

Le résultat de tout cela est un modèle commun que beaucoup de logiciels utilise à partir de la source:

        ./configure && make && make install

    

De nombreux programmes populaires utilisent ce modèle – ou une variante – y compris Apache, qui explique le processus dans son fichier d'installation:

Node.js est un autre exemple de logiciel qui utilise ce modèle. Son fichier Building.md contient des instructions pertinentes:

Chaque projet adopte sa propre approche pour construire sa source, même s'il s'agit d'une variation simple du modèle en trois étapes. Une distinction importante est la façon dont vous exécutez la chaîne de commandement. L'exécuter avec le logique et l'opérateur (&&) provoquera l'arrêt de la chaîne si l'une de ses pièces échoue:

        ./configure && make && make install

    

Alternativement, vous pouvez exécuter chaque commande séparément, mais toujours utiliser une seule ligne, avec des demi-colons:

        ./configure; make; make install

    

Cela entraînera l'exécution de chaque pièce, même si les étapes précédentes ont échoué. Votre choix ne fera pas toujours beaucoup de différence pratique, et vous pouvez également les exécuter comme trois commandes distinctes à la place:

        ./configure
make
make install

    

Vous ne souhaiterez peut-être pas installer complètement le logiciel, préférant l'exécuter directement à partir de son propre répertoire. C'est parfaitement OK à faire; Vous aurez juste besoin de laisser tomber le faire l'installation commande.

Certains repos contiennent un script de configuration, d'autres (comme Grep) s'attendent à ce que vous exécutiez un autre script qui génère d'abord ce fichier de configuration. Si vous recherchez l'option la plus simple, reportez-vous toujours au fichier Installer ou Build ou ReadMe et suivez la recommandation du projet.

Comment ./configure lance les choses

Le script de shell de configuration est généralement le point de départ du processus de construction. Il configure le reste du processus pour votre environnement spécifique.

Le script vérifie diverses dépendances dont le projet a besoin. Il garantit que tous les éléments requis sont présents et corrects, dans les versions appropriées. Courir ./configure Et vous devriez vous retrouver avec un fichier nommé MakeFile qui est utilisé par l'étape suivante.

Le script de configuration est lui-même, hautement configurable, via des options de ligne de commande. Courir ./configure – help pour une description complète d'eux.

Les deux configurent et font gérer beaucoup de sorties. Si vous voulez simplement exécuter ces commandes et ignorer ce qu'ils font dans les coulisses, vous pouvez utiliser le –calme Option pour supprimer la plupart des sorties.

S'il n'y a pas de script de configuration, un projet peut fournir un moyen d'en générer un. Par exemple, le référentiel HTOP comprend un script autogen.sh. Exécution cela générera un script de configuration:

Des projets très simples, et ceux qui ne sont pas écrits dans le langage C, peuvent manquer complètement d'un script de configuration. Dans ce cas, le processus en trois étapes devient un processus en deux étapes: il suffit d'exécuter faire et faire l'installation.

Le script de configuration contrôle souvent ce qui se passe plus tard lors de l'installation. En particulier, l'option – préfix est courante. Cela définit le répertoire racine dans lequel le logiciel sera installé. Par défaut, c'est / USR / local, mais vous pouvez fournir une alternative si vous aimez organiser vos fichiers différemment.

faire fait la majeure partie du travail

Une fois que la configuration a généré un makefile, vous pouvez commencer le processus réel de création du logiciel. Le programme Make se lit dans un Makefile et vérifie une série de règles pour décider quoi construire.

Les makefiles écrits à la main sont généralement faciles à lire, une fois que vous connaissez leur syntaxe. Dans le cas le plus simple, un makefile décrit comment générer un fichier à partir d'un autre, lorsque ce dernier est plus ancien. Par exemple, ce makefile décrit le processus de construction d'un programme très simple:

        program: program.c
    gcc -o program program.c

    

Ici, le programme de fichier exécutable dépend du programme de fichiers source.c. Lorsque vous effectuez des exécutions, il vérifiera le fichier par rapport à ses dépendances. Si rien n'a changé depuis la dernière version – le programme est plus récent que Program.C – Préparera simplement, en toute sécurité, en supposant que rien ne doit être fait. Si Program.c a changé, cependant, il exécutera GCC et compilera le programme.

Il y a beaucoup plus à faire au-delà de ce cas le plus simple, et les makefiles générés ont tendance à être beaucoup plus complexes. Par exemple, ce makefile généré pour le programme HTOP est de 2 440 lignes de long:

Mais vous n'avez pas à vous soucier de cela. À moins que vous ne piratez le code source – ou que vous écriviez le vôtre – vous pouvez courir sans vous soucier de ce qui se passe sous le capot.

L'étape de marque peut prendre beaucoup de temps à s'exécuter, en particulier pour des logiciels complexes qui impliquent plusieurs composants. Soyez patient, et ne vous inquiétez pas si faire échouer. La cause sera généralement une dépendance manquante, et l'un des avantages de la réalisation est qu'il reprendra le processus de construction sans perdre les travaux déjà effectués.

Enveloppez-vous avec l'installation

Une version typique générera un exécutable compilé, soit dans la racine du projet, soit souvent dans un sous-répertoire nommé Bin. Il s'agit généralement d'un programme autonome que vous pouvez exécuter via son chemin complet:

C'est bien pour tester ou travailler sur votre propre logiciel, mais vous voudrez éventuellement l'installer dans un emplacement plus pratique.

La plupart des MakeFiles ont une cible d'installation qui vérifiera lorsque vous exécutez l'installation de faire. Cela utilise souvent la commande d'installation pour copier des fichiers individuels et définir les autorisations et la propriété appropriées.

L'emplacement d'installation dépendra de la façon dont vous avez exécuté la configuration. N'oubliez pas que l'emplacement par défaut des exécutables est / usr / local / bin, à laquelle vous ne pouvez pas avoir la permission d'écrire. Si votre utilisateur ne peut pas écrire à l'emplacement d'installation, vous devrez exécuter Sudo Faire installer et fournir le mot de passe racine pour continuer.

Quel que soit l'emplacement d'installation, il devrait être sur votre chemin afin que vous puissiez exécuter le programme simplement en tapant son nom sur la ligne de commande, plutôt que sur son chemin complet.