Lab 04: Costruire una soluzione dati polyglot

Interfaccia utente di Microsoft Azure

Considerata la natura dinamica degli strumenti cloud di Microsoft, è possibile rilevare modifiche all’interfaccia utente di Azure apportate dopo lo sviluppo di questo contenuto per la formazione. È quindi possibile che le istruzioni e le procedure del lab non siano allineate correttamente.

Microsoft aggiorna questo corso di formazione quando la community segnala le modifiche necessarie. Poiché gli aggiornamenti cloud vengono apportati spesso, tuttavia, è possibile che si rilevino modifiche all’interfaccia utente prima degli aggiornamenti del contenuto per la formazione. In questo caso, adattarsi alle modifiche e quindi eseguire le operazioni necessarie nei lab.

Istruzioni

Prima di iniziare

Accedere all’ambiente lab

Accedere alla macchina virtuale Windows 10 usando le credenziali seguenti:

Nome utente: Admin
Password: Pa55w.rd

Nota: il docente fornirà le istruzioni necessarie per la connessione all’ambiente lab virtuale.

Esaminare le applicazioni installate

Trovare la barra delle applicazioni nel desktop di Windows 10. La barra delle applicazioni include le icone per le applicazioni che verranno usate nel lab, tra cui:

Microsoft Edge
Esplora file
Visual Studio Code

Diagramma dell’architettura

Diagramma dell'architettura che illustra la creazione di una soluzione dati polyglot da parte di un utente tramite la creazione di un account di archiviazione di Azure e di un account Azure Cosmos DB.

Esercizio 1: Creazione di risorse dell’archivio dati in Azure

Attività 1: Aprire il portale di Azure

Sulla barra delle applicazioni selezionare l’icona di Microsoft Edge.
Nella finestra aperta del browser passare al portale di Azure (portal.azure.com) e quindi accedere con l’account che si userà per questo lab.

Nota: se si sta eseguendo l’accesso al portale di Azure per la prima volta, verrà visualizzata una presentazione del portale. Selezionare Attività iniziali per ignorare la presentazione e iniziare a usare il portale.

Attività 2: Creare una risorsa dell’account Azure Cosmos DB

Nel portale di Azure usare la casella di testo Cerca risorse, servizi e documentazione per cercare Azure Cosmos DB e quindi nell’elenco di risultati selezionare Azure Cosmos DB.
Nel riquadro Azure Cosmos DB selezionare + Crea.
Nel riquadro Seleziona l’opzione API selezionare Crea nella casella Azure Cosmos DB for NoSQL.

Nella scheda Informazioni di base della pagina Crea account Azure Cosmos DB - Azure Cosmos DB for NoSQL eseguire le azioni seguenti e quindi selezionare Rivedi e crea:

Impostazione	Azione
Elenco Sottoscrizioni	Mantieni impostazioni predefinite
Sezione Gruppo di risorse	Selezionare Crea nuovo
Casella di testo Nome	Immettere Polyglotdata e selezionare OK
Casella di testo AccountName	Immettere polycosmos [nomeutente]
Elenco a discesa Posizione	Selezionare un’area di Azure più vicina alla posizione del computer lab e in cui è possibile creare un account Cosmos DB
Sezione Modalità di capacità	Selezionare Serverless

Lo screenshot seguente mostra le impostazioni configurate nella pagina Crea account Azure Cosmos DB - Azure Cosmos DB for NoSQL.

Screenshot che mostra le opzioni configurate per la creazione di un account Azure Cosmos DB

Nella scheda Rivedi e crea della pagina Crea account Azure Cosmos DB - Azure Cosmos DB for NoSQL esaminare le opzioni selezionate durante i passaggi precedenti.
Selezionare Crea per creare l’account Azure Cosmos DB usando la configurazione specificata.

Nota: prima di procedere con il lab, attendere il completamento dell’attività di creazione.
Selezionare Vai alla risorsa.
Nel riquadro Account Azure Cosmos DB trovare la sezione Impostazioni e quindi selezionare il collegamento Chiavi .
Nel riquadro Chiavi registrare i valori delle caselle di testo URI, CHIAVE PRIMARIA e STRINGA DI CONNESSIONE PRIMARIA nella scheda Chiavi di lettura/scrittura. Questi valori verranno utilizzati più avanti in questo lab.

Attività 3: Creare una risorsa dell’account di archiviazione di Azure

Nel portale di Azure usare la casella di testo Cerca risorse, servizi e documentazione per cercare Account di archiviazione e quindi nell’elenco di risultati selezionare Account di archiviazione.
Nel riquadro Account di archiviazione selezionare + Crea.

Nella scheda Informazioni principali del pannello Crea un account di archiviazione eseguire le azioni seguenti e selezionare Rivedi:

Impostazione	Azione
Elenco Sottoscrizioni	Mantieni impostazioni predefinite
Sezione Gruppo di risorse	Selezionare PolyglotData
Casella di testo Nome account di archiviazione	Immettere polystor [nomeutente]
Elenco a discesa Area	Selezionare la stessa area in cui è stato creato l’account Cosmos DB in precedenza in questo esercizio
Sezione Prestazioni	selezionare Standard
Elenco a discesa Ridondanza	Selezionare Archiviazione con ridondanza locale.

Lo screenshot seguente mostra le impostazioni configurate nel pannello Crea un account di archiviazione.

Screenshot che mostra le opzioni configurate per la creazione di un account di archiviazione di Azure

Nella scheda Rivedi del pannello Crea un account di archiviazione esaminare le opzioni selezionate durante i passaggi precedenti.
Selezionare Crea per creare l’account di archiviazione usando la configurazione specificata.

Nota: prima di procedere con il lab, attendere il completamento dell’attività di creazione.

Verifica

In questo esercizio sono state create le risorse di Azure necessarie per la soluzione dati polyglot che verrà implementata in questo lab. Le risorse di Azure create includono un account Azure Cosmos DB e un account di archiviazione di Azure.

Esercizio 2: Esaminare e caricare i dati

Attività 1: Caricare immagini in Archiviazione BLOB di Azure

Nel riquadro di spostamento del portale di Azure tornare al pannello Account di archiviazione e quindi selezionare l’account di archiviazione polystor [nomeutente] creato nell’esercizio precedente di questo lab.
Nel pannello dell’account di archiviazione polystor [nomeutente] selezionare il collegamento Contenitori nella sezione Archiviazione dati.
Nella sezione Contenitori selezionare + Contenitore.

Nella finestra popup Nuovo contenitore eseguire le azioni seguenti e quindi selezionare Crea:

Impostazione	Azione
Casella di testo Nome	Immettere images
Elenco a discesa Livello di accesso pubblico	Selezionare BLOB (accesso in lettura anonimo solo per i BLOB)

Nella sezione Contenitori selezionare il contenitore images appena creato.
Trovare la sezione Impostazioni nel pannello Contenitore e quindi selezionare il collegamento Proprietà.
Nel riquadro Proprietà prendere nota del valore nella casella di testo URL e registrarlo. Questo valore verrà usato più avanti nel lab.
Trovare e selezionare il collegamento Panoramica nel pannello.
Nel pannello selezionare Carica.
Nella finestra Carica BLOB eseguire le azioni seguenti:

a. Nella sezione File selezionare l’icona Cartella.

b. Nella finestra Esplora file passare a Allfiles (F):\Allfiles\Labs\04\Starter\Images, selezionare tutti i 42 file immagine .jpg e quindi selezionare Apri.

c. Assicurarsi che sia selezionata l’opzione Sovrascrivi se i file esistono già e quindi selezionare Carica.

Nota: prima di procedere con questo lab, attendere il completamento del caricamento di tutti i BLOB.

Attività 2: Esaminare i dati JSON

Dal computer del lab avviare Visual Studio Code.
Dal menu File selezionare Apri file, passare a Allfiles (F):\Allfiles\Labs\04\Starter\AdventureWorks\AdventureWorks.Upload, selezionare models.json e quindi Apri.
Esaminare il formato del file models.json e notare che contiene una matrice di oggetti JSON, con una matrice annidata di oggetti che fanno parte della proprietà Products.

Nota: determina le classi che verranno definite per deserializzare il contenuto del file JSON prima di caricarlo in una raccolta Cosmos DB.
Nel file models.json si noti che una delle proprietà è denominata Category.

Nota: si userà la proprietà Category per definire il partizionamento della raccolta di Cosmos DB.
Chiudere Visual Studio Code.

Attività 3: Creare un database e una raccolta Cosmos DB ed eseguire un caricamento di dati JSON

Nella schermata Start selezionare il riquadro Visual Studio Code.
Dal menu File selezionare Apri cartella.
Nella finestra Esplora file visualizzata passare a Allfiles (F):\Allfiles\Labs\04\Starter\AdventureWorks e quindi selezionare Seleziona cartella.
Nella finestra di Visual Studio Code, nella barra dei menu, selezionare Terminale e quindi Nuovo terminale.
Nel terminale verificare che la directory corrente sia impostata su AdventureWorks (o modificarla in caso contrario), quindi eseguire il comando seguente per commutare il contesto del terminale sulla cartella AdventureWorks.Upload:
```
cd .\AdventureWorks.Upload\
```
Nota: prima di eseguire il passaggio successivo, aprire Esplora risorse e rimuovere l’attributo Sola lettura dal file Allfiles (F):\Allfiles\Labs\04\Starter\AdventureWorks\AdventureWorks.Upload\AdventureWorks.Upload.csproj
Dal prompt del terminale eseguire il comando seguente per aggiungere la libreria client .NET di Azure Cosmos DB al progetto attualmente aperto:
```
dotnet add package Microsoft.Azure.Cosmos --version 3.28.0
```
Nota: il comando dotnet add package aggiungerà il pacchetto Microsoft.Azure.Cosmos da NuGet. Per altre informazioni, vedere Microsoft.Azure.Cosmos.
Osservare i risultati della compilazione stampata nel terminale. La compilazione dovrebbe essere completata correttamente senza errori o messaggi di avviso.
Nel riquadro Esplora risorse della finestra di Visual Studio Code espandere il progetto AdventureWorks.Upload.
Aprire il file Program.cs.
Nel file Program.cs esaminare le direttive using e notare che includono Microsoft.Azure.Cosmos, System.IO, System.Text.Json, System.Threading.Tasks e System.Collections.Generic. Ciò consente il caricamento asincrono di elementi JSON da un file locale nel computer lab a una raccolta in un database Cosmos DB.
Nella riga 14 del file Program.cs impostare il valore di EndpointUrl sostituendo la stringa vuota con la proprietà URI dell’account Cosmos DB registrato in precedenza in questo lab. Assicurarsi che il valore sia racchiuso tra virgolette doppie.
Nella riga 15 impostare il valore di AuthorizationKey sostituendo la stringa vuota con la proprietà PRIMARY KEY dell’account Cosmos DB registrato in precedenza in questo lab. Assicurarsi che il valore sia racchiuso tra virgolette doppie.
Nella riga 18 impostare il valore di PartitionKey sostituendo la stringa vuota con “/Category” .
Alla riga 19 impostare il valore di JsonFilePath sostituendo la stringa vuota con “F:\\Allfiles\\Labs\\04\\Starter\\AdventureWorks\\AdventureWorks.Upload\\models.json” .
All’interno del blocco try si noti la chiamata del metodo CreateDatabaseIfNotExistsAsync della classe CosmosClient. Verrà creato un database, se non ne esiste già uno.
Si noti la chiamata del metodo DefineContainer della classe Database. Verrà creato un contenitore che ospiterà gli elementi JSON, se non ne esiste già uno.

Nota: il metodo DefineContainer include un’opzione di riduzione dei costi che consente di modificare i criteri di indicizzazione predefiniti (indicizzazione automatica di tutti gli attributi).
Si noti l’istruzione using che si basa su un oggetto StreamReader per leggere elementi JSON da un file di testo e deserializzarli in oggetti della classe Model definiti ulteriormente nel file Program.cs.
Si noti il ciclo foreach che esegue la reiterazione della raccolta di oggetti deserializzati e li inserisce in modo asincrono nella raccolta di destinazione.
Esaminare le classi Model e Product che riflettono il formato degli oggetti archiviati nel file in formato JSON esaminato in precedenza in questo lab.
Salvare e chiudere il file Program.cs.

Nota: selezionare Sovrascrivere se è stata visualizzata una richiesta indicante che il file è di sola lettura.
Nel terminale eseguire il comando seguente per ripristinare eventuali pacchetti NuGet mancanti e compilare il progetto nella cartella:
```
 dotnet build
```
Nota: il comando dotnet build ripristina automaticamente tutti i pacchetti NuGet mancanti prima di compilare tutti i progetti nella cartella.
Dal prompt del terminale eseguire il comando seguente per eseguire l’applicazione console .NET Core:
```
dotnet run
```
Nota: il comando dotnet run compila automaticamente le modifiche al progetto e quindi avvia l’applicazione Web senza un debugger collegato. Il comando restituisce i messaggi che indicano lo stato di avanzamento del caricamento dei dati, inclusi il numero di elementi inseriti nella raccolta di destinazione e la durata dell’operazione di inserimento.
Osservare i risultati dell’esecuzione del comando stampato nel terminale. L’esecuzione dovrebbe essere completata correttamente, visualizzando il messaggio che indica che nella raccolta di destinazione di Cosmos DB sono stati inseriti 119 elementi.
Selezionare Termina il terminale (l’icona del Cestino) per chiudere il riquadro del terminale e tutti i processi associati.

Attività 4: Convalidare il caricamento dei dati JSON

Nel computer del lab passare alla finestra del browser Microsoft Edge in cui è visualizzato il portale di Azure.
Nel portale di Azure selezionare la casella di testo Cerca risorse, servizi e documentazione, nell’elenco Risorse recenti selezionare l’account di Azure Cosmos DB polycosmos [nomeutente] creato in precedenza in questo lab.
Nel riquadro Account Azure Cosmos DB trovare e selezionare il collegamento Esplora dati.
Nel riquadro Esplora dati espandere il nodo Retail.
Espandere il nodo di contenitore Online e quindi selezionare Nuova query SQL.

Nota: l’etichetta per questa opzione potrebbe essere nascosta. È possibile visualizzare le etichette passando il puntatore sulle icone del riquadro Esplora dati.
Nella scheda query immettere il testo seguente:
```
SELECT * FROM models
```
Selezionare Esegui query e quindi osservare l’elenco di elementi JSON restituiti dalla query.
Nell’editor di query sostituire il testo esistente con il seguente:
```
SELECT VALUE COUNT(1) FROM models
```
Selezionare Esegui querye quindi osservare il risultato dell’operazione di aggregazione COUNT.
Tornare alla finestra di Visual Studio Code.

Verifica

In questo esercizio è stato usato .NET SDK per Azure Cosmos DB per inserire dati in Azure Cosmos DB. L’applicazione Web che verrà implementata successivamente userà questi dati.

Esercizio 3: Configurare un’applicazione Web .NET

Attività 1: Aggiornare i riferimenti agli archivi dati e compilare l’applicazione Web

Nel riquadro Esplora risorse della finestra di Visual Studio Code espandere il progetto AdventureWorks.Web.
Aprire il file appsettings.json.
Nell’oggetto JSON alla riga 3 trovare il percorso ConnectionStrings.AdventureWorksCosmosContext. Si noti che il valore corrente è vuoto:
```
"ConnectionStrings": {
    "AdventureWorksCosmosContext": "",
},
```
Aggiornare il valore della proprietà AdventureWorksCosmosContext impostandone il valore sulla STRINGA DI CONNESSIONE PRIMARIA dell’account Azure Cosmos DB registrato in precedenza in questo lab.
Nell’oggetto JSON alla riga 6 trovare il percorso Settings.BlobContainerUrl. Si noti che il valore corrente è vuoto:
```
"Settings": {
    "BlobContainerUrl": "",
    ...
}
```
Aggiornare la proprietà BlobContainerUrl impostandone il valore sulla proprietà URL del contenitore BLOB di archiviazione di Azure denominato images registrato in precedenza in questo lab.
Salvare il file appsettings.json e chiuderlo.

Nota: selezionare Sovrascrivere se è stata visualizzata una richiesta indicante che il file è di sola lettura.
Nella finestra di Visual Studio Code selezionare AdventureWorks.Context, attivare il menu di scelta rapida e quindi selezionare Apri nel terminale integrato.

Nota: prima di eseguire il passaggio successivo, aprire Esplora risorse e rimuovere l’attributo di sola lettura dal file Allfiles (F):\Allfiles\Labs\04\Starter\AdventureWorks\AdventureWorks.Context\AdventureWorks.Context.csproj
Dal prompt del terminale verificare che la directory corrente sia impostata su AdventureWorks.Context (o modificarla in caso contrario), quindi eseguire il comando seguente per importare Microsoft.Azure.Cosmos da NuGet:
```
dotnet add package Microsoft.Azure.Cosmos --version 3.28.0
```
Dal prompt del terminale eseguire il comando seguente per compilare l’applicazione Web .NET:
```
dotnet build
```
Osservare i risultati della compilazione stampata nel terminale. La compilazione dovrebbe essere completata correttamente senza errori o messaggi di avviso.

Attività 2: Configurare la connettività ad Azure Cosmos DB

