Python Flask App Docker in ISPConfig3 mit Nginx - Teil 1: Minimale App

Dies ist ein Beitrag, der zeigt, wie man eine Flask App auf ISPConfig3. Warum? Ich habe einen VPS im Internet Debian und ISPConfig3. Es betreibt statische Websites und PHP Websites. Aber jetzt will ich auch meine Flask Python-Apps hier laufen lassen. Auf diese Weise kann ich das Domain-Management nutzen, an das ich gewöhnt bin, und brauche keinen zusätzlichen Server für Python Apps.

Diese Lösung wird für die Ausführung der Flask App, den Druck von Hello world", verwendet Docker und ist ein erster Proof of Concept, der zeigt, dass es möglich ist, eine Flasp-App auf ISPConfig3.

Meine lokale Maschine:

• Ubuntu desktop 18.04.1
• Python3.6.7
• nginx 1.14.0
• Docker 18.09.0
• Docker-zusammensetzen 1.23.2

Mein VPS:

• Debian 9 (Dehnen)
• ISPConfig3 3.1.13
• Nginx 1.10.3
• Docker 18.09.0
• Docker-zusammensetzen 1.23.2

Versuchen Sie, die Versionen Docker und Docker-compose auf beiden Maschinen identisch zu halten. Docker Entwickler können manchmal die Abwärtskompatibilität nicht aufrecht erhalten.

Inhalt:

• Schritt 1: Erstellen und betreiben Sie eine Flask App helloworld auf dem lokalen Rechner mit dem Entwicklungsserver.
• Schritt 2: Führen Sie helloworld auf dem lokalen Rechner unter Verwendung des Produktionsservers aus. Gunicorn
• Schritt 3: Führen Sie helloworld auf dem lokalen Rechner mit Hilfe von Docker
• Schritt 4: Auf dem lokalen Rechner die dockarized Hallo-Welt mit einem proxy Reverse-Nginx-Server bedienen.
• Schritt 5: Auf der ISPConfig3-Maschine die dockarized Helloworld einsetzen.
• Zusammenfassung
• Notizen

Schritt 1: Erstellen und betreiben Sie eine Flask App helloworld auf dem lokalen Rechner mit dem Entwicklungsserver.

1.1. Virtuelle Umgebung erstellen und aktivieren

Siehe Anweisungen im Internet. Mach so etwas wie:

> mkdir flask_docker
> cd flask_docker
> mkdir python3
> cd python3
> mkdir venvs
> python3 -m venv venvs/helloworld
> source venvs/helloworld/bin/activate
> cd venvs/helloworld
> pwd
.../flask_docker/python3/venvs/helloworld

1.2. Überprüfen Sie das Verzeichnis helloworld

Du solltest so etwas sehen:

