Wie man eine Python Flask API-Anwendung auf Docker bereitstellt – techsyncer

Wenn Sie neu bei Docker und Containern sind, ist es eine gute Möglichkeit, das Bereitstellen einer Python Flask API-Anwendung auf Docker zu erlernen. Docker ermöglicht es Ihnen, Anwendungen mit leichtgewichtiger Technologie und Sicherheit zu containerisieren, um sie schnell bereitzustellen.

In diesem Tutorial lernen Sie, wie Sie Python Flask API-Anwendungen auf Docker-Containern einrichten und bereitstellen können.

Machen Sie sich bereit und starten Sie die Bereitstellung!

Voraussetzungen

Wenn Sie Schritt für Schritt folgen möchten, müssen Sie Folgendes installiert haben:

Ubuntu-Maschine mit installiertem Docker. Dieses Tutorial verwendet Ubuntu 18.04.5 LTS mit Docker v19.03.8.

Python v3.9 oder höher auf der Ubuntu-Maschine installiert. In diesem Tutorial wird Python v3.9.2 auf einer Ubuntu-Maschine verwendet.

Elinks-Paket auf der Ubuntu-Maschine installiert, das in diesem Tutorial zur API-Test verwendet wird.

Erstellen einer Python Flask API-Anwendung (GET und POST API)

Beginnen Sie dieses Tutorial, indem Sie eine Python Flask-Anwendung erstellen. Flask ist ein leichtgewichtiges WSGI-Micro-Webanwendungsframework, das in Python geschrieben wurde. Flask bietet praktische Werkzeuge und Funktionen zur Erstellung von Webanwendungen in Python.

Vor der Erstellung einer Python Flask-Anwendung installieren Sie Flask und eine Python-Virtual-Umgebung, in der Flask ausgeführt wird.

1. Melden Sie sich mit Ihrem bevorzugten SSH-Client bei Ihrer Ubuntu-Maschine an.

2. Führen Sie anschließend die folgenden Befehle aus, um ein Verzeichnis namens ~/docker_python_flask_demo zu erstellen und in dieses zu wechseln. Dieses Verzeichnis enthält alle Dateien, die von Python und Docker zum Ausführen einer Anwendung benötigt werden.

mkdir ~/docker_python_flask_demo
cd ~/docker_python_flask_demo

3. Führen Sie den folgenden Befehl aus, um eine Python-Virtual-Umgebung (virtualenv) zu installieren, die von Flask zum Ausführen der Anwendungen benötigt wird. Eine Python-Virtual-Umgebung bietet eine eigene Python-Binärdatei und für die Anwendung installierte Pakete, um Konflikte mit anderen Anwendungen zu vermeiden.

pip install virtualenv

Installing the environment needed by Flask to execute the applications

4. Führen Sie den Befehl virtualenv aus, um eine virtuelle Umgebung zu erstellen und zu aktivieren mit dem Modul venv.

virtualenv venv

Creating the virtual environment for Python

5. Führen Sie nun den folgenden Befehl aus, um das Python-Paket flask mit dem Paketmanager pip zu installieren.

pip install flask

6. Führen Sie den folgenden Befehl aus, um Pakete in Ihrer virtuellen Umgebung zu aktivieren, bevor Sie sie installieren oder verwenden können. Dadurch wird die Umgebungsvariable VIRTUAL_ENV geändert, um auf Ihre virtuelle Umgebung zu verweisen, und der virtuelle Umgebungs-Python-Binärpfad wird dem Pfad vorangestellt, damit Sie den richtigen Binärpfad ausführen können.

source venv/bin/activate

7. Erstellen Sie eine weitere Datei mit dem Namen requirements.txt und definieren Sie die Abhängigkeit der Flask-Anwendung, wie unten gezeigt.

Flask==2.0.2

8. Erstellen Sie eine Textdatei ~/docker_python_flask_demo/app.py und füllen Sie die Datei mit dem untenstehenden Python-Code.

