Sviluppo InnerLoop mediante Cloud Workstations con NodeJS

1. Panoramica

Questo lab mostra funzionalità e capacità progettate per semplificare il workflow di sviluppo per gli ingegneri software incaricati di sviluppare applicazioni NodeJS 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 un'applicazione Node.js iniziale
• Configurazione dell'applicazione Node.js per lo sviluppo di container
• Codifica di 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
• (Facoltativo) Integrare Cloud SQL per la persistenza del backend

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.

Configura gcloud

In Cloud Shell, imposta l'ID progetto e la regione in cui vuoi eseguire il deployment dell'applicazione. Salvali come variabili PROJECT_ID e REGION.

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 CloudSQL. 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/nodejs/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 Cloud SQL 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/nodejs/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-js.

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. Creazione di una nuova applicazione starter Node.js

In questa sezione creerai una nuova applicazione Node.js.

1. Apri un nuovo terminale.

2. In Cloud Shell, crea una nuova directory con il nome mynodejsapp.

mkdir mynodejsapp

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

3. Passa a questa directory e aprila come workspace. L'editor verrà ricaricato creando una configurazione dello spazio di lavoro nella cartella appena creata.

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

1. Apri di nuovo un nuovo terminale. Installa Node e NPM utilizzando NVM.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash
        
        # This loads nvm bash_completion
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  

nvm install stable

nvm alias default stable

4. Crea una nuova applicazione iniziale

1. Inizializzare l'applicazione

Creazione di un file package.json eseguendo il seguente comando

npm init

    Choose the `entry point: (index.js) src/index.js` and leave default values for the rest of the parameters. This will create the `package.json` file with following contents

