Partager via

Développer pour Azure Files avec .NET

Découvrez comment développer des applications .NET qui utilisent Azure Files pour stocker des données. Azure Files est un service de partage de fichiers managé dans le cloud. Il fournit des partages de fichiers entièrement managés accessibles via les protocoles SMB (Server Message Block) et NFS (Network File System). Azure Files fournit également une API REST pour l’accès par programmation aux partages de fichiers.

Dans cet article, vous allez découvrir les différentes approches de développement avec Azure Files dans .NET et comment choisir l’approche qui convient le mieux aux besoins de votre application. Vous allez également apprendre à créer une application console de base qui interagit avec les ressources Azure Files.

S’applique à

Modèle de gestion Modèle de facturation Échelon médiatique Redondance PME Système de fichiers en réseau (NFS)
Microsoft.Storage V2 approvisionné HDD (standard) Local (LRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) Zone (ZRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) Géo (GRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) GeoZone (GZRS) Oui Non
Microsoft.Storage V1 approvisionné SSD (Premium) Local (LRS) Oui Non
Microsoft.Storage V1 approvisionné SSD (Premium) Zone (ZRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Local (LRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Zone (ZRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Géo (GRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) GeoZone (GZRS) Oui Non

À propos du développement d’applications .NET avec Azure Files

Azure Files offre plusieurs façons aux développeurs .NET d’accéder aux données et de gérer les ressources dans Azure Files. Le tableau suivant répertorie les approches, résume leur fonctionnement et fournit des conseils sur le moment où utiliser chaque approche :

Approche Fonctionnement Quand l’utiliser
Bibliothèques d’E/S de fichiers standard Utilise des appels d’API au niveau du système d’exploitation via des partages de fichiers Azure montés à l’aide de SMB ou NFS. Lorsque vous montez un partage de fichiers à l’aide de SMB/NFS, vous pouvez utiliser des bibliothèques d’E/S de fichiers pour un langage de programmation ou une infrastructure, comme System.IO pour .NET. Vous disposez d’applications métier avec du code existant qui utilise des E/S de fichiers standard, et vous ne souhaitez pas réécrire du code pour que l’application fonctionne avec un partage de fichiers Azure.
FileREST API Appelle directement des points de terminaison HTTPS pour interagir avec les données stockées dans Azure Files. Fournit un contrôle programmatique sur les ressources de partage de fichiers. Le Kit de développement logiciel (SDK) Azure fournit la bibliothèque de client Partages de fichiers (Azure.Storage.Files.Shares) qui s’appuie sur l’API FileREST, ce qui vous permet d’interagir avec les opérations de l’API FileREST via des paradigmes de langage de programmation .NET familiers. Vous créez des services et applications cloud à valeur ajoutée pour les clients et vous souhaitez utiliser des fonctionnalités avancées non disponibles via System.IO.
API REST du fournisseur de ressources de stockage Utilise Azure Resource Manager (ARM) pour gérer les comptes de stockage et les partages de fichiers. Appelle des points de terminaison d’API REST pour différentes opérations de gestion de ressources. Votre application ou service doit effectuer des tâches de gestion des ressources, telles que la création, la suppression ou la mise à jour de comptes de stockage ou de partages de fichiers.

Pour obtenir des informations générales sur ces approches, consultez Vue d’ensemble du développement d’applications avec Azure Files.

Cet article se concentre sur l’utilisation des ressources Azure Files à l’aide des approches suivantes :

Conditions préalables

Configurer votre environnement

Cette section vous guide tout au long des étapes de préparation d’une application console .NET pour utiliser Azure Files.

Créer le projet

Si vous n’avez pas encore d’application .NET, créez-en une à l’aide de Visual Studio ou de l’interface CLI .NET. Dans cet article, nous créons une application console pour plus de simplicité.

  1. Démarrez Visual Studio et sélectionnez Créer un projet. Ou si vous êtes dans Visual Studio, accédez à Fichier>Nouveau>Projet.
  2. Dans la fenêtre de boîte de dialogue, choisissez Application console pour C# et sélectionnez Suivant.
  3. Entrez un nom pour le projet, laissez les valeurs par défaut, puis sélectionnez Suivant.
  4. Pour Framework, sélectionnez la dernière version installée de .NET. Conservez les autres valeurs par défaut, puis sélectionnez Créer.

Installer le package

Si vous envisagez d’interagir avec Azure Files à l’aide de l’espace System.IO de noms, vous n’avez pas besoin d’installer de packages supplémentaires. L’espace System.IO de noms est inclus dans le Kit de développement logiciel (SDK) .NET. Si vous envisagez d’utiliser la bibliothèque cliente Partages de fichiers pour .NET ou la bibliothèque de gestion stockage Azure pour .NET, installez le package à l’aide de NuGet.

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis choisissez Gérer les packages NuGet.

  2. Dans le Gestionnaire de package NuGet, sélectionnez Parcourir. Ensuite, recherchez et choisissez le package approprié, puis sélectionnez Installer. Pour la bibliothèque cliente Partages de fichiers, choisissez Azure.Storage.Files.Shares. Pour la bibliothèque de gestion stockage Azure, choisissez Azure.ResourceManager.Storage. Pour la bibliothèque Azure Identity, qui est nécessaire pour les connexions sans mot de passe, choisissez Azure.Identity.

    Cette étape installe le package et ses dépendances.

Ajouter des directives d’utilisation

Si vous envisagez d’utiliser l'espace de noms System.IO, ajoutez la directive using suivante en haut de votre fichier Program.cs :

using System.IO;

Si vous envisagez d’utiliser la bibliothèque cliente Partages de fichiers pour .NET, ajoutez la directive using suivante en haut de votre fichier Program.cs :

using Azure.Storage.Files.Shares;

Si vous envisagez d’utiliser la bibliothèque de gestion stockage Azure pour .NET, ajoutez la directive d’utilisation suivante en haut de votre fichier Program.cs :

using Azure.ResourceManager;

Pour utiliser la bibliothèque d’identités Azure pour les connexions sans mot de passe aux services Azure, ajoutez la directive suivante à l’aide de votre fichier Program.cs :

using Azure.Identity;

Utiliser Azure Files à l’aide de System.IO

Les bibliothèques d’E/S de fichiers standard sont le moyen le plus courant d’accéder aux ressources Azure Files et de les utiliser. Lorsque vous montez un partage de fichiers à l’aide de SMB ou NFS, votre système d’exploitation redirige les demandes d’API pour le système de fichiers local. Cette approche vous permet d’utiliser des bibliothèques d’E/S de fichiers standard, telles que System.IO, pour interagir avec des fichiers et des répertoires dans le partage.

Envisagez d’utiliser System.IO quand votre application nécessite :

  • Compatibilité des applications : Idéal pour les applications métier avec du code existant qui utilise System.IOdéjà . Vous n’avez pas besoin de réécrire du code pour que l’application fonctionne avec un partage de fichiers Azure.
  • Facilité d’utilisation :System.IO est bien connu par les développeurs et facile à utiliser. Une proposition de valeur clé d’Azure Files est qu’elle expose des API de système de fichiers natives via SMB et NFS.

Dans cette section, vous allez apprendre à utiliser System.IO pour utiliser des ressources Azure Files.

Pour plus d’informations et d’exemples, consultez les ressources suivantes :

Monter un partage de fichiers

Pour l’utiliser System.IO, vous devez d’abord monter un partage de fichiers. Consultez les ressources suivantes pour obtenir des conseils sur le montage d’un partage de fichiers à l’aide de SMB ou NFS :

Dans cet article, nous utilisons le chemin suivant pour faire référence à un partage de fichiers SMB monté sur Windows :

string fileSharePath = @"Z:\file-share";

Exemple : Se connecter à un partage de fichiers et énumérer des répertoires à l’aide de System.IO

L’exemple de code suivant montre comment se connecter à un partage de fichiers et répertorier les répertoires du partage :

using System.IO;

string fileSharePath = @"Z:\file-share";

EnumerateDirectories(@"Z:\file-share");

static void EnumerateDirectories(string path)
{
    try
    {
        List<string> dirs = new List<string>(Directory.EnumerateDirectories(path));

        foreach (var dir in dirs)
        {
            Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}");
        }
        Console.WriteLine($"{dirs.Count} directories found.");
    }
    catch (UnauthorizedAccessException ex)
    {
        Console.WriteLine(ex.Message);
    }
    catch (PathTooLongException ex)
    {
        Console.WriteLine(ex.Message);
    }
}

Exemple : Écrire dans un fichier dans un partage de fichiers à l’aide de System.IO

L’exemple de code suivant montre comment écrire et ajouter du texte avec la File classe :

using System.IO;

string fileSharePath = @"Z:\file-share";

WriteToFile(fileSharePath, "test.txt");

static void WriteToFile(string fileSharePath, string fileName)
{
    string textToWrite = "First line" + Environment.NewLine;
    string filePath = Path.Combine(fileSharePath, fileName);
    
    File.WriteAllText(filePath, textToWrite);

    string[] textToAppend = { "Second line", "Third line" };
    File.AppendAllLines(filePath, textToAppend);
}

Exemple : Verrouiller un fichier dans un partage de fichiers à l’aide de System.IO

Les clients SMB qui montent des partages de fichiers peuvent utiliser des mécanismes de verrouillage du système de fichiers pour gérer l’accès aux fichiers partagés.

L’exemple de code suivant montre comment verrouiller un fichier dans un partage de fichiers avec le mode de partage défini sur None. Ce mode de partage refuse le partage du fichier actif jusqu’à ce que le fichier soit fermé.

using System.IO;

string fileSharePath = @"Z:\file-share";

LockFile(Path.Combine(fileSharePath, "test.txt"));

static void LockFile(string filePath)
{
    try
    {
        using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            Console.WriteLine("File locked.");

            // Do something with file, press Enter to close the stream and release the lock
            Console.ReadLine();

            fs.Close();
            Console.WriteLine("File closed.");
        }
    }
    catch (IOException ex)
    {
        Console.WriteLine(ex.Message);
    }
}

Lorsque vous utilisez SMB et l’API FileREST, gardez à l’esprit que l’API FileREST utilise des baux pour gérer les verrous de fichier, tandis que SMB utilise des verrous de système de fichiers gérés par le système d’exploitation. Pour en savoir plus sur la gestion des interactions de verrouillage de fichiers entre SMB et l’API FileREST, consultez Gérer les verrous de fichier.

Exemple : Énumérer des listes de contrôle d’accès de fichier à l’aide de System.IO

L’exemple de code suivant montre comment énumérer les listes de contrôle d’accès (ACL) pour un fichier :

using System.IO;
using System.Security.AccessControl;

string fileSharePath = @"Z:\file-share";
string fileName = "test.txt";
string filePath = Path.Combine(fileSharePath, fileName);

EnumerateFileACLs(filePath);

static void EnumerateFileACLs(string filePath)
{
    FileInfo fileInfo = new FileInfo(filePath);

    // For directories, use DirectorySecurity instead of FileSecurity
    FileSecurity fSecurity = FileSystemAclExtensions.GetAccessControl(fileInfo);

    // List all access rules for the file
    foreach (FileSystemAccessRule rule in fSecurity.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)))
    {
        Console.WriteLine($"Identity: {rule.IdentityReference.Value}");
        Console.WriteLine($"Access Control Type: {rule.AccessControlType}");
        Console.WriteLine($"File System Rights: {rule.FileSystemRights}");
        Console.WriteLine();
    }

}