Der untenstehende Python-Code importiert die Python flask-Klasse und erstellt eine Klasseninstanz namens app. Die Klasseninstanz app enthält zwei login()-Funktionen, die ausgeführt werden, wenn Benutzer Anfragen auf der Seite /login senden.

Die Funktion success() wird dann ausgeführt und zeigt die Willkommensnachricht „name-of-the-user“ im Browser an.


from flask import Flask , redirect , url_for , request # Importieren der Klasse flask
# app ist das Objekt oder die Instanz von Flask
app = Flask(__name__)
# app.route informiert Flask über die zu verwendende URL durch die Funktion
@app.route('/success/<name>')
# Erstellen einer Funktion namens success
def success(name):
    return 'welcome %s' % name

@app.route('/login', methods = ['GET','POST'])
# Erstellen einer Funktion namens login
def login():
    if request.method == 'POST':
       user = request.form['adamlistek']
       return redirect(url_for('success', name = user)) 
    else:
       return "INVALID"
# Programme werden von hier aus auf einem Entwicklungsserver (lokal auf Ihrem System) ausgeführt
# mit aktivierter Debugging-Funktion
  
if __name__ == '__main__':
   app.run(debug = True)

9. Erstellen Sie eine weitere Datei mit dem Namen ~/docker_python_flask_demo/form.html und kopieren/einfügen Sie den unten stehenden Code.

Das Ausführen des folgenden HTML-Codes erstellt ein Formular mit zwei Eingabefeldern; eines ist Text, um Ihren Namen anzugeben, und das andere ist eine Schaltfläche zum Absenden.

Sobald Sie einen Benutzernamen angeben und die Schaltfläche zum Absenden drücken, wird eine POST-Anforderung gesendet, und Flask führt eine weitere Funktion aus und öffnet eine neue Webseite auf http://localhost:5000/success/<username>.

<html>
  <body>
    <form action="http://localhost:5000/login" method="post">
      <p>Please Enter your name</p>
      <p><input type="text" name="adamlistek" /></p>
      <p><input type="submit" value="Submit" /></p>
    </form>
  </body>
</html>

10. Führen Sie abschließend den Python-Befehl unten aus, um die Anwendung (app.py) lokal auf Ihrem System zu überprüfen.

Python app.py

Wie Sie unten sehen können, läuft die Anwendung erfolgreich auf der Ubuntu-Maschine, aber nicht auf Docker. Sie werden die gleiche Anwendung in den folgenden Abschnitten auf Docker starten.

Running the Python application on the ubuntu machine.

Erstellen eines Dockerfiles zum Bereitstellen der Python Flask API-Anwendung

Sie haben gerade die Python Flask-Anwendung erstellt und überprüft, dass sie lokal auf Ihrem Rechner funktioniert. Bevor Sie die Anwendung jedoch auf Docker bereitstellen, werden Sie zuerst eine Dockerfile erstellen, um alle Anweisungen zum Erstellen des Docker-Images zu definieren.

Erstellen Sie eine Datei mit dem Namen Dockerfile im Verzeichnis ~/docker_python_flask_demo und kopieren/einfügen Sie den unten stehenden Inhalt in die Dockerfile.

Docker wird dieses Dockerfile verwenden, um alle Anweisungen oder Befehle auszuführen, die erforderlich sind, um ein neues Docker-Image auf Basis des Basisimages (`ubuntu:18.04`) zu erstellen.

# Setzt das Basisimage für nachfolgende Anweisungen fest
FROM ubuntu:18.04
# Legt das Arbeitsverzeichnis im Container fest
WORKDIR /app
RUN apt-get update -y
RUN apt-get install -y python-pip python-dev
# Kopiert die Dateien in das Arbeitsverzeichnis
COPY form.html /app/form.html
# Kopiert die Abhängigkeitsdateien in das Arbeitsverzeichnis
COPY requirements.txt /app/requirements.txt
# Installiert Abhängigkeiten
RUN pip install -r requirements.txt
# Kopiert alles in das Arbeitsverzeichnis
COPY . /app
# Befehl, der beim Starten des Containers ausgeführt wird
CMD [ "python" , "./app.py" ]

