Desarrollo para Azure Files con Java

Aprenda a desarrollar aplicaciones Java que usan Azure Files para almacenar datos. Azure Files es un servicio de recurso compartido de archivos administrado en la nube. Proporciona recursos compartidos de archivos totalmente administrados a los que se puede acceder a través de los protocolos estándar del bloque de mensajes del servidor (SMB) y del sistema de archivos de red (NFS). Azure Files también proporciona una API REST para el acceso mediante programación a los recursos compartidos de archivos.

En este artículo, obtendrá información sobre los diferentes enfoques para desarrollar con Azure Files en Java y cómo elegir el enfoque que mejor se adapte a las necesidades de la aplicación. También aprenderá a crear una aplicación de consola básica que interactúe con Azure Files recursos.

Acerca del desarrollo de aplicaciones de Java con Azure Files

Azure Files ofrece varias maneras para que los desarrolladores de Java accedan a los datos y administren recursos en Azure Files. En la tabla siguiente se enumeran los enfoques, se resume cómo funcionan y se proporcionan instrucciones sobre cuándo usar cada enfoque:

Para obtener información general sobre estos enfoques, consulte Información general del desarrollo de aplicaciones con Azure Files.

Este artículo se centra en trabajar con recursos de Azure Files mediante los siguientes enfoques:

• Trabajar con Azure Files mediante bibliotecas de E/S de archivos Java: monte un recurso compartido de archivos mediante SMB o NFS y use bibliotecas de E/S de archivos Java para trabajar con archivos y directorios en el recurso compartido.
• Trabaje con Azure Files mediante la biblioteca cliente de compartición de archivos para Java: utilice la biblioteca cliente de compartición de archivos de Azure Storage para Java para trabajar con archivos y directorios en un recurso compartido de archivos. Esta biblioteca cliente se basa en la API FileREST.
• Administrar recursos de Azure Files mediante las bibliotecas de administración de Azure Storage: use las bibliotecas de administración de Azure Storage para administrar recursos compartidos de archivos y otros recursos de la cuenta de almacenamiento. Las bibliotecas de administración se basan en la API REST del proveedor de recursos Azure Storage.

Prerrequisitos

• suscripción a Azure: crear una gratuita
• Azure cuenta de almacenamiento: crear una cuenta de almacenamiento
• Java Kit de desarrollo (JDK) versión 8 o posterior
• Apache Maven se usa para la administración de proyectos en este ejemplo

Configuración del entorno

Use Maven para crear una aplicación de consola o abrir un proyecto existente. Siga estos pasos para instalar paquetes y agregar las directivas necesarias import .

Instalación de paquetes

Abra el archivo pom.xml en el editor de texto. Instale los paquetes mediante la inclusión del archivo BOM o la inclusión de una dependencia directa.

Inclusión del archivo BOM

Agregue azure-sdk-bom para depender de la versión más reciente de la biblioteca. En el fragmento de código siguiente, reemplace el {bom_version_to_target} marcador de posición por el número de versión. El uso de azure-sdk-bom le impide tener que especificar la versión de cada dependencia individual. Para obtener más información sobre el BOM, consulte el README de BOM de Azure SDK.

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

Agregue los siguientes elementos de dependencia al grupo de dependencias. La dependencia azure-identity es necesaria para las conexiones sin contraseña a los servicios de Azure. Tenga en cuenta que los artefactos de Resource Manager no se incluyen en el archivo BOM, por lo que debe agregarlos como dependencias directas.

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

Incluir una dependencia directa

Para tomar una dependencia en una versión determinada de la biblioteca, agregue la dependencia directa al proyecto:

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

Incluir directivas de importación

A continuación, abra el archivo de código y agregue las directivas necesarias import . En este ejemplo, agregamos las siguientes directivas en el archivo 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 planea usar las bibliotecas de E/S de archivos de Java, también debe agregar las siguientes directivas de importación:

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