Utiliser des données Azure Files à l’aide de la bibliothèque cliente Partages de fichiers pour .NET

L’API FileREST fournit un accès programmatique à Azure Files. Il vous permet d’appeler des points de terminaison HTTPS pour effectuer des opérations sur des partages de fichiers, des répertoires et des fichiers. L’API FileREST est conçue pour une scalabilité élevée et des fonctionnalités avancées qui peuvent ne pas être disponibles via des protocoles natifs. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques clientes, telles que la bibliothèque cliente Partages de fichiers pour .NET, qui s’appuient sur l’API FileREST.

Envisagez d’utiliser l’API FileREST et la bibliothèque cliente de partage de fichiers si votre application nécessite :

  • Fonctionnalités avancées : Opérations et fonctionnalités d’accès qui ne sont pas disponibles via des protocoles natifs.
  • Intégrations cloud personnalisées : Créez des services à valeur ajoutée personnalisés, tels que la sauvegarde, l’antivirus ou la gestion des données, qui interagissent directement avec Azure Files.
  • Optimisation des performances : Tirez parti des avantages en matière de performances dans les scénarios à grande échelle à l’aide d’opérations de plan de données.

L’API FileREST modélise Azure Files en tant que hiérarchie de ressources et est recommandée pour les opérations effectuées au niveau du répertoire ou du fichier . Vous devez préférer l’API REST du fournisseur de ressources de stockage pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers .

Dans cette section, vous allez apprendre à utiliser la bibliothèque cliente Partages de fichiers pour utiliser les ressources Azure Files.

Pour plus d’informations et d’exemples, consultez les ressources suivantes :

Autoriser l’accès et créer un client

Pour connecter une application à Azure Files, créez un ShareClient objet. Cet objet est votre point de départ pour l’utilisation des ressources Azure Files. Les exemples de code suivants montrent comment créer un ShareClient objet à l’aide de différents mécanismes d’autorisation.

Pour autoriser avec Microsoft Entra ID, vous devez utiliser un principal de sécurité. Le type de principal de sécurité dont vous avez besoin dépend de l’emplacement d’exécution de votre application. Utilisez ce tableau comme guide.

Où l’application s’exécute Principal de sécurité Assistance
Ordinateur local (développement et test) Principal du service Pour découvrir comment inscrire l’application, configurer un groupe Microsoft Entra, attribuer des rôles et configurer des variables d’environnement, consultez Autoriser l’accès à l’aide de principaux de service de développeur
Ordinateur local (développement et test) Identité de l’utilisateur Pour découvrir comment configurer un groupe Microsoft Entra, attribuer des rôles et se connecter à Azure, consultez Autoriser l’accès à l’aide des informations d’identification du développeur
Hébergé dans Azure Identité managée Pour savoir comment activer une identité managée et attribuer des rôles, consultez Autoriser l’accès à partir d’applications hébergées sur Azure en utilisant une identité managée.
Hébergé en dehors d’Azure (par exemple, des applications locales) Principal du service Pour savoir comment inscrire l’application, attribuer des rôles et configurer des variables d’environnement, consultez Autoriser l’accès à partir d’applications locales en utilisant un principal de service d’application.

