Condividi tramite

Sviluppare per File di Azure con Java

Informazioni su come sviluppare applicazioni Java che usano File di Azure per archiviare i dati. File di Azure è un servizio di condivisione file gestito nel cloud. Fornisce condivisioni file completamente gestite accessibili tramite i protocolli SMB (Server Message Block) e NFS (Network File System) standard del settore. File di Azure fornisce anche un'API REST per l'accesso a livello di codice alle condivisioni file.

Questo articolo illustra i diversi approcci allo sviluppo con File di Azure in Java e come scegliere l'approccio più adatto alle esigenze dell'app. Si apprenderà anche come creare un'app console di base che interagisce con le risorse di File di Azure.

Si applica a

Modello di gestione Modello di fatturazione Livello supporti Ridondanza SMB NFS
Microsoft.Storage Con provisioning v2 HDD (standard) Locale Sì No
Microsoft.Storage Con provisioning v2 HDD (standard) Della zona Sì No
Microsoft.Storage Con provisioning v2 HDD (standard) Geografica Sì No
Microsoft.Storage Con provisioning v2 HDD (standard) GeoZone (GZRS) Sì No
Microsoft.Storage Con provisioning v1 SSD (Premium) Locale Sì No
Microsoft.Storage Con provisioning v1 SSD (Premium) Della zona Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) Locale Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) Della zona Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) Geografica Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) GeoZone (GZRS) Sì No

Informazioni sullo sviluppo di app Java con File di Azure

File di Azure offre diversi modi per consentire agli sviluppatori Java di accedere ai dati e gestire le risorse in File di Azure. La tabella seguente elenca gli approcci, riepiloga il funzionamento e fornisce indicazioni su quando usare ogni approccio:

Avvicinarsi Come funziona Quando utilizzare
Librerie di I/O file standard Usa chiamate API a livello di sistema operativo tramite condivisioni file di Azure montate usando SMB o NFS. Quando si monta una condivisione file usando SMB/NFS, è possibile usare librerie di I/O di file per un linguaggio di programmazione o un framework, ad esempio java.io e java.nio per Java. Hai app line-of-business con codice esistente che utilizza l'I/O di file standard e non vuoi riscrivere il codice per far sì che l'app funzioni con una condivisione file di Azure.
FileREST API Chiama direttamente gli endpoint HTTPS per interagire con i dati archiviati in File di Azure. Fornisce il controllo a livello di codice sulle risorse di condivisione file. Azure SDK fornisce la libreria client delle condivisioni file (com.azure.storage.file.share) basata sull'API FileREST, consentendo di interagire con le operazioni dell'API FileREST tramite paradigmi noti del linguaggio di programmazione Java. Si creano servizi cloud e app a valore aggiunto per i clienti e si vogliono usare funzionalità avanzate non disponibili tramite librerie di I/O di file standard.
API REST del provider di risorse di archiviazione Usa Azure Resource Manager (ARM) per gestire gli account di archiviazione e le condivisioni file. Chiama gli endpoint DELL'API REST per varie operazioni di gestione delle risorse. L'app o il servizio deve eseguire attività di gestione delle risorse, ad esempio la creazione, l'eliminazione o l'aggiornamento di account di archiviazione o condivisioni file.

Per informazioni generali su questi approcci, vedere Panoramica dello sviluppo di applicazioni con File di Azure.

Questo articolo è incentrato sull'uso delle risorse di File di Azure usando gli approcci seguenti:

Prerequisiti

Configurazione dell'ambiente

Annotazioni

Questo articolo usa lo strumento di compilazione Maven per compilare ed eseguire il codice di esempio. Altri strumenti di compilazione, ad esempio Gradle, funzionano anche con Azure SDK per Java.

Usare Maven per creare una nuova app console o aprire un progetto esistente. Seguire questa procedura per installare i pacchetti e aggiungere le direttive necessarie import .

Installare i pacchetti

Aprire il file pom.xml nell'editor di testo. Installare i pacchetti includendo il file bom o includendo una dipendenza diretta.

Includere il file BOM

Aggiungere azure-sdk-bom per acquisire una dipendenza dalla versione più recente della libreria. Nel frammento di codice seguente sostituire il {bom_version_to_target} segnaposto con il numero di versione. L'uso di azure-sdk-bom impedisce di specificare la versione di ogni singola dipendenza. Per maggiori informazioni sul BOM, vedere il file README 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>

Aggiungere gli elementi di dipendenza seguenti al gruppo di dipendenze. La dipendenza azure-identity è necessaria per le connessioni senza password ai servizi di Azure. Si noti che gli artefatti di Resource Manager non sono inclusi nel file bom, quindi è necessario aggiungerli come dipendenze dirette.

<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-storage-file-share</artifactId>
</dependency>
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-identity</artifactId>
</dependency>
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-core-management</artifactId>
</dependency>
<dependency>
  <groupId>com.azure.resourcemanager</groupId>
  <artifactId>azure-resourcemanager</artifactId>
  <version>{package_version_to_target}</version>
</dependency>
<dependency>
  <groupId>com.azure.resourcemanager</groupId>
  <artifactId>azure-resourcemanager-storage</artifactId>
  <version>{package_version_to_target}</version>
</dependency>

Includere una dipendenza diretta

Per accettare una dipendenza da una determinata versione della libreria, aggiungere la dipendenza diretta al progetto:

<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-storage-file-share</artifactId>
  <version>{package_version_to_target}</version>
</dependency>
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-identity</artifactId>
  <version>{package_version_to_target}</version>
</dependency>
<dependency>
  <groupId>com.azure.resourcemanager</groupId>
  <artifactId>azure-resourcemanager</artifactId>
  <version>{package_version_to_target}</version>
</dependency>
<dependency>
  <groupId>com.azure.resourcemanager</groupId>
  <artifactId>azure-resourcemanager-storage</artifactId>
  <version>{package_version_to_target}</version>
</dependency>
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-core-management</artifactId>
  <version>{package_version_to_target}</version>
</dependency>

Includere direttive import

Aprire quindi il file di codice e aggiungere le direttive necessarie import . In questo esempio vengono aggiunte le direttive seguenti nel file App.java :

import com.azure.identity.*;
import com.azure.storage.file.share.*;
import com.azure.resourcemanager.*;
import com.azure.resourcemanager.storage.models.*;
import com.azure.core.management.*;
import com.azure.core.management.profile.*;

Se si prevede di usare le librerie di I/O dei file Java, è necessario aggiungere anche le direttive di importazione seguenti:

import java.io.*;
import java.nio.file.*;

Utilizzare le librerie di I/O di file Java con Azure Files

Le librerie di I/O di file standard sono il modo più comune per accedere e usare le risorse di File di Azure. Quando si monta una condivisione file usando SMB o NFS, il sistema operativo reindirizza le richieste API per il file system locale. Questo approccio consente di usare librerie di I/O di file standard, ad esempio java.io e java.nio, per interagire con file e directory nella condivisione.

Prendere in considerazione l'uso delle librerie di I/O di file Java quando l'app richiede:

  • Compatibilità delle app: Ideale per le app line-of-business con codice esistente che usa già librerie di I/O di file Java. Non è necessario riscrivere il codice affinché l'app funzioni con una condivisione file di Azure.
  • Facilità d'uso: Le librerie di I/O di file Java sono note dagli sviluppatori e facili da usare. Una proposta di valore chiave di File di Azure consiste nell'esposizione delle API del file system native tramite SMB e NFS.

In questa sezione si apprenderà come usare le librerie di I/O di file Java per usare le risorse di File di Azure.

Per altre informazioni ed esempi, vedere la risorsa seguente:

Montare una condivisione di file

Per usare le librerie di I/O di file Java, è prima necessario montare una condivisione file. Per indicazioni su come montare una condivisione file con SMB o NFS, vedere le risorse seguenti:

In questo articolo viene usato il percorso seguente per fare riferimento a una condivisione file SMB montata in Windows:

String fileSharePath = "Z:\\file-share";

Esempio: Connettersi a una condivisione file ed enumerare le directory usando le librerie di I/O dei file Java

Nell'esempio di codice seguente viene illustrato come connettersi a una condivisione file ed elencare le directory nella condivisione:

import java.io.*;
import java.nio.file.*;

// Add the following code to a new or existing function

String fileSharePath = "Z:\\file-share";

try {
    File directory = new File(fileSharePath);
    File[] dirs = directory.listFiles(File::isDirectory);
            
    if (dirs != null) {
        for (File dir : dirs) {
            System.out.println(dir.getName());
        }
        System.out.println(dirs.length + " directories found.");
    }
} catch (Exception e) {
    System.out.println("Error: " + e.getMessage());
}

Esempio: Scrivere in un file all'interno di una condivisione di file usando le librerie Java per l'I/O di file

Nell'esempio di codice seguente viene illustrato come scrivere e aggiungere testo a un file:

import java.io.*;
import java.nio.file.*;
import java.util.Arrays;

// Add the following code to a new or existing function

String fileSharePath = "Z:\\file-share";
String fileName = "test.txt";

try {
    String textToWrite = "First line" + System.lineSeparator();
    Path filePath = Paths.get(fileSharePath, fileName);
        
    // Write initial content to file
    Files.write(filePath, textToWrite.getBytes());
    System.out.println("Initial text written to file");
        
    // Append additional lines to the file
    String[] textToAppend = { "Second line", "Third line" };
    Files.write(filePath, 
                Arrays.asList(textToAppend),
                StandardOpenOption.APPEND);
    System.out.println("Additional lines appended to file");
} catch (IOException ex) {
    System.out.println("Error writing to file: " + ex.getMessage());
}

Esempio: Bloccare un file in una condivisione file usando librerie di I/O di file Java

I client SMB che montano condivisioni file possono usare meccanismi di blocco del file system per gestire l'accesso ai file condivisi.

L'esempio di codice seguente illustra come bloccare un file in una condivisione file:

import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.*;

// Add the following code to a new or existing function

String fileSharePath = "Z:\\file-share";
String fileName = "test.txt";
String filePath = Paths.get(fileSharePath, fileName).toString();

try (
    FileOutputStream fos = new FileOutputStream(filePath);
    FileChannel fileChannel = fos.getChannel()) {

    // Acquire an exclusive lock on this file
    FileLock lock = fileChannel.lock();

    System.out.println("File is locked.");

    // Perform file operations here

    // Release the lock
    lock.release();
    System.out.println("File lock released.");

} catch (Exception e) {
    e.printStackTrace();
}

Quando si usano sia SMB che l'API FileREST, tenere presente che l'API FileREST usa lease per gestire i blocchi di file, mentre SMB usa blocchi del file system gestiti dal sistema operativo. Per altre informazioni sulla gestione delle interazioni di blocco dei file tra SMB e l'API FileREST, vedere Gestire i blocchi di file.

Esempio: Enumerare gli ACL di file usando librerie di I/O di file Java

Nell'esempio di codice seguente viene illustrato come enumerare gli elenchi di controllo di accesso (ACL) per un file:

import java.nio.file.*;
import java.nio.file.attribute.AclEntry;
import java.nio.file.attribute.AclFileAttributeView;
import java.util.List;

// Add the following code to a new or existing function

String fileSharePath = "Z:\\file-share";
String fileName = "test.txt";
String filePath = Paths.get(fileSharePath, fileName).toString();

try {
    Path path = Paths.get(filePath);

    // Get the ACL view for the file
    AclFileAttributeView aclView = Files.getFileAttributeView(
            path, AclFileAttributeView.class);

    // Get the ACL entries
    List<AclEntry> aclEntries = aclView.getAcl();

    // List all access rules for the file
    for (AclEntry entry : aclEntries) {
        System.out.println("Identity: " + entry.principal().getName());
        System.out.println("Access Control Type: " + entry.type());
        System.out.println("File System Rights: " + entry.permissions());
        System.out.println();
    }

    System.out.println(aclEntries.size() + " ACL entries found.");
} catch (Exception ex) {
    System.out.println("Error: " + ex.getMessage());
}

Usare File di Azure usando la libreria client di condivisione file per Java

L'API FileREST fornisce l'accesso a livello di codice a File di Azure. Consente di chiamare gli endpoint HTTPS per eseguire operazioni su condivisioni file, directory e file. L'API FileREST è progettata per funzionalità avanzate e scalabilità elevate che potrebbero non essere disponibili tramite protocolli nativi. Azure SDK fornisce librerie client, ad esempio la libreria client Condivisioni file per Java, che si basano sull'API FileREST.