Nel riquadro Esplora risorse della finestra di Visual Studio Code espandere il progetto AdventureWorks.Context.
Dal menu di scelta rapida del nodo cartelle AdventureWorks.Context selezionare Nuovo file.
Al prompt del nuovo file immettere AdventureWorksCosmosContext.cs.
Nella scheda dell’editor di codice per il file AdventureWorksCosmosContext.cs aggiungere le righe di codice seguenti per importare lo spazio dei nomi AdventureWorks.Models dal progetto AdventureWorks.Models a cui si fa riferimento:
```
using AdventureWorks.Models;
```
Aggiungere le righe di codice seguenti per importare gli spazi dei nomi Microsoft.Azure.Cosmos e Microsoft.Azure.Cosmos.Linq dal pacchetto Microsoft.Azure.Cosmos importato da NuGet:
```
using Microsoft.Azure.Cosmos;
using Microsoft.Azure.Cosmos.Linq;
```
Aggiungere le righe di codice seguenti per aggiungere direttive using per gli spazi dei nomi predefiniti che verranno usati da questo file:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
```
Immettere il codice seguente per aggiungere un blocco dello spazio dei nomi AdventureWorks.Context:
```
namespace AdventureWorks.Context
{
}
```
Nello spazio dei nomi AdventureWorks.Context immettere il codice seguente per creare una nuova classe AdventureWorksCosmosContext:
```
public class AdventureWorksCosmosContext
{
}
```
Aggiornare la dichiarazione della classe AdventureWorksCosmosContext aggiungendo una specifica che indica che questa classe implementerà l’interfaccia IAdventureWorksProductContext:
```
public class AdventureWorksCosmosContext : IAdventureWorksProductContext
{
}
```
All’interno della classe AdventureWorksCosmosContext immettere il codice seguente per creare una nuova variabile Container di sola lettura denominata _container:
```
private readonly Container _container;
```

All’interno della classe AdventureWorksCosmosContext aggiungere un nuovo costruttore con la firma seguente:

public AdventureWorksCosmosContext(string connectionString, string database = "Retail", string container = "Online")
{
}

All’interno del costruttore aggiungere il blocco di codice seguente per creare una nuova istanza della classe CosmosClient e quindi ottenere sia un’istanza Database che un’istanza Container dal client:
```
_container = new CosmosClient(connectionString)
    .GetDatabase(database)
    .GetContainer(container);
