Docker ENTRYPOINT Expliqué : Utilisation, syntaxe et bonnes pratiques

Docker ENTRYPOINT est une instruction du fichier Docker qui définit et contrôle la commande par défaut exécutée au démarrage de votre conteneur. Mastering ENTRYPOINT simplifie le développement de conteneurs prévisibles, reproductibles et maintenables qui se comportent comme prévu. 

Ce guide a pour but d'aider les ingénieurs DevOps, les développeurs backend et les ingénieurs logiciels de niveau intermédiaire à utiliser ENTRYPOINT en toute confiance et à éviter les pièges les plus courants.

Si vous ne connaissez pas Docker, consultez notre tutoriel d'introduction à Docker, car ce tutoriel suppose un certain niveau de compréhension de Docker. Pour vous familiariser avec Docker, consultez notre cours d'introduction à Docker. 

Qu'est-ce que Docker ENTRYPOINT ?

ENTRYPOINT définit la commande exécutée par défaut au lancement de votre conteneur Docker. Contrairement à l'instruction CMD, l'instruction ENTRYPOINT garantit la cohérence en fournissant des commandes qui s'exécutent à chaque fois que le conteneur démarre.

Comment fonctionne Docker ENTRYPOINT ?

ENTRYPOINT dans un fichier Docker définit la commande principale qui s'exécute toujours lorsque vous démarrez un conteneur à partir d'une image. C'est comme dire :  "Quels que soient les arguments fournis par l'utilisateur lors de l'exécution de ce conteneur, commencez toujours par cette commande."

Nous abordons plus en détail les Dockerfiles dans notre tutoriel Comment conteneuriser une application à l'aide de Docker. 

Par exemple, dans un fichier Docker :

ENTRYPOINT ["python", "app.py"]Propulsé par

Maintenant, quand vous courez :

docker run myimagePropulsé par

Il sera toujours exécuté :

python app.pyPropulsé par

Voici un organigramme du fonctionnement de ENTRYPOINT:

+---------------------------+

|       Dockerfile          |

+---------------------------+

|                           |

|  ENTRYPOINT ["app"]       |

|  CMD ["--default-arg"]    |

+---------------------------+

             |

             v

+---------------------------+

|   Build Docker Image      |

+---------------------------+

             |

             v

+---------------------------+

|    Run Container          |

|   (docker run image)      |

+---------------------------+

             |

             v

+---------------------------+

| Executed Command:         |

|   app --default-arg       |

+---------------------------+

Override CMD at Runtime:

(docker run image --custom-arg)

             |

             v

+---------------------------+

| Executed Command:         |

|   app --custom-arg        |

+---------------------------+

Override ENTRYPOINT at Runtime:

(docker run --entrypoint /bin/bash image)

             |

             v

+---------------------------+

| Executed Command:         |

|   /bin/bash               |

+---------------------------+Propulsé par

Principes fondamentaux de Docker ENTRYPOINT

La compréhension des principes de base vous permettra d'utiliser ENTRYPOINT avec plus d'assurance et d'efficacité.

Cadre conceptuel

ENTRYPOINT spécifie l'exécutable ou le script qui s'exécute automatiquement au démarrage de votre conteneur. Il s'agit du processus principal de votre conteneur, qui conduit le comportement de votre conteneur de manière prévisible.

Syntaxe de base

La syntaxe de Dockerfile pour ENTRYPOINT est simple et généralement utilisée avec CMD pour fournir des arguments ou des paramètres par défaut. ENTRYPOINT définit l'exécutable, tandis que CMD spécifie les arguments par défaut que ENTRYPOINT utilise.

Comprendre les concepts de Docker tels que ENTRYPOINT est essentiel pour réussir les entretiens en science des données. Découvrez les questions d'entretien les plus courantes dans notre Top 26 Docker Interview Questions and Answers for 2025. 

Formulaires de syntaxe ENTRYPOINT

Docker ENTRYPOINT se présente sous deux formes distinctes : la forme shell et la forme exec. Connaître les différences entre ces formes peut vous aider à faire un choix judicieux.

Forme de la coquille

Exemple de syntaxe : 

ENTRYPOINT /usr/bin/ping -c 3 localhost

La forme shell permet d'intégrer facilement les fonctionnalités du shell (substitution de variables, manipulation de l'environnement).

