Partage via

Développer pour Azure Files avec Java

Découvrez comment développer des applications Java qui utilisent Azure Files pour stocker des données. Azure Files est un service de partage de fichiers managé dans le cloud. Il fournit des partages de fichiers entièrement managés accessibles via les protocoles SMB (Server Message Block) et NFS (Network File System). Azure Files fournit également une API REST pour l’accès par programmation aux partages de fichiers.

Dans cet article, vous allez découvrir les différentes approches de développement avec Azure Files en Java et comment choisir l’approche qui convient le mieux aux besoins de votre application. Vous allez également apprendre à créer une application console de base qui interagit avec les ressources Azure Files.

S’applique à

Modèle de gestion Modèle de facturation Échelon médiatique Redondance SMB NFS
Microsoft.Storage V2 approvisionné HDD (standard) Local (LRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) Zone (ZRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) Géo (GRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) GeoZone (GZRS) Oui Non
Microsoft.Storage V1 approvisionné SSD (Premium) Local (LRS) Oui Non
Microsoft.Storage V1 approvisionné SSD (Premium) Zone (ZRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Local (LRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Zone (ZRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Géo (GRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) GeoZone (GZRS) Oui Non

À propos du développement d’applications Java avec Azure Files

Azure Files offre plusieurs façons aux développeurs Java d’accéder aux données et de gérer les ressources dans Azure Files. Le tableau suivant répertorie les approches, résume leur fonctionnement et fournit des conseils sur le moment où utiliser chaque approche :

Approche Fonctionnement Quand utiliser
Bibliothèques d’E/S de fichiers standard Utilise des appels d’API au niveau du système d’exploitation via des partages de fichiers Azure montés à l’aide de SMB ou NFS. Lorsque vous montez un partage de fichiers à l’aide de SMB/NFS, vous pouvez utiliser des bibliothèques d’E/S de fichiers pour un langage de programmation ou une infrastructure, comme java.io et java.nio pour Java. Vous disposez d’applications métier avec du code existant qui utilise des E/S de fichiers standard, et vous ne souhaitez pas réécrire du code pour que l’application fonctionne avec un partage de fichiers Azure.
FileREST API Appelle directement des points de terminaison HTTPS pour interagir avec les données stockées dans Azure Files. Fournit un contrôle programmatique sur les ressources de partage de fichiers. Le Kit de développement logiciel (SDK) Azure fournit la bibliothèque de client Partages de fichiers (com.azure.storage.file.share) qui s’appuie sur l’API FileREST, ce qui vous permet d’interagir avec les opérations de l’API FileREST via des paradigmes de langage de programmation Java familiers. Vous créez des services cloud et des applications cloud à valeur ajoutée pour les clients et vous souhaitez utiliser des fonctionnalités avancées non disponibles via des bibliothèques d’E/S de fichiers standard.
API REST du fournisseur de ressources de stockage Utilise Azure Resource Manager (ARM) pour gérer les comptes de stockage et les partages de fichiers. Appelle des points de terminaison d’API REST pour différentes opérations de gestion de ressources. Votre application ou service doit effectuer des tâches de gestion des ressources, telles que la création, la suppression ou la mise à jour de comptes de stockage ou de partages de fichiers.

Pour obtenir des informations générales sur ces approches, consultez Vue d’ensemble du développement d’applications avec Azure Files.

Cet article se concentre sur l’utilisation des ressources Azure Files à l’aide des approches suivantes :

Conditions préalables

Configurer votre environnement

Remarque

Cet article utilise l’outil de génération Maven pour générer et exécuter l’exemple de code. D’autres outils de génération, comme Gradle, fonctionnent également avec le Kit de développement logiciel (SDK) Azure pour Java.

Utilisez Maven pour créer une application console ou ouvrir un projet existant. Suivez ces étapes pour installer des packages et ajouter les directives import nécessaires.

Installer des packages

Ouvrez le fichier pom.xml dans votre éditeur de texte. Installez les packages en incluant le fichier BOM ou en incluant une dépendance directe.

Inclure le fichier BOM

Ajoutez azure-sdk-bom pour établir une dépendance sur la dernière version de la bibliothèque. Dans l’extrait de code suivant, remplacez l’espace réservé {bom_version_to_target} par le numéro de version. L’utilisation d’azure-sdk-bom vous empêche de devoir spécifier la version de chaque dépendance individuelle. Pour en savoir plus sur la nomenclature, consultez le fichier Lisez-moi de la nomenclature du SDK Azure.

<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>

Ajoutez les éléments de dépendance suivants au groupe de dépendances. La dépendance azure-identity est nécessaire pour les connexions sans mot de passe aux services Azure. Notez que les artefacts du gestionnaire de ressources ne sont pas inclus dans le fichier BOM. Vous devez donc les ajouter en tant que dépendances directes.

<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>

Inclure une dépendance directe

Pour prendre une dépendance sur une version particulière de la bibliothèque, ajoutez la dépendance directe à votre projet :

<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>

Inclure des directives d’importation

Ouvrez ensuite votre fichier de code et ajoutez les directives import nécessaires. Dans cet exemple, nous ajoutons les directives suivantes dans le fichier 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.*;

Si vous envisagez d’utiliser les bibliothèques d’E/S de fichier Java, vous devez également ajouter les directives d’importation suivantes :

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

Utiliser Azure Files à l’aide de bibliothèques d’E/S de fichiers Java

Les bibliothèques d’E/S de fichiers standard sont le moyen le plus courant d’accéder aux ressources Azure Files et de les utiliser. Lorsque vous montez un partage de fichiers à l’aide de SMB ou NFS, votre système d’exploitation redirige les demandes d’API pour le système de fichiers local. Cette approche vous permet d’utiliser des bibliothèques d’E/S de fichiers standard, telles que java.io et java.nio, pour interagir avec des fichiers et des répertoires dans le partage.

Envisagez d’utiliser des bibliothèques d’E/S de fichiers Java lorsque votre application nécessite :

  • Compatibilité des applications : Idéal pour les applications métier avec du code existant qui utilise déjà des bibliothèques d’E/S de fichiers Java. Vous n’avez pas besoin de réécrire du code pour que l’application fonctionne avec un partage de fichiers Azure.
  • Facilité d’utilisation : Les bibliothèques d’E/S de fichiers Java sont bien connues des développeurs et faciles à utiliser. Une proposition de valeur clé d’Azure Files est qu’elle expose des API de système de fichiers natives via SMB et NFS.

Dans cette section, vous allez apprendre à utiliser des bibliothèques d’E/S de fichiers Java pour utiliser des ressources Azure Files.

Pour plus d’informations et d’exemples, consultez la ressource suivante :

Monter un partage de fichiers

Pour utiliser des bibliothèques d’E/S de fichiers Java, vous devez d’abord monter un partage de fichiers. Consultez les ressources suivantes pour obtenir des conseils sur le montage d’un partage de fichiers à l’aide de SMB ou NFS :

Dans cet article, nous utilisons le chemin suivant pour faire référence à un partage de fichiers SMB monté sur Windows :

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

Exemple : Se connecter à un partage de fichiers et énumérer des répertoires à l’aide de bibliothèques d’E/S de fichiers Java

L’exemple de code suivant montre comment se connecter à un partage de fichiers et répertorier les répertoires du partage :

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());
}

Exemple : Écrire dans un fichier dans un partage de fichiers à l’aide de bibliothèques d’E/S de fichiers Java

L’exemple de code suivant montre comment écrire et ajouter du texte à un fichier :

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());
}