{
  "name": "mynodejsapp",
  "version": "1.0.0",
  "description": "",
  "main": "src/index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

2. Aggiungere un punto di accesso

Apri e modifica il file package.json nell'IDE per includere il comando di avvio nello script "start": "node src/index.js",. Dopo la modifica, gli script dovrebbero avere l'aspetto dello snippet di codice riportato di seguito:

"scripts": {
    "start": "node src/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

3. Aggiungere la dipendenza Express

Il codice che aggiungeremo utilizza anche express, quindi aggiungiamo questa dipendenza al file package.json. Dopo tutte le modifiche, il file package.json dovrebbe essere come mostrato di seguito.

{
 "name": "mynodejsapp",
 "version": "1.0.0",
 "description": "",
 "main": "src/index.js",
 "scripts": {
   "start": "node src/index.js",
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "author": "",
 "license": "ISC",
 "dependencies": {
   "express": "^4.17.3"
 }
}

4. Crea il file index.js

Crea una directory di origine denominata src selezionando Nuova cartella nella visualizzazione Esplora.

Crea il file src/index.js

con il seguente codice

const express = require('express');
const app = express();
const PORT = 8080;

app.get('/', (req, res) => {
    var message="Greetings from Node";
    res.send({ message: message });
  });

app.listen(PORT, () => {
  console.log(`Server running at: http://localhost:${PORT}/`);

});

Tieni presente che la porta è impostata sul valore 8080

Genera manifest

Skaffold fornisce strumenti integrati per semplificare lo sviluppo dei container. In questo passaggio inizializzerai Skaffold, che creerà automaticamente i file YAML di base di Kubernetes. Esegui il comando riportato di seguito per iniziare la procedura.

Esegui questo comando nel terminale

skaffold init --generate-manifests

Quando richiesto:

• Inserisci 8080 per la porta.
• Inserisci y per salvare la configurazione.

Allo spazio di lavoro vengono aggiunti due file: skaffold.yaml e deployment.yaml

Aggiorna il nome dell'app

I valori predefiniti inclusi nella configurazione non corrispondono attualmente al nome dell'applicazione. Aggiorna i file in modo che facciano riferimento al nome dell'applicazione anziché ai valori predefiniti.

1. Modificare le voci nella configurazione di Skaffold

• Apri skaffold.yaml
• Seleziona il nome dell'immagine attualmente impostata come package-json-image
• Fai clic con il tasto destro del mouse e scegli Modifica tutte le occorrenze.
• Digita il nuovo nome come mynodejsapp

2. Modificare le voci nella configurazione di Kubernetes

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

Nota che nel file skaffold.yaml, la sezione build utilizza buildpacks per inserire l'applicazione in un container. Questo codice non ha Dockerfile e lo sviluppatore non ha bisogno di alcuna conoscenza di Docker per creare il container di questa applicazione.

Inoltre, la sincronizzazione rapida viene attivata automaticamente tra l'editor e il container in esecuzione da questa configurazione di Skaffold. Non è necessaria alcuna configurazione aggiuntiva per attivare la sincronizzazione rapida.

5. Esaminare il processo di sviluppo

In questa sezione, seguirai alcuni passaggi utilizzando il plug-in Cloud Code per apprendere le procedure di base e convalidare la configurazione e la configurazione dell'applicazione iniziale.

Cloud Code 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 in GKE. Questa operazione avviene dietro le quinte, astraendo i dettagli dal flusso dello sviluppatore. Cloud Code migliora anche il processo di sviluppo fornendo funzionalità di debug e sincronizzazione rapida tradizionali allo sviluppo basato su container.

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 "mycluster" 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 sotto SESSIONI DI SVILUPPO, seleziona Esegui su Kubernetes. Se richiesto, seleziona Sì per utilizzare il contesto Kubernetes attuale.

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 e Kubernetes: Run/Debug nel menu a discesa per visualizzare l'avanzamento e le notifiche.

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.

7. Torna alla visualizzazione semplificata selezionando "Kubernetes: Run/Debug" (Kubernetes: esegui/debug) dal menu a discesa.
8. Al termine della build e dei test, nella scheda Output viene visualizzato il messaggio Resource deployment/mynodejsapp status completed successfully e viene elencato un URL: "Forwarded URL from service demo-app: http://localhost:8080"
9. Nel terminale di Cloud Code, passa il mouse sopra l'URL nell'output (http://localhost:8080) e poi seleziona Segui link nel suggerimento visualizzato.

La risposta sarà:

{"message":"Greetings from Node"}

Ricaricamento rapido

1. Vai a src/index.js. Modifica il codice del messaggio di saluto in 'Hello from Node'

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

Update initiated
File sync started for 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
File sync succeeded for 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Update succeeded

2. Se passi alla visualizzazione Kubernetes: Run/Debug - Detailed, noterai che riconosce le modifiche ai file e riavvia il nodo

files modified: [src/index.js]
Copying files:map[src/index.js:[/workspace/src/index.js]]togcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Syncing 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Watching for changes...
[mynodejsapp]
[mynodejsapp]> mynodejsapp@1.0.0 start /workspace
[mynodejsapp]> node src/index.js
[mynodejsapp]
[mynodejsapp]Server running at: http://localhost:8080/

3. Aggiorna il browser per visualizzare i risultati aggiornati.

Debug

1. Vai alla visualizzazione Debug e interrompi il thread corrente .
2. 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.
• La creazione e il deployment dell'applicazione richiedono un paio di minuti. Questa volta noterai un debugger collegato.

Port forwarding pod/mynodejsapp-6bbcf847cd-vqr6v in namespace default, remote port 9229 -> http://127.0.0.1:9229
[mynodejsapp]Debugger attached.

3. Il colore della barra di stato inferiore cambia da blu ad arancione, indicando che è in modalità di debug.

4. Nella visualizzazione Kubernetes Run/Debug, nota che viene avviato un container di cui è possibile eseguire il debug

**************URLs*****************
Forwarded URL from service mynodejsapp-service: http://localhost:8080
Debuggable container started pod/mynodejsapp-deployment-6bc7598798-xl9kj:mynodejsapp (default)
Update succeeded
***********************************

Utilizzare i punti di interruzione

1. Apri src/index.js
2. Individua l'istruzione var message="Hello from Node";.
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. 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
5. Fai clic nella sezione delle variabili fino a trovare la variabile "message".
6. Esegui la riga premendo Step over (Passa sopra) .
7. Osserva il valore attuale della variabile "message" che cambia in "Hello from Node"
8. Fai doppio clic sul nome della variabile "target" e, nel popup, modifica il valore in qualcosa di diverso, ad esempio "Hi from Node".
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.

6. 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 di servizio REST che si connettono a un database gestito in Google Cloud.

Configura le dipendenze

Il codice dell'applicazione utilizza un database per archiviare i dati del servizio REST. Assicurati che le dipendenze siano disponibili aggiungendo quanto segue nel file package.json

1. Aggiungi altre due dipendenze pg e sequelize al file package.json per creare un'applicazione CRUD Postgres. La sezione delle dipendenze dopo aver caricato le modifiche avrebbe il seguente aspetto.

    "dependencies": {
    "express": "^4.17.3",
    "pg": "^8.8.0",
    "sequelize": "^6.25.7"
  }

Codifica del servizio REST

1. Aggiungi il codice dell'applicazione CRUD a questa applicazione

wget -O app.zip https://github.com/GoogleCloudPlatform/container-developer-workshop/raw/main/labs/nodejs/app.zip

unzip app.zip

Questo codice ha

• Cartella models con il modello di entità per item
• Cartella controllers con il codice che esegue le operazioni CRUD
• Cartella routes che indirizza pattern URL specifici a chiamate diverse
• Cartella config con i dettagli di connettività del database

2. Tieni presente che la configurazione del database nel file db.config.js fa riferimento alle variabili di ambiente che devono essere fornite per connettersi al database. Inoltre, devi analizzare la richiesta in arrivo per la codifica URL.
3. Aggiungi il seguente snippet di codice in src/index.js per poter connetterti al codice CRUD dal file JavaScript principale subito prima dell'ultima sezione che inizia con app.listen(PORT, () => {

const bodyParser = require('body-parser')
app.use(bodyParser.json())
app.use(
 bodyParser.urlencoded({
   extended: true,
 })
)
const db = require("../app/models");
db.sequelize.sync();
require("../app/routes/item.routes")(app);

4. Modifica il deployment nel file deployment.yaml per aggiungere le variabili di ambiente per fornire le informazioni di connettività del database.

Aggiorna la voce della specifica alla fine del file in modo che corrisponda alla seguente definizione

    spec:
      containers:
      - name: mynodejsapp
        image: mynodejsapp
        env:
        - name: DB_HOST
          value: ${DB_INSTANCE_IP}        
        - name: DB_PORT
          value: "5432"  
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: database

5. Sostituisci il valore DB_HOST con l'indirizzo del tuo database.

export DB_INSTANCE_IP=$(gcloud sql instances describe mytest-instance \
    --format=json | jq \
    --raw-output ".ipAddresses[].ipAddress")

envsubst < deployment.yaml > deployment.new && mv deployment.new deployment.yaml

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/mynodejsapp status completed successfully e viene elencato un URL: "Forwarded URL from service mynodejsapp: http://localhost:8080"
3. Aggiungi un paio di elementi.

Dal terminale Cloud Shell, esegui i comandi riportati di seguito.

URL=localhost:8080
curl -X POST $URL/items -d '{"itemName":"Body Spray", "itemPrice":3.2}' -H "Content-Type: application/json"
curl -X POST $URL/items -d '{"itemName":"Nail Cutter", "itemPrice":2.5}' -H "Content-Type: application/json"

4. Prova GET eseguendo $URL/items nel browser. Puoi anche eseguire curl dalla riga di comando

curl -X GET $URL/items

5. Test di eliminazione: ora prova a eliminare un elemento eseguendo il comando riportato di seguito. Modifica il valore di item-id, se necessario.

curl -X DELETE $URL/items/1

    This throws an error message

{"message":"Could not delete Item with id=[object Object]"}

Identificare e risolvere il problema

1. L'applicazione è in esecuzione in modalità di debug. Utilizza i punti di interruzione per trovare 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 nel metodo itemcontroller.js->exports.delete.
• 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 request.params, aggiungi questa variabile alla finestra Espressioni di controllo.

2. Tieni presente che il valore assegnato a id è undefined. Modifica il codice per risolvere il problema.

Lo snippet di codice corretto sarà simile al seguente.

// Delete a Item with the specified id in the request
exports.delete = (req, res) => {
    const id = req.params.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

7. Esegui la pulizia

Complimenti! In questo lab hai creato una nuova applicazione Node.js da zero e l'hai configurata per funzionare in modalità di deployment rapido 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 mynodejsapp && rm -f setup.sh

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