Condividi tramite

Guida introduttiva: Libreria client di Archiviazione BLOB di Azure per Java

  • Articolo

Nota

L'opzione Compila da zero illustra in modo dettagliato il processo di creazione di un nuovo progetto, l'installazione di pacchetti, la scrittura del codice e l'esecuzione di un'app console di base. Questo approccio è consigliato se si vogliono comprendere tutti i dettagli relativi alla creazione di un'app che si connette all'Archiviazione BLOB di Azure. Se si preferisce automatizzare le attività di distribuzione e iniziare con un progetto completato, scegliere Inizia con un modello.

Nota

L'opzione Inizia con un modello usa Azure Developer CLI per automatizzare le attività di distribuzione e inizia con un progetto completato. Questo approccio è consigliato se si vuole esplorare il codice il più rapidamente possibile, senza eseguire le attività di configurazione. Se si preferisce istruzioni dettagliate per compilare l'app, scegliere Compila da zero.

Introduzione alla libreria client di Archiviazione BLOB di Azure per Java per gestire BLOB e contenitori.

In questo articolo, vengono illustrati i passaggi per installare il pacchetto e provare il codice di esempio per le attività di base.

In questo articolo si usa Azure Developer CLI per distribuire le risorse di Azure ed eseguire un'app console completata con pochi comandi.

Suggerimento

Se si lavora con le risorse di Archiviazione di Azure in un'applicazione Spring, è consigliabile prendere in considerazione Spring Cloud Azure come alternativa. Spring Cloud Azure è un progetto open source che offre l'integrazione perfetta di Spring con i servizi di Azure. Per altre informazioni su Spring Cloud Azure e per un esempio relativo all'uso dell'Archiviazione BLOB, vedere Caricare un file in un BLOB di archiviazione di Azure.

Documentazione di riferimento dell'API | Codice sorgente della libreria | Pacchetto (Maven) | Esempi

Prerequisiti

Configurazione

Questa sezione illustra come preparare un progetto da usare con la libreria client di Archiviazione BLOB di Azure per Java.

Creare il progetto

Creare un'applicazione Java denominata blob-quickstart.

  1. Nella finestra di una console (ad esempio PowerShell o Bash) usare Maven per creare una nuova app console con il nome blob-quickstart. Digitare il comando mvn seguente per creare un progetto Java "Hello world!" .

    mvn archetype:generate `
    --define interactiveMode=n `
    --define groupId=com.blobs.quickstart `
    --define artifactId=blob-quickstart `
    --define archetypeArtifactId=maven-archetype-quickstart `
    --define archetypeVersion=1.4

  2. L'output della generazione del progetto avrà un aspetto simile al seguente:

    [INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.1.2:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.1.2:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.1.2:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: maven-archetype-quickstart:1.4
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.blobs.quickstart
[INFO] Parameter: artifactId, Value: blob-quickstart
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.blobs.quickstart
[INFO] Parameter: packageInPathFormat, Value: com/blobs/quickstart
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.blobs.quickstart
[INFO] Parameter: groupId, Value: com.blobs.quickstart
[INFO] Parameter: artifactId, Value: blob-quickstart
[INFO] Project created from Archetype in dir: C:\QuickStarts\blob-quickstart
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  7.056 s
[INFO] Finished at: 2019-10-23T11:09:21-07:00
[INFO] ------------------------------------------------------------------------
    ```

  3. Passare alla cartella blob-quickstart appena creata.

    cd blob-quickstart

  4. Nella directory blob-quickstart creare un'altra directory denominata data. In questa cartella verranno creati e archiviati i file di dati BLOB.

    mkdir data

Installare i pacchetti

Aprire il file pom.xml nell'editor di testo.

