![] Grand aperçu](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/4f54cdfd-7bfd-44e5-92b4-d19a9313414e/postman-response-2-api-flask-google-cloud-sql-app-engine.png){kind=link}
L’Outil Surpuissant pour Exploser ton Chiffre d'Affaires en 2025 !
Configurer une API à l'aide de Flask, de Google Cloud SQL et d'App Engine
Quelques frameworks Python peuvent être utilisés pour créer des API, dont deux sont Flask et Django. Frameworks est livré 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 est cependant qu'elle 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.
Flask
Flask en revanche, 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 de vue 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 un but d'apprentissage, 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 endpoints seront pour les requêtes GET et POST : extraction et création de ressources. Parallèlement, nous utiliserons la suite de services sur la plate-forme Google Cloud . Nous allons configurer le Cloud SQL de Google pour notre base de données et lancer notre application en déployant sur App Engine . Ce didacticiel s'adresse aux débutants qui tentent pour la première fois d'utiliser Google Cloud pour leur application.
Configurer 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: [19659014] python -V
Notre première étape consiste à créer le répertoire dans lequel évoluera notre projet. 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 opérationnel. Cela signifie que ce projet peut avoir ses propres dépendances, différentes des autres projets sur vos machines. venv est un module livré 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.
(env ) apparaît avant l'invite ( Grand aperçu )Maintenant, installons notre package Flask:
pip install flask
Créez un répertoire nommé api dans notre répertoire actuel. 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 entrez le code suivant:
# main.py
depuis Flask Import Flask
app = Flacon (__ nom__)
@ app.route ('/')
def home ():
retourne 'Hello World'
si __nom__ == '__main__':
app.run ()
Voyons 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 assigné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 de vue qui appelle la route / – elle renvoie Hello World .
Exécutons l'application:
python main.py
Cela démarre notre serveur local et sert notre application sur http://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 voilà! Notre application est opérationnelle. La tâche suivante est de le rendre fonctionnel.
Pour appeler nos endpoints, nous utiliserons Postman, qui est un service qui aide les développeurs à tester les endpoints. Vous pouvez le télécharger sur le site officiel.
Faisons en sorte que main.py renvoie des données:
# main.py
depuis Flask Import Flask, jsonify
app = Flacon (__ nom__)
chansons = [
{
"title": "Rockstar",
"artist": "Dababy",
"genre": "rap",
},
{
"title": "Say So",
"artist": "Doja Cat",
"genre": "Hiphop",
},
{
"title": "Panini",
"artist": "Lil Nas X",
"genre": "Hiphop"
}
]
@ app.route ('/ chansons')
def home ():
return jsonify (chansons)
si __nom__ == '__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 route racine / en / chansons . Cette route renvoie le tableau de chansons que nous avons spécifié. Afin d'obtenir notre liste en tant que 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 http://127.0.0.1:5000/songs .
get de Postman ( Grand aperçu ) 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 demande de publication à notre tableau. Tout d'abord, importez l'objet request afin que nous puissions traiter la demande entrante de nos utilisateurs. Nous utiliserons ultérieurement l'objet request dans la fonction d'affichage pour obtenir l'entrée de l'utilisateur au format JSON.
# main.py
depuis le flask import Flask, jsonify, request
app = Flacon (__ nom__)
chansons = [
{
"title": "Rockstar",
"artist": "Dababy",
"genre": "rap",
},
{
"title": "Say So",
"artist": "Doja Cat",
"genre": "Hiphop",
},
{
"title": "Panini",
"artist": "Lil Nas X",
"genre": "Hiphop"
}
]
@ app.route ('/ chansons')
def home ():
return jsonify (chansons)
@ app.route ('/ chansons', méthodes = ['POST'])
def add_songs ():
chanson = demande.get_json ()
songs.append (chanson)
return jsonify (chansons)
si __nom__ == '__main__':
app.run (debug = True)
Notre fonction d'affichage add_songs prend une chanson soumise par un utilisateur et l'ajoute à notre liste de chansons existante.
Jusqu'à présent, nous avons renvoyé nos données à partir d'une liste Python. C'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. Voici Cloud SQL.
Pourquoi utiliser une instance Cloud SQL?
D'après le site Web officiel :
«Google Cloud SQL est un service de base de données entièrement géré qui facilite sa configuration -up, maintenir, gérer et administrer 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 s'exécutant n'importe où. »
Cela signifie que nous pouvons sous-traiter la gestion de l'infrastructure d'une base de données entièrement à Google, à des tarifs flexibles.
Différence entre Cloud SQL et A 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'un hôte d'autres configurations. Avec Cloud SQL, nous prenons en charge une grande partie de la configuration, ce qui nous permet de passer plus de temps sur le code et moins de temps à configurer.
Avant de commencer:
- Inscrivez-vous à Google Cloud . Google offre un crédit gratuit de 300 $ en aux nouveaux utilisateurs.
- 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. [19659064] Cette image montre une sous-section des services GCP « />
Tout d'abord, nous devons choisir un moteur SQL. Nous allons utiliser MySQL pour cet article.
Ensuite, nous ' Je vais 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 la liste déroulante «Afficher les options de configuration». Les paramètres vous permettent de configurer la taille de l'instance, la capacité de stockage, la sécurité, la disponibilité, les sauvegardes, etc. Pour cet article, nous allons utiliser les paramètres par défaut. Ne vous inquiétez pas, ces variables peuvent être modifiées plus tard.
Le processus peut prendre quelques minutes. Vous saurez que l'instance est prête lorsque vous voyez 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:
- Créer une base de données.
- Créer un nouvel utilisateur.
- 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 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 choisissez 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é ajoutées à la liste blanche peuvent accéder à la base de données.
Pour ajouter votre adresse IP à la liste blanche, saisissez mon adresse IP dans une recherche Google pour obtenir votre adresse IP. Ensuite, allez dans l'onglet «Connexions» et «Ajouter un réseau».
Connectez-vous à l'instance
Ensuite, accédez au panneau "Vue d'ensemble" et connectez-vous à l'aide du Cloud Shell.
La commande pour vous connecter à notre instance Cloud SQL sera pré-tapé dans la console.
Vous pouvez utiliser l'utilisateur root ou 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é à saisir 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é par la commande ci-dessus et saisissez-le dans la commande ci-dessous, en remplaçant PROJECT_ID par lui.
gcloud config set project PROJECT_ID
Ensuite, exécutez la commande gcloud sql connect et nous serons connectés.
Exécutez cette commande pour voir 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 . Celles-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 tracks (
song_id INT NOT NULL AUTO_INCREMENT,
titre VARCHAR (255),
artiste VARCHAR (255),
genre VARCHAR (255),
CLÉ PRIMAIRE (song_id)
);
Ce code est une commande SQL qui crée une table nommée chansons avec quatre colonnes ( song_id title artist et genre ). Nous avons également demandé à la table de définir song_id comme clé primaire et d'incrémenter automatiquement à partir de 1.
Maintenant, exécutez show tables; pour confirmer que la table a été créée .
Et juste comme ça, nous avons a créé une base de données et notre table chansons .
Notre prochaine tâche consiste à configurer Google App Engine afin que nous puissions déployer notre application.
Google App Engine
App Engine est un outil entièrement géré plate-forme de développement et d'hébergement d'applications Web à grande échelle. L'avantage du déploiement sur App Engine est qu'il permet à une application de s'adapter automatiquement au trafic entrant.
Le site Web App Engine indique:
«Avec zéro gestion de serveur et aucun déploiement de configuration, les développeurs ne peut se concentrer que sur la création d’applications de qualité 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.
Installez 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 a été installé, nous allons mettre à jour notre script Python avec les informations d'identification de notre base de données et déployer vers App Engine.
Configuration locale
Dans notre environnement local, nous allons mettre à jour la configuration pour l'adapter à notre nouvelle architecture, qui comprend Cloud SQL et App Engine.
Commencez par ajouter une application . yaml dans 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 informe App Engine de notre environnement d'exécution et d'autres variables qui pourraient être requises. 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 soit au courant de 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 à partir 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
exécution: python37
env_variables:
CLOUD_SQL_USERNAME: VOTRE-DB-USERNAME
CLOUD_SQL_PASSWORD: VOTRE-DB-PASSWORD
CLOUD_SQL_DATABASE_NAME: VOTRE-DB-NAME
CLOUD_SQL_CONNECTION_NAME: VOTRE-NOM DE CONNEXION
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 Database Connector
Tout d'abord, créez un fichier db.py dans notre dossier racine et ajoutez le code ci-dessous:
# db.py
importer le système d'exploitation
importer pymysql
à partir de l'importation de flacon jsonify
db_user = os.environ.get ('CLOUD_SQL_USERNAME')
db_password = os.environ.get ('CLOUD_SQL_PASSWORD')
nom_base = 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)
essayer:
si os.environ.get ('GAE_ENV') == 'standard':
conn = pymysql.connect (utilisateur = db_user, password = db_password,
unix_socket = unix_socket, db = db_name,
cursorclass = pymysql.cursors.DictCursor
)
sauf pymysql.MySQLError comme e:
imprimer (e)
retour conn
def get_songs ():
conn = connexion_ouverte ()
avec conn.cursor () comme curseur:
result = cursor.execute ('SELECT * FROM chansons;')
chansons = curseur.fetchall ()
si résultat> 0:
got_songs = jsonify (chansons)
autre:
got_songs = 'Aucune chanson dans la base de données'
conn.close ()
retourne got_songs
def add_songs (chanson):
conn = connexion_ouverte ()
avec conn.cursor () comme curseur:
curseur.execute ('INSÉRER DANS les chansons (titre, artiste, genre) VALUES (% s,% s,% s)', (chanson ["title"]chanson ["artist"]chanson ["genre"]))
conn.commit ()
conn.close ()
Nous avons fait quelques choses ici.
Premièrement, nous avons récupéré les informations d'identification de notre base de données à partir du fichier app.yaml en utilisant la méthode os.environ.get . App Engine peut rendre les variables d'environnement définies dans app.yaml disponibles dans l'application.
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 chansons pour chaque ligne et, si elle est vide, renvoie «No Songs in DB». La fonction add_songs insère un nouvel enregistrement dans la table chansons .
Enfin, nous retournons à 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 du base de données.
Refactorisons main.py :
# main.py
depuis importation de flacon Flask, jsonify, request
depuis db import get_songs, add_songs
app = Flacon (__ nom__)
@ app.route ('/', méthodes = ['POST', 'GET'])
def chansons ():
si request.method == 'POST':
sinon request.is_json:
return jsonify ({"msg": "JSON manquant dans la requête"}), 400
add_songs (request.get_json ())
retour 'Chanson ajoutée'
retourne get_songs ()
si __name__ == '__main__':
app.run ()
Nous avons importé les fonctions get_songs et add_songs et les avons appelées dans notre fonction de visualisation chansons () . Si nous faisons une demande post nous appelons la fonction add_songs et si nous faisons une demande get nous appelons la get_songs ].
Et notre application est terminée.
Ensuite, ajoutez 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.
At à ce stade, nous avons ajouté trois nouveaux fichiers: db.py app.yaml et requirements.txt .
Déployer sur Google App Engine [19659058] Exécutez la commande suivante pour déployer votre application: gcloud app deploy
gcloud app deploy
Si tout s'est bien passé, votre console affichera ceci:
Votre l'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 nos requêtes post et get .
get request ( Large preview )Notre application est désormais hébergée sur l'infrastructure de Google et nous pouvons modifier la configuration pour bénéficier de 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) comme 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. Cependant, si vous avez besoin de contrôler la configuration sous-jacente, il peut être préférable d'utiliser un service personnalisé.
Références
(ks, ra, al, il) Source link