Uso de Java para administrar directorios y archivos en Azure Data Lake Storage Gen2

  • Artículo

En este artículo se explica cómo usar Java para crear y administrar directorios y archivos en cuentas de almacenamiento que tengan habilitado un espacio de nombres jerárquico.

Para obtener información sobre cómo obtener, establecer y actualizar las listas de control de acceso (ACL) de directorios y archivos, consulte Uso de Java para administrar listas de control de acceso en Azure Data Lake Storage Gen2.

Paquete (Maven) | Muestras | Referencia de API | Asignación de Gen1 a Gen2 | Envíenos sus comentarios

Requisitos previos

Configurar su proyecto

Para empezar, abra esta página y busque la versión más reciente de la biblioteca de Java. Después, abra el archivo pom.xml en el editor de texto. Agregue un elemento de dependencia que haga referencia a esa versión.

Si planea autenticar la aplicación cliente mediante Microsoft Entra ID, agregue una dependencia a la biblioteca de Azure Identity. Para más información, consulte la biblioteca cliente de Azure Identity para Java.

A continuación, agregue estas instrucciones Imports al archivo de código.

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:

El acceso a varios protocolos en Data Lake Storage permite a las aplicaciones usar las API de blobs y las API de Data Lake Storage Gen2 para trabajar con datos en cuentas de almacenamiento con el espacio de nombres jerárquico (HNS) habilitado. Al trabajar con capacidades exclusivas de Data Lake Storage Gen2, como las operaciones de directorio y las ACL, use las API de Data Lake Storage Gen2, como se muestra en este artículo.

Al elegir qué API usar en un escenario determinado, tenga en cuenta la carga de trabajo y las necesidades de la aplicación, junto con los problemas conocidos y el impacto de HNS en cargas de trabajo y aplicaciones.

Autorización del acceso y conexión a recursos de datos

Para trabajar con los ejemplos de código de este artículo, debe crear una instancia DataLakeServiceClient autorizada que represente la cuenta de almacenamiento. Puede autorizar un objeto DataLakeServiceClient mediante Microsoft Entra ID, una clave de acceso de cuenta o una firma de acceso compartido (SAS).

Puede usar la biblioteca cliente de identidad de Azure para Java para autenticar la aplicación con Microsoft Entra ID.

Cree una instancia de DataLakeServiceClient y pase una nueva instancia de la clase 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;
}

Para más información sobre el uso de DefaultAzureCredential para autorizar el acceso a los datos, consulte la Biblioteca cliente de Azure Identity para Java.

Crear un contenedor

Un contenedor actúa como sistema de archivos para sus archivos. Puede crear un contenedor mediante el método siguiente:

En el siguiente ejemplo se crea un contenedor y se devuelve un objeto DataLakeFileSystemClient para su uso posterior:

public DataLakeFileSystemClient CreateFileSystem(
        DataLakeServiceClient serviceClient,
        String fileSystemName) {

    DataLakeFileSystemClient fileSystemClient = serviceClient.createFileSystem(fileSystemName);

    return fileSystemClient;
}

Creación de un directorio

Puede crear una referencia de directorio en el contenedor mediante el método siguiente:

En el ejemplo de código siguiente se agrega un directorio a un contenedor y, a continuación, se agrega un subdirectorio y se devuelve un objeto DataLakeDirectoryClient para su uso posterior:

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

    DataLakeDirectoryClient directoryClient = fileSystemClient.createDirectory(directoryName);

    return directoryClient.createSubdirectory(subDirectoryName);
}

Cambio de nombre o traslado de un directorio

Puede cambiar el nombre o mover un directorio mediante el método siguiente:

Pase la ruta de acceso del directorio que busca como un parámetro. En el código de ejemplo siguiente, se muestra cómo cambiar el nombre de un subdirectorio:

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

En el ejemplo de código siguiente se muestra cómo mover un subdirectorio de un directorio a otro:

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

Carga de un archivo en un directorio

Puede cargar contenido en un archivo nuevo o existente, mediante el método siguiente:

En el ejemplo de código siguiente se muestra cómo cargar un archivo local en un directorio mediante el método uploadFromFile:

public void UploadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

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

Puede usar este método para crear y cargar contenido en un archivo nuevo, o bien puede establecer el parámetro overwrite en true para sobrescribir un archivo existente.

Anexión de datos a un archivo

Puede cargar los datos que se van a anexar a un archivo mediante el método siguiente:

En el ejemplo de código siguiente se muestra cómo anexar datos al final de un archivo mediante estos pasos:

  • Cree un objeto DataLakeFileClient para representar el recurso de archivo con el que está trabajando.
  • Cargue datos en el archivo mediante el método DataLakeFileClient.append.
  • Complete la carga llamando al método DataLakeFileClient.flush para escribir los datos cargados anteriormente en el archivo.
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);
}

Descarga de un directorio

En el ejemplo de código siguiente se muestra cómo descargar un archivo de un directorio a un archivo local mediante estos pasos:

  • Cree un objeto DataLakeFileClient para representar el archivo que desea descargar.
  • Use el método DataLakeFileClient.readToFile para leer el archivo. En este ejemplo se establece el parámetro overwrite en true, que sobrescribe un archivo existente.
public void DownloadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

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

Lista del contenido del directorio

Puede crear una lista del contenido del directorio mediante el método siguiente y enumerar el resultado:

La enumeración de las rutas de acceso en el resultado puede realizar varias solicitudes al servicio mientas captura los valores.

En este código de ejemplo, se imprimen los nombres de cada uno de los archivos que se ubican en un directorio:

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

}

Eliminación de un directorio

Puede eliminar un directorio mediante uno de los métodos siguientes:

En el ejemplo de código siguiente se usa deleteWithResponse para eliminar un directorio no vacío y todas las rutas de acceso debajo del directorio:

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

Consulte también