Trabajar con Azure Files mediante bibliotecas de E/S de archivos de Java

Las bibliotecas de E/S de archivos estándar son la manera más común de acceder a los recursos de Azure Files y trabajar con ellos. Al montar un recurso compartido de archivos mediante SMB o NFS, el sistema operativo redirige las solicitudes de API para el sistema de archivos local. Este enfoque permite usar bibliotecas de E/S de archivos estándar, como java.io y java.nio, para interactuar con archivos y directorios en el recurso compartido.

Considere la posibilidad de usar bibliotecas de E/S de archivos Java cuando la aplicación requiera:

• App compatibility: Ideal para aplicaciones de línea de negocio con código existente que ya usa bibliotecas de E/S de archivos Java. No es necesario volver a escribir código para que la aplicación funcione con un recurso compartido de archivos Azure.
• Facilidad de uso: Las bibliotecas Java de E/S de archivos son bien conocidas por los desarrolladores y fáciles de usar. Una propuesta de valor clave de Azure Files es que expone las API nativas del sistema de archivos a través de SMB y NFS.

En esta sección, aprenderá a usar las bibliotecas de E/S de archivos de Java para trabajar con recursos de Azure Files.

Para obtener más información y ejemplos, consulte el siguiente recurso:

• Java E/S básica

Montar un recurso compartido de archivos

Para utilizar las bibliotecas de E/S de archivos de Java, primero debe montar un recurso compartido de archivos. Consulte los siguientes recursos para obtener instrucciones sobre cómo montar un recurso compartido de archivos mediante SMB o NFS:

• Montar un recurso compartido de archivos SMB en Windows
• Montaje de un recurso compartido de archivos SMB en Linux
• Montaje de un recurso compartido de archivos NFS en Linux

En este artículo, usamos la siguiente ruta de acceso para hacer referencia a un recurso compartido de archivos SMB montado en Windows:

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

Ejemplo: Conexión a un recurso compartido de archivos y enumeración de directorios mediante bibliotecas de E/S de archivos Java

En el ejemplo de código siguiente se muestra cómo conectarse a un recurso compartido de archivos y enumerar los directorios del recurso compartido:

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

Ejemplo: Escritura en un archivo en un recurso compartido de archivos mediante bibliotecas de E/S de archivos de Java

En el ejemplo de código siguiente se muestra cómo escribir y anexar texto a un archivo:

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

Ejemplo: Bloquear un archivo en una compartición de archivos utilizando bibliotecas de E/S de archivos Java

Los clientes SMB que montan recursos compartidos de archivos pueden usar mecanismos de bloqueo del sistema de archivos para administrar el acceso a archivos compartidos.

En el ejemplo de código siguiente se muestra cómo bloquear un archivo en un recurso compartido de archivos:

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

Al usar SMB y la API FileREST, tenga en cuenta que la API FileREST usa concesiones para administrar bloqueos de archivos, mientras que SMB usa bloqueos del sistema de archivos administrados por el sistema operativo. Para obtener más información sobre cómo administrar las interacciones de bloqueo de archivos entre SMB y la API FileREST, consulte Administración de bloqueos de archivos.

Ejemplo: Enumerar ACL de archivos mediante bibliotecas de E/S de archivos Java

En el ejemplo de código siguiente se muestra cómo enumerar listas de control de acceso (ACL) para un archivo:

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

Trabajar con Azure Files mediante la biblioteca cliente de recursos compartidos de archivos para Java

La API FileREST proporciona acceso mediante programación a Azure Files. Permite llamar a puntos de conexión HTTPS para realizar operaciones en comparticiones de archivos, directorios y archivos. La API FileREST está diseñada para alta escalabilidad y características avanzadas que podrían no estar disponibles a través de protocolos nativos. El Azure SDK proporciona bibliotecas cliente, como la biblioteca cliente de recursos compartidos de archivos para Java, que se basan en la API FileREST.

