Configuración de una API con Flask, Cloud SQL de Google y App Engine

Se pueden usar algunos marcos de trabajo de Python para crear API, dos de los cuales son Flask y Django. Frameworks viene con una funcionalidad que facilita a los desarrolladores la implementación de las funciones que los usuarios necesitan para interactuar con sus aplicaciones. La complejidad de una aplicación web podría ser un factor decisivo a la hora de elegir con qué marco trabajar.

Django

Django es un marco robusto que tiene una estructura predefinida con funcionalidad integrada. Sin embargo, la desventaja de su robustez es que podría hacer que el marco sea demasiado complejo para ciertos proyectos. Es más adecuado para aplicaciones web complejas que necesitan aprovechar la funcionalidad avanzada de Django.

Matraz

Flask, por otro lado, es un marco liviano para construir API. Comenzar con él es fácil y hay paquetes disponibles para hacerlo más sólido a medida que avanza. Este artículo se centrará en definir las funciones de vista y el controlador y en conectarse a una base de datos en Google Cloud e implementar en Google Cloud.

Con el fin de aprender, crearemos una API de Flask con algunos puntos finales para administrar una colección de nuestras canciones favoritas. Los puntos finales serán para solicitudes GET y POST : obtención y creación de recursos. Además de eso, utilizaremos el conjunto de servicios en la plataforma Google Cloud. Configuraremos Cloud SQL de Google para nuestra base de datos y lanzaremos nuestra aplicación implementándola en App Engine. Este tutorial está dirigido a principiantes que intentan por primera vez usar Google Cloud para su aplicación.

Configuración de un proyecto Flask

Este tutorial asume que tiene instalado Python 3.x. Si no lo hace, diríjase al sitio web oficial para descargarlo e instalarlo.

Para verificar si Python está instalado, inicie su interfaz de línea de comandos (CLI) y ejecute el siguiente comando:

 python -V

Nuestro primer paso es crear el directorio donde vivirá nuestro proyecto. Lo llamaremos flask-app :

 mkdir flask-app && cd flask-app

Lo primero que debe hacer al iniciar un proyecto de Python es crear un entorno virtual. Los entornos virtuales aíslan su desarrollo Python en funcionamiento. Esto significa que este proyecto puede tener sus propias dependencias, diferentes de otros proyectos en sus máquinas. venv es un módulo que se envía con Python 3.

Vamos a crear un entorno virtual en nuestro directorio flask-app :

 python3 -m venv env

Este comando crea una carpeta env en nuestro directorio. El nombre (en este caso, env ) es un alias para el entorno virtual y puede tener cualquier nombre.

Ahora que hemos creado el entorno virtual, tenemos que decirle a nuestro proyecto que lo use. Para activar nuestro entorno virtual, utilice el siguiente comando:

 source env/bin/activate

Verá que su indicador CLI ahora tiene env al principio, lo que indica que nuestro entorno está activo.

Ahora, instalemos nuestro paquete Flask:

 pip install flask

Cree un directorio llamado api en nuestro directorio actual. Estamos creando este directorio para que tengamos una carpeta donde residirán las otras carpetas de nuestra aplicación.

 mkdir api && cd api

A continuación, cree un archivo main.py , que servirá como punto de entrada a nuestra aplicación:

 touch main.py

Abra main.py e ingrese el siguiente código:

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

Entendamos lo que hemos hecho aquí. Primero importamos la clase Flask del paquete Flask. Luego, creamos una instancia de la clase y la asignamos a la app . A continuación, creamos nuestro primer punto final, que apunta a la raíz de nuestra aplicación. En resumen, esta es una función de vista que invoca la ruta / — devuelve Hello World .

Ejecutemos la aplicación:

 python main.py

Esto inicia nuestro servidor local y sirve nuestra aplicación en https://127.0.0.1:5000/ . Ingrese la URL en su navegador y verá la respuesta Hello World impresa en su pantalla.

¡Y voilá! Nuestra aplicación está en funcionamiento. La siguiente tarea es hacerlo funcional.

Para llamar a nuestros puntos finales, usaremos Postman, que es un servicio que ayuda a los desarrolladores a probar los puntos finales. Puedes descargarlo desde el sitio web oficial.

Hagamos que main.py devuelva algunos datos:

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

Aquí, incluimos una lista de canciones, incluido el título de la canción y el nombre del artista. Luego cambiamos la raíz / ruta a /songs . Esta ruta devuelve la matriz de canciones que especificamos. Para obtener nuestra lista como un valor JSON, JSONificamos la lista pasándola a través jsonify . Ahora, en lugar de ver un simple Hello world , vemos una lista de artistas cuando accedemos al extremo https://127.0.0.1:5000/songs .

Es posible que haya notado que después de cada cambio, teníamos que reiniciar nuestro servidor. Para habilitar la recarga automática cuando cambia el código, habilitemos la opción de depuración. Para hacer esto, cambie app.run a esto:

 app.run(debug=True)

A continuación, agreguemos una canción usando una solicitud de publicación a nuestra matriz. Primero, importe el objeto de la request , para que podamos procesar la solicitud entrante de nuestros usuarios. Más adelante usaremos el objeto de request en la función de vista para obtener la entrada del usuario en 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)

Nuestra función de vista add_songs toma una canción enviada por el usuario y la agrega a nuestra lista de canciones existente.

Hasta ahora, hemos devuelto nuestros datos de una lista de Python. Esto es solo experimental, porque en un entorno más robusto, nuestros datos recién agregados se perderían si reiniciamos el servidor. Eso no es factible, por lo que necesitaremos una base de datos en vivo para almacenar y recuperar los datos. Llega Cloud SQL.

¿Por qué usar una instancia de Cloud SQL?

Según el sitio web oficial:

“Google Cloud SQL es un servicio de base de datos totalmente administrado que facilita la configuración, el mantenimiento, la gestión y la administración de sus bases de datos MySQL y PostgreSQL relacionales en la nube. Alojado en Google Cloud Platform, Cloud SQL proporciona una infraestructura de base de datos para aplicaciones que se ejecutan en cualquier lugar”.

Esto significa que podemos externalizar la gestión de la infraestructura de una base de datos por completo a Google, a un precio flexible.

Diferencia entre Cloud SQL y un motor de cómputo autoadministrado

En Google Cloud, podemos activar una máquina virtual en la infraestructura de Compute Engine de Google e instalar nuestra instancia de SQL. Esto significa que seremos responsables de la escalabilidad vertical, la replicación y muchas otras configuraciones. Con Cloud SQL, obtenemos mucha configuración lista para usar, por lo que podemos dedicar más tiempo al código y menos tiempo a la configuración.

Antes de que comencemos:

1. Regístrese en Google Cloud. Google ofrece $300 en crédito gratis a nuevos usuarios.
2. Crea un proyecto. Esto es bastante sencillo y se puede hacer directamente desde la consola.

Crear una instancia de Cloud SQL

Después de registrarse en Google Cloud, en el panel izquierdo, desplácese hasta la pestaña "SQL" y haga clic en ella.

Primero, debemos elegir un motor SQL. Iremos con MySQL para este artículo.

A continuación, crearemos una instancia. De forma predeterminada, nuestra instancia se creará en los EE. UU. y la zona se seleccionará automáticamente para nosotros.

Establezca la contraseña de root y asigne un nombre a la instancia, y luego haga clic en el botón "Crear". Puede configurar aún más la instancia haciendo clic en el menú desplegable "Mostrar opciones de configuración". La configuración le permite configurar el tamaño de la instancia, la capacidad de almacenamiento, la seguridad, la disponibilidad, las copias de seguridad y más. Para este artículo, utilizaremos la configuración predeterminada. No se preocupe, estas variables se pueden cambiar más adelante.

El proceso puede tardar unos minutos en finalizar. Sabrá que la instancia está lista cuando vea una marca de verificación verde. Haga clic en el nombre de su instancia para ir a la página de detalles.

Ahora que estamos en funcionamiento, haremos algunas cosas:

1. Crear una base de datos.
2. Crear un nuevo usuario.
3. Lista blanca de nuestra dirección IP.

Crear una base de datos

Vaya a la pestaña "Base de datos" para crear una base de datos.

Crear un nuevo usuario

En la sección "Nombre de host", configúrelo para permitir "% (cualquier host)".

Dirección IP de la lista blanca

Puede conectarse a su instancia de base de datos de una de dos maneras. Una dirección IP privada requiere una nube privada virtual (VPC). Si opta por esta opción, Google Cloud creará una VPC administrada por Google y colocará su instancia en ella. Para este artículo, usaremos la dirección IP pública , que es la predeterminada. Es público en el sentido de que solo las personas cuyas direcciones IP se han incluido en la lista blanca pueden acceder a la base de datos.

Para incluir en la lista blanca su dirección IP, escriba my ip en una búsqueda de Google para obtener su IP. Luego, vaya a la pestaña "Conexiones" y "Agregar red".

Conéctese a la instancia

A continuación, navegue hasta el panel "Descripción general" y conéctese usando el shell de la nube.

El comando para conectarse a nuestra instancia de Cloud SQL se escribirá previamente en la consola.

Puede usar el usuario raíz o el usuario que se creó anteriormente. En el comando a continuación, decimos: Conéctese a la instancia flask-demo como el USERNAME del usuario. Se le pedirá que ingrese la contraseña del usuario.

 gcloud sql connect flask-demo --user=USERNAME

Si recibe un error que dice que no tiene una ID de proyecto, puede obtener la ID de su proyecto ejecutando esto:

 gcloud projects list

Tome el ID del proyecto que se generó con el comando anterior e ingréselo en el comando a continuación, reemplazando PROJECT_ID con él.

 gcloud config set project PROJECT_ID

Luego, ejecuta el gcloud sql connect y estaremos conectados.

Ejecute este comando para ver las bases de datos activas:

 > show databases; 

Mi base de datos se llama db_demo y ejecutaré el siguiente comando para usar la base de datos db_demo . Es posible que vea otras bases de datos, como information_schema y performance_schema . Estos están ahí para almacenar metadatos de tablas.

 > use db_demo;

A continuación, cree una tabla que refleje la lista de nuestra aplicación Flask. Escriba el código a continuación en un bloc de notas y péguelo en su shell de nube:

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

Este código es un comando SQL que crea una tabla llamada songs , con cuatro columnas ( song_id , title , artist y genre ). También hemos indicado que la tabla debe definir song_id como clave principal y aumentar automáticamente desde 1.

Ahora, ejecuta show tables; para confirmar que la tabla ha sido creada.

Y así, hemos creado una base de datos y nuestra tabla de songs .

Nuestra próxima tarea es configurar Google App Engine para que podamos implementar nuestra aplicación.

Motor de aplicaciones de Google

App Engine es una plataforma totalmente administrada para desarrollar y alojar aplicaciones web a escala. Una ventaja de la implementación en App Engine es que permite que una aplicación se escale automáticamente para cumplir con el tráfico entrante.

El sitio web de App Engine dice:

“Con cero implementaciones de administración de servidores y configuración, los desarrolladores pueden enfocarse solo en crear excelentes aplicaciones sin la sobrecarga de administración”.

Configurar el motor de aplicaciones

Hay algunas formas de configurar App Engine: a través de la interfaz de usuario de Google Cloud Console o a través del SDK de Google Cloud. Usaremos el SDK para esta sección. Nos permite implementar, administrar y monitorear nuestra instancia de Google Cloud desde nuestra máquina local.

Instalar el SDK de Google Cloud

Siga las instrucciones para descargar e instalar el SDK para Mac o Windows. La guía también le mostrará cómo inicializar el SDK en su CLI y cómo elegir un proyecto de Google Cloud.

Ahora que se instaló el SDK, actualizaremos nuestro script de Python con las credenciales de nuestra base de datos y lo implementaremos en App Engine.

Configuración local

En nuestro entorno local, actualizaremos la configuración para adaptarla a nuestra nueva arquitectura, que incluye Cloud SQL y App Engine.

Primero, agregue un archivo app.yaml a nuestra carpeta raíz. Este es un archivo de configuración que App Engine requiere para alojar y ejecutar nuestra aplicación. Le informa a App Engine de nuestro tiempo de ejecución y otras variables que podrían ser necesarias. Para nuestra aplicación, necesitaremos agregar las credenciales de nuestra base de datos como variables de entorno, para que App Engine reconozca la instancia de nuestra base de datos.

En el archivo app.yaml , agregue el fragmento a continuación. Habrá obtenido las variables de base de datos y tiempo de ejecución al configurar la base de datos. Reemplaza los valores con el nombre de usuario, la contraseña, el nombre de la base de datos y el nombre de la conexión que usaste cuando configuraste 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

Ahora, vamos a instalar PyMySQL. Este es un paquete Python MySQL que se conecta y realiza consultas en una base de datos MySQL. Instale el paquete PyMySQL ejecutando esta línea en su CLI:

 pip install pymysql

En este punto, estamos listos para usar PyMySQL para conectarnos a nuestra base de datos de Cloud SQL desde la aplicación. Esto nos permitirá obtener e insertar consultas en nuestra base de datos.

Inicializar conector de base de datos

Primero, cree un archivo db.py en nuestra carpeta raíz y agregue el código a continuación:

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

Hicimos algunas cosas aquí.

Primero, recuperamos las credenciales de nuestra base de datos del archivo app.yaml usando el método os.environ.get . App Engine puede hacer que las variables de entorno definidas en app.yaml estén disponibles en la aplicación.

En segundo lugar, creamos una función open_connection . Se conecta a nuestra base de datos MySQL con las credenciales.

En tercer lugar, agregamos dos funciones: get_songs y add_songs . El primero inicia una conexión a la base de datos llamando a la función open_connection . Luego consulta la tabla de songs para cada fila y, si está vacía, devuelve "No hay canciones en la base de datos". La función add_songs inserta un nuevo registro en la tabla de songs .

Finalmente, volvemos a donde empezamos, nuestro archivo main.py Ahora, en lugar de obtener nuestras canciones de un objeto, como hicimos antes, llamamos a la función add_songs para insertar un registro y llamamos a la función get_songs para recuperar los registros de la base de datos.

Vamos a refactorizar 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()

Importamos las funciones get_songs y add_songs y las llamamos en nuestra función de visualización de songs() . Si estamos haciendo una solicitud de post , llamamos a la función add_songs , y si estamos haciendo una solicitud de get , llamamos a la función get_songs .

Y nuestra aplicación está lista.

El siguiente paso es agregar un archivo requirements.txt . Este archivo contiene una lista de paquetes necesarios para ejecutar la aplicación. App Engine comprueba este archivo e instala los paquetes enumerados.

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

Esta línea obtiene los dos paquetes que estamos usando para la aplicación (Flask y PyMySQL), crea un archivo requirements.txt y agrega los paquetes y sus versiones al archivo.

En este punto, hemos agregado tres archivos nuevos: db.py , app.yaml y requirements.txt .

Implementar en Google App Engine

Ejecute el siguiente comando para implementar su aplicación:

 gcloud app deploy

Si salió bien, su consola mostrará esto:

Su aplicación ahora se ejecuta en App Engine. Para verlo en el navegador, ejecute gcloud app browse en su CLI.

Podemos lanzar Postman para probar nuestra post y get solicitudes.

Nuestra aplicación ahora está alojada en la infraestructura de Google y podemos modificar la configuración para obtener todos los beneficios de una arquitectura sin servidor. En el futuro, puede aprovechar este artículo para hacer que su aplicación sin servidor sea más sólida.

Conclusión

El uso de una infraestructura de plataforma como servicio (PaaS) como App Engine y Cloud SQL básicamente abstrae el nivel de infraestructura y nos permite construir más rápidamente. Como desarrolladores, no tenemos que preocuparnos por la configuración, la copia de seguridad y la restauración, el sistema operativo, el escalado automático, los firewalls, la migración del tráfico, etc. Sin embargo, si necesita controlar la configuración subyacente, entonces podría ser mejor usar un servicio personalizado.

Referencias

• “Descarga Python”
• “venv — Creación de entornos virtuales”, Python (documentación)
• “Descargar Cartero”
• “Cloud SQL”, nube de Google
• Nube de Google
• “Nivel gratuito de Google Cloud”, Google Cloud
• “Creación y gestión de proyectos”, Google Cloud
• "Descripción general de VPC" (nube privada virtual), Google Cloud
• “Motor de aplicaciones”, Google Cloud
• “Inicios rápidos” (descargar SDK de Google Cloud), Google Cloud
• Documentación de PyMySQL