Deployment di un'applicazione web Python Flask nell'ambiente flessibile di App Engine

Riepilogo

In questo codelab imparerai a eseguire il deployment di un'applicazione web Python Flask nell'ambiente flessibile di App Engine. L'applicazione di esempio consente a un utente di caricare una foto del volto di una persona e scoprire la probabilità che la persona sia felice. L'applicazione utilizza le API Google Cloud per Vision, Storage e Datastore.

Informazioni su App Engine

Le applicazioni Google App Engine sono facili da creare, gestire e scalare in base alle esigenze di traffico e spazio di archiviazione dei dati. Con App Engine, non ci sono server da mantenere. Ti basterà caricare la tua richiesta e sarà pronta.

Le applicazioni App Engine vengono scalate automaticamente in base al traffico in entrata. Il bilanciamento del carico, i microservizi, l'autorizzazione, i database SQL e NoSQL, la suddivisione del traffico, il logging, la ricerca, il controllo delle versioni, l'implementazione e il rollback e la scansione di sicurezza sono tutti supportati in modo nativo e sono altamente personalizzabili.

L'ambiente flessibile di App Engine supporta tutti i seguenti linguaggi di programmazione: C#, Go, Java, Node.js, PHP, Python e Ruby. App Engine Flexible esegue la tua applicazione all'interno di container Docker in esecuzione su macchine virtuali Google Compute Engine. L'ambiente standard di App Engine è un'opzione alternativa per alcuni linguaggi, tra cui Python. App Engine Standard esegue l'applicazione in un ambiente sandbox più restrittivo. Per ulteriori informazioni, consulta la sezione Scegliere un ambiente App Engine.

Cosa imparerai a fare

  • Come eseguire il deployment di una semplice applicazione web nell'ambiente flessibile di App Engine
  • Come accedere alle librerie client Google Cloud per Vision, Storage e Datastore
  • Come utilizzare Google Cloud Console e Google Cloud SDK per gestire varie risorse cloud
  • Come utilizzare Cloud Shell

Che cosa ti serve

  • Familiarità con Python
  • Familiarità con gli editor di testo standard di Linux, ad esempio Vim, Emacs o Nano

Creazione di progetti

Se non hai ancora un Account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console di Google Cloud (console.cloud.google.com) e crea un nuovo progetto:

Ricorda l'ID progetto, un nome univoco per tutti i progetti Google Cloud (il nome riportato sopra è già stato utilizzato e non funzionerà per te, mi dispiace). In questo codelab verrà indicato come PROJECT_ID.

Fatturazione

Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le risorse Google Cloud.

L'esecuzione di questo codelab non dovrebbe costarti più di qualche dollaro, ma potrebbe essere più cara se decidi di utilizzare più risorse o se le lasci in esecuzione.

I nuovi utenti di Google Cloud Platform possono beneficiare di una prova senza costi di 300$.

Anche se Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzeremo Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud. Questa macchina virtuale basata su Debian viene caricata con tutti gli strumenti di sviluppo di cui avrai bisogno (gcloud, python, virtualenv, pip e altri), offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Ciò significa che per questo codelab ti servirà solo un browser (sì, funziona su Chromebook).

Per attivare Google Cloud Shell, fai clic sul pulsante in alto a destra della console per gli sviluppatori (il provisioning e la connessione all'ambiente richiedono solo pochi istanti):

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo PROJECT_ID:

gcloud auth list
Credentialed accounts:
- <myaccount>@<mydomain>.com (active)
 
gcloud config list project
[core]
Project = <PROJECT_ID>

Se per qualche motivo il progetto non è impostato, esegui questo comando:

gcloud config set project <PROJECT_ID>

Stai cercando il tuo PROJECT_ID? Controlla l'ID progetto che hai utilizzato nei passaggi di configurazione o cercalo nella dashboard della console:

In Cloud Shell, esegui questo comando dalla riga di comando per clonare il repository GitHub:

git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

Passa alla directory python-docs-samples/codelabs/flex_and_vision:

cd python-docs-samples/codelabs/flex_and_vision

Prima di poter iniziare a utilizzare le API Vision, Storage e Datastore, devi abilitarle con i seguenti comandi:

gcloud services enable vision.googleapis.com
 
gcloud services enable storage-component.googleapis.com
 
gcloud services enable datastore.googleapis.com

Per effettuare richieste alle API Vision, Storage e Datastore, avrai bisogno delle credenziali del service account. Le credenziali del service account del tuo progetto possono essere generate utilizzando lo strumento gcloud.

Imposta una variabile di ambiente per PROJECT_ID, sostituendo [YOUR_PROJECT_ID] con il tuo ID progetto:

export PROJECT_ID=[YOUR_PROJECT_ID]

Crea un service account per accedere alle API Google Cloud durante i test in locale:

gcloud iam service-accounts create codelab \
  --display-name "My Codelab Service Account"

Concedi al service account appena creato le autorizzazioni appropriate:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
--member serviceAccount:codelab@${PROJECT_ID}.iam.gserviceaccount.com \
--role roles/owner

Dopo aver creato il service account, crea una chiave del service account:

gcloud iam service-accounts keys create ~/key.json \
--iam-account codelab@${PROJECT_ID}.iam.gserviceaccount.com

Questo comando genera una chiave dell'account di servizio archiviata in un file JSON denominato key.json nella tua home directory.

Utilizzando il percorso assoluto della chiave generata, imposta una variabile di ambiente per la chiave del service account in Cloud Shell:

export GOOGLE_APPLICATION_CREDENTIALS="/home/${USER}/key.json"

Puoi scoprire di più sull'autenticazione dell'API Vision.

Avvio dell'ambiente virtuale e installazione delle dipendenze

Crea un ambiente Python 3 isolato denominato env con virtualenv:

virtualenv -p python3 env

Inserisci l'ambiente virtualenv appena creato denominato env:

source env/bin/activate

Utilizza pip per installare le dipendenze per il tuo progetto dal file requirements.txt:

pip install -r requirements.txt

Il file requirements.txt è un elenco delle dipendenze dei pacchetti necessarie per il tuo progetto. Il comando precedente ha scaricato tutte le dipendenze dei pacchetti elencati in virtualenv.

Creazione di un'app App Engine

Successivamente, crea un'istanza App Engine utilizzando:

gcloud app create

Creazione di un bucket di archiviazione

Innanzitutto, imposta la variabile di ambiente CLOUD_STORAGE_BUCKET uguale al nome del tuo PROJECT_ID. Per comodità, in genere è consigliabile assegnare al bucket lo stesso nome dell'PROJECT_ID.

export CLOUD_STORAGE_BUCKET=${PROJECT_ID}

La nostra applicazione utilizza un bucket Cloud Storage, che dovrai creare da Cloud Shell con uno strumento chiamato gsutil. Esegui il comando seguente, che crea un bucket con lo stesso nome del tuo PROJECT_ID.

gsutil mb gs://${PROJECT_ID}

Esecuzione dell'applicazione

python main.py

Una volta avviata l'applicazione, fai clic sull'icona Anteprima web nella barra degli strumenti di Cloud Shell e scegli "Anteprima sulla porta 8080".

Si apre una scheda nel browser e si connette al server appena avviato. Il risultato dovrebbe essere simile a questo:

Screen Shot 2017-02-23 at 7.22.50 PM.png

Prova a caricare una foto che contenga un volto umano. Fai clic sul pulsante Scegli file, scegli un'immagine dal computer e poi fai clic su Invia.

Dopo aver caricato una foto, dovresti vedere qualcosa di simile a questo:

Screen Shot 2017-02-23 at 7.32.08 PM.png

Layout del codice di esempio

L'esempio ha il layout seguente:

templates/
  homepage.html   /* HTML template that uses Jinja2 */
app.yaml          /* App Engine application configuration file */
main.py           /* Python Flask web application */
requirements.txt  /* List of dependencies for the project */

main.py

Questo file Python è un'applicazione web Flask. L'applicazione consente agli utenti di inviare foto (preferibilmente di volti), che vengono archiviate in Cloud Storage e analizzate utilizzando la funzionalità di rilevamento dei volti dell'API Cloud Vision. Le informazioni chiave su ogni foto vengono archiviate in Datastore, il database NoSQL di Google Cloud Platform, a cui si accede ogni volta che un utente visita il sito web.

Questa applicazione utilizza le librerie client di Google Cloud Platform per Storage, Datastore e Vision. Queste librerie client semplificano l'accesso alle API Cloud dai tuoi linguaggi di programmazione preferiti.

Diamo un'occhiata ad alcuni snippet chiave del codice.

La sezione delle importazioni in alto è dove importiamo i vari pacchetti necessari per il nostro codice. Ecco come importiamo le nostre librerie client Google Cloud per Datastore, Storage e Vision:

from google.cloud import datastore
from google.cloud import storage
from google.cloud import vision

Ecco il codice di ciò che accade quando un utente visita l'URL principale del sito web. Creiamo un oggetto client Datastore, che viene utilizzato per accedere alla libreria client Datastore. Quindi eseguiamo una query su Datastore per le entità di tipo Faces. Infine, eseguiamo il rendering del nostro modello HTML, passando le image_entities che estraiamo da Datastore come variabile.

@app.route('/')
def homepage():
    # Create a Cloud Datastore client.
    datastore_client = datastore.Client()

    # Use the Cloud Datastore client to fetch information from Datastore about
    # each photo.
    query = datastore_client.query(kind='Faces')
    image_entities = list(query.fetch())

    # Return a Jinja2 HTML template and pass in image_entities as a parameter.
    return render_template('homepage.html', image_entities=image_entities)

Vediamo come vengono salvate le entità in Datastore. Datastore è la soluzione di database NoSQL di Google Cloud. I dati vengono archiviati in oggetti chiamati entità. A ogni entità viene assegnata una chiave identificativa univoca, che può essere creata utilizzando una stringa kind e una stringa nome chiave. Un tipo è un bucket organizzativo per il tipo di entità. Ad esempio, potremmo voler configurare tipi per Foto, Persone e Animali.

Ogni entità può avere più proprietà definite dallo sviluppatore, che possono avere valori di diversi tipi, tra cui numeri interi, numeri in virgola mobile, stringhe, date o dati binari.

    # Create a Cloud Datastore client.
    datastore_client = datastore.Client()

    # Fetch the current date / time.
    current_datetime = datetime.now()

    # The kind for the new entity.
    kind = 'Faces'

    # The name/ID for the new entity.
    name = blob.name

    # Create the Cloud Datastore key for the new entity.
    key = datastore_client.key(kind, name)

    # Construct the new entity using the key. Set dictionary values for entity
    # keys blob_name, storage_public_url, timestamp, and joy.
    entity = datastore.Entity(key)
    entity['blob_name'] = blob.name
    entity['image_public_url'] = blob.public_url
    entity['timestamp'] = current_datetime
    entity['joy'] = face_joy

    # Save the new entity to Datastore.
    datastore_client.put(entity)

È possibile accedere alle librerie client Storage e Vision in modo programmatico in modo simile a Datastore. Puoi aprire il file main.py utilizzando vim, emacs o nano per esplorare tutto il codice di esempio.

Scopri di più su Flask all'indirizzo http://flask.pocoo.org/.

Scopri di più sulle librerie client all'indirizzo https://googlecloudplatform.github.io/google-cloud-python/.

homepage.html

Il framework web Flask utilizza Jinja2 come motore di modelli. In questo modo possiamo passare variabili ed espressioni da main.py a homepage.html, che vengono sostituite con i valori una volta eseguito il rendering della pagina.

Scopri di più su Jinja2 all'indirizzo http://jinja.pocoo.org/docs/2.9/templates/.

Questo modello HTML Jinja2 mostra un modulo in cui gli utenti possono inviare foto al database. Mostra anche ogni immagine inviata in precedenza insieme al nome del file, alla data/ora di caricamento e alla probabilità che il volto rilevato dall'API Vision sia felice.

homepage.html

<h1>Google Cloud Platform - Face Detection Sample</h1>

<p>This Python Flask application demonstrates App Engine Flexible, Google Cloud
Storage, Datastore, and the Cloud Vision API.</p>

<br>

<html>
  <body>
    <form action="upload_photo" method="POST" enctype="multipart/form-data">
      Upload File: <input type="file" name="file"><br>
      <input type="submit" name="submit" value="Submit">
    </form>
    
  </body>
</html>

App Engine Flexible utilizza un file denominato app.yaml per descrivere la configurazione di deployment di un'applicazione. Se questo file non è presente, App Engine tenterà di indovinare la configurazione di deployment. Tuttavia, è consigliabile fornire questo file.

Successivamente, modificherai app.yaml utilizzando un editor a tua scelta: vim, nano o emacs. Utilizzeremo l'editor nano:

nano app.yaml

app.yaml

runtime: python
env: flex
entrypoint: gunicorn -b :$PORT main:app

runtime_config:
    python_version: 3

env_variables:
    CLOUD_STORAGE_BUCKET: <your-cloud-storage-bucket>

Questa è la configurazione di base necessaria per eseguire il deployment di un'applicazione Python 3 App Engine Flex. Puoi scoprire di più sulla configurazione di App Engine qui.

Una volta aperto app.yaml, sostituisci < your-cloud-storage-bucket > con il nome del tuo bucket Cloud Storage. Se hai dimenticato il nome del bucket Cloud Storage, copia l'ID progetto GCP da Qwiklabs, che è lo stesso. La sezione env_variables configura le variabili di ambiente che verranno utilizzate in main.py una volta eseguito il deployment dell'applicazione.

Ora puoi salvare e chiudere il file in nano utilizzando (Ctrl + x), che ti chiederà:

Screen Shot 2017-02-17 at 4.47.12 PM.png

Digita la lettera y e premi di nuovo il tasto INVIO per confermare il nome del file per il seguente prompt:

Screen Shot 2017-02-24 at 4.18.23 PM.png

Esegui il deployment dell'app su App Engine utilizzando gcloud:

gcloud app deploy

Dopo il deployment dell'applicazione, puoi visitarla aprendo l'URL https://< PROJECT_ID >.appspot.com nel browser web.

Riepilogo

In questo passaggio, hai configurato un'applicazione web Python e ne hai eseguito il deployment nell'ambiente flessibile di App Engine.

Hai imparato a scrivere ed eseguire il deployment della tua prima applicazione web flessibile di App Engine.

Esegui la pulizia

Per evitare che al tuo account Google Cloud Platform vengano addebitate le risorse utilizzate in questa guida rapida, procedi come segue.

  • Vai alla console di Cloud Platform.
  • Seleziona il progetto che vuoi chiudere, quindi fai clic su "Elimina" in alto: il progetto viene pianificato per l'eliminazione.

Scopri di più

Licenza

Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.