Configurer une API à l'aide de Flask, Cloud SQL de Google et App Engine

Quelques frameworks Python peuvent être utilisés pour créer des API, dont deux sont Flask et Django. Les frameworks sont livrés avec des fonctionnalités qui permettent aux développeurs d'implémenter facilement les fonctionnalités dont les utilisateurs ont besoin pour interagir avec leurs applications. La complexité d'une application Web peut être un facteur décisif lorsque vous choisissez le framework avec lequel travailler.

Django

Django est un framework robuste qui a une structure prédéfinie avec des fonctionnalités intégrées. L'inconvénient de sa robustesse, cependant, est qu'il pourrait rendre le cadre trop complexe pour certains projets. Il convient mieux aux applications Web complexes qui doivent tirer parti des fonctionnalités avancées de Django.

Ballon

Flask, d'autre part, est un framework léger pour la création d'API. La mise en route est facile et des packages sont disponibles pour le rendre robuste au fur et à mesure. Cet article se concentrera sur la définition des fonctions d'affichage et du contrôleur, ainsi que sur la connexion à une base de données sur Google Cloud et le déploiement sur Google Cloud.

Dans le but d'apprendre, nous allons créer une API Flask avec quelques points de terminaison pour gérer une collection de nos chansons préférées. Les points de terminaison seront pour les requêtes GET et POST : récupération et création de ressources. En parallèle, nous utiliserons la suite de services sur la plateforme Google Cloud. Nous allons configurer Cloud SQL de Google pour notre base de données et lancer notre application en la déployant sur App Engine. Ce didacticiel est destiné aux débutants qui tentent pour la première fois d'utiliser Google Cloud pour leur application.

Mise en place d'un projet Flask

Ce didacticiel suppose que Python 3.x est installé. Si ce n'est pas le cas, rendez-vous sur le site officiel pour le télécharger et l'installer.

Pour vérifier si Python est installé, lancez votre interface de ligne de commande (CLI) et exécutez la commande ci-dessous :

 python -V

Notre première étape consiste à créer le répertoire dans lequel notre projet vivra. Nous l'appellerons flask-app :

 mkdir flask-app && cd flask-app

La première chose à faire lors du démarrage d'un projet Python est de créer un environnement virtuel. Les environnements virtuels isolent votre développement Python de travail. Cela signifie que ce projet peut avoir ses propres dépendances, différentes des autres projets sur vos machines. venv est un module fourni avec Python 3.

Créons un environnement virtuel dans notre répertoire flask-app :

 python3 -m venv env

Cette commande crée un dossier env dans notre répertoire. Le nom (dans ce cas, env ) est un alias pour l'environnement virtuel et peut être nommé n'importe quoi.

Maintenant que nous avons créé l'environnement virtuel, nous devons dire à notre projet de l'utiliser. Pour activer notre environnement virtuel, utilisez la commande suivante :

 source env/bin/activate

Vous verrez que votre invite CLI a maintenant env au début, indiquant que notre environnement est actif.

Maintenant, installons notre package Flask :

 pip install flask

Créez un répertoire nommé api dans notre répertoire courant. Nous créons ce répertoire afin d'avoir un dossier dans lequel les autres dossiers de notre application résideront.

 mkdir api && cd api

Ensuite, créez un fichier main.py , qui servira de point d'entrée à notre application :

 touch main.py

Ouvrez main.py et saisissez le code suivant :

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

Comprenons ce que nous avons fait ici. Nous avons d'abord importé la classe Flask du package Flask. Ensuite, nous avons créé une instance de la classe et l'avons affectée à app . Ensuite, nous avons créé notre premier point de terminaison, qui pointe vers la racine de notre application. En résumé, il s'agit d'une fonction d'affichage qui invoque la / route — elle renvoie Hello World .

Lançons l'application :

 python main.py

Cela démarre notre serveur local et sert notre application sur https://127.0.0.1:5000/ . Entrez l'URL dans votre navigateur et vous verrez la réponse Hello World imprimée sur votre écran.

Et voila ! Notre application est opérationnelle. La tâche suivante consiste à le rendre fonctionnel.

Pour appeler nos points de terminaison, nous utiliserons Postman, qui est un service qui aide les développeurs à tester les points de terminaison. Vous pouvez le télécharger sur le site officiel.

Faisons en sorte que main.py renvoie des données :

 #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()

Ici, nous avons inclus une liste de chansons, y compris le titre de la chanson et le nom de l'artiste. Nous avons ensuite changé la racine / route en /songs . Cette route renvoie le tableau de chansons que nous avons spécifié. Afin d'obtenir notre liste sous forme de valeur JSON, nous avons JSONifié la liste en la passant par jsonify . Maintenant, plutôt que de voir un simple Hello world , nous voyons une liste d'artistes lorsque nous accédons au point de terminaison https://127.0.0.1:5000/songs .

Vous avez peut-être remarqué qu'après chaque modification, nous devions redémarrer notre serveur. Pour activer le rechargement automatique lorsque le code change, activons l'option de débogage. Pour ce faire, remplacez app.run par ceci :

 app.run(debug=True)

Ensuite, ajoutons une chanson à l'aide d'une requête de publication à notre tableau. Tout d'abord, importez l'objet de request , afin que nous puissions traiter les requêtes entrantes de nos utilisateurs. Nous utiliserons plus tard l'objet de request dans la fonction d'affichage pour obtenir l'entrée de l'utilisateur dans JSON.

 #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)

Notre fonction d'affichage add_songs prend une chanson soumise par l'utilisateur et l'ajoute à notre liste existante de chansons.

Jusqu'à présent, nous avons renvoyé nos données à partir d'une liste Python. Ceci est juste expérimental, car dans un environnement plus robuste, nos données nouvellement ajoutées seraient perdues si nous redémarrions le serveur. Ce n'est pas faisable, nous aurons donc besoin d'une base de données en direct pour stocker et récupérer les données. Vient Cloud SQL.

Pourquoi utiliser une instance Cloud SQL ?

Selon le site officiel :

« Google Cloud SQL est un service de base de données entièrement géré qui facilite la configuration, la maintenance, la gestion et l'administration de vos bases de données relationnelles MySQL et PostgreSQL dans le cloud. Hébergé sur Google Cloud Platform, Cloud SQL fournit une infrastructure de base de données pour les applications exécutées n'importe où."

Cela signifie que nous pouvons externaliser entièrement la gestion de l'infrastructure d'une base de données à Google, à des tarifs flexibles.

Différence entre Cloud SQL et un moteur de calcul autogéré

Sur Google Cloud, nous pouvons faire tourner une machine virtuelle sur l'infrastructure Compute Engine de Google et installer notre instance SQL. Cela signifie que nous serons responsables de l'évolutivité verticale, de la réplication et d'une multitude d'autres configurations. Avec Cloud SQL, nous obtenons de nombreuses configurations prêtes à l'emploi, ce qui nous permet de passer plus de temps sur le code et moins de temps sur la configuration.

Avant que nous commencions:

1. Inscrivez-vous à Google Cloud. Google offre 300 $ de crédit gratuit aux nouveaux utilisateurs.
2. Créez un projet. C'est assez simple et peut être fait directement depuis la console.

Créer une instance Cloud SQL

Après vous être inscrit à Google Cloud, dans le panneau de gauche, faites défiler jusqu'à l'onglet "SQL" et cliquez dessus.

Tout d'abord, nous devons choisir un moteur SQL. Nous irons avec MySQL pour cet article.

Ensuite, nous allons créer une instance. Par défaut, notre instance sera créée aux États-Unis et la zone sera automatiquement sélectionnée pour nous.

Définissez le mot de passe root et donnez un nom à l'instance, puis cliquez sur le bouton "Créer". Vous pouvez configurer davantage l'instance en cliquant sur le menu déroulant "Afficher les options de configuration". Les paramètres vous permettent de configurer la taille, la capacité de stockage, la sécurité, la disponibilité, les sauvegardes, etc. de l'instance. Pour cet article, nous allons utiliser les paramètres par défaut. Ne vous inquiétez pas, ces variables peuvent être modifiées ultérieurement.

Cela peut prendre quelques minutes pour que le processus se termine. Vous saurez que l'instance est prête lorsque vous verrez une coche verte. Cliquez sur le nom de votre instance pour accéder à la page de détails.

Maintenant que nous sommes opérationnels, nous allons faire quelques choses :

1. Créer une base de données.
2. Créez un nouvel utilisateur.
3. Ajoutez notre adresse IP à la liste blanche.

Créer une base de données

Accédez à l'onglet "Base de données" pour créer une base de données.

Créer un nouvel utilisateur

Dans la section "Nom d'hôte", définissez-le pour autoriser "% (tout hôte)".

Adresse IP de la liste blanche

Vous pouvez vous connecter à votre instance de base de données de deux manières. Une adresse IP privée nécessite un cloud privé virtuel (VPC). Si vous optez pour cette option, Google Cloud créera un VPC géré par Google et y placera votre instance. Pour cet article, nous utiliserons l'adresse IP publique , qui est la valeur par défaut. Elle est publique dans le sens où seules les personnes dont les adresses IP ont été whitelistées peuvent accéder à la base de données.

Pour ajouter votre adresse IP à la liste blanche, saisissez my ip dans une recherche Google pour obtenir votre adresse IP. Ensuite, allez dans l'onglet "Connexions" et "Ajouter un réseau".

Se connecter à l'instance

Ensuite, accédez au panneau "Aperçu" et connectez-vous à l'aide du cloud shell.

La commande pour se connecter à notre instance Cloud SQL sera pré-saisie dans la console.

Vous pouvez utiliser soit l'utilisateur root, soit l'utilisateur qui a été créé précédemment. Dans la commande ci-dessous, nous disons : Connectez-vous à l'instance flask-demo en tant qu'utilisateur USERNAME . Vous serez invité à entrer le mot de passe de l'utilisateur.

 gcloud sql connect flask-demo --user=USERNAME

Si vous obtenez une erreur indiquant que vous n'avez pas d'ID de projet, vous pouvez obtenir l'ID de votre projet en exécutant ceci :

 gcloud projects list

Prenez l'ID de projet qui a été généré à partir de la commande ci-dessus et entrez-le dans la commande ci-dessous, en remplaçant PROJECT_ID par celui-ci.

 gcloud config set project PROJECT_ID

Ensuite, exécutez la commande gcloud sql connect et nous serons connectés.

Exécutez cette commande pour afficher les bases de données actives :

 > show databases; 

Ma base de données s'appelle db_demo et j'exécuterai la commande ci-dessous pour utiliser la base de données db_demo . Vous pouvez voir d'autres bases de données, telles que information_schema et performance_schema . Ceux-ci sont là pour stocker les métadonnées des tables.

 > use db_demo;

Ensuite, créez un tableau qui reflète la liste de notre application Flask. Tapez le code ci-dessous sur un bloc-notes et collez-le dans votre cloud shell :

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

Ce code est une commande SQL qui crée une table nommée songs , avec quatre colonnes ( song_id , title , artist et genre ). Nous avons également indiqué que la table doit définir song_id comme clé primaire et s'incrémenter automatiquement à partir de 1.

Maintenant, lancez show tables; pour confirmer que la table a été créée.

Et juste comme ça, nous avons créé une base de données et notre table de songs .

Notre prochaine tâche consiste à configurer Google App Engine afin que nous puissions déployer notre application.

Google App Engine

App Engine est une plate-forme entièrement gérée pour le développement et l'hébergement d'applications Web à grande échelle. L'un des avantages du déploiement sur App Engine est qu'il permet à une application de s'adapter automatiquement au trafic entrant.

Le site Web d'App Engine indique :

"Avec zéro gestion de serveur et zéro déploiement de configuration, les développeurs peuvent se concentrer uniquement sur la création d'excellentes applications sans les frais de gestion."

Configurer App Engine

Il existe plusieurs façons de configurer App Engine : via l'interface utilisateur de Google Cloud Console ou via le SDK Google Cloud. Nous utiliserons le SDK pour cette section. Il nous permet de déployer, gérer et surveiller notre instance Google Cloud à partir de notre machine locale.

Installer le SDK Google Cloud

Suivez les instructions pour télécharger et installer le SDK pour Mac ou Windows. Le guide vous montrera également comment initialiser le SDK dans votre CLI et comment choisir un projet Google Cloud.

Maintenant que le SDK est installé, nous allons mettre à jour notre script Python avec les identifiants de notre base de données et le déployer sur App Engine.

Configuration locale

Dans notre environnement local, nous allons mettre à jour la configuration pour l'adapter à notre nouvelle architecture, qui inclut Cloud SQL et App Engine.

Tout d'abord, ajoutez un fichier app.yaml à notre dossier racine. Il s'agit d'un fichier de configuration dont App Engine a besoin pour héberger et exécuter notre application. Il indique à App Engine notre environnement d'exécution et d'autres variables qui pourraient être nécessaires. Pour notre application, nous devrons ajouter les informations d'identification de notre base de données en tant que variables d'environnement, afin qu'App Engine connaisse l'instance de notre base de données.

