Einrichten einer API mit Flask, Googles Cloud SQL und App Engine

Einige Python-Frameworks können zum Erstellen von APIs verwendet werden, zwei davon sind Flask und Django. Frameworks verfügt über Funktionen, die es Entwicklern erleichtern, die Funktionen zu implementieren, die Benutzer für die Interaktion mit ihren Anwendungen benötigen. Die Komplexität einer Webanwendung kann ein entscheidender Faktor bei der Auswahl des Frameworks sein, mit dem Sie arbeiten möchten.

Django

Django ist ein robustes Framework, das eine vordefinierte Struktur mit integrierter Funktionalität hat. Die Kehrseite seiner Robustheit ist jedoch, dass es das Framework für bestimmte Projekte zu komplex machen könnte. Es eignet sich am besten für komplexe Webanwendungen, die die erweiterten Funktionen von Django nutzen müssen.

Flasche

Flask hingegen ist ein leichtgewichtiges Framework zum Erstellen von APIs. Der Einstieg ist einfach, und Pakete sind verfügbar, um es robust zu machen. Dieser Artikel konzentriert sich auf die Definition der Ansichtsfunktionen und des Controllers sowie auf die Verbindung zu einer Datenbank in Google Cloud und die Bereitstellung in Google Cloud.

Zum Zwecke des Lernens erstellen wir eine Flask-API mit einigen Endpunkten, um eine Sammlung unserer Lieblingssongs zu verwalten. Die Endpunkte sind für GET und POST Anforderungen: Abrufen und Erstellen von Ressourcen. Daneben werden wir die Suite von Diensten auf der Google Cloud-Plattform nutzen. Wir richten Cloud SQL von Google für unsere Datenbank ein und starten unsere App, indem wir sie in App Engine bereitstellen. Dieses Tutorial richtet sich an Anfänger, die zum ersten Mal versuchen, Google Cloud für ihre App zu verwenden.

Ein Flask-Projekt einrichten

Dieses Tutorial setzt voraus, dass Sie Python 3.x installiert haben. Wenn Sie dies nicht tun, besuchen Sie die offizielle Website, um es herunterzuladen und zu installieren.

Um zu überprüfen, ob Python installiert ist, starten Sie Ihre Befehlszeilenschnittstelle (CLI) und führen Sie den folgenden Befehl aus:

 python -V

Unser erster Schritt besteht darin, das Verzeichnis zu erstellen, in dem unser Projekt gespeichert wird. Wir nennen es flask-app :

 mkdir flask-app && cd flask-app

Wenn Sie ein Python-Projekt starten, müssen Sie zunächst eine virtuelle Umgebung erstellen. Virtuelle Umgebungen isolieren Ihre funktionierende Python-Entwicklung. Dies bedeutet, dass dieses Projekt seine eigenen Abhängigkeiten haben kann, die sich von anderen Projekten auf Ihren Computern unterscheiden. venv ist ein Modul, das mit Python 3 ausgeliefert wird.

Lassen Sie uns eine virtuelle Umgebung in unserem flask-app Verzeichnis erstellen:

 python3 -m venv env

Dieser Befehl erstellt einen env -Ordner in unserem Verzeichnis. Der Name (in diesem Fall env ) ist ein Alias ​​für die virtuelle Umgebung und kann beliebig benannt werden.

Nachdem wir die virtuelle Umgebung erstellt haben, müssen wir unserem Projekt mitteilen, dass es sie verwenden soll. Um unsere virtuelle Umgebung zu aktivieren, verwenden Sie den folgenden Befehl:

 source env/bin/activate

Sie werden sehen, dass Ihre CLI-Eingabeaufforderung jetzt env am Anfang hat, was darauf hinweist, dass unsere Umgebung aktiv ist.

Lassen Sie uns nun unser Flask-Paket installieren:

 pip install flask

Erstellen Sie ein Verzeichnis namens api in unserem aktuellen Verzeichnis. Wir erstellen dieses Verzeichnis, damit wir einen Ordner haben, in dem sich die anderen Ordner unserer App befinden.

 mkdir api && cd api

