Exécutez une application Web Python avec Docker

Dernière fois: Utilisation d'Emby avec Docker C'est la trajectoire de mes essais et erreurs que je souhaite pouvoir utiliser prochainement Docker.

Application Web Python avec Docker

La dernière fois, nous avons migré le service de streaming multimédia Emby vers un conteneur.

Cette fois, j'ai créé une image Docker capable de déployer des applications Web Python. Migrez les applications Web Socket et Django vers Docker. Ensuite, déplacez le contenu statique vers le conteneur et fermez le serveur VM.

Contenu statique

J'ai déplacé ce qui se trouvait sur le serveur VM vers l'hôte Docker et je l'ai lié au répertoire de distribution lorsque le conteneur a démarré.

docker-compose.yml

    deploy:
        image: nginx
        restart: always
        ports:
            - 80:80
            - 443:443
        volumes:
            - /home/fclef/docker/server/deploy/nginx/conf:/etc/nginx/conf.d
+           - /home/fclef/docker/server/deploy/content/html:/usr/share/nginx/html

Fonctionnement Docker de l'application Python

Puisque l'application utilisant Web Socket est également faite par Python (bouteille), nous visons à créer un conteneur qui peut facilement déployer des applications Python.

Conception de conteneurs

J'écris souvent des applications Web en Python. Donc, plutôt que de consolider l'ensemble de l'application dans une image Imaginez la fondation qui peut être exécutée sur n'importe quelle application Python L'application spécifique elle-même transmet les informations git lorsque le conteneur est démarré, et les clone et les développe dans le conteneur.

Dockerfile Chaque fois que j'écris quelque chose en Python, j'utilise Pipenv. De plus, dans le cas d'une application Web, elle sera connectée et livrée par nginx, donc Installez Pipenv et nginx au moment de l'image.

Dockerfile

FROM python:3.8-slim-buster

#Installation de packages dépendants
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get install -y git make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libs
qlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libffi-dev nginx

#Installez Pyenv
RUN git clone https://github.com/yyuu/pyenv.git /.pyenv
ENV PYENV_ROOT /.pyenv
ENV PATH $PYENV_ROOT/bin:$PATH
RUN pyenv init - | bash
#Installation de Pipenv
RUN pip install pipenv
ENV PIPENV_VENV_IN_PROJECT 1
ENV PIPENV_YES true

RUN mkdir /app #Répertoire de déploiement d'applications
RUN mkdir /script #Divers répertoires de placement de scripts

COPY up.sh /script #Script de démarrage

#Déplacez le projet git vers l'application dans le script de démarrage
WORKDIR /app
#La livraison d'applications Web est un proxy inverse via le serveur Web principal, ne laissez donc que 80 ports ouverts.
EXPOSE 80
RUN chmod +x /script/up.sh
ENTRYPOINT [ "/script/up.sh" ]　#Lorsque le conteneur démarre, le script de démarrage est activé.courir sh

Script de démarrage du conteneur

Les informations git de l'application sont transmises en tant que variable d'environnement au démarrage du conteneur. Pour une raison quelconque, git ne peut pas être cloné avec ssh dans mon environnement, c'est donc une condition préalable au clonage avec https. Une fois cloné, analysez le Pipfile dans le répertoire racine du projet pour déterminer la version Python requise. Certaines bibliothèques Python doivent avoir des programmes dépendants installés, donc Le script (dependencies.sh) pour les installer est lié au moment du démarrage du conteneur et appelé ici. Puisque gunicorn est utilisé pour insérer des applications Web Python, gunicorn est également installé.

up.sh

#!/bin/bash

#Obtenir des informations git à partir des variables d'environnement
gitCloneUrl=${GIT_CLONE_URL}
gitUserName=${GIT_USER_NAME}
gitPassword=${GIT_PASSWORD}
gitCloneTarget=`echo ${gitCloneUrl} | sed -r "s#^(https?://)(.*)#\1${gitUserName}:${gitPassword}@\2#g
"`

#Obtenez le nom du projet
projectName=`echo ${gitCloneUrl} | sed -r "s#.*/(\w+)\.git#\1#g"`
echo "■ ■ ■ PROJECT NAME <${projectName}> ■ ■ ■"

git clone ${gitCloneTarget}

#Obtenez la version python de Pipfile
cd ${projectName}
pythonVersion=`grep python_version Pipfile | sed -r 's/python_version = "(.+)"/\1/g'`
echo "■ ■ ■ PYTHON VERSION <${pythonVersion}> ■ ■ ■"

#Si certaines des bibliothèques Python à installer dépendent d'autres programmes, installez-les ici.
if [ -f /script/dependencies.sh ]; then
    source /script/dependencies.sh
fi

pipenv --python ${pythonVersion}
pipenv install
pipenv install gunicorn

curPath=`pwd`
export APP_ROOT=${curPath}

chmod +x /script/run.sh
service nginx start
/script/run.sh #Script de lancement d'application
while true; do sleep 1000; done

Démarrer le conteneur

A titre d'exemple, je vais vous montrer la configuration pour lancer l'application Django.

docker-compose.extrait yml

django:
    image: pipenv-gunicorn
    restart: always
    environment:
        GIT_CLONE_URL: https://xxxxxxxx/user/project.git
        GIT_USER_NAME: user
        GIT_PASSWORD: password
    volumes:
        - /home/fclef/docker/server/app/dependencies.sh:/script/dependencies.sh
        - /home/fclef/docker/server/app/run.sh:/script/run.sh
        - /home/fclef/docker/server/app/app.conf:/etc/nginx/conf.d/nginx_gunicorn.co
nf
    depends_on:
        - deploy
        - gitlab

dependencies.sh

apt-get -y --no-install-recommends install libpq-dev

run.sh

cd /app/project

source .venv/bin/activate

python manage.py collectstatic --noinput
python manage.py makemigrations
python manage.py migrate

deactivate

/app/project/.venv/bin/gunicorn \
          --access-logfile /var/log/socket_success.log \
          --error-logfile /var/log/socket_error.log \
          --workers 1 \
          --bind unix:/run/socket.sock \
          config.wsgi:application

app.conf

server {
    listen       80;
    listen [::]:80;
    server_name xxxx.xxx.xxx;

    root /app;

    location /static {
        alias /app/project/static;
    }

    location / {
        include /etc/nginx/proxy_params;
        proxy_pass http://unix:/run/socket.sock;
    }

    location ~ ^/apple-touch-icon(.*)\.png$ {
        root /app/project/;
        rewrite ^/apple-touch-icon(.+)\.png$ /static/img/apple-touch-icon.png break;
    }
}

L'application elle-même est clonée depuis git au démarrage du conteneur, Puisque les données sont stockées dans PostgreSQL dans un conteneur séparé, Quel que soit le nombre de recréations de ce conteneur, vous pouvez déployer le service dans l'état de fonctionnement normalement.

Fondamentalement, la plupart des applications Python peuvent être exécutées avec l'image ci-dessus et la méthode de démarrage. Puisque la procédure du clonage git au déploiement est simple, j'ai pu créer une image facile à réutiliser en sortant de l'application. Pour les applications avec une construction d'environnement compliquée, il peut être plus facile à maintenir en créant une image pour chaque application.

Il s'agit de la série de migration de serveurs VM vers des conteneurs.