Führen Sie nun den tree-Befehl unten aus, um zu überprüfen, ob alle erforderlichen Dateien zur Ausführung der Python Flask-Anwendung im Arbeitsverzeichnis (~/docker_python_flask_demo) enthalten sind.

tree

Verifying all Required Files to Run the Flask Application Exist

Erstellen eines Docker-Images für die Python Flask-API-Anwendung

Sie haben jetzt die erforderlichen Dateien, um eine Python Flask-Anwendung bereitzustellen, aber diese Dateien werden nichts tun, es sei denn, Sie erstellen ein Image. Sie werden den Befehl docker build ausführen, um ein Docker-Image basierend auf den Anweisungen zu erstellen, die Sie im Dockerfile festgelegt haben.

Führen Sie den Befehl docker build unten aus, um ein Docker-Image im Arbeitsverzeichnis (.) zu erstellen. Dieser Befehl markiert (-t) das Image als flask-image Version 1 (:v1).

sudo docker build -t flask-image:v1 .

Jetzt führen Sie den Befehl docker unten aus, um alle verfügbaren Images aufzulisten.

sudo docker images

Unten sehen Sie verschiedene zurückgegebene Attribute, wie REPOSITORY. Beachten Sie, dass der REPOSITORY-Name flask-image ist und mit einer Version (v1) markiert ist, wie unten gezeigt.

Verifying the New Docker Image (flask-image)

Ausführen der Python Flask-Anwendung im Docker-Container

Nachdem Sie ein Docker-Image erstellt haben, können Sie jetzt die Python Flask-Anwendung in einem Docker-Container ausführen. Ein Docker-Container verpackt Code und seine Abhängigkeiten, um Anwendungen schnell auszuführen.

1. Führen Sie den Befehl docker run unten aus, um Folgendes zu tun:

Starten Sie den Container im Hintergrundmodus (-d), damit er als Hintergrundprozess läuft und die Konsolenausgabe bei der Erstellung zurückgibt.
Ordnet den Docker-Host-Port (-p 5000:5000) mit dem Port des Containers zu.
Startet den Docker-Container (flask-image:v1)

sudo docker run -d -p 5000:5000 flask-image:v1

2. Als nächstes führen Sie den folgenden docker-Befehl aus, um alle Container im Docker-Engine aufzulisten. Überprüfen Sie, ob Docker den Container erfolgreich erstellt hat.

sudo docker ps -a

Verifying the Docker container in the Docker engine

3. Führen Sie abschließend den folgenden Befehl aus, um Ihren Webbrowser in der Ubuntu-Maschine mit elinks zu öffnen.

elinks form.html

Der Befehl öffnet den Webbrowser im Terminal und fordert nach einem Namen, wie unten gezeigt.

Geben Sie Ihren Namen ein und drücken Sie die Schaltfläche „Senden“.

Accessing the login web page with the form to enter your name

4. Wie unten gezeigt, leitet die Login-Funktion nach dem Drücken der Senden-Schaltfläche zur Erfolgsfunktion in der Flask-Anwendung weiter.

Displaying the welcome message in the web browser

Fazit

Dieses Tutorial hatte zum Ziel, Ihnen bei der Einrichtung eines Python Flask API Docker-Containers mithilfe von Docker-Images zu helfen. Sie haben auch gelernt, wie Sie Python Flask-Container mithilfe von Dockerfiles starten können, um Container nach Ihren Wünschen zu bearbeiten und zu erstellen.

Haben Sie bereits andere Anwendungen im Sinn, die Sie auf einem Docker-Container bereitstellen möchten? Vielleicht ein Docker MongoDB-Container?