Up(sun) and running mit Flask

FlachmannGitGitOpsCLIKonfiguration

Teilen Sie

Dieser Beitrag ist auch auf Englische.

Diese Anleitung enthält Anweisungen für den Einsatz und die Arbeit mit Flask, einemleichtgewichtigen und beliebten Web-Framework für die Erstellung von Webanwendungen mit Python auf Upsun. Es wird oft als Mikro-Framework bezeichnet, weil es die wesentlichen Komponenten für die Erstellung von Webanwendungen bereitstellt, aber viele Entscheidungen und Erweiterungen dem Entwickler überlässt - lassen Sie uns in diese im Kontext von Upsun eintauchen.

Wenn Sie eher der Typ sind, der einfach nur die Schritte erklärt, können Sie direkt zu der Schritt-für-Schritt-Anleitung am Ende dieser Anleitung springen.

Einrichten der Anwendung und des Repositorys

Für diesen Leitfaden beginnen wir mit der Erstellung eines Flask-Paketprojekts aus Cookiecutter und gehen von dort aus die Schritte durch, die für die Bereitstellung des Projekts auf Upsun erforderlich sind. Wie bei allen Dingen in der Technik gibt es viele Wege, um das gleiche Ziel zu erreichen; der richtige Weg hängt von Ihren spezifischen Bedürfnissen und Zielen sowie der Beschaffenheit Ihres Projekts ab. Die folgende Anleitung ist nur ein Weg, um eine Flask-Anwendung auf Upsun zu implementieren, aber ein Weg, der von unserem Team erprobt und getestet wurde.

Installieren Sie zunächst Cookiecutter von einem Terminal/Befehlszeile aus:

> pip3 install cookiecutter

Als Nächstes müssen Sie die Flask-Vorlage aus Cookiecutter generieren - wenn Sie zum ersten Mal eine Flask-Vorlage generieren, müssen Sie auf die vollständige Adresse des GitHub-Repository verweisen:

> cookiecutter https://github.com/cookiecutter-flask/cookiecutter-flask.git

Andernfalls können Sie einfach die spezifische Vorlage angeben, die Sie erstellen möchten:

> cookiecutter cookiecutter-flask

Cookiecutter wird Ihnen als nächstes eine Reihe von 10 Fragen stellen, wie Sie unten sehen können:

[1/10] full_name (): Paul Gilzow [2/10] email (): paul.gilzow@upsun.com [3/10] github_username (): gilzow [4/10] project_name (): my_flask_project [5/10] app_name (): my_flask_cookie [6/10] project_short_description (): Ein Demonstrationsprojekt [7/10] use_pipenv (): n [8/10] python_version (): 3.11 [9/10] node_version (): 18 [10/10] use_heroku (): N

Beantworten Sie jede Frage und achten Sie darauf, was Sie für die Frage app_name verwenden, da Sie es später brauchen werden. Sobald Cookiecutter die Vorlage erstellt hat, wechseln Sie in das Verzeichnis, das er gerade erstellt hat; es wird denselben Namen haben, den Sie für die Frage app_name angegeben haben. Für dieses Beispiel habe ich es my_flask_cookie genannt und werde im weiteren Verlauf der Anleitung darauf verweisen.
Sie müssen den Inhalt dieses Verzeichnisses als Git-Repository einrichten. Bevor Sie also etwas anderes tun, müssen Sie das Repository initialisieren:

> git init .

Standardmäßig verwendet Git immer noch master als Namen für den ersten Zweig. Wenn Sie den Standardnamen der Verzweigung ändern möchten, können Sie dies mit dem Befehl git branch -m tun. Ich werde meinen in main umbenennen:

> git branch -m main

Flask für den Einsatz von Upsun vorbereiten

Nun, da das Repository initialisiert und unsere Vorlage erstellt wurde, können wir sie für die Verwendung auf Upsun vorbereiten. Bevor Sie den nächsten Befehl ausführen, vergewissern Sie sich, dass das Upsun-CLI-Tool installiert ist und funktioniert, und dass Sie das CLI-Tool mit Ihrem Upsun-Kontoauthentifiziert haben . Sobald diese Aufgaben abgeschlossen sind, können Sie das Upsun CLI-Tool die Konfigurationsdateien generieren lassen, die wir für die Bereitstellung auf Upsun benötigen.

