Wie erstellt und implementiert man eine Python-Anwendung?

Python ist eine freie und quelloffene Programmiersprache, die viele Anwendungen hat. Sie wurde 1991 von Guido Van Rossum entwickelt und hat sich seither zu einer der beliebtesten Programmiersprachen entwickelt.

In diesem Artikel werden wir über Python, seine Vor- und Nachteile, Anwendungsfälle und Bereitstellungsoptionen sprechen. Darüber hinaus zeigen wir, wie man eine einfache Python-Anwendung erstellt, andockt und in Back4app Containern bereitstellt.

Lesen Sie weiter, um mehr darüber zu erfahren, wie man ein Python-Projekt erstellt und einsetzt.

Python Überblick

Python ist eine universelle Programmiersprache auf hohem Niveau. Sie ist interpretiert, dynamisch typisiert und kann sowohl für Skripte als auch für die Programmierung verwendet werden. Entwickler bezeichnen Python aufgrund seiner umfangreichen Standardbibliothek gewöhnlich als eine Sprache mit “Batterien im Gepäck”.

Die Sprache erschien erstmals 1991 und hat sich seither aufgrund ihrer einfachen und lesbaren Syntax zu einer der beliebtesten und beliebtesten Programmiersprachen entwickelt. Die wichtigsten Gestaltungsprinzipien von Python werden in dem Buch The Zen of Python von Tim Peters behandelt.

Python hat eine große Gemeinschaft von Entwicklern und gebrauchsfertigen Paketen. Heutzutage wird Python so ziemlich überall eingesetzt – in der Serververwaltung, im wissenschaftlichen Rechnen, beim maschinellen Lernen, bei der Erstellung von RESTful-APIs und so weiter. Python kann als eine der wesentlichen Fähigkeiten eines modernen Entwicklers angesehen werden.

Vorteile von Python

Einfach zu benutzen

Python ist eine der am einfachsten zu verwendenden und zu erlernenden Sprachen. Die Lernkurve ist so gut wie nicht vorhanden, da der Schwerpunkt der Designphilosophie auf Einfachheit und Lesbarkeit des Codes liegt. Python wird auch in der Ausbildung bevorzugt, weil es ein großartiges Werkzeug zum Erlernen grundlegender Programmierkonzepte ist.

Schnelle Entwicklung

Ein weiterer großer Vorteil von Python ist, dass es eine schnelle Entwicklung ermöglicht. Es ist eine großartige Sprache für das Prototyping und die schnelle Erledigung von Aufgaben. Wenn Sie Python verwenden, müssen Sie sich nicht um komplexe Syntax, Speicherzuweisung usw. kümmern, sondern können sich auf Ihre Anwendung konzentrieren.

Vielseitig

Python ist eine der vielseitigsten Programmiersprachen. Sie wird in einer Vielzahl von Branchen und Bereichen eingesetzt. Einige der Bereiche, in denen Python verwendet wird, sind Buchhaltung, wissenschaftliche Forschung, Datenwissenschaft, Webentwicklung, Spieleentwicklung und Automatisierung.

Tragbar

Python ist eine portable Sprache, da sie interpretiert (wie Java) und nicht kompiliert wird (wie C++). Das bedeutet, dass der auf einer Plattform geschriebene Code leicht auf eine andere Plattform übertragen werden kann. Das macht Python zu einer beliebten Wahl für Entwickler, die mehrere Plattformen unterstützen müssen, darunter Windows, macOS, Linux und Android.

Umfangreiche Bibliotheken

Die Programmiersprache Python wird von einer riesigen Gemeinschaft von Entwicklern unterstützt. Es gibt eine Bibliothek für fast alles, was Sie sich vorstellen können. Einige der beliebtesten Bibliotheken sind:

• Webentwicklung(Django, Flask, FastAPI)
• Maschinelles Lernen und Datenwissenschaft(TensorFlow, PyTorch)
• Computer Vision(OpenCV, Pillow, Scikit-image)
• Wissenschaftliches Rechnen(NumPy, SciPy)
• Grafische Benutzeroberfläche(Qt, GTK)

Und das kratzt kaum an der Oberfläche. Wenn Sie eine vollständige Liste der fantastischen Python-Pakete sehen wollen, werfen Sie einen Blick auf awesome-python auf GitHub.

Dynamisch typisiert

Python ist eine dynamisch typisierte Sprache, was bedeutet, dass Sie beim Erstellen von Variablen den Datentyp nicht deklarieren müssen. Der Variablentyp wird erst zugewiesen, wenn der Code ausgeführt wird.

So großartig sie auch sein mögen, dynamisch typisierte Sprachen können manchmal ein zweischneidiges Schwert sein. Sie sind in der Regel fehleranfälliger und haben im Vergleich zu statisch typisierten Sprachen eine geringere Speicherkontrolle.

Erweiterbar

Wenn Ihre Projektanforderungen rechenintensive Aufgaben umfassen, können Sie diese in schnelleren Sprachen wie C oder C++ schreiben und sie dann von Ihrem Python-Code aus aufrufen.

Um mehr über den Aufruf von C/C++ aus Python heraus zu erfahren, lesen Sie diesen großartigen Artikel.

Beschränkungen von Python

Schlechte Leistung

Python ist im Vergleich zu anderen Programmiersprachen relativ langsam. Die beiden Faktoren, die die Leistung am meisten beeinträchtigen, sind, dass Python eine interpretierte Sprache ist und dynamisch typisiert ist. Wenn Ihr Projekt hohe Anforderungen an die Rechenleistung oder das Multithreading stellt, ist Python möglicherweise nicht das am besten geeignete Werkzeug. Dann sind Sie mit C, C++ oder einer anderen kompilierten Sprache besser bedient.

Speicherintensiv

Python-Programme verbrauchen im Vergleich zu Programmen, die in statisch typisierten Sprachen geschrieben wurden, in der Regel mehr Speicher und bieten ein geringeres Maß an Kontrolle über den Speicher. Dies kann ein wenig problematisch sein, wenn Ihre Anwendungen speichereffizient sein müssen.

Anfällig für Laufzeitfehler

Da Python eine interpretierte Sprache ist, ist es anfälliger für Laufzeitfehler. Da es keinen Kompilierungsprozess gibt, können Fehler nicht zur Kompilierungszeit entdeckt werden. Darüber hinaus ist Python dynamisch typisiert, was bedeutet, dass Entwickler den Typ einer Variablen jederzeit ändern können. Dies kann manchmal zu Fehlern führen und verlangt von den Entwicklern, dass sie auf die Variablentypen achten.

Globale Dolmetschersperre (GIL)

Das Global Interpreter Lock (GIL) in Python ist ein Mechanismus, der sicherstellt, dass jeweils nur ein Thread den Python-Bytecode ausführt. Dies vereinfacht zwar die Implementierung der Sprache und bietet einige Leistungsvorteile für bestimmte Programmtypen, schränkt aber auch die Möglichkeit ein, Multi-Core-Prozessoren in CPU-gebundenen Anwendungen voll auszunutzen.

Nicht für den Datenbankzugriff optimiert

Die Arbeit mit Datenbanken in Python-Anwendungen kann aufgrund des Fehlens leistungsfähiger und benutzerfreundlicher Schnittstellen wie der Java Database Connectivity (JDBC) eine größere Herausforderung darstellen. Python kann zwar für Datenbankoperationen verwendet werden, die einfache Lese- und Schreibaufgaben beinhalten, ist aber möglicherweise nicht die beste Option für Anwendungen, die mit großen und komplexen Datenbanken arbeiten müssen.

Optionen für die Python-Bereitstellung

Python-Anwendungen können auf verschiedenen Cloud-Plattformen bereitgestellt werden. Im Allgemeinen können wir sie in die folgenden drei Kategorien einteilen:

• Infrastruktur als Dienstleistung (IaaS)
• Plattform als Dienstleistung (PaaS)
• Container als Dienstleistung (CaaS)

IaaS ist am wenigsten abstrahiert und CaaS ist am meisten abstrahiert. Es gibt auch konventionelles Hosting, aber ich bin mir ziemlich sicher, dass Sie damit bereits vertraut sind.