Pour utiliser les exemples de code de cet article, attribuez le rôle intégré d’Azure RBAC Storage File Data Privileged Contributor au principal de sécurité. Ce rôle fournit un accès complet en lecture, écriture, modification des ACL et suppression sur toutes les données des partages pour tous les comptes de stockage configurés, quelles que soient les autorisations NTFS définies au niveau du fichier/répertoire. Pour plus d’informations, consultez Accéder aux partages de fichiers Azure à l’aide de Microsoft Entra ID avec Azure Files OAuth via REST.

Autoriser l’accès en utilisant DefaultAzureCredential

Un moyen simple et sécurisé d’autoriser l’accès et de se connecter à Azure Files consiste à obtenir un jeton OAuth en créant une instance DefaultAzureCredential . Vous pouvez ensuite utiliser ces informations d’identification pour créer un objet ShareClient.

L’exemple suivant crée un objet ShareClient autorisé à l'aide de DefaultAzureCredential, puis crée un objet ShareDirectoryClient pour travailler avec un répertoire dans le partage :

using Azure.Identity;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;

// ...

string accountName = "<account-name>";
string shareName = "<share-name>";

ShareClientOptions options = new()
{
    AllowSourceTrailingDot = true,
    AllowTrailingDot = true,
    ShareTokenIntent = ShareTokenIntent.Backup,
};
ShareClient shareClient = new(
   new Uri($"https://{accountName}.file.core.windows.net/{shareName}"),
   new DefaultAzureCredential(),
   options);

ShareDirectoryClient directoryClient = shareClient.GetDirectoryClient("sample-directory");

Si vous savez exactement quel type d’informations d’identification vous utilisez pour authentifier les utilisateurs, vous pouvez obtenir un jeton OAuth à l’aide d’autres classes dans la bibliothèque de client Azure Identity pour .NET. Ces classes dérivent de la classe TokenCredential.

Pour en savoir plus sur chacun de ces mécanismes d’autorisation, consultez Choisir comment autoriser l’accès aux données de fichier.

Exemple : Copier des fichiers à l’aide de la bibliothèque cliente Partages de fichiers

Vous pouvez copier des fichiers dans un partage de fichiers ou entre des partages de fichiers à l’aide de la méthode suivante :

Vous pouvez copier un fichier dans un objet blob de destination à l’aide de la méthode suivante à partir d’un BlobClient objet :

L’exemple de code suivant montre comment copier un fichier dans un fichier dans un autre partage de fichiers :

using Azure.Core;
using Azure.Identity;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;

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

ShareClientOptions options = new()
{
    ShareTokenIntent = ShareTokenIntent.Backup,
};

ShareFileClient srcShareFileClient = new(
    new Uri($"https://{accountName}.file.core.windows.net/{srcShareName}/{srcFilePath}"),
    tokenCredential,
    options);

ShareFileClient destShareFileClient = new(
    new Uri($"https://{accountName}.file.core.windows.net/{destShareName}/{destFilePath}"),
    tokenCredential,
    options);