Aggiungere azure-sdk-bom per inserire una dipendenza dall'ultima versione della libreria. Nel frammento di codice seguente sostituire il segnaposto {bom_version_to_target} con il numero di versione. L'uso di azure-sdk-bom permette di non specificare la versione di ogni singola dipendenza. Per altre informazioni sul file BOM, vedere il file LEGGIMI di BOM di Azure SDK.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Poi, aggiungere gli elementi di dipendenza seguenti al gruppo di dipendenze. La dipendenza azure-identity è necessaria per le connessioni senza password ai servizi di Azure.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-blob</artifactId>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
</dependency>

Configurare il framework dell'app

Nella directory del progetto, seguire la procedura per creare la struttura di base dell'app:

  1. Passare alla directory /src/main/java/com/blobs/quickstart
  2. Aprire il file App.java nell'editor
  3. Eliminare la riga System.out.println("Hello world!");
  4. Aggiungere le direttive necessarie import

Il codice dovrebbe essere simile a questo framework:

package com.blobs.quickstart;

/**
 * Azure Blob Storage quickstart
 */
import com.azure.identity.*;
import com.azure.storage.blob.*;
import com.azure.storage.blob.models.*;
import java.io.*;

public class App
{
    public static void main(String[] args) throws IOException
    {
        // Quickstart code goes here
    }
}

Con Azure Developer CLI installata, è possibile creare un account di archiviazione ed eseguire il codice di esempio con pochi comandi. È possibile eseguire il progetto nell'ambiente di sviluppo locale o in un DevContainer.

Inizializzare il modello Azure Developer CLI e distribuire le risorse

Da una directory vuota seguire questa procedura per inizializzare il modello azd, effettuare il provisioning delle risorse di Azure e iniziare a usare il codice:

  • Clonare gli asset del repository di avvio rapido da GitHub e inizializzare il modello in locale:

    azd init --template blob-storage-quickstart-java

    Verranno richieste le informazioni seguenti:

    • Nome ambiente: questo valore viene usato come prefisso per tutte le risorse di Azure create da Azure Developer CLI. Il nome deve essere univoco in tutte le sottoscrizioni di Azure e deve avere una lunghezza compresa tra 3 e 24 caratteri. Il nome può contenere solo lettere minuscole e numeri.

  • Accedere ad Azure:

    azd auth login

  • Effettuare il provisioning e distribuire le risorse in Azure:

    azd up

    Verranno richieste le informazioni seguenti:

    • Sottoscrizione: sottoscrizione di Azure in cui vengono distribuite le risorse.
    • Posizione: area in cui sono distribuite le risorse.

    Il completamento della distribuzione può richiedere alcuni minuti. L'output del comando azd up include il nome dell'account di archiviazione appena creato, che sarà necessario in un secondo momento per eseguire il codice.

Eseguire il codice di esempio

A questo punto, le risorse vengono distribuite in Azure e il codice è quasi pronto per l'esecuzione. Seguire questa procedura per aggiornare il nome dell'account di archiviazione nel codice ed eseguire l'app console di esempio:

  • Eseguire l’aggiornamento del nome dell'account di archiviazione:
    1. Nella directory locale passare alla directory blob-quickstart/src/main/java/com/blobs/quickstart.
    2. Aprire il file denominato App.java nell'editor. Trovare il segnaposto <storage-account-name> e sostituirlo con il nome effettivo dell'account di archiviazione creato dal comando azd up.
    3. Salvare le modifiche.
  • Eseguire il progetto:
    1. Passare alla directory blob-quickstart contenente il pom.xml file. Compilare il progetto usando il comando mvn seguente: 
      mvn compile
    2. Creare un pacchetto del codice compilato nel formato distribuibile: 
      mvn package
    3. Eseguire il comando mvn seguente per eseguire l'app: 
      mvn exec:java
  • Osservare l'output: questa app crea un file di test nella cartella dati locale e lo carica in un contenitore nell'account di archiviazione. L'esempio elenca quindi i BLOB presenti nel contenitore e scarica il file con un nuovo nome per consentire il confronto tra i nuovi file e quelli precedenti.

Per altre informazioni sul funzionamento del codice di esempio, vedere Esempi di codice.

Al termine del test del codice, vedere la sezione Pulire le risorse per eliminare le risorse create dal comando azd up.