```
All’interno della classe AdventureWorksCosmosContext aggiungere un nuovo metodo FindModelAsync con la firma seguente:
```
public async Task<Model> FindModelAsync(Guid id)
{
}
```

All’interno del metodo FindModelAsync aggiungere i blocchi di codice seguenti per creare una query LINQ, trasformarla in un iteratore, eseguire l’iterazione sul set di risultati e quindi restituire il singolo elemento nel set di risultati:

var iterator = _container.GetItemLinqQueryable<Model>()
    .Where(m => m.id == id)
    .ToFeedIterator<Model>();
List<Model> matches = new List<Model>();
while (iterator.HasMoreResults)
{
    var next = await iterator.ReadNextAsync();
    matches.AddRange(next);
}
return matches.SingleOrDefault();

All’interno della classe AdventureWorksCosmosContext aggiungere un nuovo metodo GetModelsAsync con la firma seguente:
```
public async Task<List<Model>> GetModelsAsync()
{
}
```

All’interno del metodo GetModelsAsync aggiungere i blocchi di codice seguenti per eseguire una query SQL, ottenere l’iteratore dei risultati della query, eseguire l’iterazione sul set di risultati e quindi restituire l’unione di tutti i risultati:

string query = $@"SELECT * FROM items";
var iterator = _container.GetItemQueryIterator<Model>(query);
List<Model> matches = new List<Model>();
while (iterator.HasMoreResults)
{
    var next = await iterator.ReadNextAsync();
    matches.AddRange(next);
}
return matches;

All’interno della classe AdventureWorksCosmosContext aggiungere un nuovo metodo FindProductAsync con la firma seguente:
```
public async Task<Product> FindProductAsync(Guid id)
{
}
```

All’interno del metodo FindProductAsync aggiungere i blocchi di codice seguenti per eseguire una query SQL, ottenere l’iteratore dei risultati della query, eseguire l’iterazione sul set di risultati e quindi restituire il singolo elemento nel set di risultati:

string query = $@"SELECT VALUE products
                    FROM models
                    JOIN products in models.Products
                    WHERE products.id = '{id}'";
var iterator = _container.GetItemQueryIterator<Product>(query);
List<Product> matches = new List<Product>();
while (iterator.HasMoreResults)
{
    var next = await iterator.ReadNextAsync();
    matches.AddRange(next);
}
return matches.SingleOrDefault();

Salvare e chiudere il file AdventureWorksCosmosContext.cs .
Dal prompt del terminale, con la directory corrente impostata su AdventureWorks.Context, eseguire il comando seguente per compilare l’applicazione Web .NET:
```
dotnet build
```
Nota: se sono presenti errori di compilazione, esaminare il file AdventureWorksCosmosContext.cs nella cartella Allfiles (F):\Allfiles\Labs\04\Solution\AdventureWorks\AdventureWorks.Context.

Attività 3: Esaminare la logica di avvio dell’applicazione .NET

Nel riquadro Esplora risorse della finestra di Visual Studio Code espandere il progetto AdventureWorks.Web.
Aprire il file Startup.cs.

Nella classe Startup prendere nota del metodo ConfigureProductService esistente:

public void ConfigureProductService(IServiceCollection services)
{
    services.AddScoped<IAdventureWorksProductContext, AdventureWorksCosmosContext>(provider =>
        new AdventureWorksCosmosContext(
            _configuration.GetConnectionString(nameof(AdventureWorksCosmosContext))
        )
    );
}

Nota: il servizio del prodotto usa Cosmos DB come database.

Chiudere il file Startup.cs senza apportare modifiche.

Attività 4: Verificare che l’applicazione .NET si connetta correttamente agli archivi dati

Nel prompt del terminale di Visual Studio Code eseguire il comando seguente per commutare il contesto del terminale sulla cartella AdventureWorks.Web:
```
cd ..\AdventureWorks.Web\
```
Dal prompt del terminale eseguire il comando seguente per eseguire l’applicazione Web ASP.NET:
```
dotnet run
```
Nota: il comando dotnet run compila automaticamente le modifiche al progetto e quindi avvia l’applicazione Web senza un debugger collegato. Il comando restituisce l’URL dell’applicazione in esecuzione e tutte le porte assegnate.
Sulla barra delle applicazioni selezionare l’icona di Microsoft Edge.
Nella finestra del browser aperta passare all’applicazione Web attualmente in esecuzione (http://localhost:5000).
Nell’applicazione Web osservare l’elenco dei modelli visualizzati nella prima pagina.
Trovare il modello Touring-1000 e quindi selezionare Visualizza dettagli.
Nella pagina dei dettagli del prodotto Touring-1000 esaminare l’elenco delle opzioni.
Chiudere la finestra del browser che visualizza l’applicazione Web.
Passare alla finestra di Visual Studio Code e quindi selezionare Termina il terminale (l’icona del Cestino) per chiudere il terminale attualmente aperto e tutti i processi associati.

Verifica

In questo esercizio è stato scritto codice C# per eseguire query su una raccolta di Azure Cosmos DB usando .NET SDK.

Esercizio 4: Pulire la sottoscrizione

Attività 1: Aprire Azure Cloud Shell

Nel portale di Azure selezionare l’icona di Cloud Shell per aprire una nuova sessione di Bash. Se in Cloud Shell viene aperta per impostazione predefinita una sessione di PowerShell, selezionare PowerShell e nel menu a discesa selezionare Bash.

Nota: se è la prima volta che si avvia Cloud Shell, quando viene richiesto di selezionare Bash oppure PowerShell selezionare PowerShell. Quando viene visualizzato il messaggio Non sono state montate risorse di archiviazione, selezionare la sottoscrizione usata in questo lab, quindi selezionare Crea risorsa di archiviazione.

Attività 2: Eliminare i gruppi di risorse

Nel riquadro Cloud Shell eseguire il comando seguente per eliminare il gruppo di risorse PolyglotData:
```
az group delete --name PolyglotData --no-wait --yes
```
Nota: il comando viene eseguito in modo asincrono, come determinato dal parametro –no-wait. Anche se sarà possibile eseguire un altro comando dell’interfaccia della riga di comando di Azure nella stessa sessione Bash immediatamente dopo l’esecuzione di questo comando, saranno necessari alcuni minuti prima che i gruppi di risorse vengano effettivamente rimossi.
Chiudere il riquadro Cloud Shell nel portale.

Attività 3: Chiudere le applicazioni attive

Chiudere l’applicazione Microsoft Edge in esecuzione.
Chiudere l’applicazione Visual Studio Code in esecuzione.

Verifica

In questo esercizio è stata pulita la sottoscrizione mediante la rimozione dei gruppi di risorse usati in questo lab.