Python Flask App Docker in ISPConfig3 mit Nginx - Teil 1: Minimale App
ISPConfig ist ein großartiges Hosting-Control Panel, unterstützt aber keine Python Anwendungen direkt nach dem Auspacken. Dieser Beitrag zeigt, wie du es mit Docker.
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
Neueste
- Ausblenden der Primärschlüssel der Datenbank UUID Ihrer Webanwendung
- Don't Repeat Yourself (DRY) mit Jinja2
- SQLAlchemy, PostgreSQL, maximale Anzahl von Zeilen pro user
- Anzeige der Werte in den dynamischen Filtern SQLAlchemy
- Sichere Datenübertragung mit Public Key Verschlüsselung und pyNaCl
- rqlite: eine hochverfügbare und distverteilte SQLite -Alternative
Meistgesehen
- Verwendung von Pythons pyOpenSSL zur Überprüfung von SSL-Zertifikaten, die von einem Host heruntergeladen wurden
- Verwendung von UUIDs anstelle von Integer Autoincrement Primary Keys mit SQLAlchemy und MariaDb
- Verbindung zu einem Dienst auf einem Docker -Host von einem Docker -Container aus
- PyInstaller und Cython verwenden, um eine ausführbare Python-Datei zu erstellen
- SQLAlchemy: Verwendung von Cascade Deletes zum Löschen verwandter Objekte
- Flask RESTful API Validierung von Anfrageparametern mit Marshmallow-Schemas