// Copy the file from the source share to the destination share

await destShareFileClient.StartCopyAsync(srcShareFileClient.Uri);

Exemple : louer un fichier à l’aide de la bibliothèque cliente Partages de fichiers

Un bail crée un verrou sur un fichier géré par Azure via un ID de bail. Le bail fournit un mécanisme permettant de coordonner l’accès aux fichiers entre plusieurs clients d’un système distribué. Un bail sur un fichier fournit un accès exclusif en écriture et suppression. Pour en savoir plus sur les états de bail et les actions, consultez Fichier de bail.

L’exemple de code suivant montre comment créer un client de bail, acquérir un bail de durée infinie sur un fichier et libérer le bail :

using Azure.Core;
using Azure.Identity;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;
using Azure.Storage.Files.Shares.Specialized;

string accountName = "<account-name>";
string shareName = "sample-file-share";
string filePath = "path/to/file";

TokenCredential tokenCredential = new DefaultAzureCredential();

ShareClientOptions options = new()
{
    ShareTokenIntent = ShareTokenIntent.Backup,
};

ShareFileClient fileClient = new(
    new Uri($"https://{accountName}.file.core.windows.net/{shareName}/{filePath}"),
    tokenCredential,
    options);

ShareLeaseClient leaseClient = fileClient.GetShareLeaseClient();

// Acquire a lease on the source file
await leaseClient.AcquireAsync(duration: ShareLeaseClient.InfiniteLeaseDuration);

// Do something with the file

// Release the lease
await leaseClient.ReleaseAsync();

Lorsque vous utilisez SMB et l’API FileREST, gardez à l’esprit que l’API FileREST utilise des baux pour gérer les verrous de fichier, tandis que SMB utilise des verrous de système de fichiers gérés par le système d’exploitation. Pour en savoir plus sur la gestion des interactions de verrouillage de fichiers entre SMB et l’API FileREST, consultez Gérer les verrous de fichier.

Exemple : Créer et répertorier des instantanés de partage à l’aide de la bibliothèque cliente Partages de fichiers

Les instantanés de partage sont des copies en lecture seule d’un partage de fichiers à un moment donné. Vous pouvez créer un instantané d’un partage de fichiers, puis utiliser l’instantané pour accéder aux données du partage au moment de la création de l’instantané. Vous pouvez également répertorier tous les instantanés d’un partage de fichiers et supprimer des instantanés de partage.

L’exemple de code suivant montre comment créer un instantané de partage, répertorier les instantanés d’un partage de fichiers et parcourir l’arborescence de répertoires dans un instantané de partage :

using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;

string connectionString = "<connection-string>";

ShareServiceClient shareServiceClient = new ShareServiceClient(connectionString);
ShareClient shareClient = shareServiceClient.GetShareClient("sample-file-share");

// Create a snapshot

ShareSnapshotInfo snapshotInfo = await shareClient.CreateSnapshotAsync();
Console.WriteLine($"Snapshot created: {snapshotInfo.Snapshot}");

// List snapshots in a share

await foreach (ShareItem shareItem in shareServiceClient.GetSharesAsync(ShareTraits.All, ShareStates.Snapshots))
{
    if (shareItem.Snapshot != null)
    {
        Console.WriteLine($"Share: {shareItem.Name} (Snapshot: {shareItem.Snapshot})");
    }
}

// List directories and files in a share snapshot

string snapshotTimestamp = snapshotInfo.Snapshot.ToString();
ShareClient shareSnapshot = shareClient.WithSnapshot(snapshotTimestamp);
ShareDirectoryClient rootDir = shareSnapshot.GetRootDirectoryClient();

await ListDirectoryTreeAsync(rootDir);

static async Task ListDirectoryTreeAsync(ShareDirectoryClient directory)
{
    await foreach (ShareFileItem fileItem in directory.GetFilesAndDirectoriesAsync())
    {
        if (fileItem.IsDirectory)
        {
            Console.WriteLine($"Directory: {fileItem.Name}");
            await ListDirectoryTreeAsync(directory.GetSubdirectoryClient(fileItem.Name));
        }
        else
        {
            Console.WriteLine($"File: {fileItem.Name}");
        }
    }
}

Remarque

