Partage via

Utiliser Java pour gérer les répertoires et les fichiers dans Azure Data Lake Storage

  • Article

Cet article vous explique comment utiliser Java pour créer et gérer les répertoires et les fichiers sur les comptes de stockage dotés d’un espace de noms hiérarchique.

Pour en savoir plus sur la façon d’obtenir, de définir et de mettre à jour les listes de contrôle d’accès (ACL, Access Control List) des répertoires et des fichiers, consultez Utiliser Java pour gérer les listes de contrôle d’accès dans Azure Data Lake Storage.

Package (Maven) | Exemples | Référence de l’API | Mappage de Gen1 à Gen2 | Envoyer des commentaires

Prérequis

  • Un abonnement Azure. Pour plus d’informations, consultez Obtenir l’essai gratuit Azure.

  • Un compte de stockage doté d’un espace de noms hiérarchique activé. Pour créer un test, suivez ces instructions.

Configuration de votre projet

Pour commencer, ouvrez cette page et recherchez la dernière version de la bibliothèque Java. Ensuite, ouvrez le fichier pom.xml dans votre éditeur de texte. Ajoutez un élément de dépendance qui référence cette version.

Si vous envisagez d'authentifier votre application client à l'aide de Microsoft Entra ID, ajoutez une dépendance à la bibliothèque Azure Identity. Pour plus d’informations, consultez Bibliothèque de clients Azure Identity pour Java.

Ajoutez ensuite ces instructions Imports à votre fichier de code.

import com.azure.identity.*;
import com.azure.storage.common.StorageSharedKeyCredential;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.util.BinaryData;
import com.azure.storage.file.datalake.*;
import com.azure.storage.file.datalake.models.*;
import com.azure.storage.file.datalake.options.*;

Remarque

L’accès multiprotocole sur Data Lake Storage permet aux applications d’utiliser à la fois les API Blob et les API Data Lake Storage Gen2 pour utiliser des données dans des comptes de stockage dont l’espace de noms hiérarchique (HNS) est activé. Lorsque vous travaillez avec des fonctionnalités propres à Data Lake Storage Gen2, telles que les opérations de répertoire et les listes ACL, utilisez les API de Data Lake Storage Gen2, comme indiqué dans cet article.

Lorsque vous choisissez les API à utiliser dans un scénario donné, tenez compte de la charge de travail et des besoins de votre application, ainsi que des problèmes connus et de l’impact de HNS sur les charges de travail et les applications.

Autoriser l’accès aux ressources de données et se connecter à celles-ci

Pour utiliser les exemples de code de cet article, vous devez créer une instance DataLakeServiceClient autorisée qui représente le compte de stockage. Vous pouvez autoriser un objet DataLakeServiceClient à l'aide de Microsoft Entra ID, d'une clé d'accès au compte ou d'une signature d'accès partagé (SAP).

Vous pouvez utiliser la bibliothèque cliente d'identité Azure pour Java pour authentifier votre application avec Microsoft Entra ID.

Créez une instance DataLakeServiceClient et transmettez une nouvelle instance de la classe DefaultAzureCredential.

static public DataLakeServiceClient GetDataLakeServiceClient(String accountName){
    DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

    DataLakeServiceClient dataLakeServiceClient = new DataLakeServiceClientBuilder()
        .endpoint("https://" + accountName + ".dfs.core.windows.net")
        .credential(defaultCredential)
        .buildClient();

    return dataLakeServiceClient;
}

Pour en savoir plus sur l'utilisation de DefaultAzureCredential pour l'autorisation d'accès aux données, consultez Bibliothèque cliente Azure Identity pour Java.

Créez un conteneur.

Un conteneur fait office de système de fichiers pour vos fichiers. Vous pouvez créer un conteneur à l’aide de la méthode suivante :

L’exemple de code suivant crée un conteneur et retourne un objet DataLakeFileSystemClient pour une utilisation ultérieure :

public DataLakeFileSystemClient CreateFileSystem(
        DataLakeServiceClient serviceClient,
        String fileSystemName) {

    DataLakeFileSystemClient fileSystemClient = serviceClient.createFileSystem(fileSystemName);

    return fileSystemClient;
}

Créer un répertoire

Vous pouvez créer une référence de répertoire dans le conteneur à l’aide de la méthode suivante :

L’exemple de code suivant ajoute un répertoire à un conteneur, puis ajoute un sous-répertoire et retourne un objet DataLakeDirectoryClient pour une utilisation ultérieure :

public DataLakeDirectoryClient CreateDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryName,
        String subDirectoryName) {

    DataLakeDirectoryClient directoryClient = fileSystemClient.createDirectory(directoryName);

    return directoryClient.createSubdirectory(subDirectoryName);
}