Infrastruktur als Dienstleistung (IaaS)

Infrastructure as a Service (IaaS) ist ein Cloud-Computing-Modell, bei dem ein Drittanbieter virtualisierte Datenverarbeitungsressourcen wie Server, Speicher, Betriebssysteme und Netzwerke über das Internet anbietet. Die bereitgestellten Ressourcen können dann über erweiterte Dashboards oder hochentwickelte APIs verwaltet werden, so dass die Kunden die volle Kontrolle über ihre gesamte Infrastruktur haben.

Die Hauptvorteile von IaaS sind Skalierbarkeit, Kosteneinsparungen, verbesserter Support, Leistung und Sicherheit. Die Zahlungsstruktur der meisten IaaS-Anbieter basiert auf einem Pay-as-you-go-System, bei dem Sie nur für die von Ihnen genutzten Ressourcen zahlen müssen.

IaaS ist das flexibelste Cloud-Computing-Modell und bleibt seit seiner Einführung in den frühen 2010er Jahren die beliebteste Option. Der größte Nachteil ist, dass der Kunde die volle Verantwortung für seine Anwendungen, Betriebssysteme und Daten trägt.

Plattform als Dienstleistung (PaaS)

Platform as a Service (PaaS) ist ein Cloud-Computing-Dienst, der Benutzern eine Cloud-Umgebung zur Erstellung, Verwaltung und Bereitstellung von Anwendungen zur Verfügung stellt. PaaS bietet vorgefertigte Tools für die App-Entwicklung, -Anpassung und -Tests. Mit PaaS können sich die Nutzer auf ihre Anwendung konzentrieren, da sich der Dienstanbieter um die zugrunde liegende Infrastruktur kümmert, einschließlich Server, Betriebssysteme, Software, Backups und mehr.

Zu den Vorteilen von PaaS gehören eine schnellere Markteinführung, erhöhte Sicherheit, Kosteneffizienz, Skalierbarkeit, hohe Verfügbarkeit und in der Regel ein geringerer Codebedarf. Allerdings gibt es auch ein paar Nachteile. Die drei wichtigsten Nachteile sind mangelnde Flexibilität, fehlende Kontrolle und das Risiko der Anbieterbindung. Nichtsdestotrotz ermöglicht PaaS den Benutzern, Anwendungen schneller und mit weniger Verwaltungsaufwand zu erstellen.

Container als Dienstleistung (CaaS)

Container as a Service (CaaS) ist ein Cloud-Computing-Modell, das es Unternehmen ermöglicht, ihre Container mithilfe von Container-Virtualisierungstechnologie hochzuladen, auszuführen, zu skalieren und zu verwalten. CaaS-Anbieter abstrahieren einen Großteil der erforderlichen Arbeit, wie Infrastruktur, Betriebssysteme, Software, Containerisierungs-Engines und mehr.

Das Tolle an Containern ist, dass Sie Ihre Anwendung, sobald sie containerisiert ist, so gut wie überall einsetzen können und dass sie sich garantiert genauso verhält. Bei Bedarf können Sie von einem CaaS-Anbieter zu einem anderen wechseln. CaaS-Kunden werden in der Regel pro Container abgerechnet (basierend auf den Container-Spezifikationen).

CaaS ist im Allgemeinen teurer als IaaS und PaaS, bietet ein geringeres Maß an Flexibilität und Kontrolle und erfordert einige anfängliche Arbeit, z. B. das Dockerisieren der Anwendung usw. Nichtsdestotrotz ist es eines der einfacheren Cloud-Computing-Modelle, wenn Ihre Anwendung erst einmal containerisiert ist.

Wenn Sie mehr über Container erfahren möchten, lesen Sie bitte Was sind Container im Cloud Computing?

Prozess der Python-Bereitstellung

In diesem Abschnitt des Tutorials zeigen wir Ihnen, wie Sie eine einfache Python-Anwendung Schritt für Schritt erstellen und bereitstellen können. Die Webanwendung wird mit dem Flask-Framework implementiert und in Back4app-Containern bereitgestellt.

Voraussetzungen

• Erfahrung mit Python und Flask
• Grundlegendes Verständnis von Docker
• Python Version 3.8 oder höher und Docker Desktop installiert