Modello a oggetti

Il servizio Archiviazione BLOB di Azure è ottimizzato per archiviare enormi quantità di dati non strutturati. I dati non strutturati non seguono una definizione o un modello di dati specifico, ad esempio dati di testo o binari. L'archiviazione BLOB offre tre tipi di risorse:

  • L'account di archiviazione
  • Un contenitore nell'account di archiviazione
  • Un oggetto BLOB in un contenitore

Il diagramma seguente mostra la relazione tra queste risorse.

Diagramma dell'architettura dell'archivio BLOB

Per interagire con queste risorse, usare le classi Java seguenti:

  • BlobServiceClient: la classe BlobServiceClient consente di modificare le risorse di Archiviazione di Azure e i contenitori BLOB. L'account di archiviazione rappresenta lo spazio dei nomi di primo livello per il servizio BLOB.
  • BlobServiceClientBuilder: la classe BlobServiceClientBuilder offre un'API del generatore per la configurazione e la creazione di istanze di oggetti BlobServiceClient.
  • BlobContainerClient: la classe BlobContainerClient consente di modificare i contenitori di Archiviazione di Azure e i relativi oggetti BLOB.
  • BlobClient: la classe BlobClient consente di modificare gli oggetti BLOB di Archiviazione di Azure.
  • BlobItem: la classe BlobItem rappresenta singoli BLOB restituiti da una chiamata a listBlobs.

Esempi di codice

Questi frammenti di codice di esempio illustrano come eseguire le azioni seguenti con la libreria client di Archiviazione BLOB di Azure per Java:

Importante

Assicurarsi di avere le dipendenze corrette in pom.xml e le direttive necessarie per il funzionamento degli esempi di codice, come descritto nella sezione relativa alla configurazione.

Nota

Il modello Azure Developer CLI include un file con codice di esempio già disponibile. Negli esempi seguenti vengono forniti dettagli per ogni parte del codice di esempio. Il modello implementa il metodo di autenticazione senza password consigliato, come descritto nella sezione Eseguire l'autenticazione in Azure. Il metodo della stringa di connessione viene visualizzato come alternativa, ma non viene usato nel modello e non è consigliato per il codice di produzione.

Eseguire l'autenticazione in Azure e autorizzare l'accesso ai dati BLOB

Le richieste dell'applicazione ad Archiviazione BLOB di Azure devono essere autorizzate. L'uso della classe DefaultAzureCredential fornita dalla libreria client di identità di Azure è l'approccio consigliato per l'implementazione di connessioni senza password ai servizi di Azure nel codice.

È anche possibile autorizzare le richieste all'Archiviazione BLOB di Azure usando la chiave di accesso dell'account. Tuttavia, questo approccio deve essere usato con cautela. Gli sviluppatori devono essere diligenti per non esporre mai la chiave di accesso in una posizione non sicura. Chiunque abbia la chiave di accesso può autorizzare richieste all'account di archiviazione e di fatto ha accesso a tutti i dati. DefaultAzureCredential offre maggiore sicurezza e semplicità di gestione rispetto alla chiave dell'account per consentire l'autenticazione senza password. Entrambe le opzioni sono illustrate nell'esempio seguente.

DefaultAzureCredential è una classe fornita dalla libreria client di Azure Identity per Java. DefaultAzureCredential supporta più metodi di autenticazione e determina il metodo da usare in fase di esecuzione. Questo approccio consente all'app di usare metodi di autenticazione diversi in ambienti diversi (locale e di produzione) senza implementare codice specifico dell'ambiente.

L'ordine e le posizioni in cui DefaultAzureCredential cerca le credenziali sono disponibili nella panoramica della libreria di identità di Azure.

Ad esempio, l'app può eseguire l'autenticazione usando le credenziali di accesso di Visual Studio Code con durante lo sviluppo in locale. L'app può quindi usare un'identità gestita dopo la distribuzione in Azure. Per questa transizione non sono necessarie modifiche al codice.

Assegnare ruoli all'account utente di Microsoft Entra