Exemple : Verrouiller un fichier dans un partage de fichiers à l’aide de bibliothèques d’E/S de fichiers Java

Les clients SMB qui montent des partages de fichiers peuvent utiliser des mécanismes de verrouillage du système de fichiers pour gérer l’accès aux fichiers partagés.

L’exemple de code suivant montre comment verrouiller un fichier dans un partage de fichiers :

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();
}

Lorsque vous utilisez SMB et l’API FileREST, gardez à l’esprit que l’API FileREST utilise des baux pour gérer les verrous de fichier, tandis que SMB utilise des verrous de système de fichiers gérés par le système d’exploitation. Pour en savoir plus sur la gestion des interactions de verrouillage de fichiers entre SMB et l’API FileREST, consultez Gérer les verrous de fichier.

Exemple : Énumérer des listes de contrôle d’accès de fichier à l’aide de bibliothèques d’E/S de fichiers Java

L’exemple de code suivant montre comment énumérer les listes de contrôle d’accès (ACL) pour un fichier :

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());
}

Utiliser Azure Files à l’aide de la bibliothèque cliente Partages de fichiers pour Java

L’API FileREST fournit un accès programmatique à Azure Files. Il vous permet d’appeler des points de terminaison HTTPS pour effectuer des opérations sur des partages de fichiers, des répertoires et des fichiers. L’API FileREST est conçue pour une scalabilité élevée et des fonctionnalités avancées qui peuvent ne pas être disponibles via des protocoles natifs. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques clientes, telles que la bibliothèque cliente partages de fichiers pour Java, qui s’appuient sur l’API FileREST.

Envisagez d’utiliser l’API FileREST et la bibliothèque cliente de partage de fichiers si votre application nécessite :

  • Fonctionnalités avancées : Opérations et fonctionnalités d’accès qui ne sont pas disponibles via des protocoles natifs.
  • Intégrations cloud personnalisées : Créez des services à valeur ajoutée personnalisés, tels que la sauvegarde, l’antivirus ou la gestion des données, qui interagissent directement avec Azure Files.
  • Optimisation des performances : Tirez parti des avantages en matière de performances dans les scénarios à grande échelle à l’aide d’opérations de plan de données.

L’API FileREST modélise Azure Files en tant que hiérarchie de ressources et est recommandée pour les opérations effectuées au niveau du répertoire ou du fichier . Vous devez préférer l’API REST du fournisseur de ressources de stockage pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers .

Dans cette section, vous allez apprendre à utiliser la bibliothèque cliente Partages de fichiers pour Java afin d’utiliser des ressources Azure Files.

Pour plus d’informations et d’exemples, consultez les ressources suivantes :

Autoriser l’accès et créer un client

Pour connecter une application à Azure Files, créez un ShareClient objet. Cet objet est votre point de départ pour l’utilisation des ressources Azure Files. Les exemples de code suivants montrent comment créer un ShareClient objet à l’aide de différents mécanismes d’autorisation.

Pour autoriser avec Microsoft Entra ID, vous devez utiliser un principal de sécurité. Le type de principal de sécurité dont vous avez besoin dépend de l’emplacement d’exécution de votre application. Pour en savoir plus sur les scénarios d’authentification, consultez l’authentification Azure avec Java et Azure Identity.

Pour utiliser les exemples de code de cet article, attribuez le rôle intégré d’Azure RBAC Storage File Data Privileged Contributor au principal de sécurité. Ce rôle fournit un accès complet en lecture, écriture, modification des ACL et suppression sur toutes les données des partages pour tous les comptes de stockage configurés, quelles que soient les autorisations NTFS définies au niveau du fichier/répertoire. Pour plus d’informations, consultez Accéder aux partages de fichiers Azure à l’aide de Microsoft Entra ID avec Azure Files OAuth via REST.

Autoriser l’accès en utilisant DefaultAzureCredential

Un moyen simple et sécurisé d’autoriser l’accès et de se connecter à Azure Files consiste à obtenir un jeton OAuth en créant une instance DefaultAzureCredential . Vous pouvez ensuite utiliser ces informations d’identification pour créer un objet ShareClient.

L’exemple suivant crée un objet ShareClient autorisé à l'aide de DefaultAzureCredential, puis crée un objet ShareDirectoryClient pour travailler avec un répertoire dans le partage :

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");

Si vous connaissez exactement le type d’informations d’identification que vous utilisez pour authentifier les utilisateurs, vous pouvez obtenir un jeton OAuth à l’aide d’autres classes de la bibliothèque cliente Azure Identity pour Java. Ces classes dérivent de la classe TokenCredential.

Pour en savoir plus sur chacun de ces mécanismes d’autorisation, consultez Choisir comment autoriser l’accès aux données de fichier.

Exemple : Copier des fichiers à l’aide de la bibliothèque cliente Partages de fichiers

Vous pouvez copier des fichiers dans un partage de fichiers ou entre des partages de fichiers à l’aide de la méthode suivante :

Vous pouvez copier un fichier dans un objet blob de destination à l’aide de la méthode suivante à partir d’un BlockBlobClient objet :

L’exemple de code suivant montre comment copier un fichier dans un fichier dans un autre partage de fichiers :

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());

Exemple : louer un fichier à l’aide de la bibliothèque cliente Partages de fichiers

Un bail crée un verrou sur un fichier géré par Azure via un ID de bail. Le bail fournit un mécanisme permettant de coordonner l’accès aux fichiers entre plusieurs clients d’un système distribué. Un bail sur un fichier fournit un accès exclusif en écriture et suppression. Pour en savoir plus sur les états de bail et les actions, consultez Fichier de bail.

L’exemple de code suivant montre comment créer un client de bail, acquérir un bail de durée infinie sur un fichier et libérer le bail :

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());
    }
}