Erstellen Sie als Nächstes eine main.py -Datei, die als Einstiegspunkt für unsere App dient:

 touch main.py

Öffnen main.py und geben Sie den folgenden Code ein:

 #main.py from flask import Flask app = Flask(__name__) @app.route('/') def home(): return 'Hello World' if __name__ == '__main__': app.run()

Lassen Sie uns verstehen, was wir hier getan haben. Wir haben zuerst die Flask -Klasse aus dem Flask-Paket importiert. Dann haben wir eine Instanz der Klasse erstellt und sie app zugewiesen. Als Nächstes haben wir unseren ersten Endpunkt erstellt, der auf den Stamm unserer App verweist. Zusammenfassend ist dies eine Ansichtsfunktion, die die / Route aufruft – sie gibt Hello World zurück.

Lassen Sie uns die App ausführen:

 python main.py

Dies startet unseren lokalen Server und stellt unsere App auf https://127.0.0.1:5000/ . Geben Sie die URL in Ihren Browser ein, und Sie sehen die Hello World Antwort auf Ihrem Bildschirm.

Und voila! Unsere App ist in Betrieb. Die nächste Aufgabe besteht darin, es funktionsfähig zu machen.

Um unsere Endpunkte anzurufen, verwenden wir Postman, einen Dienst, der Entwickler beim Testen von Endpunkten unterstützt. Sie können es von der offiziellen Website herunterladen.

Lassen Sie main.py einige Daten zurückgeben:

 #main.py from flask import Flask, jsonify app = Flask(__name__) songs = [ { "title": "Rockstar", "artist": "Dababy", "genre": "rap", }, { "title": "Say So", "artist": "Doja Cat", "genre": "Hiphop", }, { "title": "Panini", "artist": "Lil Nas X", "genre": "Hiphop" } ] @app.route('/songs') def home(): return jsonify(songs) if __name__ == '__main__': app.run()

Hier haben wir eine Liste von Songs eingefügt, einschließlich des Songtitels und des Künstlernamens. Wir haben dann die root / route in /songs geändert. Diese Route gibt das von uns angegebene Array von Songs zurück. Um unsere Liste als JSON-Wert zu erhalten, haben wir die Liste JSONifiziert, indem wir sie durch jsonify . Anstatt ein einfaches Hello world sehen, sehen wir jetzt eine Liste von Künstlern, wenn wir auf den Endpunkt https://127.0.0.1:5000/songs zugreifen.

Sie haben vielleicht bemerkt, dass wir nach jeder Änderung unseren Server neu starten mussten. Um das automatische Neuladen zu aktivieren, wenn sich der Code ändert, aktivieren wir die Debug-Option. Ändern Sie dazu app.run wie folgt:

 app.run(debug=True)

Als Nächstes fügen wir einen Song mit einer Post-Anfrage zu unserem Array hinzu. Importieren Sie zunächst das request , damit wir eingehende Anforderungen unserer Benutzer verarbeiten können. Wir werden später das request in der Ansichtsfunktion verwenden, um die Eingabe des Benutzers in JSON abzurufen.

 #main.py from flask import Flask, jsonify, request app = Flask(__name__) songs = [ { "title": "Rockstar", "artist": "Dababy", "genre": "rap", }, { "title": "Say So", "artist": "Doja Cat", "genre": "Hiphop", }, { "title": "Panini", "artist": "Lil Nas X", "genre": "Hiphop" } ] @app.route('/songs') def home(): return jsonify(songs) @app.route('/songs', methods=['POST']) def add_songs(): song = request.get_json() songs.append(song) return jsonify(songs) if __name__ == '__main__': app.run(debug=True)

Unsere add_songs -Ansichtsfunktion nimmt einen vom Benutzer eingereichten Song und hängt ihn an unsere bestehende Liste von Songs an.

Bisher haben wir unsere Daten aus einer Python-Liste zurückgegeben. Dies ist nur experimentell, denn in einer robusteren Umgebung würden unsere neu hinzugefügten Daten verloren gehen, wenn wir den Server neu starten. Das ist nicht machbar, daher benötigen wir eine Live-Datenbank, um die Daten zu speichern und abzurufen. Jetzt kommt Cloud SQL.

