Création d’une AppImage « Hello World » sur Linux

AppImage est un format permettant de distribuer des logiciels portables sous Linux sans avoir besoin d’autorisations de super-utilisateur pour installer l’application. Il permet aux développeurs de packager des applications de bureau de manière à ce qu’elles puissent s’exécuter sur diverses distributions Linux. Ce tutoriel montre comment créer une AppImage « Hello World » de base, fournissant un exemple simple de la façon de regrouper et de distribuer des logiciels dans l’écosystème Linux.

Dans ce tutoriel, vous allez apprendre :

Qu’est-ce qu’une AppImage et ses avantages ?
Comment créer une application simple « Hello World » en tant qu’AppImage
Étapes d’exécution et de test de votre AppImage sur un système Linux

Création de votre première application Hello WorldImage

ATTENTION AVEC APPIMAGES
La sécurité des AppImages n’est pas vérifiée de manière inhérente. Il est crucial de télécharger et d’utiliser AppImages uniquement à partir de sources fiables. En raison de leur nature portable et exécutable, AppImages peut potentiellement contenir des logiciels nuisibles, tels que des virus ou des logiciels malveillants, conçus pour voler des informations ou endommager votre système. Le téléchargement d’AppImages à partir de sources non vérifiées ou suspectes augmente le risque de cyberattaques et compromet la sécurité de votre système. Vérifiez toujours l’authenticité et l’intégrité de la source avant de télécharger et d’exécuter une AppImage.

Ce guide vous guidera à travers les étapes de la création d’une simple AppImage « Hello World ». Vous commencerez par écrire un programme C de base, l’empaqueter dans une AppImage et l’exécuter sur votre système Linux.

Installer l’outil AppImage et ses dépendances : téléchargez l’outil AppImage et rendez-le exécutable.
```
wget https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
chmod +x appimagetool-x86_64.AppImage
```
De plus, installez zsync qui est nécessaire pour mettre à jour AppImages.
```
sudo apt-get install zsync
```
Créer une structure de répertoires : Configurez la structure de répertoires qui hébergera les fichiers de votre application.
```
mkdir -p AppDir/usr/bin
```
Créez un binaire Hello World : écrivez votre programme Hello World en C, enregistrez-le sous le nom hello-world.c, compilez-le et testez la sortie.
```
#include <stdio.h>

int main() {
    printf("Hello, LinuxConfig.org!\n");
    return 0;
}
```
Compilez et exécutez votre programme pour vous assurer qu’il fonctionne :
```
gcc hello-world.c -o hello-world
./hello-world
```
Vous devriez voir le message suivant : « Bonjour, LinuxConfig.org ! »
Copier le binaire vers AppDir : déplacez le fichier binaire compilé dans la structure de répertoires que vous avez créée précédemment.
```
cp hello-world AppDir/usr/bin/
```
Créer une entrée de bureau : Écrivez un fichier .desktop pour spécifier comment votre application doit être intégrée dans les menus du bureau.
```
[Desktop Entry]
Type=Application
Name=Hello World
Exec=hello-world
Icon=hello-world
Categories=Utility;
```

Enregistrez ce contenu sous le nom AppDir/hello-world.desktop.

Créez ou téléchargez une icône personnalisée : Générez une icône simple pour votre application à l’aide d’ImageMagick. Cette étape implique la création d’une image qui servira d’icône pour votre AppImage. Utilisez la commande suivante pour créer une icône de base « Hello World » et l’enregistrer dans la structure AppDir, en vous assurant qu’elle est correctement reconnue par les environnements de bureau lors de l’exécution de votre AppImage.
```
convert -size 256x256 xc:white -gravity center -pointsize 24 -fill black -annotate +0+0 "Hello World" AppDir/hello-world.png
```

Après avoir exécuté la commande, assurez-vous que le fichier d’icône hello-world.png est enregistré dans AppDir/. Cet emplacement est couramment utilisé pour les icônes d’application et permet de s’assurer que votre AppImage s’intègre correctement aux environnements de bureau.

Créer AppRun : ce script sert de point d’entrée pour votre AppImage. Écrivez le script suivant et rendez-le exécutable.
```
#!/bin/bash
exec $APPDIR/usr/bin/hello-world
```
Enregistrez ce script sous le nom AppDir/AppRun et rendez-le exécutable :
```
chmod +x AppDir/AppRun
```
Compiler/créer l’AppImage : cette étape implique l’utilisation de l’outil appimagetool pour empaqueter votre application dans une AppImage. La commande ci-dessous spécifie l’architecture du système cible sur lequel AppImage s’exécutera. Dans cet exemple, nous utilisons ARCH=x86_64 pour désigner un système 64 bits. Cette variable d’environnement aide l’outil à comprendre l’architecture pour laquelle il doit empaqueter l’AppImage. Il est crucial d’assurer la compatibilité avec le système cible.
```
ARCH=x86_64 ./appimagetool-x86_64.AppImage AppDir HelloWorld.AppImage
```
La variable d’environnement ARCH peut être définie sur des valeurs différentes en fonction de l’architecture cible de votre application. Par exemple, si vous ciblez un système basé sur ARM, vous pouvez utiliser ARCH=armhf ou ARCH=aarch64 pour les architectures ARM 32 bits et 64 bits, respectivement. L’ajustement de cette variable permet de créer AppImage spécifiquement pour l’architecture de l’appareil sur lequel il s’exécutera, garantissant ainsi des performances et une compatibilité optimales. Assurez-vous de télécharger et d’utiliser la version d’appimagetool qui correspond à l’architecture pour laquelle vous compilez. Cette étape finalise le processus d’empaquetage, produisant un exécutable AppImage nommé HelloWorld.AppImage qui est prêt à être distribué et exécuté sur des systèmes Linux compatibles.
Testez votre AppImage :
Enfin, exécutez votre AppImage nouvellement créée pour voir le message « Hello World ».
```
./HelloWorld.AppImage
```
Si tout a été fait correctement, vous devriez voir « Bonjour, LinuxConfig.org ! » imprimé dans votre terminal, indiquant que votre AppImage fonctionne correctement.

Conclusion

Grâce à ce tutoriel, vous avez appris les bases de la création d’une AppImage en empaquetant une simple application « Hello World ». Ce processus implique la compilation de votre application, la configuration d’une structure de répertoires, la création des fichiers de métadonnées nécessaires tels que l’entrée de bureau et le script AppRun, et enfin, l’utilisation de l’outil appimagetool pour regrouper le tout dans un seul fichier AppImage portable.

AppImages est un moyen puissant de distribuer des applications Linux, car elles peuvent fonctionner sur pratiquement n’importe quelle distribution Linux sans avoir besoin d’installation ou d’accès root. En suivant les étapes décrites dans ce guide, vous pouvez empaqueter vos propres applications en tant qu’AppImages, ce qui les rend facilement partageables et utilisables sur différents systèmes. Que vous développiez un utilitaire simple ou une application complexe, AppImages fournit une méthode de distribution pratique et conviviale.

Au fur et à mesure que vous vous familiarisez avec le format AppImage, vous pouvez explorer des fonctionnalités plus avancées, telles que l’intégration de fonctionnalités de mise à jour, la personnalisation des icônes d’application et l’optimisation de votre AppImage pour différents environnements Linux. La simplicité et la portabilité d’AppImages en font un excellent choix pour les développeurs qui cherchent à atteindre un public Linux plus large.

Création d’une AppImage « Hello World » sur Linux

Création de votre première application Hello WorldImage

Conclusion

Articles connexes: