Ambiente di sviluppo

1. Panoramica

Questo lab illustra caratteristiche e funzionalità progettate per semplificare il flusso di lavoro di sviluppo per i tecnici del software incaricati di sviluppare applicazioni Python in un ambiente containerizzato. Lo sviluppo tipico dei container richiede che l'utente comprenda i dettagli dei container e del processo di compilazione dei container. Inoltre, gli sviluppatori in genere devono interrompere il flusso, uscendo dal loro IDE per testare ed eseguire il debug delle loro applicazioni in ambienti remoti. Con gli strumenti e le tecnologie menzionati in questo tutorial, gli sviluppatori possono lavorare in modo efficace con le applicazioni containerizzate senza uscire dall'IDE.

Che cos'è Cloud Workstations?

Cloud Workstations fornisce ambienti di sviluppo gestiti su Google Cloud con sicurezza integrata e ambienti di sviluppo preconfigurati, ma personalizzabili. Accedi a Cloud Workstations tramite un IDE basato su browser da più editor di codice locali (come gli IDE VSCode o JetBrains come IntelliJ IDEA Ultimate e PyCharm Professional) o tramite SSH.

Cloud Workstations utilizza le seguenti risorse:

• Gli amministratori creano cluster di workstation
• In ogni cluster di workstation, gli amministratori creano una o più configurazioni di workstation che fungono da modelli per le workstation.
• Gli sviluppatori possono creare workstation che definiscono ambienti di sviluppo che forniscono un IDE Cloud, strumenti per il linguaggio, librerie e altro ancora.

Cloud Workstations consente agli amministratori IT e della sicurezza di eseguire facilmente il provisioning, scalare, gestire e proteggere i propri ambienti di sviluppo e consente agli sviluppatori di accedere agli ambienti di sviluppo con configurazioni coerenti e strumenti personalizzabili.

Cloud Workstations contribuisce a modificare il livello di sicurezza migliorando la condizione di sicurezza degli ambienti di sviluppo delle applicazioni. Include funzionalità di sicurezza come Controlli di servizio VPC, traffico privato in entrata o in uscita, aggiornamento forzato delle immagini e criteri di accesso a Identity and Access Management.

Che cos'è Cloud Code?

Cloud Code fornisce il supporto IDE per l'intero ciclo di sviluppo delle applicazioni Kubernetes e Cloud Run, dalla creazione e dalla personalizzazione di una nuova applicazione, dai modelli di esempio all'esecuzione dell'applicazione completa. Cloud Code ti supporta lungo il percorso con esempi pronti per l'esecuzione, snippet di configurazione pronti all'uso e un'esperienza di debug su misura, semplificando lo sviluppo con Kubernetes e Cloud Run.

Ecco alcune delle funzionalità di Cloud Code:

• Crea ed esegui applicazioni in modo continuo
• Il supporto del debug per l'applicazione Kubernetes in fase di sviluppo
• Streaming e visualizzazione dei log

Scopri di più su altre funzionalità di Cloud Code.

Cosa imparerai a fare

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

• Esamina Cloud Workstations
• Avvia workstation
• Rivedi Cloud Code
• Debug su Kubernetes

2. Configurazione e requisiti

Configurazione dell'ambiente autogestito

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 progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi aggiornarla in qualsiasi momento.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere è identificato come PROJECT_ID). Se l'ID generato non ti soddisfa, puoi generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimarrà per tutta la durata del progetto.
• Per informazione, c'è 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 nessun altro utente dopo essere stato selezionato. Sei l'unico utente di quell'ID. Anche se un progetto viene eliminato, l'ID non può più essere riutilizzato

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

2. Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. Eseguire questo codelab non dovrebbe costare molto. Per arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial, puoi eliminare le risorse che hai creato o eliminare l'intero progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Configurazione dell'ambiente

In Cloud Shell, imposta l'ID e il numero del progetto. Salvale 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)')

In questo lab eseguirai il deployment del codice su GKE. Utilizzerai anche le workstation Cloud come IDE.

Lo script di configurazione riportato di seguito prepara l'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 che utilizzerai in questo lab. Questa configurazione richiederà circa 20 minuti.

./setup_with_cw.sh &

4. Apri Cloud Workstations nella console Cloud. Attendi che il cluster si trovi nello stato READY prima di andare ai passaggi successivi.
5. Se la sessione di Cloud Shell è stata disconnessa, fai clic su "Riconnetti" quindi esegui il comando gcloud cli per impostare l'ID progetto. Sostituisci l'ID progetto di esempio riportato di seguito con il tuo ID progetto qwiklabs prima di eseguire il comando.

gcloud config set project qwiklabs-gcp-project-id

6. Scarica ed esegui lo script seguente 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

Cluster e configurazione di Cloud Workstations

Apri Cloud Workstations nella console Cloud. Verifica che lo stato del cluster sia READY.

Verifica lo stato delle configurazioni esistenti.

Crea una nuova workstation.

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

Avvia workstation

1. Avvia e avvia la workstation. L'avvio della workstation richiederà qualche istante.

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

3. Fai clic su "Sito non funzionante?".

4. Fai clic su "Accetta i cookie".

5. Una volta avviata la workstation, verrà visualizzato l'IDE Code OSS.

Fai clic su "Segna come completato". nella pagina Getting Started (Per iniziare) l'IDE

3. Panoramica di Cloud Code

Esamina le diverse sezioni disponibili in Cloud Code.

• Sviluppo in Kubernetes. Approfitta di un ambiente di sviluppo e debug di Kubernetes completamente integrato all'interno del tuo IDE. Crea e gestisci i cluster direttamente dall'interno dell'IDE.
• Debug delle applicazioni in esecuzione. Esegui il debug del codice all'interno degli IDE utilizzando Cloud Code for VS Code e Cloud Code for IntelliJ, sfruttando le funzionalità di debug integrate dell'IDE.
• Esplora i deployment. Visualizza le risorse e i metadati sottostanti per i tuoi cluster Kubernetes e i servizi Cloud Run. Puoi recuperare una descrizione, visualizzare i log, gestire i secret o inserire un terminale direttamente in un pod.
• Semplifica lo sviluppo locale in Kubernetes. Cloud Code per IDE utilizza strumenti diffusi come Skaffold, Jib e kubectl per fornire feedback continui sul codice in tempo reale.

Accedi a Google Cloud

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

2. Fai clic su "Procedi per accedere".

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

4. Accedi con le tue credenziali Qwiklabs per studenti.

5. Seleziona "Consenti":

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

7. Incolla il codice di verifica e premi Invio.

Fai clic sul pulsante "Consenti" se viene visualizzato questo messaggio, che consente di copiare e incollare i dati nella workstation.

4. 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 spazio di lavoro

mkdir music-service && cd music-service

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

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

Flask
gunicorn
ptvsd==4.3.2

4. Crea un file denominato app.py e incollaci il codice seguente

import os
from flask import Flask, request, jsonify

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 incollaci il seguente codice

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 tuo terminale, esegui questo comando per generare skaffold.yaml e deployment.yaml predefiniti

1. Inizializza Skaffold con il seguente comando

skaffold init --generate-manifests

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

Scegli:

• 8080 per la porta
• y per salvare la configurazione

Aggiornamento configurazioni Skaffold

• Modificare il nome predefinito dell'applicazione
• Apri skaffold.yaml
• Seleziona il nome dell'immagine attualmente impostato su 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 relativa alla build in
• aggiungi docker.buildArgs per superare FLASK_DEBUG=1
• Sincronizza le impostazioni per caricare eventuali modifiche ai file *.py dall'IDE al contenitore in esecuzione

Dopo le modifiche, la sezione di compilazione nel file skaffold.yaml sarebbe quella seguente:

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

Modifica file di configurazione Kubernetes

1. Modificare il nome predefinito

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

5. Panoramica del processo di sviluppo

Con la logica di business aggiunta, ora puoi eseguire il deployment e testare la tua applicazione. La seguente sezione illustra 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 su GKE nei passaggi seguenti, Cloud Code e Skaffold creano automaticamente l'immagine container, ne eseguono il push a un Container Registry e quindi eseguono il deployment dell'applicazione your su GKE. Ciò avviene dietro le quinte, astraendo i dettagli dal flusso degli sviluppatori.

Aggiungi cluster Kubernetes

1. Aggiungi un cluster

2. Seleziona Google Kubernetes Engine:

3. Seleziona progetto.

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

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

Eseguire il deployment in Kubernetes

1. Nel riquadro nella parte inferiore dell'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 quindi esegue i test. L'esecuzione della build e dei test richiederà alcuni minuti. Questi test includono i test delle unità e una fase di convalida che controlla le regole impostate per l'ambiente di deployment. Questo passaggio di convalida è già configurato e garantisce che tu riceva avvisi relativi a problemi di deployment anche mentre stai utilizzando l'ambiente di sviluppo.

3. La prima volta che esegui il comando, nella parte superiore dello schermo viene visualizzato un prompt che chiede se vuoi il contesto attuale di Kubernetes. Seleziona "Sì". per accettare e utilizzare il contesto corrente.
4. A seguire, viene visualizzato un prompt in cui si chiede quale Container Registry utilizzare. Premi Invio per accettare il valore predefinito fornito
5. Seleziona "Output". nel riquadro inferiore per visualizzare l'avanzamento e le notifiche. Utilizzando il menu a discesa, seleziona "Kubernetes: Run/Debug"

6. Seleziona "Kubernetes: Esegui/Debug - Dettagliato" nel menu a discesa del canale a destra per visualizzare ulteriori dettagli e i log trasmessi in live streaming dai container

Una volta completati la build e i test, i log della scheda Output avranno l'URL http://localhost:8080 elencato in "Kubernetes: Run/Debug" vista.

7. Nel terminale Cloud Code, passa il mouse sopra il primo URL nell'output (http://localhost:8080), quindi nella descrizione comando visualizzata seleziona Apri anteprima web.
8. Viene visualizzata una nuova scheda del browser in cui viene visualizzato il messaggio: Hello, World!

Ricarica a caldo

1. Apri il file app.py
2. Cambia il messaggio di benvenuto in Hello from Python

Nota immediatamente che nella finestra Output, nella visualizzazione Kubernetes: Run/Debug, il visualizzatore 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 vedere i risultati aggiornati.

Debug

1. Vai alla visualizzazione debug e interrompi il thread corrente . Se ti viene richiesto, puoi scegliere di eseguire la pulizia 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. La prima volta che viene eseguita, un prompt chiederà 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 impiegheranno un paio di minuti. Se la sessione di debug è disconnessa, esegui nuovamente i passaggi per "Debug su Kubernetes" dalle sessioni di sviluppo .

5. Al termine del processo. Noterai un debugger collegato, la scheda Output indica Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully. e compare l'URL http://localhost:8080.

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

6. La barra di stato in basso cambia colore da blu ad arancione per indicare che è in modalità di debug.

7. Nella vista Kubernetes Run/Debug, nota che è stato 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
***********************************

Utilizza i punti di interruzione

1. Apri il file app.py
2. Individua l'istruzione return message.
3. Aggiungi un punto di interruzione alla 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. Ricarica il browser e nota che il debugger interrompe il processo in corrispondenza del punto di interruzione e ti consente di esaminare le variabili e lo stato dell'applicazione in esecuzione da remoto in GKE
5. Fai clic nella sezione VARIABILI.
6. Fai clic su Locali per trovare la variabile "message".
7. Fai doppio clic sul nome della variabile "message" e, nel popup, modifica il valore in modo diverso, ad esempio "Greetings from Python".
8. Fai clic sul pulsante Continua nel pannello di controllo del debug
9. Esamina la risposta nel browser, che ora mostra il valore aggiornato che hai appena inserito.
10. Interrompi il "Debug" premendo il pulsante di interruzione e rimuovere il punto di interruzione facendo di nuovo clic sul punto di interruzione.

6. Esegui la pulizia

Complimenti In questo lab hai creato da zero una nuova applicazione Python e l'hai configurata per funzionare in modo efficace con i container. Hai quindi eseguito il deployment dell'applicazione ed eseguito il debug in un cluster GKE remoto seguendo lo stesso flusso di sviluppatori che si trova negli stack di applicazioni tradizionali.

Per eseguire la pulizia dopo aver completato il lab:

1. Elimina i file utilizzati nel lab

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

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

—

Ultimo aggiornamento: 22/03/23