Sviluppo InnerLoop mediante Cloud Workstations con Python

1. Panoramica

Questo lab mostra le funzionalità e le capacità progettate per semplificare il flusso di lavoro di sviluppo per gli ingegneri software incaricati di sviluppare applicazioni Python in un ambiente containerizzato. Il tipico sviluppo di container richiede all'utente di comprendere i dettagli dei container e il processo di compilazione dei container. Inoltre, gli sviluppatori in genere devono interrompere il flusso di lavoro, uscire dall'IDE per testare ed eseguire il debug delle applicazioni in ambienti remoti. Con gli strumenti e le tecnologie menzionati in questo tutorial, gli sviluppatori possono lavorare in modo efficace con le applicazioni in contenitori senza uscire dall'IDE.

Cosa imparerai a fare

In questo lab imparerai i metodi per sviluppare con i container in Google Cloud, tra cui:

• Creazione di una nuova applicazione Python iniziale
• Esaminare la procedura di sviluppo
• Sviluppare un semplice servizio REST CRUD
• Deployment in GKE
• Eseguire il debug di uno stato di errore
• Utilizzo di punti di interruzione / log
• Deployment a caldo delle modifiche in GKE

2. Configurazione e requisiti

Configurazione dell'ambiente autonomo

1. Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

• Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi aggiornarlo in qualsiasi momento.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (in genere è identificato come PROJECT_ID). Se non ti piace l'ID generato, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimarrà per tutta la durata del progetto.
• Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da altri dopo che lo hai selezionato. Sei l'unico utente di questo ID. Anche se un progetto viene eliminato, l'ID non potrà mai più essere utilizzato

Nota:se utilizzi un account Gmail, puoi lasciare la località predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

2. Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. L'esecuzione di questo codelab non dovrebbe costare molto, se non nulla. Per arrestare le risorse in modo da non incorrere in costi di fatturazione al termine di questo tutorial, puoi eliminare le risorse che hai creato o l'intero progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Avvia l'editor di Cloud Shell

Questo lab è stato progettato e testato per l'utilizzo con l'editor di Google Cloud Shell. Per accedere all'editor:

1. accedi al tuo progetto Google all'indirizzo https://console.cloud.google.com.
2. Nell'angolo in alto a destra, fai clic sull'icona dell'editor Cloud Shell.

3. Si aprirà un nuovo riquadro nella parte inferiore della finestra.
4. Fai clic sul pulsante Apri editor.

5. L'editor si aprirà con un explorer a destra e l'editor nell'area centrale
6. Nella parte inferiore dello schermo dovrebbe essere disponibile anche un riquadro del terminale
7. Se il terminale NON è aperto, utilizza la combinazione di tasti "Ctrl + `" per aprire una nuova finestra del terminale.

Configurazione dell'ambiente

In Cloud Shell, imposta l'ID progetto e il numero del tuo progetto. Salvali come variabili PROJECT_ID e PROJECT_ID.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format='value(projectNumber)')

Esegui il provisioning dell'infrastruttura utilizzata in questo lab

In questo lab eseguirai il deployment del codice in GKE e accederai ai dati archiviati in un database Spanner. Utilizzerai anche Cloud Workstations come IDE. Lo script di configurazione riportato di seguito prepara questa infrastruttura per te.

1. Scarica lo script di configurazione e rendilo eseguibile.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/setup_with_cw.sh
chmod +x setup_with_cw.sh

2. Apri il file setup_with_cw.sh e modifica i valori delle password attualmente impostate su CHANGEME
3. Esegui lo script di configurazione per creare un cluster GKE e un database Spanner che utilizzerai in questo lab

./setup_with_cw.sh &

Cluster Cloud Workstations

1. Apri Cloud Workstations in Cloud Console. Attendi che il cluster sia nello stato READY.

Crea configurazione workstation

1. Se la sessione di Cloud Shell è stata disconnessa, fai clic su "Riconnetti" e poi esegui il comando gcloud CLI per impostare l'ID progetto. Prima di eseguire il comando, sostituisci l'ID progetto di esempio riportato di seguito con il tuo ID progetto Qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

2. Scarica ed esegui lo script riportato di seguito nel terminale per creare la configurazione di Cloud Workstations.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/workstation_config_setup.sh
chmod +x workstation_config_setup.sh
./workstation_config_setup.sh

3. Verifica i risultati nella sezione Configurazioni. Il passaggio allo stato PRONTO richiederà 2 minuti.

4. Apri Cloud Workstations nella console e crea una nuova istanza.

5. Modifica il nome in my-workstation e seleziona la configurazione esistente: codeoss-python.

6. Verifica i risultati nella sezione Workstation.

Avvia workstation

1. Avvia la workstation. L'avvio della workstation richiede un paio di minuti.

2. Consenti i cookie di terze parti facendo clic sull'icona nella barra degli indirizzi.

3. Fai clic su "Il sito non funziona?".

4. Fai clic su "Consenti cookie".

5. Una volta avviata la workstation, viene visualizzato l'IDE Code OSS. Fai clic su "Mark Done" (Segna come completato) nella pagina Getting Started (Guida introduttiva) dell'IDE della workstation.

3. Crea una nuova applicazione iniziale Python

In questa sezione creerai una nuova applicazione Python.

1. Apri un nuovo terminale.

2. Crea una nuova directory e aprila come workspace

mkdir music-service && cd music-service

code-oss-cloud-workstations -r --folder-uri="$PWD"

Se visualizzi questo messaggio, fai clic sul pulsante Consenti per poter copiare e incollare nella workstation.

3. Crea un file denominato requirements.txt e copia al suo interno i seguenti contenuti:

Flask
gunicorn
google-cloud-spanner
ptvsd==4.3.2

4. Crea un file denominato app.py e incolla il seguente codice al suo interno

import os
from flask import Flask, request, jsonify
from google.cloud import spanner

app = Flask(__name__)

@app.route("/")
def hello_world():
    message="Hello, World!"
    return message

if __name__ == '__main__':
    server_port = os.environ.get('PORT', '8080')
    app.run(debug=False, port=server_port, host='0.0.0.0')

5. Crea un file denominato Dockerfile e incolla al suo interno quanto segue

FROM python:3.8
ARG FLASK_DEBUG=0
ENV FLASK_DEBUG=$FLASK_DEBUG
ENV FLASK_APP=app.py
WORKDIR /app
COPY requirements.txt .
RUN pip install --trusted-host pypi.python.org -r requirements.txt
COPY . .
ENTRYPOINT ["python3", "-m", "flask", "run", "--port=8080", "--host=0.0.0.0"]

Nota: FLASK_DEBUG=1 consente di ricaricare automaticamente le modifiche al codice in un'app Flask Python. Questo Dockerfile consente di passare questo valore come argomento di build.

Genera manifest

Nel terminale, esegui questo comando per generare un file skaffold.yaml e deployment.yaml predefinito

1. Inizializza Skaffold con il seguente comando

skaffold init --generate-manifests

Quando ti viene chiesto, utilizza le frecce per spostare il cursore e la barra spaziatrice per selezionare le opzioni.

Scegli:

• 8080 per il porto
• y per salvare la configurazione.

Aggiorna le configurazioni di Skaffold

• Modificare il nome dell'applicazione predefinita
• Apri skaffold.yaml
• Seleziona il nome dell'immagine attualmente impostata come dockerfile-image
• Fai clic con il tasto destro del mouse e scegli Modifica tutte le occorrenze.
• Digita il nuovo nome come python-app
• Modifica ulteriormente la sezione di creazione per
• aggiungi docker.buildArgs alla tessera FLASK_DEBUG=1
• Sincronizza le impostazioni per caricare le modifiche ai file *.py dall'IDE al contenitore in esecuzione

Dopo le modifiche, la sezione build del file skaffold.yaml sarà la seguente:

build:
 artifacts:
 - image: python-app
   docker:
     buildArgs:
       FLASK_DEBUG: "1"
     dockerfile: Dockerfile
   sync:
     infer:
     - '**/*.py'

Modifica del file di configurazione di Kubernetes

1. Modificare il nome predefinito

• Apri il file deployment.yaml
• Seleziona il nome dell'immagine attualmente impostata come dockerfile-image
• Fai clic con il tasto destro del mouse e scegli Modifica tutte le occorrenze.
• Digita il nuovo nome come python-app

4. Esaminare il processo di sviluppo

Ora che hai aggiunto la logica di business, puoi eseguire il deployment e testare l'applicazione. La sezione seguente mostrerà l'utilizzo del plug-in Cloud Code. Tra le altre cose, questo plug-in si integra con Skaffold per semplificare il processo di sviluppo. Quando esegui il deployment in GKE nei passaggi successivi, Cloud Code e Skaffold creeranno automaticamente l'immagine container, eseguiranno il push in Container Registry e poi eseguiranno il deployment dell'applicazione your in GKE. Questa operazione avviene dietro le quinte, astraendo i dettagli dal flusso dello sviluppatore.

Accedi a Google Cloud

1. Fai clic sull'icona di Cloud Code e seleziona "Accedi a Google Cloud":

2. Fai clic su "Procedi all'accesso".

3. Controlla l'output nel terminale e apri il link:

4. Accedi con le credenziali degli studenti Qwiklabs.

5. Seleziona "Consenti":

6. Copia il codice di verifica e torna alla scheda Workstation.

7. Incolla il codice di verifica e premi Invio.

Aggiungi cluster Kubernetes

1. Aggiungere un cluster

2. Seleziona Google Kubernetes Engine:

3. Seleziona il progetto.

4. Seleziona "python-cluster" creato nella configurazione iniziale.

5. Il cluster ora viene visualizzato nell'elenco dei cluster Kubernetes in Cloud Code. Naviga ed esplora il cluster da qui.

Imposta l'ID progetto corrente utilizzando gcloud CLI

1. Copia l'ID progetto per questo lab dalla pagina di Qwiklabs.

2. Dal terminale, esegui il comando gcloud CLI per impostare l'ID progetto. Sostituisci l'ID progetto di esempio prima di eseguire il comando. SOSTITUISCI l'ID progetto prima di eseguire il comando riportato di seguito.

gcloud config set project qwiklabs-gcp-project-id

Eseguire il deployment in Kubernetes

1. Nel riquadro in fondo all'editor di Cloud Shell, seleziona Cloud Code. 

2. Nel riquadro visualizzato in alto, seleziona Esegui su Kubernetes. Se richiesto, seleziona Sì per utilizzare il contesto Kubernetes attuale.

Questo comando avvia una build del codice sorgente e poi esegue i test. L'esecuzione della build e dei test richiederà alcuni minuti. Questi test includono test unitari e un passaggio di convalida che verifica le regole impostate per l'ambiente di deployment. Questo passaggio di convalida è già configurato e ti avvisa dei problemi di deployment anche mentre lavori ancora nel tuo ambiente di sviluppo.

3. La prima volta che esegui il comando, nella parte superiore dello schermo viene visualizzato un prompt che ti chiede se vuoi utilizzare il contesto Kubernetes attuale. Seleziona "Sì" per accettare e utilizzare il contesto attuale.
4. Successivamente, verrà visualizzato un prompt che chiede quale registro dei container utilizzare. Premi Invio per accettare il valore predefinito fornito.
5. Seleziona la scheda "Output" nel riquadro inferiore per visualizzare l'avanzamento e le notifiche. Utilizza il menu a discesa per selezionare "Kubernetes: Run/Debug" (Kubernetes: esegui/debug).

6. Seleziona "Kubernetes: Run/Debug - Detailed" (Kubernetes: esecuzione/debug - dettagliato) nel menu a discesa del canale a destra per visualizzare ulteriori dettagli e i log in streaming live dai container.

Al termine della build e dei test, i log della scheda Output con l'URL http://localhost:8080 sono elencati nella visualizzazione "Kubernetes: Run/Debug".

7. Nel terminale Cloud Code, passa il mouse sopra il primo URL nell'output (http://localhost:8080) e poi seleziona Apri anteprima web nel suggerimento visualizzato.
8. Si aprirà una nuova scheda del browser in cui verrà visualizzato il messaggio Hello, World!

Ricaricamento rapido

1. Apri il file app.py
2. Modifica il messaggio di saluto in Hello from Python

Nota immediatamente che nella finestra Output, nella visualizzazione Kubernetes: Run/Debug, il watcher sincronizza i file aggiornati con il container in Kubernetes

Update initiated
Build started for artifact python-app
Build completed for artifact python-app

Deploy started
Deploy completed

Status check started
Resource pod/python-app-6f646ffcbb-tn7qd status updated to In Progress
Resource deployment/python-app status updated to In Progress
Resource deployment/python-app status completed successfully
Status check succeeded
...

3. Se passi alla visualizzazione Kubernetes: Run/Debug - Detailed, noterai che riconosce le modifiche ai file, quindi crea ed esegue nuovamente il deployment dell'app.

files modified: [app.py]
Syncing 1 files for gcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Copying files:map[app.py:[/app/app.py]]togcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Watching for changes...
[python-app] * Detected change in '/app/app.py', reloading
[python-app] * Restarting with stat
[python-app] * Debugger is active!
[python-app] * Debugger PIN: 744-729-662

4. Aggiorna la scheda del browser in cui hai visualizzato i risultati precedenti per visualizzare i risultati aggiornati.

Debug

1. Vai alla visualizzazione Debug e interrompi il thread corrente . Se ti viene chiesto, puoi scegliere di liberare spazio dopo ogni esecuzione.
2. 
3. Fai clic su Cloud Code nel menu in basso e seleziona Debug on Kubernetes per eseguire l'applicazione in modalità debug.

• Nella visualizzazione Kubernetes Run/Debug - Detailed della finestra Output, nota che Skaffold eseguirà il deployment di questa applicazione in modalità di debug.

4. Al termine della procedura. Noterai un debugger collegato e la scheda Output indica: Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully. e l'URL http://localhost:8080 è elencato.

Port forwarding pod/python-app-8bd64cf8b-cskfl in namespace default, remote port 5678 -> http://127.0.0.1:5678

5. Il colore della barra di stato inferiore cambia da blu ad arancione, indicando che è in modalità di debug.
6. Nella visualizzazione Kubernetes Run/Debug, nota che viene avviato un container di cui è possibile eseguire il debug

**************URLs*****************
Forwarded URL from service python-app: http://localhost:8080
Debuggable container started pod/python-app-8bd64cf8b-cskfl:python-app (default)
Update succeeded
***********************************

Utilizzare i punti di interruzione

1. Apri il file app.py
2. Individua l'istruzione return message.
3. Aggiungi un punto di interruzione a quella riga facendo clic sullo spazio vuoto a sinistra del numero di riga. Viene visualizzato un indicatore rosso per indicare che il punto di interruzione è impostato
4. La prima volta che viene eseguito, un prompt chiede dove si trova l'origine all'interno del container. Questo valore è correlato alle directory nel Dockerfile.

Premi Invio per accettare il valore predefinito

La creazione e il deployment dell'applicazione richiedono un paio di minuti.

5. Ricarica il browser e nota che il debugger interrompe il processo nel punto di interruzione e ti consente di esaminare le variabili e lo stato dell'applicazione in esecuzione in remoto in GKE
6. Fai clic sulla sezione VARIABILI.
7. Fai clic su Locals (Variabili locali) per trovare la variabile "message".
8. Fai doppio clic sul nome della variabile "message" e, nel popup, cambia il valore in qualcosa di diverso, ad esempio "Greetings from Python"
9. Fai clic sul pulsante Continua nel pannello di controllo del debug
10. Controlla la risposta nel browser, che ora mostra il valore aggiornato appena inserito.
11. Arresta la modalità "Debug" premendo il pulsante di arresto e rimuovi il punto di interruzione facendo di nuovo clic su di esso.

5. Sviluppo di un semplice servizio REST CRUD

A questo punto, l'applicazione è completamente configurata per lo sviluppo containerizzato e hai esaminato il flusso di lavoro di sviluppo di base con Cloud Code. Nelle sezioni seguenti metterai in pratica ciò che hai imparato aggiungendo endpoint del servizio REST che si connettono a un database gestito in Google Cloud.

Codifica il servizio REST

Il codice riportato di seguito crea un semplice servizio REST che utilizza Spanner come database di backend dell'applicazione. Crea l'applicazione copiando il seguente codice.

1. Crea l'applicazione principale sostituendo app.py con i seguenti contenuti

import os
from flask import Flask, request, jsonify
from google.cloud import spanner


app = Flask(__name__)


instance_id = "music-catalog"

database_id = "musicians"

spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)


@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

@app.route('/singer', methods=['POST'])
def create():
    try:
        request_json = request.get_json()
        singer_id = request_json['singer_id']
        first_name = request_json['first_name']
        last_name = request_json['last_name']
        def insert_singers(transaction):
            row_ct = transaction.execute_update(
                f"INSERT Singers (SingerId, FirstName, LastName) VALUES" \
                f"({singer_id}, '{first_name}', '{last_name}')"
            )
            print("{} record(s) inserted.".format(row_ct))

        database.run_in_transaction(insert_singers)

        return {"Success": True}, 200
    except Exception as e:
        return e



@app.route('/singer', methods=['GET'])
def get_singer():

    try:
        singer_id = request.args.get('singer_id')
        def get_singer():
            first_name = ''
            last_name = ''
            with database.snapshot() as snapshot:
                results = snapshot.execute_sql(
                    f"SELECT SingerId, FirstName, LastName FROM Singers " \
                    f"where SingerId = {singer_id}",
                    )
                for row in results:
                    first_name = row[1]
                    last_name = row[2]
                return (first_name,last_name )
        first_name, last_name = get_singer()  
        return {"first_name": first_name, "last_name": last_name }, 200
    except Exception as e:
        return e


@app.route('/singer', methods=['PUT'])
def update_singer_first_name():
    try:
        singer_id = request.args.get('singer_id')
        request_json = request.get_json()
        first_name = request_json['first_name']
        
        def update_singer(transaction):
            row_ct = transaction.execute_update(
                f"UPDATE Singers SET FirstName = '{first_name}' WHERE SingerId = {singer_id}"
            )

            print("{} record(s) updated.".format(row_ct))

        database.run_in_transaction(update_singer)
        return {"Success": True}, 200
    except Exception as e:
        return e


@app.route('/singer', methods=['DELETE'])
def delete_singer():
    try:
        singer_id = request.args.get('singer')
    
        def delete_singer(transaction):
            row_ct = transaction.execute_update(
                f"DELETE FROM Singers WHERE SingerId = {singer_id}"
            )
            print("{} record(s) deleted.".format(row_ct))

        database.run_in_transaction(delete_singer)
        return {"Success": True}, 200
    except Exception as e:
        return e

port = int(os.environ.get('PORT', 8080))
if __name__ == '__main__':
    app.run(threaded=True, host='0.0.0.0', port=port)

Aggiungere configurazioni del database

Per connetterti a Spanner in modo sicuro, configura l'applicazione in modo che utilizzi Workload Identity. In questo modo, la tua applicazione può fungere da account di servizio e disporre di autorizzazioni individuali per accedere al database.

1. Aggiorna deployment.yaml. Aggiungi il seguente codice alla fine del file (assicurati di mantenere i rientri delle schede nell'esempio riportato di seguito)

      serviceAccountName: python-ksa
      nodeSelector:
        iam.gke.io/gke-metadata-server-enabled: "true" 

Dopo le modifiche, la sezione delle specifiche dovrebbe avere il seguente aspetto

   spec:
     containers:
     - name: python-app
       image: python-app
     serviceAccountName: python-ksa
     nodeSelector:
       iam.gke.io/gke-metadata-server-enabled: "true"

Esegui il deployment e convalida l'applicazione

1. Nel riquadro in basso di Cloud Shell Editor, seleziona Cloud Code, poi seleziona Debug on Kubernetes nella parte superiore dello schermo.
2. Al termine della build e dei test, nella scheda Output viene visualizzato il messaggio Resource deployment/python-app status completed successfully e un URL: "Forwarded URL from service python-app: http://localhost:8080"
3. Aggiungi un paio di voci.

Dal terminale Cloud Shell, esegui il comando riportato di seguito.

curl -X POST http://localhost:8080/singer -H 'Content-Type: application/json' -d '{"first_name":"Cat","last_name":"Meow", "singer_id": 6}'

4. Prova il metodo GET eseguendo il comando riportato di seguito nel terminale.

curl -X GET http://localhost:8080/singer?singer_id=6

5. Test di eliminazione: ora prova a eliminare una voce eseguendo questo comando. Modifica il valore di item-id, se necessario.

curl -X DELETE http://localhost:8080/singer?singer_id=6

    This throws an error message

500 Internal Server Error

Identificare e risolvere il problema

1. Modalità di debug e individua il problema. Ecco alcuni suggerimenti:

• Sappiamo che c'è qualcosa che non va con l'eliminazione, in quanto non restituisce il risultato desiderato. Quindi, imposteresti il punto di interruzione in app.py nel metodo delete_singer.
• Esegui l'esecuzione passo passo e osserva le variabili in ogni passaggio per visualizzare i valori delle variabili locali nella finestra a sinistra.
• Per osservare valori specifici come singer_id e request.args, aggiungi queste variabili alla finestra Espressioni di controllo.

2. Tieni presente che il valore assegnato a singer_id è None. Modifica il codice per risolvere il problema.

Lo snippet di codice corretto sarà simile al seguente.

@app.route('/delete-singer', methods=['DELETE', 'GET'])
def delete_singer():
    try:
        singer_id = request.args.get('singer_id')

3. Una volta riavviata l'applicazione, riprova a eliminare.
4. Interrompi la sessione di debug facendo clic sul quadrato rosso nella barra degli strumenti di debug

6. Esegui la pulizia

Complimenti! In questo lab hai creato una nuova applicazione Python da zero e l'hai configurata per funzionare in modo efficace con i container. Successivamente, hai eseguito il deployment e il debug dell'applicazione in un cluster GKE remoto seguendo lo stesso flusso di sviluppo presente negli stack di applicazioni tradizionali.

Per liberare spazio dopo aver completato il lab:

1. Eliminare i file utilizzati nel lab

cd ~ && rm -rf ~/music-service

2. Elimina il progetto per rimuovere tutte le infrastrutture e le risorse correlate