> upsun projekt:init

Bitte beachten Sie: dieser Befehl ist auch als upsun ify verfügbar

Das Upsun CLI-Tool wird Ihnen nun eine Reihe von Fragen stellen, um die Anforderungen an Ihr Projekt zu ermitteln, wie Sie unten sehen können:

> upsun project:init Willkommen bei Upsun! Lassen Sie uns mit ein paar Fragen beginnen. Wir müssen etwas mehr über Ihr Projekt wissen. Dies wird nur eine Minute dauern! Welche Sprache verwendet Ihr Projekt? Wir unterstützen die folgenden Sprachen: Verwenden Sie die Pfeile, um nach oben und unten zu gehen, tippen Sie, um zu filtern C#/.Net Core Elixir Go Java Lisp JavaScript/Node.js PHP > Python Ruby

Scrollen Sie nach unten und wählen Sie Python, dann sollte Ihr Abhängigkeitsmanager automatisch erkannt werden:

Welche Sprache wird in Ihrem Projekt verwendet? Wir unterstützen die folgenden Sprachen: [Python] ✓ Erkannte Abhängigkeitsmanager: Pip

Dann wird nach dem Namen Ihrer Anwendung gefragt und Sie werden nach den Dienstengefragt, die Ihr Projekt benötigt. Wählen Sie jeden einzelnen aus und drücken Sie dann die Eingabetaste. Für dieses Beispiel benötige ich nur PostgreSQL:

                                              (\_/) Wir sind fast fertig... =(^.^)= Zu guter Letzt, sofern Sie keine statische Website erstellen, verwendet Ihr Projekt Dienste. Definieren wir sie: Wählen Sie alle Dienste aus, die Sie verwenden: Verwenden Sie die Pfeile zum Verschieben, die Leertaste zum Auswählen und die Eingabetaste zum Filtern [ ] MariaDB [ ] MySQL > [x] PostgreSQL [ ] Redis [ ] Redis Persistent [ ] Memcached [ ] OpenSearch

Es wird dann eine Reihe von Konfigurationsdateien für Sie generiert:

┌───────────────────────────────────────────────────┐ │ HERZLICHEN GLÜCKWUNSCH!                                                                                                                      │ │ │ │ Wir haben die folgenden Dateien für Sie erstellt:                                                                         │ │ - .environment │ │ - .upsun/config.yaml │ │ │ │ Wir freuen uns riesig! ⍢ │ └───────────────────────────────────────────────────┘ │ / │/ │ (\ /) ( . .) o (_(")(") Jetzt können Sie Ihre Anwendung auf Upsun bereitstellen! Übertragen Sie dazu Ihre Dateien und stellen Sie Ihre Anwendung mit der Upsun-CLI bereit: $ git add . $ git commit -m 'Add Upsun configuration files' $ upsun project:set-remote $ upsun push

Zum Schluss müssen Sie alle von Cookiecutter und Upsun CLI generierten Dateien zu Ihrem Git-Repository hinzufügen:

> git add . > git commit -m "initial commit"

Bevor Sie Ihre Anwendung einsetzen können, müssen Sie ein neues Projekt auf Upsun von der Kommandozeile aus erstellen:

> upsun project:create

Das CLI-Tool führt Sie nun durch die Erstellung eines Projekts und fragt Sie nach Ihrer Organisation, dem Titel des Projekts, der Region, in der die Anwendung untergebracht werden soll, und dem Namen der Verzweigung (verwenden Sie denselben, den Sie zuvor festgelegt haben). Erlauben Sie dem CLI-Tool zunächst, Upsun als Remote-Repository festzulegen, und wählen Sie dann Y, damit das Tool das Projekt erstellen kann. Der Upsun-Bot beginnt mit der Erstellung Ihres Upsun-Projekts und meldet nach Abschluss die Details Ihres Projekts zurück, einschließlich der Projekt-ID und der URL, unter der Sie das Projekt über die Upsun-Webkonsoleverwalten können . Keine Sorge, wenn Sie diese Informationen vergessen haben, können Sie sie später mit abrufen:

> upsun projekt:info

Und Sie können die Webkonsole für Ihr Projekt jederzeit wie folgt aufrufen:

> upsun web

Nachdem wir nun unser Upsun-Projekt erstellt und unser lokales Projekt generiert und mit dem Upsun-Projekt verknüpft haben, müssen wir nur noch die anwendungsspezifischen Konfigurationen hinzufügen. Zu Beginn müssen wir eine Umgebungsvariable für FLASK_APP für alle Umgebungen hinzufügen, die auf unsere Datei autoapp.py verweist. Öffnen Sie die Datei config.yaml im Verzeichnis .upsun, das das CLI-Tool erstellt hat, und suchen Sie die kommentierte Zeile, die mit # Variables to control the environment... beginnt. Wir müssen die nächsten beiden Zeilen unterhalb dieser Zeile auskommentieren und unsere Umgebungsvariable in die Liste aufnehmen:

# Variablen zur Steuerung der Umgebung. Weitere Informationen: https://docs.upsun.com/create-apps/app-reference.html#variables variables: env: FLASK_APP: autoapp.py # # Fügen Sie hier Umgebungsvariablen hinzu, die statisch sind. # PYTHONUNBUFFERED: "1"

Bitte beachten Sie: Wenn Sie einen Abschnitt auskommentieren, stellen Sie sicher, dass Sie sowohl die Kommentar-Markierung # als auch das zusätzliche Leerzeichen entfernen. Wenn Sie das zusätzliche Leerzeichen nicht entfernen, erhalten Sie bei der Validierung der Konfigurationsdatei den Fehler " Ungültige Blockzuordnung - Schlüsseleinrückung ".

Statische Elemente

Als Nächstes benötigen Sie einen beschreibbaren Speicherplatz für die statischen Assets, die npm erstellt und flask-static-digest generiert. Dieses Verzeichnis existiert unter unserem Anwendungspaket namens ./<Anwendungsname>/static. In ./.upsun/config.yml finden Sie die Zeile, die mit # Mounts define directories that are writable beginnt. Sie müssen die Zeile # mounts: auskommentieren und dann einen Eintrag hinzufügen, der beschreibt, wo wir ein beschreibbares Mount hinzufügen wollen:

# Mounts definieren Verzeichnisse, die nach der Erstellung beschreibbar sind. # Weitere Informationen: https://docs.upsun.com/create-apps/app-reference.html#mounts mounts: "my_flask_cookie/static": source: "storage" 
   source_path: "static_assets"

source gibt den Typ der Einhängung an: storage, tmp oder service und source_path gibt an, wohin die Einhängung innerhalb des externen Verzeichnisseszeigt . Weitere Informationen finden Sie in der Dokumentation zu mounts.

Der Build-Hook ermöglicht es uns, Änderungen an der Anwendung vorzunehmen, bevor sie fertiggestellt und bereitgestellt wird. Sie werden feststellen, dass das CLI-Tool bei der Erstellung der Konfigurationsdatei automatisch pip install -r requirements.txt hinzugefügt hat! In diesem Abschnitt werden Sie Upsun auch anweisen, Ihre npm-Pakete zu installieren. Aber vorher möchte ich pip upgraden, bevor ich pip install ausführe, also füge ich eine neue Zeile darüber ein und füge pip install --upgrade pip ein. Dann füge ich eine weitere Zeile nach der ersten pip install ein und füge npm install hinzu:

# Hooks erlauben es Ihnen, Ihren Code/Ihre Umgebung anzupassen, während das Projekt die Build- und Deploy-Phasen durchläuft # Weitere Informationen: https://docs.upsun.com/create-apps/app-reference.html#hooks hooks: # Der Build-Hook wird nach jedem Build-Flavor ausgeführt. # Weitere Informationen: https://docs.upsun.com/create-apps/hooks/hooks-comparison.html#build-hook build: | set -eux pip install --upgrade pip pip install -r requirements.txt npm install

Sie müssen Upsun auch mitteilen, was geschehen soll, wenn Ihre Anwendung bereitgestellt wird. Der Deploy-Hook ähnelt dem Build-Hook, wird aber ausgeführt, nachdem das Anwendungsimage erstellt wurde. Zu diesem Zeitpunkt ist das Anwendungsimage schreibgeschützt, aber Ihr beschreibbarer Speicherplatz wurde gemountet und ist nun zugänglich. Suchen Sie den deploy: YAML-Schlüssel, fügen Sie eine neue Zeile nach set -eux ein und fügen Sie npm run build hinzu.

# Der Deploy-Hook wird ausgeführt, nachdem der App-Container gestartet wurde, aber bevor er beginnt, Anfragen zu akzeptieren. deploy: | set -eux npm run build

Als nächstes müssen wir konfigurieren, wie Upsun Anfragen an dieses Anwendungsimage behandeln wird. Suchen Sie in ./.upsun/config.yaml die Zeile, die mit # beginnt. Der Web-Key konfiguriert den Webserver, der vor Ihrer Anwendung läuft. Unter dieser Zeile sollte sich eine YAML-Eigenschaft commands: befinden, und ein paar Zeilen darunter eine YAML-Eigenschaft start:. Auch hier hat das CLI-Tool bereits einige Informationen hinzugefügt, aber da es nicht weiß, was genau verwendet werden muss, hat es einfach Anweisungen hinterlassen, die Sie durch Ihren eigenen Startbefehl ersetzen müssen. Im Moment brauchen Sie nur den grundlegenden Flask-Server, also ersetzen Sie den aktuellen Inhalt mit flask run -p $PORT.

web: # Befehle werden einmal nach dem Deployment ausgeführt, um den Anwendungsprozess zu starten. # Weitere Informationen: https://docs.upsun.com/create-apps/app-reference.html#web-commands commands: # Der Befehl zum Starten Ihrer Anwendung. Sie können die Umgebungsvariable $PORT oder $SOCKET verwenden, abhängig von der Socket-Familie Ihres Upstream-Starts: "flask run -p $PORT"

Da Sie (vorerst) den Flask-Server verwenden, müssen Sie auch die socket_family von unix auf tcp ändern:

start: "flask run -p $PORT" # Sie können auf einen UNIX-Socket (unix) oder einen TCP-Port (tcp, Standard) hören. # Ob Ihre Anwendung mit dem Webserver über TCP oder Unix-Socket sprechen soll. Standardwert ist tcp. # Weitere Informationen: https://docs.upsun.com/create-apps/app-reference.html#where-to-listen upstream: # Ob Ihre Anwendung den Webserver über TCP oder Unix-Socket ansprechen soll. Standardwert ist tcp # Weitere Informationen: https://docs.upsun.com/create-apps/app-reference.html#where-to-listen socket_family: tcp

Wir haben nun alle Konfigurationen hinzugefügt, die Upsun benötigt, um Ihre Anwendung zu erstellen und einzusetzen! Lassen Sie uns fortfahren und diese Änderungen übertragen:

> git add ./upsun/config.yaml > git commit -m "adds FLASK_APP env var, adds mount for static builds, build commands, npm run build on deploy, web start command"

Vorbereiten der Anwendung für Upsun

Während wir Upsun nun mitgeteilt haben, was es tun muss, um Ihre Anwendung zu bauen und bereitzustellen, muss Ihre Anwendung noch einige Dinge über Upsun wissen. Diese Art von Informationen werden normalerweise in Ihrer .env Datei gespeichert. Upsun generiert alle diese Daten und stellt sie der Anwendung als Umgebungsvariablen in dem bereitgestellten Image zur Verfügung. Da die Informationen dynamisch sind und sich von Umgebung zu Umgebung ändern, sollten Sie diese statischen Werte nicht in einer .env-Datei festhalten. Stattdessen unterstützt Upsun eine .env-Datei, die sowohl im Anwendungsimage als auch in Ihrer Shell enthalten ist, wenn Sie sich per SSH in den Container einwählen. Eine Liste aller Variablen, die Upsun generiert, finden Sie in der Dokumentation zu den bereitgestellten Umgebungsvariablen.

Öffnen Sie die Umgebungsdatei, die das CLI-Tool zuvor erzeugt hat. Beachten Sie, dass es bereits einige Umgebungsvariablen für die Verbindung zu Ihrem Datenbankdienst erstellt hat. Da Sie jedoch später einen Tunnel verwenden müssen, um Ihre Migrationsdateien zu erzeugen, müssen Sie die vom Upsun CLI-Tool erzeugte Datei durch die folgende ersetzen:

export RELATIONSHIPS_JSON="$(echo $PLATFORM_RELATIONSHIPS | base64 --decode)" # Datenbank-Umgebungsvariablen setzen export DB_HOST="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].host')" export DB_PORT="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].port')" export DB_DATABASE="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].Pfad')" export DB_USERNAME="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].username')" export DB_PASSWORD="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].password')" export DB_CONNECTION="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].scheme')" export DATABASE_URL="postgresql://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}"

Für unsere Flask-Anwendung müssen Sie noch ein paar weitere Einträge vornehmen, damit Flask über die notwendigen Informationen verfügt, um ordnungsgemäß zu funktionieren. Zu Beginn müssen Sie die restlichen Variablen hinzufügen, die in .envdefiniert sind . Um FLASK_APP haben Sie sich bereits in der Datei ./.upsun/config.yaml gekümmert, so dass nur noch die folgenden übrig bleiben:

FLASK_ENV
FLASK_DEBUG
LOG_LEVEL
SEND_FILE_MAX_AGE_DEFAULT
SECRET_KEY
GUNICORN_WORKERS

Upsun stellt uns Informationen über die Art der Umgebung, in der die Anwendung läuft, über eine Umgebungsvariable namens PLATFORM_ENVIRONMENT_TYPE zur Verfügung, deren Werte Produktion, Entwicklung oder Staging sein können. Fügen Sie innerhalb der .environment-Datei die folgende Zeile ein:

export FLASK_ENV="${PLATFORM_ENVIRONMENT_TYPE}"

Einige der anderen Umgebungsvariablen müssen sich jedoch auch ändern, unabhängig davon, ob Sie sich in einer Produktionsumgebung befinden oder nicht. Daher können Sie die Informationen in PLATFORM_ENVIRONMENT_TYPE nutzen, um nicht nur FLASK_ENV, sondern auch einige der anderen Variablen zu setzen. Sie wollen FLASK_DEBUG nur dann aktivieren (1), wenn Sie nicht in der Produktionsumgebung arbeiten. Fügen Sie in der .environment-Datei die folgende Zeile ein:

export FLASK_DEBUG=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 0 || echo 1)

Wenn die Umgebung, in der Sie sich befinden, "production" ist, geben Sie 0 (deaktiviert) zurück, andernfalls 1 (aktiviert). Lassen Sie uns etwas Ähnliches für LOG_LEVEL machen. Fügen Sie in der .environment-Datei die folgende Zeile ein:

export LOG_LEVEL=$( [ [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo "info" || echo "debug")

Wenn die Umgebung, in der Sie sich befinden, "production" ist, setzen Sie LOG_LEVEL auf "info", andernfalls setzen Sie es auf "debug".

Die letzte Umgebungsvariable, die je nach Umgebungstyp unterschiedlich sein muss, ist SEND_FILE_MAX_AGE_DEFAULT. Sie soll 0 sein, wenn wir uns nicht in der Produktionsumgebung befinden, aber einen höheren Wert haben, wenn wir uns in der Produktionsumgebung befinden. Fügen Sie in der .environment-Datei die folgende Zeile ein:

export SEND_FILE_MAX_AGE_DEFAULT=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0)

Die nächste Umgebungsvariable, die Sie setzen müssen, ist SECRET_KEY. Sie wird zum sicheren Signieren des Sitzungscookies verwendet und kann für alle anderen sicherheitsrelevanten Anforderungen von Erweiterungen oder Ihrer Anwendung genutzt werden. Es sollte eine lange zufällige Zeichenkette sein. Auch hierfür stellt Upsun uns eine Umgebungsvariable zur Verfügung: PLATFORM_PROJECT_ENTROPY. Fügen Sie in der .environment-Datei die folgende Zeile ein:

export SECRET_KEY="${PLATFORM_PROJECT_ENTROPY}"

Da wir im Moment Flask als Webserver verwenden, können Sie das Hinzufügen von GUNICORN_WORKERS zu Ihrer .environment -Datei überspringen. Wir werden den Wechsel zu Gunicorn in einem späteren Blogbeitragbehandeln .

Ihre .environment-Datei sollte nun ähnlich wie die folgende aussehen:

# Datenbank-Umgebungsvariablen setzen export DB_HOST="$POSTGRESQL_HOST" export DB_PORT="$POSTGRESQL_PORT" export DB_PATH="$POSTGRESQL_PATH" export DB_USERNAME="$POSTGRESQL_USERNAME" export DB_PASSWORD="$POSTGRESQL_PASSWORD" export DB_SCHEME="postgresql" export DATABASE_URL="${DB_SCHEME}://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_PATH}" export FLASK_ENV="${PLATFORM_ENVIRONMENT_TYPE}" export FLASK_DEBUG=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 0 || echo 1) export LOG_LEVEL=$( [ [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo "info" || echo "debug") export SEND_FILE_MAX_AGE_DEFAULT=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0) export SECRET_KEY="${PLATFORM_PROJECT_ENTROPY}"

Da Sie Änderungen an Ihrer .environment-Datei vorgenommen haben, müssen Sie diese Änderungen festschreiben, bevor Sie das Repository an Upsun weitergeben:

> git add .environment > git commit -m "fügt benötigte Flask-Umgebungsvariablen hinzu"

Nun können Sie die Änderungen an Upsun übertragen und Ihre ursprüngliche Umgebung aktivieren:

> upsun environment:push

Beantworten Sie die Frage mit Y: Sind Sie sicher, dass Sie auf den Hauptzweig (Typ: Produktion) pushen wollen?

Upsun wird nun Ihre Konfigurationsdateien lesen und mit der Erstellung Ihres Anwendungsimages beginnen. Vorausgesetzt, Sie haben keine Syntaxfehler in Ihren Konfigurationsdateien, sollte Upsun Ihr Image erstellen und bereitstellen und am Ende des Prozesses die mit unserem Projekt verbundenen URLs zurückmelden.

Einrichten der Datenbank

Sie haben vielleicht bemerkt, dass wir nichts in Bezug auf eine Datenbank getan haben. Diese Anwendung verwendet Flask-migrate, und da es sich um eine brandneue Anwendung handelt, müssen Sie die anfänglichen Migrationen einrichten und festschreiben, damit sie dann auf unsere Upsun-Datenbank angewendet werden können. Da der Migrationsbefehl jedoch Zugriff auf die Datenbank benötigt, müssen Sie eine temporäre lokale Umgebung einrichten und ihr eine Möglichkeit geben, auf den Datenbankdienst zuzugreifen. Richten wir zunächst eine virtuelle Umgebung ein, in der Sie Ihr Projekt ausführen können:

> python3 -m venv env && source venv/bin/activate

Aktualisieren Sie pip genau wie in Ihrem Build-Hook und installieren Sie Ihre Anforderungen:

> pip install --upgrade pip > pip install -r requirements.txt

Als nächstes werden Sie diese lokale Instanz so einrichten, dass sie mit Ihrem Datenbankdienst kommunizieren kann. Als Sie Upsun zuvor gepusht haben, wurde Ihr Datenbankdienst erstellt und bereitgestellt. Das Upsun CLI-Tool bietet Ihnen eine Methode zur Kommunikation mit den Diensten Ihrer Anwendung: upsun tunnel

> upsun tunnel:open -y

Damit wird ein SSH-Tunnel zu allen Diensten der Anwendung geöffnet, über den Ihre lokale Instanz mit ihnen kommunizieren kann, als ob sie ebenfalls lokal wären. Dazu müssen Sie allerdings einige Umgebungsvariablen konfigurieren, ähnlich wie Sie es zuvor getan haben. Wenn Sie die Umgebungsdatei erneut öffnen, werden Sie feststellen, dass wir eine Umgebungsvariable namens $PLATFORM_RELATIONSHIPS verwenden, um Informationen über Dienste und ihre Anmeldeinformationen abzurufen. Der von Ihnen erstellte Tunnel gibt Ihnen Zugriff auf dieselben Daten und ermöglicht es Ihnen, eine lokale Umgebungsvariable PLATFORM_RELATIONSHIPS zu erzeugen, die dieselben Informationen enthält.

> export PLATFORM_RELATIONSHIPS="$(upsun tunnel:info --encode)"

Wenn Sie nun echo $PLATFORM_RELATIONSHIPS ausprobieren, werden Sie sehen, dass es auf einen ziemlich großen base64-kodierten Wert gesetzt wurde. Diese Zeichenfolge enthält Ihre Dienste, ihre Definitionen, Standorte und vor allem ihre Anmeldeinformationen. Da Sie diese Umgebungsvariable lokal gesetzt haben, können Sie Ihre Umgebungsdatei für Upsun wiederverwenden, um viele der anderen Umgebungsvariablen, die Sie für die lokale Ausführung benötigen, neu zu erstellen.

Allerdings gibt es einige Variablen, die nicht über PLATFORM_RELATIONSHIPS gesetzt sind und die Sie trotzdem einrichten müssen.

> export PLATFORM_ENVIRONMENT_TYPE=production > export PORT=8888 > export PLATFORM_PROJECT_ENTROPY=$(openssl rand -base64 32)

Abschließend erstellen Sie Ihre .environment-Datei, um alle Umgebungsvariablen in Ihrer aktuellen Shell einzurichten:

> source ./.environment

Jetzt haben Sie alles, was Sie für Flask-Migrate brauchen, um sich mit der Datenbank zu verbinden und Ihre Migrationsdateien zu erzeugen. Zunächst muss Flask-Migrate das Migrationsverzeichnis initiieren und den Migrationsbefehl vorbereiten:

> flask db init

Nun können Sie Flask-Migrate Ihre Migrationen erzeugen lassen:

> flask db migrate

Und dann übertragen Sie die erzeugten Migrationen:

> git add migrations/* > git commit -m "fügt Migrationen hinzu"

Sie müssen nun Upsun anweisen, den Flask-Migrate-Upgrade-Befehl beim Deployment auszuführen, damit Sie wissen, dass alle Migrationsänderungen automatisch übernommen werden. Öffnen Sie erneut die ./.upsun/config.yaml und suchen Sie den Deploy-Hook, wo Sie npm run build hinzugefügt haben. Fügen Sie in der nächsten Zeile flask db upgrade hinzu:

# Der Deploy-Hook wird ausgeführt, nachdem der App-Container gestartet wurde, aber bevor er beginnt, Anfragen zu akzeptieren. # Weitere Informationen: https://docs.upsun.com/create-apps/hooks/hooks-comparison.html#deploy-hook deploy: | set -eux npm run build flask db upgrade

Übertragen Sie die Änderungen:

> git add ./.upsun/config.yaml > git commit -m "adds flask db upgrade to deploy hook"

Und zum Schluss pushen Sie alles in Ihre Upsun-Umgebung!

> upsun Umgebung:push -y

Glückwunsch, du hast deine Flask-Anwendung nun erfolgreich in Upsun installiert, nimm dir einen Moment Zeit, um deine Website zu besuchen und sie zu testen.

In zukünftigen Beiträgen werden wir die verschiedenen Optionen für Webserver, eine robustere lokale Entwicklungsumgebung, die Integration der Versionskontrolle und das Hinzufügen verschiedener Dienste zu Ihrem Projekt untersuchen. Aber bis dahin, gehen Sie los und setzen Sie es ein (auch freitags)!

Die vollständigen .upsun/config.yaml und .environment Dateien sind auf GitHub verfügbar.

Eine schnelle Schritt-für-Schritt-Anleitung

Für diejenigen unter Ihnen, die es vorziehen, so schnell wie möglich loszulegen, gibt es hier eine schnelle und einfache Schritt-für-Schritt-Anleitung:

T:` - führen Sie die Zeile in einem Terminal/Befehlszeile aus

T: pip3 install cookiecutter
T: cookiecutter https://github.com/cookiecutter-flask/cookiecutter-flask.git
Beantworten Sie Fragen:
1. Name
2. E-Mail
3. Github_Benutzername
4. Projektname
5. Name der Anwendung
6. Beschreibung
7. Pipenv
8. Python-Version
9. Node-Version
10. heroku
Cd in das Verzeichnis (sollte das sein, was Sie für 3e beantwortet haben)
T: git init .
T: git branch -m main
T: upsun projekt:init
1. Wählen Sie Python
2. Postgres auswählen
T: git add .
T: git commit -m "init commit"
T: upsun p:create
Fragen beantworten
1. Wähle deine Organisation
2. Gib ihr einen Titel
3. Wähle eine Region
4. Geben Sie den Zweignamen aus #7 ein
5. Legen Sie das Projekt (vorerst) als Remote-Projekt fest.
6. Wählen Sie Y für "weiter"
Öffnen Sie ./.upsun/config.yaml
1. Finden Sie den Abschnitt, der "Variablen" beschreibt
2. Entferne das Kommentarzeichen "# variables" und die nächste Zeile "env:".
3. Fügen Sie in der nächsten Zeile FLASK_APP hinzu: autoapp.py
4. Suchen Sie den Abschnitt, der "mounts" beschreibt
5. Entferne den Kommentar "# mounts:".
6. Fügen Sie in der nächsten Zeile hinzu
  "<Name-ihrer-Anwendung-von-3e-oben>/static":
  Quelle: storage
  quell_pfad: static_build
7. Suchen Sie den Abschnitt für hooks:build
8. In der Zeile vor pip install fügen Sie Folgendes hinzu:
  pip install --upgrade pip
9. Fügen Sie in der Zeile unter pip install Folgendes hinzu
  npm installieren
10. Scrollen Sie nach unten zum Abschnitt deploy
11. Fügen Sie in der Zeile nach set -eux Folgendes hinzu
  npm run build
12. Suchen Sie den Abschnitt web:commands:start und ändern Sie ihn in
  start: flask run -p $PORT
13. Darunter finden Sie den Abschnitt für upstream:socket_family und kommentieren entweder beide Zeilen aus oder ändern "unix" in "tcp"
T: git add ./.upsun/config.yaml
T: git commit -m "fügt FLASK_APP Umgebungsvariable hinzu, fügt Mount für statische Builds, Build-Befehle, npm run build on deploy, web start command"
Öffnen Sie die Datei .environment
1. Alles entfernen und durch ersetzen:
  # Datenbank-Umgebungsvariablen setzen
  export RELATIONSHIPS_JSON="$(echo $PLATFORM_RELATIONSHIPS | base64 --decode)"
  # Datenbank-Umgebungsvariablen setzen
  export DB_HOST="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].host')"
  export DB_PORT="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].port')"
  export DB_DATABASE="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].path')"
  export DB_USERNAME="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].username')"
  export DB_PASSWORD="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].password')"
  export DB_CONNECTION="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].scheme')"
  export DATABASE_URL="postgresql://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}"
2. Fügen Sie die folgenden Zeilen zu .environment hinzu:
  export SECRET_KEY="${upsun_PROJECT_ENTROPY}"
  export FLASK_DEBUG=$( [ "${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo 0 || echo 1)
  export FLASK_ENV="${upsun_ENVIRONMENT_TYPE}"
  export GUNICORN_WORKERS=1
  export LOG_LEVEL=$( [ "${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo "info" || echo "debug")
  # In der Produktion auf eine höhere Zahl setzen, wie 31556926
  export SEND_FILE_MAX_AGE_DEFAULT=$( [ "${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0)
T: git add .environment
T: git commit -m "fügt benötigte Flask-Umgebungsvariablen hinzu"
T: upsun e:push
1. Antwort Y
Am Ende des Deployments erhalten Sie die URL Ihres Projekts
T: python3 -m venv env
T: Quelle venv/bin/activate
T: pip install --upgrade pip
T: pip install -r anforderungen.txt
T: upsun tunnel:open -y
T: export upsun_RELATIONSHIPS="$(upsun tunnel:info --encode)"
T: export PORT=8888
T: export upsun_PROJECT_ENTROPY=$(openssl rand -base64 32)
T: export upsun_ENVIRONMENT_TYPE=production
T: Quelle ./.environment
T: flask db init
T: flask db migrate
Öffnen Sie ./.upsun/config.yaml
1. Suchen Sie den Abschnitt für hooks:deploy
2. Füge in einer neuen Zeile nach `npm run build` `flask db upgrade` hinzu
T: git add migrations/*
T: git commit -m "fügt Migrationen hinzu"
T: git add ./.upsun/config.yaml
T: git commit -m "fügt flask db upgrade zum deploy hook hinzu"
T: upsun Umgebung:push