Renommer ou déplacer un répertoire

Vous pouvez renommer ou déplacer un répertoire à l’aide de la méthode suivante :

Transmettez le chemin d’accès au répertoire souhaité en tant que paramètre. L’exemple de code suivant montre comment renommer un sous-répertoire :

public DataLakeDirectoryClient RenameDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryPath,
        String subdirectoryName,
        String subdirectoryNameNew) {

    DataLakeDirectoryClient directoryClient = fileSystemClient
            .getDirectoryClient(String.join("/", directoryPath, subdirectoryName));

    return directoryClient.rename(
            fileSystemClient.getFileSystemName(),
            String.join("/", directoryPath, subdirectoryNameNew));
}

L’exemple de code suivant montre comment déplacer un sous-répertoire d’un répertoire vers un autre :

public DataLakeDirectoryClient MoveDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryPathFrom,
        String directoryPathTo,
        String subdirectoryName) {

    DataLakeDirectoryClient directoryClient = fileSystemClient
            .getDirectoryClient(String.join("/", directoryPathFrom, subdirectoryName));

    return directoryClient.rename(
            fileSystemClient.getFileSystemName(),
            String.join("/", directoryPathTo, subdirectoryName));
}

Charger un fichier dans un répertoire

Vous pouvez charger un contenu dans un fichier nouveau ou existant à l’aide de la méthode suivante :

L’exemple de code suivant montre comment charger un fichier local dans un répertoire à l’aide de la uploadFromFile méthode :

public void UploadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

    fileClient.uploadFromFile("filePath/sample-file.txt");
}

Vous pouvez utiliser cette méthode pour créer et charger du contenu dans un nouveau fichier, ou vous pouvez définir le overwrite paramètre sur true pour remplacer un fichier existant.

Ajouter des données à un fichier

Vous pouvez charger des données à ajouter à un fichier à l’aide de la méthode suivante :

L’exemple de code suivant montre comment ajouter des données à la fin d’un fichier en procédant comme suit :

  • Créez un objet DataLakeFileClient pour représenter la ressource de fichier avec laquelle vous travaillez.
  • Téléchargez les données dans le fichier à l'aide de la méthode DataLakeFileClient.append.
  • Terminez le téléchargement en appelant la méthode DataLakeFileClient.flush pour écrire les données précédemment téléchargées dans le fichier.
public void AppendDataToFile(
        DataLakeDirectoryClient directoryClient) {

    DataLakeFileClient fileClient = directoryClient.getFileClient("sample-file.txt");
    long fileSize = fileClient.getProperties().getFileSize();

    String sampleData = "Data to append to end of file";
    fileClient.append(BinaryData.fromString(sampleData), fileSize);

    fileClient.flush(fileSize + sampleData.length(), true);
}

Télécharger à partir d’un répertoire

L’exemple de code suivant montre comment télécharger un fichier à partir d’un répertoire vers un fichier local en procédant comme suit :

  • Créez un objet DataLakeFileClient pour représenter le fichier que vous souhaitez télécharger.
  • Utilisez la méthode DataLakeFileClient.readToFile pour lire le fichier. Cet exemple définit le paramètre overwrite sur true, qui remplace un fichier existant.
public void DownloadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

    fileClient.readToFile("filePath/sample-file.txt", true);
}

Afficher le contenu du répertoire

Vous pouvez répertorier le contenu d’un répertoire à l’aide de la méthode suivante et énumérer le résultat :

L’énumération des chemins d’accès dans le résultat peut faire plusieurs requêtes au service lors de l’extraction des valeurs.

L’exemple de code suivant affiche les noms de chaque fichier situé dans un répertoire :

public void ListFilesInDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryName) {

    ListPathsOptions options = new ListPathsOptions();
    options.setPath(directoryName);

    PagedIterable<PathItem> pagedIterable = fileSystemClient.listPaths(options, null);

    java.util.Iterator<PathItem> iterator = pagedIterable.iterator();
    PathItem item = iterator.next();

    while (item != null) {
        System.out.println(item.getName());

        if (!iterator.hasNext()) {
            break;
        }
        item = iterator.next();
    }

}

Supprimer un répertoire

Vous pouvez supprimer un répertoire en utilisant l’une des méthodes suivantes :

L’exemple de code suivant utilise deleteWithResponse pour supprimer un répertoire non vide et tous les chemins d’accès sous ce répertoire :

public void DeleteDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryName) {

    DataLakeDirectoryClient directoryClient = fileSystemClient.getDirectoryClient(directoryName);

    // Set to true to delete all paths beneath the directory
    boolean recursive = true;

    directoryClient.deleteWithResponse(recursive, null, null, null);
}

Voir aussi