Warum eine Cloud SQL-Instanz verwenden?

Laut offizieller Website:

„Google Cloud SQL ist ein vollständig verwalteter Datenbankdienst, mit dem Sie Ihre relationalen MySQL- und PostgreSQL-Datenbanken in der Cloud ganz einfach einrichten, pflegen, verwalten und verwalten können. Cloud SQL wird auf der Google Cloud Platform gehostet und bietet eine Datenbankinfrastruktur für Anwendungen, die überall ausgeführt werden.“

Das bedeutet, dass wir die Verwaltung der Infrastruktur einer Datenbank zu flexiblen Preisen vollständig an Google auslagern können.

Unterschied zwischen Cloud SQL und einer selbstverwalteten Compute Engine

In Google Cloud können wir eine virtuelle Maschine in der Compute Engine-Infrastruktur von Google hochfahren und unsere SQL-Instanz installieren. Das bedeutet, dass wir für die vertikale Skalierbarkeit, Replikation und eine Vielzahl anderer Konfigurationen verantwortlich sind. Mit Cloud SQL erhalten wir sofort eine Menge Konfigurationsmöglichkeiten, sodass wir mehr Zeit für den Code und weniger Zeit für die Einrichtung aufwenden können.

Bevor wir anfangen:

1. Melden Sie sich für Google Cloud an. Google bietet neuen Nutzern ein kostenloses Guthaben von 300 $.
2. Erstellen Sie ein Projekt. Dies ist ziemlich einfach und kann direkt von der Konsole aus durchgeführt werden.

Erstellen Sie eine Cloud SQL-Instanz

Scrollen Sie nach der Anmeldung bei Google Cloud im linken Bereich zur Registerkarte „SQL“ und klicken Sie darauf.

Zuerst müssen wir eine SQL-Engine auswählen. Für diesen Artikel verwenden wir MySQL.

Als Nächstes erstellen wir eine Instanz. Standardmäßig wird unsere Instanz in den USA erstellt und die Zone wird automatisch für uns ausgewählt.

Legen Sie das Root-Passwort fest, geben Sie der Instanz einen Namen und klicken Sie dann auf die Schaltfläche „Erstellen“. Sie können die Instanz weiter konfigurieren, indem Sie auf das Dropdown-Menü „Konfigurationsoptionen anzeigen“ klicken. Mit den Einstellungen können Sie die Größe, Speicherkapazität, Sicherheit, Verfügbarkeit, Sicherungen und mehr der Instanz konfigurieren. Für diesen Artikel verwenden wir die Standardeinstellungen. Keine Sorge, diese Variablen können später geändert werden.

Es kann einige Minuten dauern, bis der Vorgang abgeschlossen ist. Sie wissen, dass die Instanz bereit ist, wenn Sie ein grünes Häkchen sehen. Klicken Sie auf den Namen Ihrer Instanz, um zur Detailseite zu gelangen.

Jetzt, da wir einsatzbereit sind, werden wir ein paar Dinge tun:

1. Erstellen Sie eine Datenbank.
2. Erstellen Sie einen neuen Benutzer.
3. Whitelist unsere IP-Adresse.

Erstellen Sie eine Datenbank

Navigieren Sie zur Registerkarte „Datenbank“, um eine Datenbank zu erstellen.

Erstellen Sie einen neuen Benutzer

Legen Sie im Abschnitt „Hostname“ fest, dass „% (beliebiger Host)“ zulässig ist.

Whitelist-IP-Adresse

Sie können auf zwei Arten eine Verbindung zu Ihrer Datenbankinstanz herstellen. Eine private IP -Adresse erfordert eine Virtual Private Cloud (VPC). Wenn Sie sich für diese Option entscheiden, erstellt Google Cloud eine von Google verwaltete VPC und platziert Ihre Instanz darin. Für diesen Artikel verwenden wir die öffentliche IP -Adresse, die die Standardeinstellung ist. Es ist öffentlich in dem Sinne, dass nur Personen, deren IP-Adressen auf der weißen Liste stehen, auf die Datenbank zugreifen können.