Was ist Back4app Containers?

Back4app Containers ist eine kostenlose und quelloffene Plattform, die es Ihnen ermöglicht, Anwendungen mithilfe von global verteilten Containern bereitzustellen und zu skalieren.

Mit Back4app Containers können Sie sich auf die Entwicklung Ihrer Software konzentrieren und sie schnell ausliefern, ohne sich um DevOps kümmern zu müssen.

Die Plattform ist eng mit GitHub integriert und verfügt über ein integriertes CI/CD-System. Durch die Verwendung von Back4app Containers können Sie Ihre App in wenigen Minuten online stellen.

Warum Back4app-Container verwenden?

• Gut mit GitHub integrierbar
• Skalierung und Zero-Downtime-Bereitstellungen
• Extrem einfach zu bedienen
• Ausgezeichnete Kundenbetreuung

Projekt-Einführung

In diesem Artikel werden wir eine einfache RESTful-API erstellen und bereitstellen, die als TODO-Liste dienen wird. Die Web-API wird es den Benutzern ermöglichen, grundlegende CRUD-Vorgänge durchzuführen – wie das Hinzufügen von Aufgaben, das Löschen von Aufgaben, das Markieren von Aufgaben als erledigt und so weiter.

Wir werden zunächst am Quellcode arbeiten und ihn später in einem Back4app Flask Container einsetzen. Die Webanwendung wird mit dem Web-Framework Flask implementiert.

Sie können den Abschnitt “Code App” auch überspringen und mit Ihrem eigenen Python-Projekt weitermachen.

Code App

Init-Projekt

Beginnen Sie damit, ein eigenes Verzeichnis für die Flask-Anwendung zu erstellen und dorthin zu navigieren:

$ mkdir flask-todo
$ cd flask-todo

Erstellen Sie eine virtuelle Umgebung und aktivieren Sie sie:

$ python3 -m venv venv && source venv/bin/activate

Als nächstes installieren Sie Flask über pip:

$ (venv) pip install Flask==2.2.2

Um sicherzustellen, dass alles funktioniert, ersetzen wir den Inhalt von app.py durch den folgenden Text:

# app.py

from flask import Flask

app = Flask(__name__)


@app.route('/')
def index_view():
    return {
        'detail': 'Hello world'
    }

Dieser Code initialisiert Flask und erstellt einen einfachen Endpunkt, der eine Nachricht zurückgibt.

Starten Sie den Server mit:

$ (venv) flask run

Navigieren Sie schließlich in Ihrem Lieblingsbrowser zu http://localhost:5000/. Sie sollten eine Meldung mit dem Wort "Hello world" sehen.

Datenbank

Kümmern wir uns nun um die Datenbank.

Anstatt rohes SQL auszuführen, werden wir Flask-SQLAlchemy verwenden – ein einfaches Flask ORM. Um es zu installieren, führen Sie aus:

$ (venv) pip install Flask-SQLAlchemy

Als Nächstes ersetzen Sie den Inhalt von app.py durch den folgenden Text:

# app.py

from datetime import datetime

from flask import Flask, jsonify, request
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()
app = Flask(__name__)
app.config['SECRET_KEY'] = '5b3ef5s80gl3b217c20fb37044fe4k33'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///default.db"
db.init_app(app)


class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), nullable=False)
    description = db.Column(db.String(256), nullable=False)

    is_done = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=datetime.now(), nullable=True)
    updated_at = db.Column(db.DateTime, default=None, nullable=True)

    def as_dict(self):
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

    def __repr__(self):
        return f'<Task {self.title}>'


@app.route('/')
def index_view():
    return {
        'name': 'flask-todo',
        'description': 'a simple todo app written in flask',
        'version': 1,
    }

Dieser Code konfiguriert Flask und definiert ein neues Modell namens Task. Das Aufgabenmodell hat einen Namen, eine Beschreibung, is_done und einige andere Variablen wie created_at und updated_at, die wir dynamisch aktualisieren werden.

Als Nächstes erstellen Sie ein Python-Skript namens init_db.py, das die SQLite-Datenbank initialisiert und auffüllt:

# init_db.py

from app import db, app
from app import Task

with app.app_context():
    db.create_all()

    if Task.query.count() == 0:
        tasks = [
            Task(name='Backup the database', description='Make sure to backup the database with all the tables.'),
            Task(name='Setup 2FA', description='Setup the two factor authentication to secure your account.'),
            Task(name='Malware scan', description='Perform a malware scan.'),
        ]

        for task in tasks:
            db.session.add(task)

        db.session.commit()

Führen Sie das Skript über die Befehlszeile aus:

$ (venv) python init_db.py

Sie werden feststellen, dass ein neues Verzeichnis mit dem Namen instance erstellt worden ist. In diesem Verzeichnis befindet sich default.db, die Standarddatenbank.

API

Die Flask-App wird die folgenden URLs haben:

1. /api/ liefert die Liste aller Aufgaben
2. /api/ / zeigt oder löscht eine bestimmte Aufgabe
3. /api/create/ erstellt eine neue Aufgabe
4. /api/toggle/ / schaltet die is_done-Eigenschaft einer bestimmten Aufgabe um

Um sie zu implementieren, fügen Sie Folgendes an das Ende von app.py an:

# app.py

@app.route('/api/')
def list_view():
    json = [task.as_dict() for task in Task.query.all()]
    return jsonify(json)


@app.route('/api/<int:task_id>/', methods=['GET', 'DELETE'])
def detail_view(task_id):
    task = db.get_or_404(Task, task_id)

    if request.method == 'DELETE':
        db.session.delete(task)
        db.session.commit()

        return {
            'detail': 'Task has been successfully deleted.'
        }
    else:
        return task.as_dict()


@app.route('/api/create/', methods=['POST'])
def create_view():
    name = request.form.get('name')
    description = request.form.get('name')

    if name is None or description is None:
        return {
            'detail': 'Please provide the name and the description.'
        }, 400

    task = Task(name=name, description=description)
    db.session.add(task)
    db.session.commit()

    return task.as_dict()


@app.route('/api/toggle/<int:task_id>/')
def toggle_view(task_id):
    task = db.get_or_404(Task, task_id)

    if task.is_done:
        task.is_done = False
    else:
        task.is_done = True

    task.updated_at = datetime.now()
    db.session.commit()

    return task.as_dict()

Dieser Code ist ziemlich selbsterklärend. Wir haben die erforderlichen Routen definiert und die erforderliche Logik implementiert. Jedes Mal, wenn wir Änderungen an der Datenbank vornehmen wollen, müssen wir sie mit commit() übertragen.

Gut, das war’s für die Flask-App. In den nächsten Abschnitten werden wir unser Projekt für die Bereitstellung vorbereiten.

Gunicorn

Der Webserver von Flask wird für den produktiven Einsatz nicht empfohlen, da er für die Bearbeitung einer einzelnen Anfrage ausgelegt ist und möglicherweise nicht in der Lage ist, große Mengen an Datenverkehr zu verarbeiten. Aus diesem Grund sollten wir ihn mit Gunicorn austauschen – einem produktionsreifen Python WSGI Server.

Installieren Sie es zunächst über pip:

$ (venv) pip install gunicorn==20.1.0

Nach der erfolgreichen Installation können Sie den Server wie folgt starten:

$ (venv) gunicorn -w 2 -b 0.0.0.0:5000 app:app

[INFO] Starting gunicorn 20.1.0
[INFO] Listening at: http://0.0.0.0:5000 (1)
[INFO] Using worker: sync
[INFO] Booting worker with pid: 3
[INFO] Booting worker with pid: 4

Beachten Sie, dass dieser Befehl nur auf UNIX-basierten Betriebssystemen funktioniert.

Dadurch werden zwei Gunicorn-Worker gestartet und Ihre Anwendung wird auf Port 5000 bereitgestellt. Um auf Ihre App zuzugreifen, öffnen Sie Ihren bevorzugten Webbrowser und navigieren Sie zu http://localhost:5000.

Anforderungen.txt

