Usare Java per gestire directory e file in Azure Data Lake Archiviazione Gen2

Articolo
04/09/2024

Questo articolo illustra come usare Java per creare e gestire directory e file negli account di archiviazione con uno spazio dei nomi gerarchico.

Per informazioni su come ottenere, impostare e aggiornare gli elenchi di controllo di accesso (ACL) di directory e file, vedere Usare . Java per gestire gli elenchi di controllo di accesso in Azure Data Lake Archiviazione Gen2.

Riferimento all'API | | package (Maven) | Da Gen1 a Gen2 | Per inviare commenti e suggerimenti

Prerequisiti

Una sottoscrizione di Azure. Per altre informazioni, vedere Ottenere la versione di valutazione gratuita di Azure.
Un account di archiviazione con spazio dei nomi gerarchico abilitato. Per crearne uno, seguire queste istruzioni.

Impostare il progetto

Per iniziare, aprire questa pagina e trovare la versione più recente della libreria Java. Aprire quindi il file pom.xml nell'editor di testo. Aggiungere un elemento di dipendenza che fa riferimento a tale versione.

Se si prevede di autenticare l'applicazione client usando Microsoft Entra ID, aggiungere una dipendenza alla libreria di identità di Azure. Per altre informazioni, vedere Libreria client di Identità di Azure per Java.

Aggiungere quindi queste istruzioni imports al file di codice.

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.*;

Nota

L'accesso multi-protocollo in Data Lake Archiviazione consente alle applicazioni di usare sia le API BLOB che le API Data Lake Archiviazione Gen2 per lavorare con i dati negli account di archiviazione con lo spazio dei nomi gerarchico (HNS) abilitato. Quando si usano funzionalità specifiche di Data Lake Archiviazione Gen2, ad esempio le operazioni di directory e gli ACL, usare le API Data Lake Archiviazione Gen2, come illustrato in questo articolo.

Quando si scelgono le API da usare in uno scenario specifico, prendere in considerazione il carico di lavoro e le esigenze dell'applicazione, insieme ai problemi noti e all'impatto di HNS su carichi di lavoro e applicazioni.

Autorizzare l'accesso e connettersi alle risorse dati

Per usare gli esempi di codice in questo articolo, è necessario creare un'istanza di DataLakeServiceClient autorizzata che rappresenta l'account di archiviazione. È possibile autorizzare un DataLakeServiceClient oggetto usando l'ID Microsoft Entra, una chiave di accesso all'account o una firma di accesso condiviso.

È possibile usare la libreria client di identità di Azure per Java per autenticare l'applicazione con l'ID Microsoft Entra.

Creare un'istanza di DataLakeServiceClient e passare una nuova istanza della 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;
}

Per altre informazioni sull'uso DefaultAzureCredential di per autorizzare l'accesso ai dati, vedere Libreria client di Identità di Azure per Java.

Per usare un token di firma di accesso condiviso (SAS), specificare il token come stringa e inizializzare un oggetto DataLakeServiceClient . Se l'URL dell'account include il token di firma di accesso condiviso, omettere il parametro delle credenziali.

static public DataLakeServiceClient GetDataLakeServiceClientSAS(String accountName, String sasToken){
    DataLakeServiceClient dataLakeServiceClient = new DataLakeServiceClientBuilder()
        .endpoint("https://" + accountName + ".dfs.core.windows.net")
        .sasToken(sasToken)
        .buildClient();

    return dataLakeServiceClient;
}

Per altre informazioni sulla generazione e la gestione dei token di firma di accesso condiviso, vedere l'articolo seguente:

Concedere accesso limitato alle risorse di Archiviazione di Azure tramite firme di accesso condiviso

È possibile autorizzare l'accesso ai dati usando le chiavi di accesso dell'account (chiave condivisa). In questo esempio viene creata un'istanza di DataLakeServiceClient autorizzata con la chiave dell'account.

static public DataLakeServiceClient GetDataLakeServiceClient
(String accountName, String accountKey){
    StorageSharedKeyCredential sharedKeyCredential =
        new StorageSharedKeyCredential(accountName, accountKey);

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

    return dataLakeServiceClient;
}

Attenzione