Cependant, il peut entraîner une mauvaise gestion des signaux ; il s'exécute à l'intérieur d'un processus intermédiaire /bin/sh plutôt que directement en tant que PID 1, ce qui pose des problèmes lors de l'arrêt et du redémarrage des conteneurs.

PID 1 est le premier processus lancé au démarrage du système. Dans Docker, le processus PID 1 gère tous les autres processus à l'intérieur du conteneur. 

Formulaire d'exécution

Exemple de syntaxe : 

ENTRYPOINT ["/usr/bin/ping", "-c", "3"]

La forme Exec assure l'exécution directe des commandes en tant que PID 1, ce qui permet de traiter et de contrôler les signaux de manière fiable.

Cependant, il ne prend pas directement en charge le shell ou l'expansion automatique des variables d'environnement ; il nécessite des scripts supplémentaires pour obtenir un comportement similaire à celui d'un shell.

ENTRYPOINT vs CMD : Principales différences et cas d'utilisation

Distinguer ENTRYPOINT de CMD évite la confusion et permet un comportement prévisible des conteneurs.

Priorité d'exécution

ENTRYPOINT définit l'exécutable toujours en cours d'exécution, tandis que CMD fournit des arguments par défaut. Si ENTRYPOINT et CMD sont tous deux définis, ENTRYPOINT est prioritaire et s'exécute en utilisant les valeurs de CMDcomme arguments, à moins qu'elles ne soient explicitement remplacées au moment de l'exécution.

Scénarios d'utilisation

ENTRYPOINT doit être utilisé lorsque vous souhaitez une exécution cohérente et forcée à chaque lancement, comme dans le cas de conteneurs à commande unique ou de scripts enveloppant d'anciennes applications. À l'inverse, CMD permet de spécifier des arguments par défaut, ce qui offre une plus grande souplesse pour les modifications au moment de l'exécution.

Nos 18 meilleures commandes Docker pour construire, exécuter et gérer des conteneurs couvrent les commandes Docker essentielles, des bases des conteneurs aux volumes et à la mise en réseau, afin que vous puissiez gérer en toute confiance des applications dans différents environnements.

Exemple pratique

Une combinaison typique de ENTRYPOINT et CMD est illustrée par ce fichier Docker :

FROM ubuntu
ENTRYPOINT ["/usr/bin/ping", "-c", "3"]
CMD ["localhost"]Propulsé par

Ce conteneur Docker émet toujours trois pings par défaut contre localhost. Les utilisateurs peuvent facilement remplacer cette cible par défaut au moment de l'exécution avec d'autres hôtes, tout en conservant le comportement d'exécution prévisible d'ENTRYPOINT :

docker run ping-container google.comPropulsé par

Vous pouvez en savoir plus sur le déploiement d'applications avec Docker dans notre cours Conteneurisation et virtualisation avec Docker et Kubernetes. 

Combiner ENTRYPOINT et CMD

Combiner correctement ENTRYPOINT avec CMD offre une certaine flexibilité sans sacrifier la cohérence.

CMD comme arguments par défaut

Le paramètre ENTRYPOINT définit la commande principale de manière fiable ; CMD fournit des paramètres par défaut pour faciliter les modifications sans reconstruire les images.

Remplacement des arguments d'exécution

Les arguments spécifiés pendant docker run n'écrasent que les valeurs par défaut définies par CMD. ENTRYPOINT reste cohérent, ce qui simplifie l'expérience des utilisateurs.

Surcharge de ENTRYPOINT au moment de l'exécution

Docker permet de surcharger ENTRYPOINT directement au moment de l'exécution, ce qui permet de déboguer sans reconstruire votre image Dockerfile.

Utilisation du drapeau du point d'entrée

Docker propose un simple drapeau --entrypoint qui modifie temporairement le comportement du conteneur.

docker run -it --entrypoint /bin/bash my-containerPropulsé par

Les dérogations temporaires permettent de dépanner à l'aide du shell et de résoudre les problèmes de démarrage les plus courants sans avoir à reconstruire l'image ou à subir des retards importants.

Personnalisation du comportement d'ENTRYPOINT

Docker offre une certaine flexibilité lorsque ENTRYPOINT nécessite une personnalisation plus poussée.

Surcharge de ENTRYPOINT au moment de l'exécution

Vous pouvez remplacer la commande ENTRYPOINT dynamiquement au moment de l'exécution en utilisant docker run --entrypoint pour le débogage ou le changement de contexte rapidement sans modifier votre fichier Docker à plusieurs reprises.