È consigliabile usare l'API FileREST e la libreria client di condivisione file se l'applicazione richiede:

  • Funzionalità avanzate: Operazioni di accesso e funzionalità non disponibili tramite protocolli nativi.
  • Integrazioni cloud personalizzate: Creare servizi personalizzati a valore aggiunto, ad esempio backup, antivirus o gestione dei dati, che interagiscono direttamente con File di Azure.
  • Ottimizzazione delle prestazioni: Sfruttare i vantaggi delle prestazioni in scenari su larga scala usando le operazioni del piano dati.

L'API FileREST modella File di Azure come gerarchia di risorse ed è consigliata per le operazioni eseguite a livello di directory o file . È consigliabile preferire l'API REST del provider di risorse di archiviazione per le operazioni eseguite a livello di servizio file o condivisione file .

In questa sezione si apprenderà come usare la libreria client File Shares per Java per interagire con le risorse di File di Azure.

Per altre informazioni ed esempi, vedere le risorse seguenti:

Autorizzare l'accesso e creare un client

Per connettere un'app a File di Azure, creare un oggetto ShareClient. Questo oggetto è il punto di partenza per l'uso delle risorse di File di Azure. Negli esempi di codice seguenti viene illustrato come creare un ShareClient oggetto usando meccanismi di autorizzazione diversi.

Per autorizzare con Microsoft Entra ID è necessario usare un'entità di sicurezza. Il tipo di principale di sicurezza necessario dipende da dove viene eseguita l'app. Per altre informazioni sugli scenari di autenticazione, vedere Autenticazione di Azure con Java e Identità di Azure.

Per usare gli esempi di codice in questo articolo, assegnare il ruolo predefinito Azure RBAC Storage File Data Privileged Contributor al principale della sicurezza. Questo ruolo fornisce l'accesso completo in lettura, scrittura, modifica ACL ed eliminazione su tutti i dati nelle condivisioni per tutti gli account di archiviazione configurati, indipendentemente dalle autorizzazioni NTFS impostate a livello di file/directory. Per ulteriori informazioni, vedi Accedi alle condivisioni file di Azure utilizzando OAuth di Azure Files con Microsoft Entra ID tramite REST.

Autorizzare l'accesso con DefaultAzureCredential

Un modo semplice e sicuro per autorizzare l'accesso e connettersi a File di Azure consiste nel ottenere un token OAuth creando un'istanza DefaultAzureCredential . È quindi possibile usare tale credenziale per creare un ShareClient oggetto .

Nell'esempio seguente viene creato un ShareClient oggetto autorizzato usando DefaultAzureCredential, quindi viene creato un ShareDirectoryClient oggetto per lavorare con una directory nella condivisione:

import com.azure.core.credential.TokenCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.storage.file.share.*;

// Add the following code to a new or existing function

String accountName = "<account-name>";
String shareName = "<share-name>";
TokenCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();

// Create the ShareClient
ShareClient shareClient = new ShareClientBuilder()
    .endpoint(String.format("https://%s.file.core.windows.net", accountName))
    .shareName(shareName)
    .credential(defaultAzureCredential)
    .buildClient();

// Create a client to interact with a directory in the share
ShareDirectoryClient directoryClient = shareClient.getDirectoryClient("sample-directory");

Se si conosce esattamente il tipo di credenziale usato per autenticare gli utenti, è possibile ottenere un token OAuth usando altre classi nella libreria client di Identità di Azure per Java. Queste classi derivano dalla classe TokenCredential .

Per altre informazioni su ognuno di questi meccanismi di autorizzazione, vedere Scegliere come autorizzare l'accesso ai dati dei file.

Esempio: Copiare file usando la libreria client File Shares

È possibile copiare file all'interno di una condivisione file o tra condivisioni file usando il metodo seguente:

È possibile copiare un file in un BLOB di destinazione usando il metodo seguente da un BlockBlobClient oggetto :

Nell'esempio di codice seguente viene illustrato come copiare un file in un file in un'altra condivisione file:

import java.time.*;
import java.util.*;

import com.azure.core.credential.TokenCredential;
import com.azure.core.util.polling.*;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.storage.file.share.*;
import com.azure.storage.file.share.models.*;

// Add the following code to a new or existing function

String accountName = "<account-name>";
String srcShareName = "src-file-share";
String destShareName = "dest-file-share";
String srcFilePath = "src/path/to/file";
String destFilePath = "dest/path/to/file";