L'autorizzazione con chiave condivisa non è consigliata, perché potrebbe essere meno sicura. Per una sicurezza ottimale, disabilitare l'autorizzazione tramite chiave condivisa per l'account di archiviazione, come descritto in Impedire l'autorizzazione con chiave condivisa per un account di archiviazione di Azure.

L'uso di chiavi di accesso e stringhe di connessione deve essere limitato ai modelli di verifica delle app iniziali o ai prototipi di sviluppo che non accedono a dati sensibili o di produzione. Diversamente, per l'autenticazione alle risorse di Azure vanno sempre preferite le classi di autenticazione basate su token disponibili in Azure SDK.

Microsoft consiglia che i client usino Microsoft Entra ID o una firma di accesso condiviso per autorizzare l'accesso ai dati in Archiviazione di Azure. Per ulteriori informazioni, consultare Autorizzare le operazioni per l'accesso ai dati.

Creazione di un contenitore

Un contenitore funge da file system per i file. È possibile creare un contenitore usando il metodo seguente:

DataLakeServiceClient.createFileSystem

Nell'esempio di codice seguente viene creato un contenitore e viene restituito un oggetto DataLakeFileSystemClient per un uso successivo:

public DataLakeFileSystemClient CreateFileSystem(
        DataLakeServiceClient serviceClient,
        String fileSystemName) {

    DataLakeFileSystemClient fileSystemClient = serviceClient.createFileSystem(fileSystemName);

    return fileSystemClient;
}

Creare una directory

È possibile creare un riferimento alla directory nel contenitore usando il metodo seguente:

DataLakeFileSystemClient.createDirectory

L'esempio di codice seguente aggiunge una directory a un contenitore, quindi aggiunge una sottodirectory e restituisce un oggetto DataLakeDirectoryClient per un uso successivo:

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

    DataLakeDirectoryClient directoryClient = fileSystemClient.createDirectory(directoryName);

    return directoryClient.createSubdirectory(subDirectoryName);
}

Rinominare o spostare una directory

È possibile rinominare o spostare una directory usando il metodo seguente:

DataLakeDirectoryClient.rename

Passare il percorso della directory desiderata come parametro. L'esempio di codice seguente illustra come rinominare una sottodirectory:

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

Nell'esempio di codice seguente viene illustrato come spostare una sottodirectory da una directory a una directory diversa:

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

Caricare un file in una directory

È possibile caricare contenuto in un file nuovo o esistente usando il metodo seguente:

L'esempio di codice seguente illustra come caricare un file locale in una directory usando il uploadFromFile metodo :

public void UploadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

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

È possibile usare questo metodo per creare e caricare contenuto in un nuovo file oppure impostare il overwrite parametro su true per sovrascrivere un file esistente.

Accodare dati a un file

È possibile caricare i dati da aggiungere a un file usando il metodo seguente:

DataLakeFileClient.append

Nell'esempio di codice seguente viene illustrato come aggiungere dati alla fine di un file attenendosi alla procedura seguente:

Creare un DataLakeFileClient oggetto per rappresentare la risorsa file con cui si sta lavorando.
Caricare i dati nel file usando il DataLakeFileClient.append metodo .
Completare il caricamento chiamando il DataLakeFileClient.flush metodo per scrivere i dati caricati in precedenza nel file.

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

Scaricare da una directory

Nell'esempio di codice seguente viene illustrato come scaricare un file da una directory in un file locale attenendosi alla procedura seguente:

Creare un DataLakeFileClient oggetto per rappresentare il file da scaricare.
Usare il DataLakeFileClient.readToFile metodo per leggere il file. In questo esempio il overwrite parametro viene impostato su true, che sovrascrive un file esistente.

public void DownloadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

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

Elencare il contenuto della directory

È possibile elencare il contenuto della directory usando il metodo seguente ed enumerando il risultato:

DataLakeDirectoryClient.listPaths

L'enumerazione dei percorsi nel risultato può effettuare più richieste al servizio durante il recupero dei valori.

L'esempio di codice seguente stampa i nomi di ogni file che si trova in una directory:

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

}

Eliminare una directory

È possibile eliminare una directory usando uno dei metodi seguenti:

Nell'esempio di codice seguente viene deleteWithResponse usato per eliminare una directory nonempty e tutti i percorsi sotto la directory:

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

Share via