Das letzte, was wir vor dem Dockerisieren unserer Anwendung tun müssen, ist das Erstellen einer requirements.txt-Datei. Die Datei requirements.txt wird verwendet, um die Abhängigkeiten des Projekts anzugeben.

Erzeugen Sie es, indem Sie den folgenden Befehl ausführen:

$ (venv) pip freeze > requirements.txt

Andere (einschließlich Docker-Container) können dann die Datei requirements.txt wie folgt verwenden:

$ (venv) pip install -r requirements.txt

Dockerize-App

Um die Anwendung zu docken, verwenden wir ein Dockerfile. Dockerdateien werden verwendet, um die Anweisungen für die Erstellung von Docker-Images zu definieren. Sie ermöglichen das Festlegen des Basis-Images, des Arbeitsverzeichnisses, der Umgebungsvariablen, der auszuführenden Befehle und mehr.

.dockerignore

Bevor wir an der Dockerdatei arbeiten, sollten wir eine .dockerignore-Datei erstellen. Eine .dockerignore-Datei wird verwendet, um festzulegen, welche Ordner und Dateien aus dem Abbild ausgelassen werden sollen.

.git/
.idea/
instance/
__pycache__/

Stellen Sie sicher, dass Sie die .dockerignore entsprechend Ihren Bedürfnissen anpassen.

Dockerdatei

Erstellen Sie im Stammverzeichnis des Projekts eine neue Datei namens Dockerfile mit folgendem Inhalt:

# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM python:3.10-alpine

WORKDIR /app

# set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# install the requirements
COPY requirements.txt /app
RUN --mount=type=cache,target=/root/.cache/pip \
    pip3 install -r requirements.txt

COPY . .

# initialize the database (create DB, tables, populate)
RUN python init_db.py

EXPOSE 5000/tcp

CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:5000", "app:app"]

Dieses Dockerfile verwendet python:3.10-alpine als Basis-Image. Es legt dann das Arbeitsverzeichnis fest, installiert die Anforderungen, kopiert das Projekt, initialisiert die Datenbank und startet schließlich den Gunicorn-Server an Port 5000.

Um mehr über Dockerfiles zu erfahren, lesen Sie dieDockerfile-Referenz.

Test

Um sicherzustellen, dass das Dockerfile funktioniert, können wir es lokal erstellen und ausführen. Um das Image zu erstellen, führen Sie aus:

$ docker build -t flask-todo:1.0 .

Wenn Sie die Bilder auflisten, sollten Sie ein neues Bild sehen:

$ docker images

REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
flask-todo        1.0       7ege66240eb1   3 hours ago   109MB

Schließlich verwenden Sie das Image, um einen neuen Docker-Container zu starten:

$ docker run -it -p 5000:5000 flask-todo:1.0

[2023-02-02 20:08:57 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-02-02 20:08:57 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-02-02 20:08:57 +0000] [1] [INFO] Using worker: sync
[2023-02-02 20:08:57 +0000] [7] [INFO] Booting worker with pid: 3
[2023-02-02 20:08:57 +0000] [8] [INFO] Booting worker with pid: 4

Sie können -d verwenden, um den Docker-Container im losgelösten Modus zu starten. Das bedeutet, dass der Container im Hintergrund Ihres Terminals läuft und keine Eingaben empfängt oder Ausgaben anzeigt.

Großartig, Ihre Anwendung läuft jetzt in einem Container. Navigieren Sie in Ihrem bevorzugten Webbrowser zu http://localhost:5000, um Ihre Webanwendung in Aktion zu sehen.

{
    "name": "flask-todo",
    "description": "a simple todo app written in flask",
    "version": 1
}

Auf GitHub verschieben

Für die folgenden Schritte benötigen Sie ein GitHub-Konto. Wenn Sie noch keines haben, melden Sie sich an, ansonsten melden Sie sich an. Stellen Sie außerdem sicher, dass Sie Git installiert und konfiguriert haben.

Sobald Sie sich bei GitHub angemeldet haben, klicken Sie auf die Schaltfläche “Plus” oben rechts auf dem Bildschirm, um das Dropdown-Menü zu öffnen. Wählen Sie dann “Neues Repository”:

Wählen Sie einen eigenen Namen für Ihr Repository. Ich werde mich für “flask-todo” entscheiden und dann auf “Repository erstellen” klicken:

Sobald Ihr Repository erstellt ist, notieren Sie sich die Remote-URL:

Jetzt navigieren wir zurück zu unserem lokalen Projekt und pushen den Code.

Da wir einige Dateien haben, die wir nicht an Git übergeben wollen, erstellen Sie eine .gitignore-Datei im Stammverzeichnis des Projekts. Ich werde die Datei wie folgt ergänzen, aber Sie können sie gerne Ihren Bedürfnissen entsprechend ändern:

instance/*
!instance/.gitignore
.webassets-cache
.env

__pycache__/
*.py[cod]
*$py.class

Öffnen Sie dann die Befehlszeile und führen Sie die folgenden Befehle aus:

$ git init
$ git remote add origin <your_remote_url>
$ git add .
$ git commit -m "init"
$ git push origin master

Dadurch wird ein neues Git-Repository initialisiert, der entfernte Ursprung hinzugefügt, alle Dateien mit VCS versehen und die erste Übergabe erstellt. Zum Schluss wird der Quellcode in das GitHub-Repository übertragen.

Großartig, das sollte alles sein. Wenn Sie jetzt in Ihrem Browser zu Ihrem Repository navigieren, sollten Sie sehen können, dass alle Dateien übertragen wurden.

App bereitstellen

Für die folgenden Schritte benötigen Sie ein Back4app-Konto. Wenn Sie bereits eines haben, loggen Sie sich ein, ansonsten melden Sie sich für das kostenlose Konto an.

Sobald Sie sich angemeldet haben, werden Sie zum Dashboard Ihrer App weitergeleitet. Klicken Sie auf die Schaltfläche “Neue App erstellen”, um den App-Erstellungsprozess zu starten.

Mit Back4app können Sie zwei Arten von Anwendungen erstellen und bereitstellen: Backend as a Service (BaaS) und Container as a Service (CaaS). Da wir eine gedockte App bereitstellen wollen, entscheiden wir uns für “Container as a Service”.

Als nächstes verbinden Sie Ihr GitHub mit Ihrem Back4app-Konto. Vergewissern Sie sich, dass Sie Back4app die Rechte für das Repository geben, das wir im vorherigen Schritt erstellt haben. Klicken Sie dann auf die grüne Schaltfläche “Auswählen”, um es auszuwählen.

Mit Back4app Containers können Sie den Bereitstellungsprozess konfigurieren. Sie können die Standardverzweigung und das Stammverzeichnis festlegen, die automatische Bereitstellung aktivieren/deaktivieren und Umgebungsvariablen festlegen. Wir brauchen nichts davon, also geben wir unserer App einen Namen und klicken auf “App erstellen”.

Back4app benötigt einige Augenblicke, um den Container zu erstellen, ihn in die Container-Registry hochzuladen und den Container zu starten. Sobald Ihr Container bereit ist, ändert sich der Status auf “Ready” und Sie können eine grüne URL auf der linken Seite des Bildschirms sehen.

Wenn Sie auf die URL klicken, wird die Webanwendung in Ihrem Browser geöffnet. Sie werden feststellen, dass Back4app automatisch ein SSL-Zertifikat für Ihre App ausgestellt hat und Ihnen erlaubt, eine Python-App kostenlos zu hosten.

Schlussfolgerung

In diesem Artikel haben Sie etwas über Python, seine Vor- und Nachteile und seine Einsatzmöglichkeiten erfahren. Außerdem haben Sie erfolgreich eine einfache Python RESTful API implementiert. Sie sollten nun in der Lage sein, Ihre einfachen APIs zu erstellen und sie in Back4app Containern bereitzustellen.

Der endgültige Quellcode ist auf GitHub zu finden.

Künftige Schritte

• Im Moment werden alle Daten bei jeder Neuverteilung gelöscht. Das liegt daran, dass die Datenbank im Docker-Image enthalten ist. Erwägen Sie den Wechsel zu einer verwalteten Datenbankinstanz.
• Erwägen Sie mehrstufige Builds, um den Bereitstellungsprozess zu beschleunigen.