Considere la posibilidad de usar la API FileREST y la biblioteca cliente del recurso compartido de archivos si la aplicación requiere:

• Características avanzadas: Acceso a las operaciones y características que no están disponibles a través de protocolos nativos.
• Integraciones en la nube personalizadas: crear servicios personalizados de valor agregado, como respaldo, antivirus o administración de datos, que interactúan directamente con Azure Files.
• Optimización del rendimiento: Beneficiarse de las ventajas de rendimiento en escenarios a gran escala mediante operaciones de plano de datos.

La API FileREST modela Azure Files como una jerarquía de recursos y es recomendada para las operaciones que se realizan en los niveles directory o file. Debe preferir la API REST del proveedor de recursos de almacenamiento para las operaciones que se realizan en el nivel de servicio de archivos o recurso compartido de archivos .

En esta sección, aprenderá a usar la biblioteca cliente de File Shares para Java para trabajar con los recursos de Azure Files.

Para obtener más información y ejemplos, consulte los siguientes recursos:

• Biblioteca cliente de Azure Storage para la compartición de archivos en Java

Autorización del acceso y creación de un cliente

Para conectar una aplicación a Azure Files, cree un objeto ShareClient. Este objeto es el punto de partida para trabajar con recursos de Azure Files. En los ejemplos de código siguientes se muestra cómo crear un ShareClient objeto mediante distintos mecanismos de autorización.

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

import com.azure.storage.common.StorageSharedKeyCredential;
import com.azure.storage.file.share.*;

// Add the following code to a new or existing function

String accountName = "<account-name>";
String accountKey = "<account-key>";
String shareName = "<share-name>";

StorageSharedKeyCredential credential =
    new StorageSharedKeyCredential(accountName, accountKey);

// Create the ShareClient
ShareClient shareClient = new ShareClientBuilder()
    .endpoint(String.format("https://%s.file.core.windows.net", accountName))
    .shareName(shareName)
    .credential(credential)
    .buildClient();

// Create a client to interact with a directory in the share
ShareDirectoryClient directoryClient = shareClient.getDirectoryClient("sample-directory");

import com.azure.storage.file.share.*;

// Add the following code to a new or existing function

String connectionString = "<connection-string>";
String shareName = "<share-name>";

// Create the ShareClient
ShareClient shareClient = new ShareClientBuilder()
        .shareName(shareName)
        .connectionString(connectionString)
        .buildClient();

// Create a client to interact with a directory in the share
ShareDirectoryClient directoryClient = shareClient.getDirectoryClient("sample-directory");

Para obtener más información sobre cada uno de estos mecanismos de autorización, consulte Elección de cómo autorizar el acceso a los datos de archivos.

Ejemplo: Copia de archivos mediante la biblioteca cliente de File Shares

Puede copiar archivos dentro de un recurso compartido de archivos o entre recursos compartidos de archivos mediante el método siguiente:

• beginCopy

Puede copiar un archivo en un blob de destino mediante el método siguiente desde un BlockBlobClient objeto :

• beginCopy

En el ejemplo de código siguiente se muestra cómo copiar un archivo en un archivo de otro recurso compartido de archivos:

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

Ejemplo: concesión de un archivo mediante la biblioteca cliente de recursos compartidos de archivos

Una concesión crea un bloqueo en un archivo administrado por Azure a través de un identificador de concesión. La concesión proporciona un mecanismo para coordinar el acceso a los archivos en varios clientes de un sistema distribuido. Una concesión en un archivo proporciona acceso exclusivo de escritura y eliminación. Para más información sobre los estados de concesión y las acciones, consulte Archivo de concesión.

En el ejemplo de código siguiente se muestra cómo crear un cliente de concesión, adquirir una concesión de duración infinita en un archivo y liberar la concesión:

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

Al usar SMB y la API FileREST, tenga en cuenta que la API FileREST usa concesiones para administrar bloqueos de archivos, mientras que SMB usa bloqueos del sistema de archivos administrados por el sistema operativo. Para obtener más información sobre cómo administrar las interacciones de bloqueo de archivos entre SMB y la API FileREST, consulte Administración de bloqueos de archivos.

