Résumé des méthodes pour déployer des applications Python à l'aide de Docker

Cet article est dérivé de l'expérience précieuse résumée par l'équipe d'auteurs au cours du processus de développement à long terme. Parmi eux, Supervisor, Gunicorn et Nginx sont les logiciels les plus couramment utilisés lors de l'utilisation de Python pour développer des applications Web. pour les lecteurs qui envisagent d'utiliser Docker pour déployer des applications Python. Ces bonnes pratiques sont d'une grande valeur de référence. En parallèle, j'espère que dans votre pratique quotidienne, vous pourrez également partager les « gouffres » que vous avez rencontrés et vos précieuses expériences, afin que chacun puisse progresser ensemble !

Nous pouvons utiliser Docker pour déployer des applications Python de manière simple et efficace. En même temps, il existe quelques bonnes pratiques pour nous aider à terminer le déploiement avec bonheur. Bien sûr, cela ne veut pas dire que ces bonnes pratiques constituent le seul moyen de finaliser le déploiement, mais notre équipe les a trouvées hautement disponibles et faciles à maintenir. Notez que la plupart du contenu de cet article ne représente que ma position. Il existe de nombreuses implémentations basées sur Docker, vous pouvez choisir comme vous le souhaitez. Je ne présenterai pas trop Volume dans cet article, car son explication peut nécessiter un sujet distinct. Nous utilisons généralement Volumes pour copier le code source dans le conteneur plutôt que de le reconstruire à chaque exécution.

DEBIAN_FRONTEND

Les utilisateurs de Docker doivent être familiers avec cette variable d'environnement, qui indique au système d'exploitation où obtenir les entrées de l'utilisateur. S'il est défini sur "non interactif", vous pouvez exécuter des commandes directement sans demander l'entrée de l'utilisateur (Note du traducteur : toutes les opérations sont non interactives). Ceci est particulièrement utile lors de l'exécution de la commande apt-get, car elle demandera constamment à l'utilisateur à quelle étape il a progressé et nécessitera une confirmation constante. Le mode non interactif sélectionnera les options par défaut et terminera la construction le plus rapidement possible.

Veuillez vous assurer de définir cette option uniquement dans la commande RUN appelée dans le Dockerfile, plutôt que d'utiliser la commande ENV pour la définir globalement, car la commande ENV prendra effet pendant tout le processus d'exécution du conteneur, donc quand vous passez BASH Lors de l'interaction avec des conteneurs, des problèmes peuvent survenir si des paramètres globaux sont définis. Un exemple est le suivant :

# 正确的做法 - 只为这个命令设置ENV变量
RUN DEBIAN_FRONTEND=noninteractive apt-get install -y python3
# 错误地做法 - 为接下来的任何命令都设置ENV变量，包括正在运行地容器
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get install -y python3

requirements.txt

Par rapport au code de base (codebase), les dépendances des applications changent rarement, nous pouvons donc installer les dépendances du projet dans le Dockerfile. peut également accélérer les builds ultérieurs (les builds ultérieurs n'ont besoin que de construire le code modifié). La construction hiérarchique des conteneurs Docker peut mettre en cache le processus d'installation des dépendances, de sorte que les versions ultérieures seront très rapides car elles ne nécessitent pas de retéléchargement ni de création de dépendances.

Ordre des fichiers

Selon l'idée ci-dessus (en utilisant le cache) de déduire, l'ordre dans lequel les fichiers sont ajoutés au conteneur est crucial. Nous devons placer les fichiers fréquemment modifiés sous le Dockerfile pour utiliser pleinement le cache afin d'accélérer le processus de construction de Docker. Par exemple, la configuration de l'application, la configuration du système et les dépendances changent rarement, nous pouvons donc les placer en haut du Dockerfile. Les fichiers sources, tels que les fichiers de routage, les vues et le code de la base de données changeront souvent, nous pouvons donc les placer sous le fichier Docker. Notez qu'il se trouve sous les commandes de configuration Docker (EXPOSE, ENV, etc.).

De plus, ne pensez pas à la façon de copier vos fichiers sur Docker, cela n'accélérera pas votre build car la plupart des fichiers ne seront pas utilisés du tout, comme les fichiers sources de l'application.

Clé d'application

Nous ne savions pas comment transmettre en toute sécurité la clé d'application à l'application auparavant, mais plus tard, nous avons découvert que nous pouvions utiliser le paramètre docker run dans la commande env-file . Nous mettrons toutes les clés et configurations dans le fichier app_config.list, puis les livrerons à l'application via ce fichier. Plus précisément :

docker run -d -t -—env-file app_config.list <image:tag>

Cette méthode nous permet de modifier simplement les paramètres et les clés de l'application sans reconstruire un conteneur.

Remarque : Veuillez vous assurer que app_config.list est dans l'enregistrement du fichier .gitignore, sinon il ne sera pas archivé dans le fichier source.

Gunicorn

Nous utilisons Gunicorn comme serveur d'applications à l'intérieur du conteneur. Gunicorn est très stable et fonctionne très bien. Il dispose de nombreuses options de configuration, telles que la spécification du nombre et du type de travailleurs. (threads verts, gevent, etc.), vous pouvez régler votre application en fonction de la charge pour des performances optimales.

Démarrer Gunicorn est simple :

# 安装
pip3 install gunicorn

# 运行服务器
gunicorn api:app -w 4 -b 127.0.0.1:5000

La dernière étape consiste à exécuter votre serveur d'applications derrière Nginx afin de pouvoir équilibrer la charge.

superviseur

Avez-vous déjà pensé à exécuter plusieurs processus dans un conteneur ? Je pense que Supervisord est définitivement votre meilleur outil auxiliaire. Supposons que nous souhaitions déployer un conteneur contenant un proxy inverse Nginx et une application Gunicorn. Vous pourriez probablement le faire avec un script BASH, mais simplifions les choses un peu.

Supervisor est "un système de contrôle de processus qui aide les utilisateurs à surveiller et contrôler certains processus sur les systèmes d'exploitation de type UNIX". Cela semble parfait ! Vous devez d'abord installer Supervisor dans votre conteneur Docker.

RUN DEBIAN_FRONTEND=noninteractive apt-get install -y
supervisor

Pour que Supervisor sache quoi exécuter et comment gérer le processus, nous devons ensuite écrire un fichier de configuration pour celui-ci.

[supervisord]
nodaemon = true  # 这个会让supervisord运行在前端

[program:nginx]  # 你想运行的第一个程序的命名
command = /usr/sbin/nginx  # nginx可执行程序的路径
startsecs = 5  # 如果nginx保持开启5s，我们视为启动成功

[program:app-gunicorn]
command = gunicorn api -w 4 -b 127.0.0.1:5000
startsecs = 5

Il s'agit d'une configuration très basique. Elle comporte également de nombreux éléments de configuration, tels que les journaux de contrôle, la redirection stdout/stderr, la stratégie de redémarrage, etc. Cet outil est vraiment sympa.

Une fois la configuration terminée, assurez-vous que Docker la copie dans le conteneur.

ADD supervisord.conf /etc/supervisord.conf

Laissez Supervisor servir de commande de démarrage automatique pour le conteneur.

CMD supervisord -c /etc/supervisord.conf

它将会在容器启动的时候，运行Gunicorn和Nginx。如果已经配置过了，那将会按需重启它们。

学到的东西以及未来的目标

我们已经花了很长时间在Docker中部署代码，并且接下来会投入更多的时间。在使用Docker的过程中，我们学到的最重要经验就是如何最小化思考（think minimally）。在一个容器中运行你的整个系统真的很诱人，但是在应用各自的容器中运行应用进程却更容易维护。一般情况下，我们会在容器中运行Nignx和Web服务器，并且在一些场景中，使用单独的容器来运行Nginx却没有任何优势，它可能只会增加复杂度。我们发现对于大多数情况，它在容器中的开销是可接受的。

我希望这些信息对各位有价值！当我们团队学到更多最佳实践时，我会更新这篇文章。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!