[GO] Führen Sie eine Python-Webanwendung mit Docker aus

Letztes Mal: Emby mit Docker betreiben Dies ist der Verlauf meines Versuchs und Irrtums, den ich bald mit Docker nutzen möchte.

Python-Webanwendung mit Docker

Beim letzten Mal haben wir den Medien-Streaming-Dienst Emby in einen Container migriert.

Dieses Mal habe ich ein Docker-Image erstellt, mit dem Python-Webanwendungen bereitgestellt werden können. Migrieren Sie Web Socket-basierte und Django-Anwendungen zu Docker. Verschieben Sie dann den statischen Inhalt in den Container und schließen Sie den VM-Server.

Statischer Inhalt

Ich habe das, was sich auf dem VM-Server befand, auf den Docker-Host verschoben und es beim Start des Containers an das Verteilungsverzeichnis gebunden.

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

Docker-Betrieb der Python-Anwendung

Da die Anwendung, die Web Socket verwendet, auch von Python (Flasche) erstellt wird, möchten wir einen Container erstellen, mit dem Python-Anwendungen problemlos bereitgestellt werden können.

Behälterdesign

Ich schreibe oft Webanwendungen in Python. Also, anstatt die gesamte Anwendung in einem Image zu konsolidieren Stellen Sie sich die Grundlage vor, die auf jeder Python-Anwendung ausgeführt werden kann Die spezifische Anwendung selbst übergibt Git-Informationen, wenn der Container gestartet wird, und klont und erweitert sie im Container.

Dockerfile Immer wenn ich etwas in Python schreibe, benutze ich Pipenv. Im Falle einer Webanwendung wird diese auch von nginx gesockelt und bereitgestellt Installieren Sie Pipenv und Nginx zum Zeitpunkt des Images.

Dockerfile

FROM python:3.8-slim-buster

#Installation von abhängigen Paketen
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

#Installieren Sie 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
#Pipenv installieren
RUN pip install pipenv
ENV PIPENV_VENV_IN_PROJECT 1
ENV PIPENV_YES true

RUN mkdir /app #Anwendungsbereitstellungsverzeichnis
RUN mkdir /script #Verschiedene Skriptplatzierungsverzeichnisse

COPY up.sh /script #Startskript

#Verschieben Sie das Git-Projekt im Startskript in die App
WORKDIR /app
#Die Bereitstellung von Webanwendungen ist ein Reverse-Proxy über den Hauptwebserver. Lassen Sie also nur 80 Ports offen.
EXPOSE 80
RUN chmod +x /script/up.sh
ENTRYPOINT [ "/script/up.sh" ]　#Wenn der Container gestartet wird, ist das Startskript aktiv.lauf sh

Container-Startskript

Die Git-Informationen der Anwendung werden beim Starten des Containers als Umgebungsvariable übergeben. Aus irgendeinem Grund kann git in meiner Umgebung nicht mit ssh geklont werden. Daher ist es eine Voraussetzung, mit https zu klonen. Analysieren Sie nach dem Klonen die Pip-Datei im Projektstammverzeichnis, um die erforderliche Python-Version zu ermitteln. In einigen Python-Bibliotheken müssen daher abhängige Programme installiert sein Das Skript (dependencies.sh) für deren Installation ist zum Zeitpunkt des Container-Starts gebunden und wird hier aufgerufen. Da Gunicorn zum Socket von Python-Webanwendungen verwendet wird, wird auch Gunicorn installiert.

up.sh

#!/bin/bash

#Holen Sie sich Git-Informationen aus Umgebungsvariablen
gitCloneUrl=${GIT_CLONE_URL}
gitUserName=${GIT_USER_NAME}
gitPassword=${GIT_PASSWORD}
gitCloneTarget=`echo ${gitCloneUrl} | sed -r "s#^(https?://)(.*)#\1${gitUserName}:${gitPassword}@\2#g
"`

#Holen Sie sich den Projektnamen
projectName=`echo ${gitCloneUrl} | sed -r "s#.*/(\w+)\.git#\1#g"`
echo "■ ■ ■ PROJECT NAME <${projectName}> ■ ■ ■"

git clone ${gitCloneTarget}

#Holen Sie sich die Python-Version von Pipfile
cd ${projectName}
pythonVersion=`grep python_version Pipfile | sed -r 's/python_version = "(.+)"/\1/g'`
echo "■ ■ ■ PYTHON VERSION <${pythonVersion}> ■ ■ ■"

#Wenn einige der zu installierenden Python-Bibliotheken von anderen Programmen abhängen, installieren Sie sie hier.
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 #Anwendungsstart-Skript
while true; do sleep 1000; done

Container starten

Als Beispiel zeige ich Ihnen die Konfiguration zum Starten der Django-Anwendung.

docker-compose.yml Auszug

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;
    }
}

Die Anwendung selbst wird beim Starten des Containers von git geklont. Da die Daten in PostgreSQL in einem separaten Container gespeichert sind, Unabhängig davon, wie oft Sie diesen Container neu erstellen, können Sie den Dienst normal im Betriebszustand bereitstellen.

Grundsätzlich können die meisten Python-Anwendungen mit dem obigen Image und der Startmethode ausgeführt werden. Da das Verfahren vom Klonen von Git bis zur Bereitstellung einfach ist, konnte ich ein Image erstellen, das durch Verlassen der Anwendung leicht wiederverwendet werden kann. Bei Anwendungen mit komplizierter Umgebungskonstruktion ist die Wartung möglicherweise einfacher, indem für jede Anwendung ein Image erstellt wird.

Dies ist die Serie zum Migrieren von VM-Servern in Container.