Dans le fichier app.yaml , ajoutez l'extrait ci-dessous. Vous aurez obtenu les variables d'exécution et de base de données lors de la configuration de la base de données. Remplacez les valeurs par le nom d'utilisateur, le mot de passe, le nom de la base de données et le nom de connexion que vous avez utilisés lors de la configuration de Cloud SQL.

 #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

Maintenant, nous allons installer PyMySQL. Il s'agit d'un package Python MySQL qui se connecte et effectue des requêtes sur une base de données MySQL. Installez le package PyMySQL en exécutant cette ligne dans votre CLI :

 pip install pymysql

À ce stade, nous sommes prêts à utiliser PyMySQL pour nous connecter à notre base de données Cloud SQL à partir de l'application. Cela nous permettra d'obtenir et d'insérer des requêtes dans notre base de données.

Initialiser le connecteur de base de données

Tout d'abord, créez un fichier db.py dans notre dossier racine et ajoutez le code ci-dessous :

 #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()

Nous avons fait quelques choses ici.

Tout d'abord, nous avons récupéré nos informations d'identification de base de données à partir du fichier app.yaml à l'aide de la méthode os.environ.get . App Engine est capable de rendre disponibles dans l'application les variables d'environnement définies dans app.yaml .

Deuxièmement, nous avons créé une fonction open_connection . Il se connecte à notre base de données MySQL avec les informations d'identification.

Troisièmement, nous avons ajouté deux fonctions : get_songs et add_songs . Le premier initie une connexion à la base de données en appelant la fonction open_connection . Il interroge ensuite la table des songs pour chaque ligne et, si elle est vide, renvoie "Aucune chanson dans la base de données". La fonction add_songs insère un nouvel enregistrement dans la table des songs .

Enfin, nous revenons à notre point de départ, notre fichier main.py Maintenant, au lieu d'obtenir nos chansons à partir d'un objet, comme nous l'avons fait précédemment, nous appelons la fonction add_songs pour insérer un enregistrement, et nous appelons la fonction get_songs pour récupérer les enregistrements de la base de données.

Refactorisons main.py :

 #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()

Nous avons importé les fonctions get_songs et add_songs et les avons appelées dans notre fonction d'affichage songs() . Si nous faisons une requête post , nous appelons la fonction add_songs , et si nous faisons une requête get , nous appelons la fonction get_songs .

Et notre application est terminée.

La prochaine étape consiste à ajouter un fichier requirements.txt . Ce fichier contient une liste des packages nécessaires pour exécuter l'application. App Engine vérifie ce fichier et installe les packages répertoriés.

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

Cette ligne récupère les deux packages que nous utilisons pour l'application (Flask et PyMySQL), crée un fichier requirements.txt et ajoute les packages et leurs versions au fichier.

À ce stade, nous avons ajouté trois nouveaux fichiers : db.py , app.yaml et requirements.txt .

Déployer sur Google App Engine

Exécutez la commande suivante pour déployer votre application :

 gcloud app deploy

Si tout s'est bien passé, votre console affichera ceci :

Votre application s'exécute désormais sur App Engine. Pour le voir dans le navigateur, exécutez gcloud app browse dans votre CLI.

Nous pouvons lancer Postman pour tester notre post et get des demandes.

Notre application est maintenant hébergée sur l'infrastructure de Google, et nous pouvons modifier la configuration pour obtenir tous les avantages d'une architecture sans serveur. À l'avenir, vous pouvez vous appuyer sur cet article pour rendre votre application sans serveur plus robuste.

Conclusion

L'utilisation d'une infrastructure de plate-forme en tant que service (PaaS) telle qu'App Engine et Cloud SQL fait abstraction du niveau d'infrastructure et nous permet de construire plus rapidement. En tant que développeurs, nous n'avons pas à nous soucier de la configuration, de la sauvegarde et de la restauration, du système d'exploitation, de la mise à l'échelle automatique, des pare-feu, de la migration du trafic, etc. Toutefois, si vous avez besoin de contrôler la configuration sous-jacente, il peut être préférable d'utiliser un service personnalisé.

Les références

• "Télécharger Python"
• « venv — Création d'environnements virtuels », Python (documentation)
• "Télécharger le facteur"
• "Cloud SQL", Google Cloud
• Google Cloud
• "Niveau gratuit de Google Cloud", Google Cloud
• "Créer et gérer des projets", Google Cloud
• "VPC Overview" (cloud privé virtuel), Google Cloud
• "App Engine", Google Cloud
• « Quickstarts » (télécharger le SDK Google Cloud), Google Cloud
• Documentation PyMySQL