Introduction à Docker pour les développeurs de logiciels embarqués

Au cours des dernières années, Docker a pris d’assaut l’industrie du logiciel. Docker fournit aux développeurs une « plate-forme ouverte pour le développement, la livraison et l’exécution d’applications ». Le principal avantage que docker offre aux développeurs est qu’il peut séparer les applications de l’infrastructure sur laquelle il s’exécute en créant l’environnement dans un conteneur. Le conteneur peut ensuite être exécuté sur presque n’importe quelle plate-forme de développement pour fournir au développeur un environnement identique. Dans cet article, nous explorerons Docker et comment les développeurs de logiciels embarqués peuvent l’utiliser pour améliorer leurs environnements de développement.

Les dockers utilisent dans le développement de logiciels embarqués

Les développeurs peuvent utiliser Docker à de nombreuses fins, mais il y en a deux qui sont les plus intéressants pour les développeurs de logiciels embarqués.

Tout d’abord, les développeurs peuvent créer un conteneur portable avec leur environnement de génération. Cela garantit que chaque développeur travaille avec les mêmes outils et environnement de développement. Un nouveau développeur peut se joindre à nous et être opérationnel presque instantanément en lui donnant accès au code source et au fichier Docker associé qui est utilisé pour créer l’image Docker. Cela peut atténuer tous ces problèmes et discussions sur les logiciels qui ne sont pas construits, qui ont les bonnes bibliothèques, les bons chemins, etc.

Deuxièmement, les développeurs peuvent créer un pipeline DevOps qui exploite leur conteneur pour automatiser les builds, les tests, les analyses et le déploiement. Les DevOps automatisés sont un concept très puissant et très précieux pour toute entreprise qui les utilise avec succès. La plupart des développements de pipeline nécessitent une machine virtuelle ou un conteneur sur lequel l’environnement de génération et de test est installé. Les développeurs peuvent tirer parti de Docker pour créer cet environnement et utiliser des outils tels que Jenkins et Gitlab pour développer leur système DevOps.

Fondamentaux de Dockerfile

Les conteneurs Docker sont créés à partir d’un fichier Docker, souvent nommé Dockerfile, est un fichier texte qui contient toutes les commandes nécessaires pour créer un conteneur Docker. Par exemple, de nombreux Dockerfiles commenceront par une commande FROM qui spécifie une image Docker existante sur laquelle le Dockerfile sera construit. Il existe différentes options telles que :

DE Ubuntu:dernier

Qui utilise la dernière image Ubuntu comme base. Quelqu’un qui travaille avec gcc pourrait utiliser quelque chose comme :

DE gcc:11.2.0

Qui utilise une version spécifique de gcc. (On pourrait aussi utiliser FROM gcc:latest).

Une autre commande courante est WORKDIR. Cela spécifie le répertoire de travail pour toutes les commandes telles que RUN, CMD, ADD, COPY, ENTRYPOINT qui pourraient suivre. Par exemple, si je voulais installer le compilateur Arm gcc-arm-none-eabi version 10.3 dans le répertoire /home/dev, je pourrais faire quelque chose comme ceci :

# Configurer un répertoire de développement d’outils

WORKDIR /home/dev

# Obtenez et installez le compilateur Arm gcc

RUN wget -qO- https://developer.arm.com/-/media/Files/downloads/gnu-rm/10.3-2021.10/gcc-arm-none-eabi-10.3-2021.10-x86_64-linux.tar.bz2 | goudron -xj

Un fichier Docker contiendra autant de commandes que nécessaire pour configurer l’environnement de développement. Cependant, le fichier lui-même n’est pas le conteneur Docker. Pour utiliser le conteneur, nous devons d’abord le construire.

Construire un conteneur Docker

Une fois que le fichier Docker contient toutes les commandes nécessaires pour générer l’image, l’image peut être générée en émettant une commande de génération telle que :

## Construire l’image du docker

image:

docker build -t beningo/gcc-arm .

Dans la commande ci-dessus, docker est invoqué pour créer le Dockerfile qui existe dans le répertoire actuel. Le -t est le paramètre de la balise. Dans ce cas, je marque l’image nouvellement créée comme beningo/gcc-arm. Par exemple, si j’exécute la commande :

images docker

Je devrais recevoir une liste de toutes les images Docker que j’ai créées :

Les tags nous aident à identifier notre image. Comme vous pouvez le voir, j’ai une image que je n’ai pas taguée. Il est utile de savoir quelle est l’image. Puisqu’une image peut facilement faire 2 Go, elles peuvent rapidement occuper beaucoup d’espace sur le disque dur si quelqu’un ne fait pas attention !

Exécuter l’image Docker

Une fois le conteneur Docker créé, nous souhaitons exécuter l’image. Nous pouvons simplement exécuter des commandes dans l’image à l’aide de la commande docker run ou nous pouvons interagir avec l’image de manière interactive en utilisant -it. Cela nous permettra d’avoir accès à l’image que nous exécutons via une interface de terminal. Une commande courante pour exécuter une image docker serait la suivante :

docker run –rm -it beningo/gcc-arm

Le –rm indique à Docker que nous voulons supprimer le volume lorsque nous le quittons. Si je veux accéder au code source qui se trouve dans le répertoire local, je peux également utiliser une commande comme celle-ci :

docker run –rm -it -v « $(PWD):/home/app » beningo/gcc-arm

Si j’exécute cette commande puis navigue jusqu’au dossier /home/app, nous pouvons voir que j’ai accès à mon référentiel de code :

Je peux ensuite quitter mon conteneur en tapant simplement EXIT dans le terminal. Si je ne veux pas quitter, je pourrais continuer à créer mon code source ou exécuter toute autre fonction que je pourrais avoir pour mon conteneur.

Conclusion

Docker est un outil utile pour les équipes embarquées qui cherchent à simplifier les environnements de build et à développer un processus DevOps. À première vue, Docker peut sembler compliqué et déroutant, mais il ne doit pas en être ainsi. Comme nous l’avons vu dans ce blog, Docker est conceptuellement simple et facile à utiliser. Certains détails peuvent être délicats, mais ils peuvent être facilement traités pour offrir plus de flexibilité aux développeurs et les aider à améliorer leurs processus.