TokenCredential tokenCredential = new DefaultAzureCredentialBuilder().build();

ShareFileClient srcShareFileClient = new ShareFileClientBuilder()
    .endpoint(String.format("https://%s.file.core.windows.net", accountName))
    .shareName(srcShareName)
    .shareTokenIntent(ShareTokenIntent.BACKUP)
    .resourcePath(srcFilePath)
    .credential(defaultAzureCredential)
    .buildFileClient();

ShareFileClient destShareFileClient = new ShareFileClientBuilder()
    .endpoint(String.format("https://%s.file.core.windows.net", accountName))
    .shareName(destShareName)
    .shareTokenIntent(ShareTokenIntent.BACKUP)
    .resourcePath(destFilePath)
    .credential(defaultAzureCredential)
    .buildFileClient();

// Copy the file from the source share to the destination share
SyncPoller<ShareFileCopyInfo, Void> poller = destShareFileClient
        .beginCopy(srcShareFileClient.getFileUrl(),
                Collections.singletonMap("file", "metadata"),
                Duration.ofSeconds(2));

final PollResponse<ShareFileCopyInfo> pollResponse = poller.poll();
final ShareFileCopyInfo value = pollResponse.getValue();
System.out.printf("Copy source: %s. Status: %s.%n", value.getCopySourceUrl(), value.getCopyStatus());

Esempio: Creare un lease su un file usando la libreria client di Condivisioni file

Un lease crea un blocco in un file gestito da Azure tramite un ID lease. Il lease fornisce un meccanismo per coordinare l'accesso ai file tra più client in un sistema distribuito. Un lease su un file fornisce accesso esclusivo in scrittura ed eliminazione. Per altre informazioni sugli stati di lease e sulle azioni, vedere File di lease.

L'esempio di codice seguente illustra come creare un client di lease, acquisire un lease di durata infinito in un file e rilasciare il lease:

import com.azure.core.credential.TokenCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.storage.file.share.*;
import com.azure.storage.file.share.models.*;
import com.azure.storage.file.share.specialized.*;

// Add the following code to a new or existing function

String accountName = "<account-name>";
String shareName = "sample-file-share";
String filePath = "path/to/file";
        
TokenCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();

ShareFileClient fileClient = new ShareFileClientBuilder()
    .endpoint(String.format("https://%s.file.core.windows.net", accountName))
    .shareName(shareName)
    .shareTokenIntent(ShareTokenIntent.BACKUP)
    .resourcePath(filePath)
    .credential(defaultAzureCredential)
    .buildFileClient();

// Get a ShareLeaseClient
ShareLeaseClient fileLeaseClient = new ShareLeaseClientBuilder()
        .fileClient(fileClient)
        .shareTokenIntent(ShareTokenIntent.BACKUP)
        .buildClient();
        
try {
    // Acquire a lease on the file with infinite duration
    fileLeaseClient.acquireLease();
    System.out.println("Lease acquired successfully");
            
    // Do something with the file

} catch (Exception e) {
    System.err.println("Error: " + e.getMessage());
} finally {
    // Release the lease when finished
    try {
        fileLeaseClient.releaseLease();
        System.out.println("Lease released successfully.");
    } catch (Exception e) {
        System.err.println(e.getMessage());
    }
}

Quando si usano sia SMB che l'API FileREST, tenere presente che l'API FileREST usa lease per gestire i blocchi di file, mentre SMB usa blocchi del file system gestiti dal sistema operativo. Per altre informazioni sulla gestione delle interazioni di blocco dei file tra SMB e l'API FileREST, vedere Gestire i blocchi di file.

Esempio: creare ed elencare snapshot di condivisioni usando la libreria client di Condivisioni file

Gli snapshot di condivisione sono copie di sola lettura di una condivisione file in un momento specifico. È possibile creare uno snapshot di una condivisione file e quindi usare lo snapshot per accedere ai dati nella condivisione al momento della creazione dello snapshot. È anche possibile elencare tutti gli snapshot in una condivisione file ed eliminare gli snapshot di condivisione.

Nell'esempio di codice seguente viene illustrato come creare uno snapshot di condivisione, elencare gli snapshot in una condivisione file e attraversare l'albero della directory in uno snapshot di condivisione:

import com.azure.storage.file.share.*;
import com.azure.storage.file.share.models.*;