Um Ihre IP-Adresse auf die Whitelist zu setzen, geben Sie my ip in eine Google-Suche ein, um Ihre IP-Adresse zu erhalten. Gehen Sie dann auf die Registerkarte „Verbindungen“ und „Netzwerk hinzufügen“.

Verbinden Sie sich mit der Instanz

Navigieren Sie als Nächstes zum Bereich „Übersicht“ und verbinden Sie sich über die Cloud Shell.

Der Befehl zum Herstellen einer Verbindung zu unserer Cloud SQL-Instanz wird in der Konsole vorab eingegeben.

Sie können entweder den Root-Benutzer oder den zuvor erstellten Benutzer verwenden. Im folgenden Befehl sagen wir: Stellen Sie als Benutzer USERNAME eine Verbindung mit der Instanz " flask-demo " her. Sie werden aufgefordert, das Passwort des Benutzers einzugeben.

 gcloud sql connect flask-demo --user=USERNAME

Wenn Sie eine Fehlermeldung erhalten, dass Sie keine Projekt-ID haben, können Sie die ID Ihres Projekts abrufen, indem Sie Folgendes ausführen:

 gcloud projects list

Nehmen Sie die Projekt-ID, die vom obigen Befehl ausgegeben wurde, und geben Sie sie in den folgenden Befehl ein, wobei PROJECT_ID damit ersetzen.

 gcloud config set project PROJECT_ID

Führen Sie dann den Befehl gcloud sql connect aus, und wir werden verbunden.

Führen Sie diesen Befehl aus, um die aktiven Datenbanken anzuzeigen:

 > show databases; 

Meine Datenbank heißt db_demo und ich führe den folgenden Befehl aus, um die Datenbank db_demo zu verwenden. Möglicherweise sehen Sie einige andere Datenbanken, z. B. information_schema und performance_schema . Diese dienen dazu, Tabellenmetadaten zu speichern.

 > use db_demo;

Erstellen Sie als Nächstes eine Tabelle, die die Liste aus unserer Flask-App widerspiegelt. Geben Sie den folgenden Code auf einem Notizblock ein und fügen Sie ihn in Ihre Cloud Shell ein:

 create table songs( song_id INT NOT NULL AUTO_INCREMENT, title VARCHAR(255), artist VARCHAR(255), genre VARCHAR(255), PRIMARY KEY(song_id) );

Dieser Code ist ein SQL-Befehl, der eine Tabelle namens songs mit vier Spalten ( song_id , title , artist und genre ) erstellt. Wir haben auch angewiesen, dass die Tabelle song_id als Primärschlüssel definieren und automatisch von 1 erhöhen soll.

Führen Sie jetzt show tables; um zu bestätigen, dass die Tabelle erstellt wurde.

Und schon haben wir eine Datenbank und unsere songs erstellt.

Unsere nächste Aufgabe besteht darin, Google App Engine einzurichten, damit wir unsere App bereitstellen können.

Google App Engine

App Engine ist eine vollständig verwaltete Plattform zum Entwickeln und Hosten von Webanwendungen in großem Maßstab. Ein Vorteil der Bereitstellung in App Engine besteht darin, dass eine Anwendung automatisch skaliert werden kann, um eingehenden Datenverkehr zu bewältigen.

Auf der App Engine-Website heißt es:

„Mit Zero-Server-Management und Zero-Configuration-Bereitstellungen können sich Entwickler nur auf die Entwicklung großartiger Anwendungen ohne den Verwaltungsaufwand konzentrieren.“

Richten Sie App Engine ein

Es gibt mehrere Möglichkeiten, App Engine einzurichten: über die Benutzeroberfläche der Google Cloud Console oder über das Google Cloud SDK. Wir werden das SDK für diesen Abschnitt verwenden. Es ermöglicht uns, unsere Google Cloud-Instanz von unserem lokalen Computer aus bereitzustellen, zu verwalten und zu überwachen.

Installieren Sie das Google Cloud-SDK

Befolgen Sie die Anweisungen zum Herunterladen und Installieren des SDK für Mac oder Windows. Der Leitfaden zeigt Ihnen auch, wie Sie das SDK in Ihrer CLI initialisieren und wie Sie ein Google Cloud-Projekt auswählen.