POINT D'ENTRÉE avec arguments

Les arguments passés dans les conteneurs deviennent des paramètres ENTRYPOINT au moment de l'exécution ; les meilleures pratiques suggèrent d'avoir un minimum de complexité ENTRYPOINT à côté de CMD pour un maximum de clarté et de contrôle.

Scripts d'enrobage

Les scripts Bash introduits en tant que commandes ENTRYPOINT peuvent exécuter une logique de démarrage conditionnelle, attendre des services dépendants (comme les bases de données), gérer des tâches d'installation, et plus encore, tout en conservant une syntaxe Dockerfile propre.

Exemples et modèles du monde réel

Les applications pratiques du site ENTRYPOINT peuvent illustrer des utilisations typiques et réalistes. Examinons-en quelques-uns.

Conteneurs à commande unique 

Pour l'installation d'une application Flask :

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]Propulsé par

Dans le fichier Docker ci-dessus :

• ENTRYPOINT ["python", "app.py"]  définit l'exécutable par défaut. C'est ce qui s'exécute au démarrage du conteneur.
• CMD ["--port", "8080"]  fournit des arguments par défaut (--port 8080) à la commande ENTRYPOINT.

La commande complète par défaut exécutée sera :

python app.py --port 8080Propulsé par

 Si vous remplacez CMD lors de l'exécution du conteneur (par exemple, docker run myimage --port 9090), il remplacera --port 8080.

Le script comme point d'entrée 

Cette fonction est utilisée pour mettre en place une logique conditionnelle de soutien : 

entrypoint.sh :

#!/bin/sh
until nc -z db_host 5432; do
  echo "Waiting for database to become available."
  sleep 2
done
exec python app.py "$@"Propulsé par

Dockerfile :

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
ENTRYPOINT ["./entrypoint.sh"]
CMD ["--port", "8080"]Propulsé par

Dans les fichiers ci-dessus :

• entrypoint.sh est utilisé pour attendre la connexion à la base de données.
• exec python app.py "$@"  remplace le processus actuel du shell par Python app.py, en passant tout argument supplémentaire. "$@" provient des paramètres CMD ou docker run.
• COPY entrypoint.sh  copie le script entrypoint.sh dans le répertoire /app du conteneur.
• ENTRYPOINT ["./entrypoint.sh"] définit entrypoint.sh comme script de démarrage par défaut lors de l'exécution du conteneur.
• CMD ["--port", "8080"] fournit des arguments par défaut qui seront transmis au script entrypoint.sh et éventuellement à python app.py. La commande finale exécutée ressemblera à : python app.py --port 8080. 

Traitement des signaux et PID 1

ENTRYPOINTLe formulaire de Docker a un impact significatif sur la capacité de Docker à gérer les signaux en raison de l'importance du PID 1. Voyons cela plus en détail : 

Formulaire d'exécution et PID 1

Exec form exécute les commandes en tant que processus PID 1 de Docker directement, ce qui améliore la fiabilité de la transmission des signaux et le comportement d'arrêt ou de redémarrage approprié.

Limites de la forme de la coquille

La forme shell ajoute un processus shell intermédiaire. Cela empêche les signaux de terminaison d'atteindre les processus d'application, ce qui crée un risque de blocage ou d'absence de réponse des conteneurs.

Débogage du comportement de ENTRYPOINT

Le dépannage des configurations entrypoint est plus facile grâce à certaines techniques et astuces. Découvrez-les ci-dessous. 

Utilisation de --entrypoint pour le débogage

Les surcharges temporaires permettent d'activer rapidement des shells de débogage interactifs au sein de vos conteneurs sans avoir à reconstruire l'image. Cela vous permet de tester différents éléments de votre application sans avoir à reconstruire l'image. 

Visualisation des journaux d'ENTRYPOINT

La vérification des journaux de sortie à l'aide de docker logs simplifie le suivi de l'historique de l'exécution et permet de détecter clairement et rapidement les problèmes de configuration.

Évitez de modifier le fichier Docker pour des tests temporaires

Les dérogations à ENTRYPOINT vous permettent d'isoler et de corriger les problèmes sans avoir à modifier et reconstruire les images des conteneurs à plusieurs reprises.

Techniques d'optimisation et meilleures pratiques

Vous trouverez ci-dessous plusieurs optimisations recommandées pour améliorer la fiabilité et la maintenabilité de ENTRYPOINT.

