Uso de Java para administrar directorios y archivos en Azure Data Lake Storage Gen2
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
Suscripción a Azure. Para obtener más información, vea Obtención de una evaluación gratuita de Azure.
Una cuenta de almacenamiento que tenga habilitado un espacio de nombres jerárquico. Siga estas instrucciones para crear uno.
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ámetrooverwrite
entrue
, 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:
- DataLakeDirectoryClient.delete
- DataLakeDirectoryClient.deleteIfExists
- DataLakeDirectoryClient.deleteWithResponse
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);
}