// Add the following code to a new or existing function

public static void main(String[] args) {
    String connectionString = "<connection-string>";

    // Create a ShareServiceClient from which you can create clients for specific shares
    ShareServiceClient shareServiceClient = new ShareServiceClientBuilder()
    .connectionString(connectionString)
        .buildClient();
        
    // Get a client for a specific share
    ShareClient shareClient = shareServiceClient.getShareClient("sample-file-share");

    try {
        // Create a snapshot
        ShareSnapshotInfo snapshotInfo = shareClient.createSnapshot();
        System.out.println("Snapshot created: " + snapshotInfo.getSnapshot());

        // List snapshots in a share
        ListSharesOptions options = new ListSharesOptions()
            .setIncludeSnapshots(true);
                
        for (ShareItem shareItem : shareServiceClient.listShares(options, null, null)) {
            if (shareItem.getSnapshot() != null) {
                System.out.println("Share: " + shareItem.getName() + 
                    " (Snapshot: " + shareItem.getSnapshot() + ")");
            }
        }

        // List directories and files in a share snapshot
        String snapshotTimestamp = snapshotInfo.getSnapshot();
        ShareClient shareSnapshot = shareClient.getSnapshotClient(snapshotTimestamp);
        ShareDirectoryClient rootDir = shareSnapshot.getRootDirectoryClient();

        listDirectoryTree(rootDir);
            
    } catch (Exception e) {
        System.err.println("Error: " + e.getMessage());
    }
 }
    
private static void listDirectoryTree(ShareDirectoryClient directory) {
    // List all files and directories in current directory
    for (ShareFileItem fileItem : directory.listFilesAndDirectories()) {
        if (fileItem.isDirectory()) {
            System.out.println("Directory: " + fileItem.getName());
            // Recursively list subdirectory contents
            listDirectoryTree(directory.getSubdirectoryClient(fileItem.getName()));
        } else {
            System.out.println("File: " + fileItem.getName());
        }
    }
}

Annotazioni

I token OAuth, ad esempio quelli ottenuti quando si usa DefaultAzureCredential, non sono consentiti per le operazioni del piano dati a livello di condivisione file. Per usare gli snapshot di condivisione, l'oggetto client deve essere autorizzato usando la chiave dell'account. L'oggetto ShareClient creato in questo esempio di codice usa una stringa di connessione, che include la chiave dell'account.

L'archiviazione delle chiavi dell'account o delle stringhe di connessione presenta un rischio per la sicurezza. È consigliabile usarli solo quando l'autenticazione di Microsoft Entra non è disponibile. Per altre informazioni sull'archiviazione sicura delle chiavi dell'account in Azure Key Vault, vedere Informazioni sulle chiavi dell'account di archiviazione gestito di Azure Key Vault.

Gestire le risorse di File di Azure usando le librerie di gestione di Archiviazione di Azure

Le librerie di gestione di Archiviazione di Azure sono basate sull'API REST del provider di risorse di Archiviazione di Azure. Il provider di risorse di Archiviazione di Azure è un servizio basato su Azure Resource Manager e supporta sia metodi dichiarativi (modelli) che imperativi (chiamata API diretta). L'API REST del provider di risorse di Archiviazione di Azure fornisce l'accesso a livello di codice alle risorse di Archiviazione di Azure, incluse le condivisioni file. Azure SDK offre librerie di gestione basate sull'API REST del provider di risorse di Archiviazione di Azure.

Le librerie di gestione sono consigliate per le operazioni eseguite a livello di servizio file o condivisione file . In questa sezione si apprenderà come usare le librerie di gestione di Archiviazione di Azure per gestire le risorse di File di Azure.

Le librerie di gestione di Archiviazione di Azure sono basate sull'API REST del provider di risorse di Archiviazione di Azure. Il provider di risorse di Archiviazione di Azure è un servizio basato su Azure Resource Manager e supporta sia metodi dichiarativi (modelli) che imperativi (chiamata API diretta). L'API REST del provider di risorse di Archiviazione di Azure fornisce l'accesso a livello di codice alle risorse di Archiviazione di Azure, incluse le condivisioni file. Azure SDK offre librerie di gestione basate sull'API REST del provider di risorse di Archiviazione di Azure.