Les jetons OAuth, tels que ceux obtenus lors de l’utilisation DefaultAzureCredential, ne sont pas autorisés pour les opérations de plan de données au niveau du partage de fichiers. Pour utiliser des instantanés de partage, l'objet client doit être autorisé avec la clé de compte. L’objet ShareClient créé dans cet exemple de code utilise une chaîne de connexion, qui inclut la clé de compte.

Le stockage des clés de compte ou des chaînes de connexion présente un risque de sécurité. Vous ne devez les utiliser que lorsque l’authentification Microsoft Entra n’est pas disponible. Pour en savoir plus sur le stockage sécurisé des clés de compte dans Azure Key Vault, consultez À propos des clés de compte de stockage managé Azure Key Vault.

Gérer les ressources Azure Files à l’aide des bibliothèques de gestion stockage Azure

Les bibliothèques de gestion stockage Azure sont basées sur l’API REST du fournisseur de ressources Stockage Azure. Le fournisseur de ressources Stockage Azure est un service basé sur Azure Resource Manager et prend en charge les méthodes déclaratives (modèles) et impératives (appel d’API directe). L’API REST du fournisseur de ressources Stockage Azure fournit un accès programmatique aux ressources stockage Azure, y compris les partages de fichiers. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques de gestion qui s’appuient sur l’API REST du fournisseur de ressources stockage Azure.

Les bibliothèques de gestion sont recommandées pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers . Dans cette section, vous allez apprendre à utiliser les bibliothèques de gestion stockage Azure pour gérer les ressources Azure Files.

Exemple : Créer un partage de fichiers à l’aide de la bibliothèque de gestion stockage Azure

L’exemple de code suivant montre comment créer un objet de niveau ArmClient supérieur, inscrire le fournisseur de ressources de stockage avec un abonnement et créer un partage de fichiers à l’aide de la bibliothèque de gestion stockage Azure :

using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Storage;

ArmClient armClient = new ArmClient(new DefaultAzureCredential());

// Create a resource identifier, then get the subscription resource
ResourceIdentifier resourceIdentifier = new($"/subscriptions/<subscription-id>");
SubscriptionResource subscription = armClient.GetSubscriptionResource(resourceIdentifier);

ResourceProviderResource resourceProvider =
    await subscription.GetResourceProviderAsync("Microsoft.Storage");

// Check the registration state of the resource provider and register, if needed
if (resourceProvider.Data.RegistrationState == "NotRegistered")
    resourceProvider.Register();

// Get a resource group
ResourceGroupResource resourceGroup = await subscription.GetResourceGroupAsync("<resource-group-name>");

// Get a collection of storage account resources
StorageAccountCollection accountCollection = resourceGroup.GetStorageAccounts();

// Get a specific storage account resource
StorageAccountResource storageAccount = await accountCollection.GetAsync("<storage-account-name>");

// Get a file service resource for the storage account
FileServiceResource fileService = storageAccount.GetFileService();

// Create a new file share (or update if it already exists)
ArmOperation <FileShareResource> fileShareOperation = await fileService
    .GetFileShares()
    .CreateOrUpdateAsync(WaitUntil.Completed, "sample-file-share", new FileShareData()
    {
        ShareQuota = 1024,
        // Add file share properties here
    });

// Get the file share resource
FileShareResource fileShare = fileShareOperation.Value;

Vous pouvez configurer les propriétés de partage de fichiers à l’aide de la classe FileShareData . L’exemple précédent montre comment définir la ShareQuota propriété.

Remarque

Pour effectuer l’opération d’inscription, vous avez besoin d’autorisations pour l’action RBAC Azure suivante : Microsoft.Storage/register/action. Cette autorisation est incluse dans les rôles intégrés Contributeur et Propriétaire.

Exemple : répertorier les partages de fichiers et les instantanés à l’aide de la bibliothèque de gestion stockage Azure

L’exemple de code suivant montre comment répertorier les partages de fichiers et les instantanés dans un compte de stockage :

// Iterate over a collection of file shares and list them along with any snapshots
string expand = "snapshots";
await foreach (FileShareResource shareResource in fileService.GetFileShares().GetAllAsync(expand: expand))
{
    // Call operations on the file share resource

    // For this demo, print out the resource name and snapshot information
    FileShareData resourceData = shareResource.Data;
    Console.WriteLine($"Resource name: {resourceData.Name}");
    if (resourceData.SnapshotOn.HasValue)
    {
        Console.WriteLine($"Snapshot: {resourceData.SnapshotOn}");
    }
}

Contenu connexe

Pour plus d’informations sur le développement avec Azure Files, consultez les ressources suivantes :