Ejemplo: Crear y enumerar instantáneas de recurso compartido mediante la biblioteca cliente de recursos compartidos de archivos

Las instantáneas de recurso compartido son copias de solo lectura de un recurso compartido de archivos en un momento dado. Puede crear una instantánea de un recurso compartido de archivos y, a continuación, usar la instantánea para acceder a los datos del recurso compartido en el momento en que se creó la instantánea. También puede enumerar todas las instantáneas de un recurso compartido de archivos y eliminar instantáneas de recurso compartido.

En el ejemplo de código siguiente se muestra cómo crear una instantánea de recurso compartido, enumerar las instantáneas de un recurso compartido de archivos y recorrer el árbol de directorios en una instantánea de recurso compartido:

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

Administración de recursos de Azure Files mediante las bibliotecas de administración de Azure Storage

Las bibliotecas de administración de Azure Storage se basan en la API REST del proveedor de recursos Azure Storage. El proveedor de recursos de Azure Storage es un servicio basado en Azure Resource Manager y admite métodos declarativos (plantillas) e imperativos (llamada a API directa). La API REST del proveedor de recursos Azure Storage proporciona acceso mediante programación a los recursos de Azure Storage, incluidos los recursos compartidos de archivos. El Azure SDK proporciona bibliotecas de administración que se basan en la API REST del proveedor de recursos de Azure Storage.

Las bibliotecas de administración se recomiendan para las operaciones que se realizan en el servicio de archivos o en el nivel de recurso compartido de archivos . En esta sección, aprenderá a usar las bibliotecas de administración de Azure Storage para administrar recursos de Azure Files.

Las bibliotecas de administración de Azure Storage se basan en la API REST del proveedor de recursos Azure Storage. El proveedor de recursos de Azure Storage es un servicio basado en Azure Resource Manager y admite métodos declarativos (plantillas) e imperativos (llamada a API directa). La API REST del proveedor de recursos Azure Storage proporciona acceso mediante programación a los recursos de Azure Storage, incluidos los recursos compartidos de archivos. El Azure SDK proporciona bibliotecas de administración que se basan en la API REST del proveedor de recursos de Azure Storage.

Las bibliotecas de administración se recomiendan para las operaciones que se realizan en el servicio de archivos o en el nivel de recurso compartido de archivos . En esta sección, aprenderá a usar las bibliotecas de administración de Azure Storage para administrar recursos de Azure Files.

Ejemplo: Creación de un recurso compartido de archivos mediante la biblioteca de administración de Azure Storage

En el ejemplo de código siguiente se muestra cómo crear un objeto de AzureResourceManager de nivel superior, registrar el proveedor de recursos de storage con una suscripción y crear un recurso compartido de archivos mediante la biblioteca de administración de Azure Storage:

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

Puede configurar las propiedades del recurso compartido de archivos mediante la clase FileShareInner . En el ejemplo anterior se muestra cómo establecer la cuota de recursos compartidos al crear el recurso compartido de archivos. Para actualizar un recurso compartido de archivos existente, llame a fileShare.update() y pase el objeto FileShareInner con las propiedades que desea actualizar.

Ejemplo: Listar recursos compartidos de archivos e instantáneas mediante la biblioteca de administración de almacenamiento de Azure.

En el ejemplo de código siguiente se muestra cómo enumerar los recursos compartidos de archivos y las instantáneas en una cuenta de almacenamiento:

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

Pasos siguientes

Para obtener más información sobre el desarrollo con Azure Files, consulte los siguientes recursos:

• Información general del desarrollo de aplicaciones con Azure Files
• Asignar nombres y hacer referencia a recursos compartidos, directorios, archivos y metadatos
• Administrar bloqueos de archivos
• Operaciones en directorios
• Operaciones en archivos