.
|-- bin
|-- include
|-- lib
|-- lib64 -> lib
|-- __pycache__
|-- share
`-- pyvenv.cfg

All commands below are from this directory. 

1.3. Installieren Flask

Typ:

> Rohrinstallationskolben

1.4. Einfache Flask Anwendung erstellen hello.py

Erstelle mit deinem Editor eine Flask App helloworld.py:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return "<h1>Hello world!</h1>"
if __name__ == '__main__':
    app.run()

1.5. Führen Sie es mit dem Entwicklungsserver aus.

> python3 helloworld.py In

deinem Browsertyp: localhost:5000 Du

solltest sehen: Hello World

Stoppen Sie den Entwicklungsserver mit Strg-C.

Schritt 2: Führen Sie helloworld auf dem lokalen Rechner unter Verwendung des Produktionsservers aus. Gunicorn

2.1. Installation des Produktionsservers gunicorn

pip install gunicorn

2.2. Erstellen Sie das Anwendungsobjekt wsgi.py Datei für gunicorn:

Erstellen Sie die wsgi.py wie folgt:

from helloworld import app

if __name__ == "__main__":
    app.run()

Wir importieren die App einfach aus helloworld.py.

2.3. Führen Sie es mit dem gunicorn server aus.

> gunicorn --bind 0.0.0.0.0.0:8000 wsgi:app In

Ihrem Browsertyp: localhost:80000 Sie

sollten sehen: Hello World

Stoppen Sie den Waffenkammer-Server mit Strg-C.

Schritt 3: Führen Sie helloworld auf dem lokalen Rechner mit Hilfe von Docker

3.1. Installation Docker und DockerZusammenstellung

Siehe Anweisungen auf docker.com, digitalocean.com, etc.

Wenn du ohne sudo keine Befehle ausgeben Docker kannst, dann füge dich selbst zur Docker Gruppe hinzu:

Schritte nach der Installation für Linux
https://docs.docker.com/install/linux/linux-postinstall/

3.2. Speichern Sie die benötigte Software in requirements.txt.

> pip freeze > requirements.txt Wenn

es eine Zeile 'pkg-resources===0.0.0.0' in requirements.txt gibt, entfernen Sie diese.
Dies ist ein Fehler auf einigen Systemen.

Meine Datei requirements.txt sieht so aus:

Click==7.0
Flask==1.0.2
gunicorn==19.9.0
itsdangerous==1.1.0
Jinja2==2.10
MarkupSafe==1.1.0
Werkzeug==0.14.1   

3.3. Erstellen einer DockerDatei

Die DockerDatei sieht so aus:

FROM python:3.6-alpine

RUN adduser -D helloworlduser

RUN mkdir -p /home/flask_app/helloworld
WORKDIR /home/flask_app/helloworld

COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY helloworld.py wsgi.py boot.sh ./
RUN chmod +x boot.sh

ENV FLASK_APP helloworld.py

RUN chown -R helloworlduser:helloworlduser ./
USER helloworlduser

EXPOSE 5000
ENTRYPOINT ["./boot.sh"]

Das Startskript boot.sh:

#!/bin/sh
# called by Dockerfile

# go to directory where wsgi.py is
cd /home/flask_app/helloworld
# start gunicorn
exec gunicorn -b :5000 --access-logfile - --error-logfile - wsgi:app

Das Verzeichnis sieht nun so aus:

.
|-- bin
|-- include
|-- lib
|-- lib64 -> lib
|-- __pycache__
|-- share
|-- boot.sh
|-- docker-compose.yml
|-- Dockerfile
|-- Dockerfile_web
|-- helloworld.py
|-- image_helloworld.tar
|-- pyvenv.cfg
|-- requirements.txt
`-- wsgi.py

3.4. Erstellen des Container-Images

> docker build -t helloworld:latest .

Die Ausgabe endet mit so etwas wie:

...
Successfully built d3e8bc220161
Successfully tagged helloworld:latest

Sie können überprüfen, ob der Container angelegt wurde:

> Docker-Bilder

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
helloworld          latest              d3e8bc220161        2 minutes ago       84.8MB
python              3.6-alpine          1837080c5e87        5 weeks ago         74.4MB

3.5. Ausführen des Container-Images

Führen Sie den Container zunächst als Vordergrundanwendung aus, d.h. ohne die Option -d:

> docker run --name helloworld -p 8001:5000 --rm helloworld:latest

Wenn etwas nicht stimmt, z.B. in boot.sh, können Sie es korrigieren und den Container wieder neu erstellen:

> docker build -t helloworld:latest .

Sie können den Container auch betreten, um zu sehen, was passiert, z.B. ob die Dateien wirklich da sind:

> docker run -it --entrypoint /bin/sh --rm helloworld:latest

Wenn alles in Ordnung ist, kannst du den Container im Hintergrund mit der Option -d laufen lassen:

> docker run --name helloworld -d -p 8001:5000 --rm helloworld:latest

In deinem Browsertyp: localhost:80001

Das solltest du sehen: Hallo Welt

Überprüfen Sie, ob der Behälter läuft:

> Docker ps

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
37f06d44cd30        helloworld:latest   "./boot.sh"         4 seconds ago       Up 4 seconds        0.0.0.0:8001->5000/tcp   helloworld

Überprüfen Sie die Protokolle:

> docker logs helloworld

[2019-02-02 14:52:57 +0000] [1] [INFO] Starting gunicorn 19.9.0
[2019-02-02 14:52:57 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2019-02-02 14:52:57 +0000] [1] [INFO] Using worker: sync
[2019-02-02 14:52:57 +0000] [9] [INFO] Booting worker with pid: 9

Um den Behälter zu stoppen:

> docker kill helloworld

Überprüfen Sie, ob der Behälter nicht mehr läuft:

> Docker ps

Schritt 4: Auf dem lokalen Rechner die dockarized Helloworld mit einem Reverse-Server proxy Nginx bedienen.

4.1. Installation Nginx auf dem lokalen Rechner

Wenn es noch nicht installiert ist:

> sudo apt installieren nginx installieren

4.2. Konfigurieren Nginx

Wir werden die Website helloworld.net am Port 8080 bedienen, konfigurieren als Nginx umgekehrte Konfiguration, d.h proxy. sie leitet Client-Anfragen an unseren Gunicorn Server weiter, der auf .

Erstellen Sie eine Datei /etc/nginx/sites-available/helloworld.conf:

server {
  listen 8080;
  server_name helloworld.net;

  location / {
    proxy_pass http://127.0.0.1:8001;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    client_max_body_size 1M;  
  }
}

Erstellen Sie einen symbolischen Link in /etc/nginx/sites-enabled:

> sudo ln -s /etc/nginx/sites-available/helloworld.conf /etc/nginx/sites-enabled/helloworld.conf

Neustart Nginx:

> sudo systemctl neustart nginx

Wenn etwas schief geht, schau dir den Status an:

> sudo systemctl status nginx.service

4.3. Hinzufügen von helloworld.net zur hosts-Datei

> sudo nano /etc/hosts

Füge eine Zeile hinzu:

127.0.0.0.0.1 helloworld.net

Überprüfen Sie, ob es funktioniert, es sollte 127.0.0.0.0.1 auf Ping reagieren:

> ping helloworld.net

PING helloworld.net (127.0.0.1) 56(84) bytes of data.
64 bytes from helloworld.net (127.0.0.1): icmp_seq=1 ttl=64 time=0.023 ms
64 bytes from helloworld.net (127.0.0.1): icmp_seq=2 ttl=64 time=0.042 ms

In Chrom (Chrom) können Sie die DNS überprüfen und löschen, indem Sie in die Adressleiste eingeben:

chrom://net-intern/#dns

4.4. Starten Sie den Container und greifen Sie auf Ihre Website zu.

In deinem Browsertyp: helloworld.net:8080

Wenn Sie das Helloworld Docker Container Image noch nicht gestartet haben, wird der Browser angezeigt:

502 Schlechtes Gateway

Starten Sie Ihren Container:

> docker run --name helloworld -d -p 8001:5000 --rm helloworld:latest

In Ihrem Browser sollten Sie sehen: Hallo Welt

Schritt 5: Auf dem ISPConfig3 VPS die dockarized Helloworld einsetzen.

Wir haben jetzt ein Docker Container-Image, das auf unserer lokalen Maschine funktioniert. Um dies auf unserer ISPConfig3er Maschine auszuführen, haben wir mehrere Möglichkeiten. Hier verwenden wir: Kopieren Sie das Docker Bild auf einen anderen Host.

5.1. Installation Docker und DockerZusammenstellung auf dem VPS

Befolgen Sie die Installationsanweisungen.

5.2. Kopieren Sie DockerDatei- und Docker-Image auf ISPConfig3 Geräte.

Finden Sie unser Bild:

> Docker-Bilder

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
helloworld          latest              bee00f1c8607        21 hours ago        84.8MB

Speichern Sie das Docker-Image als tar-Datei:

> Docker speichern -o./image_helloworld.tar helloworld

Verwenden Sie ein Dateiübertragungsprogramm, um die DockerDatei und das Bild auf das ISPConfig3-Gerät zu kopieren.