Quando si sviluppa in locale, assicurarsi che l'account utente che accede ai dati BLOB disponga delle autorizzazioni corrette. Per leggere e scrivere dati BLOB, è necessario disporre del ruolo Collaboratore ai dati dei BLOB di archiviazione. Per assegnare a se stessi questo ruolo, è necessario assegnare il ruolo Amministratore accesso utenti o un altro ruolo che include l'azione Microsoft.Authorization/roleAssignments/write. È possibile assegnare ruoli controllo degli accessi in base al ruolo di Azure a un utente usando il portale di Azure, l'interfaccia della riga di comando di Azure o Azure PowerShell. Per altre informazioni sugli ambiti disponibili per le assegnazioni di ruolo, vedere la pagina panoramica dell'ambito.

In questo scenario si assegneranno le autorizzazioni all'account utente con ambito all'account utente, per seguire il principio dei privilegi minimi. Questa procedura offre agli utenti solo le autorizzazioni minime necessarie e crea ambienti di produzione più sicuri.

L'esempio seguente assegnerà il ruolo Collaboratore ai dati dei BLOB di archiviazione all'account utente, che fornisce l'accesso in lettura e scrittura ai dati BLOB nell'account di archiviazione.

Importante

Nella maggior parte dei casi, la propagazione dell'assegnazione di ruolo in Azure richiederà almeno due minuti, ma in rari casi può richiedere fino a otto minuti. Se si ricevono errori di autenticazione quando si esegue il codice per la prima volta, attendere alcuni istanti e riprovare.

  1. Nel portale di Azure, individuare l'account di archiviazione usando la barra di ricerca principale o lo spostamento a sinistra.

  2. Nella pagina di panoramica dell'account di archiviazione selezionare Controllo di accesso (IAM) dal menu a sinistra.

  3. Nella pagina Controllo di accesso (IAM), selezionare la scheda Assegnazioni di ruolo.

  4. Selezionare + Aggiungi dal menu in alto e quindi Aggiungi assegnazione di ruolo dal menu a discesa risultante.

    Screenshot che mostra come assegnare un ruolo.

  5. Usare la casella di ricerca per filtrare i risultati in base al ruolo desiderato. Per questo esempio, cercare Collaboratore ai dati dei BLOB di archiviazione e selezionare il risultato corrispondente, quindi scegliere Avanti.

  6. In Assegna accesso a selezionare Utente, gruppo o entità servizio e quindi scegliere + Seleziona membri.

  7. Nella finestra di dialogo cercare il nome utente di Microsoft Entra (in genere l'indirizzo di posta elettronica user@domain) e quindi scegliere Selezionare nella parte inferiore della finestra di dialogo.

  8. Selezionare Rivedi e assegna per passare alla pagina finale e quindi Rivedi e assegna di nuovo per completare il processo.

Accedere e connettere il codice dell'app ad Azure usando DefaultAzureCredential

È possibile autorizzare l'accesso ai dati nell'account di archiviazione seguendo questa procedura:

  1. Assicurarsi di essere autenticati con lo stesso account Microsoft Entra a cui è stato assegnato il ruolo nell'archiviazione. È possibile eseguire l'autenticazione tramite l'interfaccia della riga di comando di Azure, Visual Studio Code o Azure PowerShell.

    Accedere ad Azure tramite l'interfaccia della riga di comando di Azure usando il comando seguente:

    az login

  2. Per usare DefaultAzureCredential, assicurarsi che la dipendenza azure-identity venga aggiunta in pom.xml:

    <dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-identity</artifactId>
</dependency>

  3. Aggiungere questo codice al metodo Main. Quando il codice viene eseguito nella workstation locale, userà le credenziali per sviluppatori dello strumento con priorità a cui si è connessi per l'autenticazione in Azure, ad esempio l'interfaccia della riga di comando di Azure o Visual Studio Code.

    /*
 * The default credential first checks environment variables for configuration
 * If environment configuration is incomplete, it will try managed identity
 */
DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

// Azure SDK client builders accept the credential as a parameter
// TODO: Replace <storage-account-name> with your actual storage account name
BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
        .endpoint("https://<storage-account-name>.blob.core.windows.net/")
        .credential(defaultCredential)
        .buildClient();

  4. Assicurarsi di aggiornare il nome dell'account di archiviazione nell'URI dell'oggetto BlobServiceClient. Il nome dell'account di archiviazione è disponibile nella pagina di panoramica del portale di Azure.

    Uno screenshot che mostra come trovare il nome dell'account di archiviazione.

    Nota

    Quando viene distribuito in Azure, questo stesso codice può essere usato per autorizzare le richieste ad Archiviazione di Azure da un'applicazione in esecuzione in Azure. È tuttavia necessario abilitare l'identità gestita nell'app in Azure. Configurare quindi l'account di archiviazione per consentire la connessione a tale identità gestita. Per istruzioni dettagliate sulla configurazione di questa connessione tra i servizi di Azure, vedere l'esercitazione Autenticazione dalle app ospitate in Azure.

Creazione di un contenitore

Creare un nuovo contenitore nell'account di archiviazione chiamando il metodo createBlobContainer sull'oggetto blobServiceClient. In questo esempio il codice aggiunge un valore GUID al nome del contenitore per assicurarsi che sia univoco.

Aggiungere questo codice alla fine del metodo Main:

// Create a unique name for the container
String containerName = "quickstartblobs" + java.util.UUID.randomUUID();

// Create the container and return a container client object
BlobContainerClient blobContainerClient = blobServiceClient.createBlobContainer(containerName);

Per altre informazioni sulla creazione di un contenitore e per esplorare altri esempi di codice, vedere Creare un contenitore BLOB con Java.

Importante

I nomi dei contenitori devono essere in minuscolo. Per altre informazioni sulla denominazione di contenitori e BLOB, vedere Naming and Referencing Containers, Blobs, and Metadata (Assegnazione di nome e riferimento a contenitori, BLOB e metadati).

Caricare BLOB in un contenitore

Caricare un BLOB in un contenitore chiamando il metodo uploadFromFile. Il codice di esempio crea un file di testo nella directory dati locale da caricare nel contenitore.

Aggiungere questo codice alla fine del metodo Main:

// Create the ./data/ directory and a file for uploading and downloading
String localPath = "./data/";
new File(localPath).mkdirs();
String fileName = "quickstart" + java.util.UUID.randomUUID() + ".txt";

// Get a reference to a blob
BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

// Write text to the file
FileWriter writer = null;
try
{
    writer = new FileWriter(localPath + fileName, true);
    writer.write("Hello, World!");
    writer.close();
}
catch (IOException ex)
{
    System.out.println(ex.getMessage());
}

System.out.println("\nUploading to Blob storage as blob:\n\t" + blobClient.getBlobUrl());

// Upload the blob
blobClient.uploadFromFile(localPath + fileName);

Per altre informazioni sul caricamento di BLOB e per esplorare altri esempi di codice, vedere Caricare un BLOB con Java.

Elencare i BLOB in un contenitore

Elencare i BLOB presenti nel contenitore chiamando il metodo listBlobs. In questo caso, al contenitore è stato aggiunto un unico BLOB, quindi l'operazione di recupero dell'elenco restituisce solo tale BLOB.

Aggiungere questo codice alla fine del metodo Main:

System.out.println("\nListing blobs...");

// List the blob(s) in the container.
for (BlobItem blobItem : blobContainerClient.listBlobs()) {
    System.out.println("\t" + blobItem.getName());
}

Per altre informazioni sull'elenco dei BLOB e per esplorare altri esempi di codice, vedere Elencare i BLOB con Java.

Scaricare BLOB

Scaricare il BLOB creato in precedenza chiamando il metodo downloadToFile. Il codice di esempio aggiunge il suffisso "DOWNLOAD" al nome del file in modo da consentire la visualizzazione di entrambi i file nel file system locale.

Aggiungere questo codice alla fine del metodo Main:

// Download the blob to a local file

// Append the string "DOWNLOAD" before the .txt extension for comparison purposes
String downloadFileName = fileName.replace(".txt", "DOWNLOAD.txt");

System.out.println("\nDownloading blob to\n\t " + localPath + downloadFileName);

blobClient.downloadToFile(localPath + downloadFileName);

Per altre informazioni sul download di BLOB e per esplorare altri esempi di codice, vedere Scaricare un BLOB con Java.

Eliminare un contenitore

Il codice seguente pulisce le risorse create dall'app eliminando l'intero contenitore tramite il metodo delete. Elimina anche i file locali creati dall'app.

L'app viene sospesa per l'input dell'utente chiamando System.console().readLine() prima dell'eliminazione di BLOB, contenitore e file locali. Si tratta di una valida opportunità per verificare che le risorse siano state create correttamente, prima che vengano eliminate.

Aggiungere questo codice alla fine del metodo Main:

File downloadedFile = new File(localPath + downloadFileName);
File localFile = new File(localPath + fileName);

// Clean up resources
System.out.println("\nPress the Enter key to begin clean up");
System.console().readLine();

System.out.println("Deleting blob container...");
blobContainerClient.delete();

System.out.println("Deleting the local source and downloaded files...");
localFile.delete();
downloadedFile.delete();

System.out.println("Done");

Per altre informazioni sull'eliminazione di un contenitore e per esplorare altri esempi di codice, vedere Eliminare e ripristinare un contenitore BLOB con Java.

Eseguire il codice

Questa app crea un file di test nella cartella locale e lo carica nell'archiviazione BLOB. L'esempio elenca quindi i BLOB presenti nel contenitore e scarica il file con un nuovo nome per consentire il confronto tra i nuovi file e quelli precedenti.

Seguire i passaggi per compilare, creare un pacchetto ed eseguire il codice

  1. Passare alla directory contenente il file pom.xml e compilare il progetto tramite il comando mvn seguente: 
    mvn compile
  2. Creare un pacchetto del codice compilato nel formato distribuibile: 
    mvn package
  3. Eseguire il comando mvn seguente per eseguire l'app: 
    mvn exec:java -D exec.mainClass=com.blobs.quickstart.App -D exec.cleanupDaemonThreads=false
    Per semplificare il passaggio di esecuzione, è possibile aggiungere exec-maven-plugin a pom.xml e configurare come illustrato di seguito: 
    <plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.4.0</version>
  <configuration>
    <mainClass>com.blobs.quickstart.App</mainClass>
    <cleanupDaemonThreads>false</cleanupDaemonThreads>
  </configuration>
</plugin>
    Con questa configurazione, è possibile eseguire l'app con il comando seguente: 
    mvn exec:java

L'output dell'app è simile all'esempio seguente (i valori UUID omessi per la leggibilità):

Azure Blob Storage - Java quickstart sample

Uploading to Blob storage as blob:
        https://mystorageacct.blob.core.windows.net/quickstartblobsUUID/quickstartUUID.txt

Listing blobs...
        quickstartUUID.txt

Downloading blob to
        ./data/quickstartUUIDDOWNLOAD.txt

Press the Enter key to begin clean up

Deleting blob container...
Deleting the local source and downloaded files...
Done

Prima di iniziare il processo di pulizia, controllare che nella cartella dati siano presenti due file. È possibile confrontarli e osservare che sono identici.

Pulire le risorse

Dopo aver verificato i file e aver completato il test, premere INVIO per eliminare i file di test insieme al contenitore creato nell'account di archiviazione. È anche possibile usare l'interfaccia della riga di comando di Azure per eliminare le risorse.

Al termine dell'avvio rapido, è possibile pulire le risorse create eseguendo il comando seguente:

azd down

Verrà richiesto di confermare l'eliminazione delle risorse. Immettere y per confermare.

Passaggio successivo

Esempi e guide per sviluppatori di Archiviazione di Azure per Java