Nachdem das SDK installiert wurde, aktualisieren wir unser Python-Skript mit den Anmeldedaten unserer Datenbank und stellen es in App Engine bereit.

Lokale Einrichtung

In unserer lokalen Umgebung werden wir das Setup aktualisieren, um es an unsere neue Architektur anzupassen, die Cloud SQL und App Engine umfasst.

Fügen Sie zunächst eine app.yaml -Datei zu unserem Stammordner hinzu. Dies ist eine Konfigurationsdatei, die App Engine benötigt, um unsere App zu hosten und auszuführen. Es informiert App Engine über unsere Laufzeit und andere Variablen, die möglicherweise erforderlich sind. Für unsere App müssen wir die Anmeldedaten unserer Datenbank als Umgebungsvariablen hinzufügen, damit App Engine die Instanz unserer Datenbank kennt.

Fügen Sie in der app.yaml -Datei das folgende Snippet hinzu. Die Laufzeit- und Datenbankvariablen haben Sie beim Einrichten der Datenbank erhalten. Ersetzen Sie die Werte durch den Benutzernamen, das Passwort, den Datenbanknamen und den Verbindungsnamen, die Sie beim Einrichten von Cloud SQL verwendet haben.

 #app.yaml runtime: python37 env_variables: CLOUD_SQL_USERNAME: YOUR-DB-USERNAME CLOUD_SQL_PASSWORD: YOUR-DB-PASSWORD CLOUD_SQL_DATABASE_NAME: YOUR-DB-NAME CLOUD_SQL_CONNECTION_NAME: YOUR-CONN-NAME

Jetzt werden wir PyMySQL installieren. Dies ist ein Python-MySQL-Paket, das eine Verbindung zu einer MySQL-Datenbank herstellt und Abfragen durchführt. Installieren Sie das PyMySQL-Paket, indem Sie diese Zeile in Ihrer CLI ausführen:

 pip install pymysql

An diesem Punkt sind wir bereit, PyMySQL zu verwenden, um von der App aus eine Verbindung zu unserer Cloud SQL-Datenbank herzustellen. Dadurch können wir Abfragen in unsere Datenbank abrufen und einfügen.

Datenbank-Connector initialisieren

Erstellen Sie zunächst eine db.py -Datei in unserem Stammordner und fügen Sie den folgenden Code hinzu:

 #db.py import os import pymysql from flask import jsonify db_user = os.environ.get('CLOUD_SQL_USERNAME') db_password = os.environ.get('CLOUD_SQL_PASSWORD') db_name = os.environ.get('CLOUD_SQL_DATABASE_NAME') db_connection_name = os.environ.get('CLOUD_SQL_CONNECTION_NAME') def open_connection(): unix_socket = '/cloudsql/{}'.format(db_connection_name) try: if os.environ.get('GAE_ENV') == 'standard': conn = pymysql.connect(user=db_user, password=db_password, unix_socket=unix_socket, db=db_name, cursorclass=pymysql.cursors.DictCursor ) except pymysql.MySQLError as e: print(e) return conn def get_songs(): conn = open_connection() with conn.cursor() as cursor: result = cursor.execute('SELECT * FROM songs;') songs = cursor.fetchall() if result > 0: got_songs = jsonify(songs) else: got_songs = 'No Songs in DB' conn.close() return got_songs def add_songs(song): conn = open_connection() with conn.cursor() as cursor: cursor.execute('INSERT INTO songs (title, artist, genre) VALUES(%s, %s, %s)', (song["title"], song["artist"], song["genre"])) conn.commit() conn.close()

Hier haben wir einiges gemacht.

Zuerst haben wir unsere Datenbankanmeldeinformationen aus der Datei app.yaml mit der Methode os.environ.get abgerufen. App Engine kann Umgebungsvariablen, die in app.yaml definiert sind, in der App verfügbar machen.

Zweitens haben wir eine open_connection -Funktion erstellt. Es stellt mit den Anmeldeinformationen eine Verbindung zu unserer MySQL-Datenbank her.