Lorsque vous utilisez SMB et l’API FileREST, gardez à l’esprit que l’API FileREST utilise des baux pour gérer les verrous de fichier, tandis que SMB utilise des verrous de système de fichiers gérés par le système d’exploitation. Pour en savoir plus sur la gestion des interactions de verrouillage de fichiers entre SMB et l’API FileREST, consultez Gérer les verrous de fichier.

Exemple : Créer et répertorier des instantanés de partage à l’aide de la bibliothèque cliente Partages de fichiers

Les instantanés de partage sont des copies en lecture seule d’un partage de fichiers à un moment donné. Vous pouvez créer un instantané d’un partage de fichiers, puis utiliser l’instantané pour accéder aux données du partage au moment de la création de l’instantané. Vous pouvez également répertorier tous les instantanés d’un partage de fichiers et supprimer des instantanés de partage.

L’exemple de code suivant montre comment créer un instantané de partage, répertorier les instantanés d’un partage de fichiers et parcourir l’arborescence de répertoires dans un instantané de partage :

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());
        }
    }
}

Remarque

Les jetons OAuth, tels que ceux obtenus lors de l’utilisation DefaultAzureCredential, ne sont pas autorisés pour les opérations de plan de données au niveau du partage de fichiers. Pour utiliser des instantanés de partage, l'objet client doit être autorisé avec la clé de compte. L’objet ShareClient créé dans cet exemple de code utilise une chaîne de connexion, qui inclut la clé de compte.

Le stockage des clés de compte ou des chaînes de connexion présente un risque de sécurité. Vous ne devez les utiliser que lorsque l’authentification Microsoft Entra n’est pas disponible. Pour en savoir plus sur le stockage sécurisé des clés de compte dans Azure Key Vault, consultez À propos des clés de compte de stockage managé Azure Key Vault.

Gérer les ressources Azure Files à l’aide des bibliothèques de gestion stockage Azure

Les bibliothèques de gestion stockage Azure sont basées sur l’API REST du fournisseur de ressources Stockage Azure. Le fournisseur de ressources Stockage Azure est un service basé sur Azure Resource Manager et prend en charge les méthodes déclaratives (modèles) et impératives (appel d’API directe). L’API REST du fournisseur de ressources Stockage Azure fournit un accès programmatique aux ressources stockage Azure, y compris les partages de fichiers. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques de gestion qui s’appuient sur l’API REST du fournisseur de ressources stockage Azure.

Les bibliothèques de gestion sont recommandées pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers . Dans cette section, vous allez apprendre à utiliser les bibliothèques de gestion stockage Azure pour gérer les ressources Azure Files.

Les bibliothèques de gestion stockage Azure sont basées sur l’API REST du fournisseur de ressources Stockage Azure. Le fournisseur de ressources Stockage Azure est un service basé sur Azure Resource Manager et prend en charge les méthodes déclaratives (modèles) et impératives (appel d’API directe). L’API REST du fournisseur de ressources Stockage Azure fournit un accès programmatique aux ressources stockage Azure, y compris les partages de fichiers. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques de gestion qui s’appuient sur l’API REST du fournisseur de ressources stockage Azure.

Les bibliothèques de gestion sont recommandées pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers . Dans cette section, vous allez apprendre à utiliser les bibliothèques de gestion stockage Azure pour gérer les ressources Azure Files.

Exemple : Créer un partage de fichiers à l’aide de la bibliothèque de gestion stockage Azure

L’exemple de code suivant montre comment créer un objet de niveau AzureResourceManager supérieur, inscrire le fournisseur de ressources de stockage avec un abonnement et créer un partage de fichiers à l’aide de la bibliothèque de gestion stockage 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)
);

Vous pouvez configurer les propriétés de partage de fichiers à l’aide de la classe FileShareInner . L’exemple précédent montre comment définir le quota de partage lors de la création du partage de fichiers. Pour mettre à jour un partage de fichiers existant, appelez fileShare.update() et transmettez l’objet FileShareInner avec les propriétés que vous souhaitez mettre à jour.

Remarque

Pour effectuer l’opération d’inscription, vous avez besoin d’autorisations pour l’action RBAC Azure suivante : Microsoft.Storage/register/action. Cette autorisation est incluse dans les rôles intégrés Contributeur et Propriétaire.

Exemple : répertorier les partages de fichiers et les instantanés à l’aide de la bibliothèque de gestion stockage Azure

L’exemple de code suivant montre comment répertorier les partages de fichiers et les instantanés dans un compte de stockage :

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());
}

Étapes suivantes

Pour plus d’informations sur le développement avec Azure Files, consultez les ressources suivantes :