Auf der ISPConfig3-Maschine gehen Sie in das Verzeichnis, in dem sich die Dateien befinden, und fügen Sie unser Bild zu Docker:

> Docker laden -i image_helloworld.tar

Dies kann einige Zeit in Anspruch nehmen. Überprüfen Sie, ob das Bild verfügbar ist:

> Docker-Bilder

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
helloworld          latest              bee00f1c8607        21 hours ago        84.8MB

5.3. Konfigurieren Sie Ihre Website in ISPConfig3 Schritten

Annahme ist, dass Sie einen Domainnamen haben, der bereits auf Ihren ISPConfig3er Rechner zeigt, Sie haben die Domain hinzugefügt und die Website hinzugefügt. In diesem Fall bei der Eingabe in Ihrem Browser:

<domain>

solltest du so etwas sehen:

Welcome to your website!

Melden Sie sich bei ISPConfig3.

Gehe zu: Standorte->Ihre Standorte

Auf der Registerkarte Domäne:

- CGI deaktivieren

- : PHPdeaktiviert

Klicken Sie auf Speichern.

Auf der Registerkarte Optionen

Fügen Sie den nginx-Richtlinien Folgendes hinzu:

location / {
    proxy_pass http://127.0.0.1:8001;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    client_max_body_size 1M;
}

Klicken Sie auf Speichern.

Wenn Ihre Website vorher funktioniert hat, sollte sie nun angezeigt werden:

FEHLER 502 - Schlechtes Tor!

5.4. Starten Sie den Container

> docker run --name helloworld -p 8001:5000 --rm helloworld:latest

Jetzt nach der Eingabe in Ihrem Browser:

<domain>

die du sehen solltest: Hallo Welt

Großartig!

Stoppen Sie die Docker Flask App:

> docker kill helloworld

Überprüfen Sie, ob es weg ist:

> Docker ps

Zusammenfassung

Wir haben eine einfache Flask App erstellt und auf unserer ISPConfig3er Maschine implementiert.

In einem nächsten Beitrag werden wir ein weiterführendes Beispiel verwenden:

• Mehrere Seiten bedienen
• Statische Dateien bereitstellen
• Verbindung zur ISPConfig3. Datenbank herstellen

Notizen

1. Sie können Gunicorn immer für die Entwicklung

verwenden. Aktivieren Sie den Flask interaktiven Debugger in der Entwicklung mit Gunicorn
https://nickjanetakis.com/blog/enabling-the-flask-interactive-debugger-in-development-with-gunicorn

Links / Impressum

Deploy flask app with nginx using gunicorn and supervisor
https://medium.com/ymedialabs-innovation/deploy-flask-app-with-nginx-using-gunicorn-and-supervisor-d7a93aa07c18

Embedding Python In Apache2 With mod_python (Debian/Ubuntu, Fedora/CentOS, Mandriva, OpenSUSE)
https://www.howtoforge.com/embedding-python-in-apache2-with-mod_python-debian-ubuntu-fedora-centos-mandriva-opensuse

How to Configure NGINX for a Flask Web Application
https://www.patricksoftwareblog.com/how-to-configure-nginx-for-a-flask-web-application/" target="_blank">How to Configure NGINX for a Flask

How to copy Docker images from one host to another without using a repository
https://stackoverflow.com/questions/23935141/how-to-copy-docker-images-from-one-host-to-another-without-using-a-repository

How to deploy a django application on a linux (Debian/Ubuntu) production server running ISPConfig 3
http://blog.yawd.eu/2011/how-to-deploy-django-app-linux-server-ispconfig/

How To Serve Flask Applications with Gunicorn and Nginx on Ubuntu 18.04
https://www.digitalocean.com/community/tutorials/how-to-serve-flask-applications-with-gunicorn-and-nginx-on-ubuntu-18-04

The Flask Mega-Tutorial Part XIX: Deployment on Docker Containers
https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-xix-deployment-on-docker-containers