Drittens haben wir zwei Funktionen hinzugefügt: get_songs und add_songs . Die erste initiiert eine Verbindung zur Datenbank, indem sie die Funktion open_connection . Es fragt dann die songs für jede Zeile ab und gibt, falls leer, „Keine Lieder in DB“ zurück. Die Funktion add_songs fügt einen neuen Datensatz in die songs ein.

Schließlich kehren wir zu unserem Ausgangspunkt zurück, unserer main.py -Datei. Anstatt wie zuvor unsere Songs von einem Objekt abzurufen, rufen wir jetzt die Funktion add_songs auf, um einen Datensatz einzufügen, und wir rufen die Funktion get_songs auf, um die Datensätze aus der Datenbank abzurufen.

Lassen Sie uns main.py umgestalten:

 #main.py from flask import Flask, jsonify, request from db import get_songs, add_songs app = Flask(__name__) @app.route('/', methods=['POST', 'GET']) def songs(): if request.method == 'POST': if not request.is_json: return jsonify({"msg": "Missing JSON in request"}), 400 add_songs(request.get_json()) return 'Song Added' return get_songs() if __name__ == '__main__': app.run()

Wir haben die get_songs und add_songs Funktionen importiert und sie in unserer songs() Ansichtsfunktion aufgerufen. Wenn wir eine post -Anfrage stellen, rufen wir die Funktion add_songs , und wenn wir eine get -Anfrage stellen, rufen wir die Funktion get_songs .

Und fertig ist unsere App.

Als Nächstes fügen Sie eine requirements.txt -Datei hinzu. Diese Datei enthält eine Liste der Pakete, die zum Ausführen der App erforderlich sind. App Engine prüft diese Datei und installiert die aufgelisteten Pakete.

 pip freeze | grep "Flask\|PyMySQL" > requirements.txt

Diese Zeile ruft die beiden Pakete ab, die wir für die App verwenden (Flask und PyMySQL), erstellt eine requirements.txt -Datei und hängt die Pakete und ihre Versionen an die Datei an.

An dieser Stelle haben wir drei neue Dateien hinzugefügt: db.py , app.yaml und requirements.txt .

In Google App Engine bereitstellen

Führen Sie den folgenden Befehl aus, um Ihre App bereitzustellen:

 gcloud app deploy

Wenn es gut gelaufen ist, gibt Ihre Konsole Folgendes aus:

Ihre App wird jetzt in App Engine ausgeführt. Um es im Browser anzuzeigen, führen gcloud app browse in Ihrer CLI aus.

Wir können Postman starten, um unseren post zu testen und Anfragen zu get .

Unsere App wird jetzt auf der Infrastruktur von Google gehostet, und wir können die Konfiguration optimieren, um alle Vorteile einer serverlosen Architektur zu nutzen. In Zukunft können Sie auf diesem Artikel aufbauen, um Ihre serverlose Anwendung robuster zu machen.

Fazit

Die Verwendung einer Platform-as-a-Service (PaaS)-Infrastruktur wie App Engine und Cloud SQL abstrahiert im Grunde die Infrastrukturebene und ermöglicht es uns, schneller zu bauen. Als Entwickler müssen wir uns nicht um die Konfiguration, das Sichern und Wiederherstellen, das Betriebssystem, die automatische Skalierung, Firewalls, die Migration des Datenverkehrs usw. kümmern. Wenn Sie jedoch die Kontrolle über die zugrunde liegende Konfiguration benötigen, ist es möglicherweise besser, einen benutzerdefinierten Dienst zu verwenden.

Verweise

• „Python herunterladen“
• „venv – Erstellung virtueller Umgebungen“, Python (Dokumentation)
• „Postbote herunterladen“
• „Cloud SQL“, Google Cloud
• Google-Cloud
• „Kostenloses Kontingent von Google Cloud“, Google Cloud
• „Projekte erstellen und verwalten“, Google Cloud
• „VPC-Übersicht“ (virtuelle private Cloud), Google Cloud
• „App Engine“, Google Cloud
• „Schnellstarts“ (Google Cloud SDK herunterladen), Google Cloud
• PyMySQL-Dokumentation