Utilisez le formulaire exec pour le traitement des signaux

Préférez toujours la forme exec pour obtenir des signaux de terminaison appropriés et améliorer la fiabilité et la gestion globales du conteneur.

Combiner efficacement ENTRYPOINT et CMD

Séparez votre exécutable (ENTRYPOINT) des arguments d'exécution par défaut (CMD) et utilisez les options d'exécution pour un maximum de flexibilité et de facilité de gestion.

Minimiser la complexité de l'ENTRYPOINT

Gardez ENTRYPOINT simple, en déléguant la logique de démarrage ou les conditions complexes dans des scripts séparés afin de garantir une bonne gestion de la complexité et d'améliorer la clarté.

Cas d'utilisation et modèles avancés

Explorons quelques cas d'utilisation et modèles avancés de ENTRYPOINT.

Constructions en plusieurs étapes avec ENTRYPOINT

ENTRYPOINT dans les étapes finales de Docker renforce la fiabilité de l'exécution, fournissant des constructions plus propres adaptées spécifiquement aux tâches de production dans les flux de travail CI/CD.

Scripts dynamiques ENTRYPOINT

ENTRYPOINT Les scripts peuvent ajuster dynamiquement leur logique de démarrage en fonction des variables d'environnement ou des arguments d'exécution fournis, s'adaptant ainsi de manière transparente aux différents contextes d'application.

ENTRYPOINT pour les pipelines CI/CD

L'utilisation de ENTRYPOINT améliore la cohérence entre les environnements de test et de production, garantissant des comportements d'exécution prévisibles et la répétabilité. Par exemple, vous pouvez configurer ENTRYPOINT pour un script qui exécute les tests automatiquement. 

Parmi les autres applications, on peut citer 

• Un site ENTRYPOINT qui attend la base de données, puis exécute les migrations et enfin démarre le site app.
• Un site ENTRYPOINT qui compile les actifs, lit le code ou valide les configurations automatiquement.
• ENTRYPOINT Les scripts peuvent détecter les environnements (dev, staging, production) et adapter les paramètres en conséquence au démarrage du conteneur. 

Voici un exemple d'image Docker qui exécute des tests automatiquement :

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["pytest"]Propulsé par

Le site .gitlab-ci.yml se présente comme suit :

build-test:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t myapp-test .
    - docker run myapp-test  # <-- No need to specify 'pytest', ENTRYPOINT does itPropulsé par

Lorsque docker run s'exécute, il déclenche automatiquement pytest à l'intérieur du conteneur. Ainsi, tous les tests seront trouvés et exécutés immédiatement. 

L'utilisation de ENTRYPOINT dans le cadre de CI/CD présente plusieurs avantages :

• Chaque conteneur démarre et se comporte de la même manière. 
• Simplifie les scripts CI/CD car vous n'avez pas à transmettre des commandes complètes à chaque fois. 
• Automatise les vérifications préalables au démarrage, les tests et les migrations, réduisant ainsi les erreurs humaines. 

Pièges courants et dépannage

ENTRYPOINT présente quelques pièges à éviter dans vos flux de travail.

Mauvaise utilisation du formulaire shell

La forme de la coquille gêne les signaux et les gestionnaires de conteneurs ; préférez toujours la forme exec pour une bonne gestion des signaux, des sorties de conteneurs et un arrêt propre.

Compliquer à l'excès ENTRYPOINT

Les scripts complexes qui manquent de clarté ou de fiabilité se détériorent davantage lors du débogage ou de la maintenance continue. La configuration simple du site ENTRYPOINT simplifie considérablement le dépannage.

Conclusion

Comprendre et mettre en œuvre efficacement Docker ENTRYPOINT permet de construire des conteneurs Docker prévisibles, fiables et faciles à maintenir pour vos applications. Utilisé correctement, ENTRYPOINT crée une cohérence sans sacrifier la flexibilité grâce au puissant système d'annulation de Docker. En expérimentant soigneusement les modèles ENTRYPOINT, en adhérant aux meilleures pratiques décrites ci-dessus, vous simplifiez considérablement l'utilisation de Docker et vous obtenez des cycles de déploiement et de gestion plus fluides en production.

Consultez nos cours sur Docker pour explorer d'autres sujets relatifs à Docker, tels que :

• Introduction à Docker
• Concepts de conteneurisation et de virtualisation 
• Conteneurisation et virtualisation avec Docker et Kubernetes
• Docker intermédiaire