Le librerie di gestione sono consigliate per le operazioni eseguite a livello di servizio file o condivisione file . In questa sezione si apprenderà come usare le librerie di gestione di Archiviazione di Azure per gestire le risorse di File di Azure.

Esempio: Creare una condivisione file usando la libreria di gestione di Archiviazione di Azure

L'esempio di codice seguente illustra come creare un oggetto di primo livello AzureResourceManager , registrare il provider di risorse di archiviazione con una sottoscrizione e creare una condivisione file usando la libreria di gestione di Archiviazione di Azure:

import com.azure.identity.*;
import com.azure.resourcemanager.*;
import com.azure.resourcemanager.storage.fluent.*;
import com.azure.resourcemanager.storage.fluent.models.*;

import com.azure.core.credential.TokenCredential;
import com.azure.core.management.*;
import com.azure.core.management.profile.*;

// Add the following code to a new or existing function

String subscriptionID = "<subscription-id>";
String rgName = "<resource-group-name>";
String saName = "<storage-account-name>";
TokenCredential credential = new DefaultAzureCredentialBuilder().build();
AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);

AzureResourceManager armClient = AzureResourceManager
        .configure()
        .authenticate(credential, profile)
        .withSubscription(subscriptionID);

// Check the registration state of the resource provider and register, if needed
if (armClient.providers().getByName("Microsoft.Storage").registrationState() == "NotRegistered")
    armClient.providers().register("Microsoft.Storage");

// Create a new file share

StorageManagementClient storageManagementClient = armClient.storageAccounts().manager().serviceClient();
FileSharesClient fileShare = storageManagementClient.getFileShares();

String shareName = "sample-file-share";
int quotaInGB = 1;
        
// Create the file share
fileShare.create(
    rgName,
    saName,
    shareName,
    new FileShareInner()
        .withShareQuota(quotaInGB)
);

È possibile configurare le proprietà della condivisione file usando la classe FileShareInner . Nell'esempio precedente viene illustrato come impostare la quota di condivisione durante la creazione della condivisione file. Per aggiornare una condivisione file esistente, chiamare fileShare.update() e passare l'oggetto FileShareInner con le proprietà da aggiornare.

Annotazioni

Per eseguire l'operazione di registrazione, sono necessarie le autorizzazioni per la seguente azione di RBAC di Azure: Microsoft.Storage/register/action. Questa autorizzazione è inclusa nei ruoli predefiniti Collaboratore e Proprietario.

Esempio: Elencare condivisioni file e snapshot usando la libreria di gestione di Archiviazione di Azure

L'esempio di codice seguente illustra come elencare condivisioni file e snapshot in un account di archiviazione:

import com.azure.identity.*;
import com.azure.resourcemanager.*;
import com.azure.resourcemanager.storage.fluent.*;
import com.azure.resourcemanager.storage.fluent.models.*;

import com.azure.core.credential.TokenCredential;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.management.*;
import com.azure.core.management.profile.*;
import com.azure.core.util.Context;

// Add the following code to a new or existing function

String subscriptionID = "<subscription-id>";
String rgName = "<resource-group-name>";
String saName = "<storage-account-name>";
TokenCredential credential = new DefaultAzureCredentialBuilder().build();
AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);

AzureResourceManager armClient = AzureResourceManager
        .configure()
        .authenticate(credential, profile)
        .withSubscription(subscriptionID);

// Check the registration state of the resource provider and register, if needed
if (armClient.providers().getByName("Microsoft.Storage").registrationState() == "NotRegistered")
    armClient.providers().register("Microsoft.Storage");

StorageManagementClient storageManagementClient = armClient.storageAccounts().manager().serviceClient();
FileSharesClient fileShare = storageManagementClient.getFileShares();

// List all file shares and include snapshots

PagedIterable<FileShareItemInner> fileShares = fileShare.list(
    rgName,               // resource group name
    saName,               // storage account name
    null,                 // maxpagesize
    null,                 // filter
    "snapshots",          // expand to include snapshots
    Context.NONE);        // context

for (FileShareItemInner fileShareItem : fileShares) {
    System.out.println("File share name: " + fileShareItem.name());
    System.out.println("File share quota: " + fileShareItem.shareQuota());
}

Passaggi successivi

Per altre informazioni sullo sviluppo con File di Azure, vedere le risorse seguenti:

  • Last updated on