Commit 4b97b55f authored by DANIEL DIAZ SANCHEZ's avatar DANIEL DIAZ SANCHEZ
Browse files

Update README.md, img/GAE_test.png, img/local_GAE_test.png files

parent 9bdeed59
......@@ -399,4 +399,226 @@ En GAE no podemos usar una base de datos SQL, por lo que tendremos que crear una
<img src="img/creacion_sql_9.png" width="500px"/>
<img src="img/creacion_sql_1.png" width="500px"/>
### Preparar el SDK de google y la base de datos
Abrimos un terminal nuevo y hacemos `cd /tmp` para poder interactuar con el SDK de google:
1. Instalar App Engine Python
```
vit131:/tmp> ./google-cloud-sdk/bin/gcloud components install app-engine-python
```
2. Indicar el proyecto que se debe usar para el despliegue (mira tu proyecto en la consola, las XXXX suelen ser tu NIA)
```
vit131:/tmp> ./google-cloud-sdk/bin/gcloud config set project uc3m-it-2109-15397-XXXXXX
```
3. Autoriza a Google SDK a desplegar la aplicación. Se abrirá un navegador. Te autenticas con la misma cuenta en la que tienes el proyecto de Google Cloud
```
vit131:/tmp> ./google-cloud-sdk/bin/gcloud auth login
```
4. Habilitar varios APIS
```
vit131:/tmp> ./google-cloud-sdk/bin/gcloud services enable cloudbuild.googleapis.com
vit131:/tmp> ./google-cloud-sdk/bin/gcloud services enable serviceusage.googleapis.com
vit131:/tmp> ./google-cloud-sdk/bin/gcloud services enable sqladmin.googleapis.com
```
5. Nos conectamos a la base de datos. Cuando nos pida contraseña, usaremos la contraseña de PASSWORD_CDIST
```
vit131:/tmp> ./google-cloud-sdk/bin/gcloud sql connect cdistrest --user=cdistrest
Allowlisting your IP for incoming connection for 5 minutes...done.
Connecting to database with SQL user [cdistrest].Enter password:
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MySQL connection id is 156
Server version: 5.7.34-google-log (Google)
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MySQL [(none)]>
```
Cuando hayamos conectado, en primer lugar creamos una base de datos llamada `cdistrest` y comprobamos que se ha creado:
```
MySQL [(none)]> CREATE DATABASE cdistrest;
Query OK, 1 row affected (0.044 sec)
MySQL [(none)]> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| cdistrest |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 rows in set (0.042 sec)
```
Autorizamos al usuario `cdistrest` con todos los privilegios sobre la base de datos recien creada:
```
MySQL [(none)]> GRANT ALL PRIVILEGES ON cdistrest.* TO 'cdistrest'@'%';
Query OK, 0 rows affected (0.044 sec)
```
Seleccionamos la base de datos:
```
MySQL [(none)]> use cdistrest
Database changed
MySQL [cdistrest]>
```
Creamos una tabla llamada `Libro` como hicimos con SQLite:
```
MySQL [cdistrest]> CREATE TABLE libro(id MEDIUMINT NOT NULL AUTO_INCREMENT PRIMARY KEY, autor VARCHAR(80), titulo VARCHAR(120));
Query OK, 0 rows affected (0.073 sec)
MySQL [cdistrest]> show tables;
+---------------------+
| Tables_in_cdistrest |
+---------------------+
| libro |
+---------------------+
1 row in set (0.041 sec)
```
Salimos
```
MySQL [cdistrest]> quit
Bye
```
### Preparar aplicación para el uso de la base de datos MySQL
Para que la aplicación pueda usarse en GAE es necesario cambiar el código por el siguiente (sólo varía la conexión con la bbdd):
```python
import os
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import Column, String, Integer, Date
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
app = Flask(__name__)
db_user = os.environ.get('CLOUD_SQL_USERNAME')
db_pass = 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')
db_host = os.environ.get('CLOUD_SQL_HOST')
host_args = db_host.split(":")
db_hostname, db_port = host_args[0], int(host_args[1])
dburl = sqlalchemy.engine.url.URL.create(drivername="mysql+pymysql",
username=db_user, # e.g. "my-database-user"
password=db_pass, # e.g. "my-database-password"
host=db_hostname, # e.g. "127.0.0.1"
port=db_port, # e.g. 3306
database=db_name, # e.g. "my-database-name"
)
print('Using url ' , dburl)
app.config["SQLALCHEMY_DATABASE_URI"] = str(dburl)
db = SQLAlchemy(app)
class Libro(db.Model):
__tablename__ = 'libro'
id = db.Column(db.Integer, primary_key=True)
autor = db.Column(db.String(80), unique=True, nullable=False)
titulo = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<Libro %r>' % self.titulo
def serialize(self):
return {
"id": self.id,
"autor": self.autor,
"titulo": self.titulo
}
@app.route("/")
def wellcome():
return "Book database"
@app.route("/addbook", methods=['POST'])
def handle_addbook():
body = request.get_json()
if body is None:
return "The request body is null", 400
if 'autor' not in body:
return 'Author (autor) missing',400
if 'titulo' not in body:
return 'Title (titulo) missing', 400
nuevolibro = Libro(autor=body['autor'], titulo=body['titulo'])
db.session.add(nuevolibro)
db.session.commit()
return jsonify({"result": "Book added successfully!"}), 200
@app.route("/books", methods=['GET'])
def handle_getbooks():
all_books = Libro.query.all()
all_books = list(map(lambda x: x.serialize(), all_books))
return jsonify(all_books),200
@app.route("/book/<sid>", methods=['GET'])
def handle_getbook(sid):
book = Libro.query.filter_by(id=sid)
book = list(map(lambda x: x.serialize(), book))
return jsonify(book),200
if __name__ == '__main__':
app.run(host='127.0.0.1', port=8080, debug=True)
```
### Creación de fichero de despliegue en GAE y para prueba en local
Para poder desplegar la aplicación en GAE, es necesario crear un fichero llamado `app.yaml` donde estará la información de despliegue de la aplicación REST. Además, en ese fichero meteremos la información relativa a la base de datos. Además crearemos un fichero que nos permita probar el interfaz REST en local, usando la base de datos de Google.
#### Creación del fichero de despliegue app.yaml
En la carpeta `~/cdist/rest` creamos un fichero de despligue llamado `app.yaml` usando Atom o nuestor editor preferido con el siguiente contenido (ojo sustituye PASSWORD_CDIST y IP_BBDD por su valor que deberás tener apuntado, el nombre de la conexión puedes sacarla del menu conexion de tu base de datos, en mi caso es uc3m-it-2109-15397-teachers:europe-central2:cdistrest):
```yaml
runtime: python39
env_variables:
CLOUD_SQL_USERNAME: cdistrest
CLOUD_SQL_PASSWORD: PASSWORD_CDIST
CLOUD_SQL_DATABASE_NAME: cdistrest
CLOUD_SQL_CONNECTION_NAME: uc3m-it-2109-15397-XXXXX:zona:cdistrest
CLOUD_SQL_HOST: IP_BBDD:3306
handlers:
- url: /.*
script: auto
```
#### Creación del fichero de variables de entrono para prueba local
En la carpeta `~/cdist` creamos un fichero llamado `env.sh` con el contenido:
```
export CLOUD_SQL_USERNAME=cdistrest
export CLOUD_SQL_PASSWORD=PASSWORD_CDIST
export CLOUD_SQL_DATABASE_NAME=cdistrest
export CLOUD_SQL_CONNECTION_NAME=uc3m-it-2109-15397-teachers:europe-central2:cdistrest
export CLOUD_SQL_HOST=IP_BBDD:3306
```
## Prueba en local del servicio REST de Google Cloud
Para probarlo en local, Flask montará localmente un servidor web, pero usará como base de datos la de Google Cloud, como se muestra en la imagen:
<img src="img/local_GAE_test.png" width="500px"/>
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment