Megosztás a következőn keresztül:

Fejlesztés az Azure Files szolgáltatáshoz a .NET-keretrendszerrel

Megtudhatja, hogyan fejleszthet olyan .NET-alkalmazásokat, amelyek az Azure Files használatával tárolják az adatokat. Az Azure Files egy felügyelt fájlmegosztási szolgáltatás a felhőben. Teljes mértékben felügyelt fájlmegosztásokat biztosít, amelyek az iparági szabvány kiszolgálói üzenetblokk (SMB) és a hálózati fájlrendszer (NFS) protokollon keresztül érhetők el. Az Azure Files rest API-t is biztosít a fájlmegosztásokhoz való programozott hozzáféréshez.

Ebben a cikkben megismerheti az Azure Files .NET-ben való fejlesztésének különböző megközelítéseit, és megtudhatja, hogyan választhatja ki az alkalmazás igényeinek leginkább megfelelő megközelítést. Azt is megtudhatja, hogyan hozhat létre egy alapszintű konzolalkalmazást, amely az Azure Files-erőforrásokat használja.

A következőre érvényes:

Felügyeleti modell Számlázási modell Médiaréteg Redundancia Kis- és középvállalkozások (SMB) Hálózati fájlrendszer (NFS)
Microsoft.Storage Előre beállított v2 HDD (standard) Lokális (LRS) Igen Nem
Microsoft.Storage Előre beállított v2 HDD (standard) Zóna (ZRS) Igen Nem
Microsoft.Storage Előre beállított v2 HDD (standard) Geo (GRS) Igen Nem
Microsoft.Storage Előre beállított v2 HDD (standard) Geozone (GZRS) Igen Nem
Microsoft.Storage Előkészített v1 SSD (prémium) Lokális (LRS) Igen Nem
Microsoft.Storage Előkészített v1 SSD (prémium) Zóna (ZRS) Igen Nem
Microsoft.Storage Fizetés a használat szerint HDD (standard) Lokális (LRS) Igen Nem
Microsoft.Storage Fizetés a használat szerint HDD (standard) Zóna (ZRS) Igen Nem
Microsoft.Storage Fizetés a használat szerint HDD (standard) Geo (GRS) Igen Nem
Microsoft.Storage Fizetés a használat szerint HDD (standard) Geozone (GZRS) Igen Nem

A .NET-alkalmazásfejlesztés az Azure Files használatával

Az Azure Files számos módot kínál a .NET-fejlesztők számára az adatok elérésére és az erőforrások Azure Filesban való kezelésére. Az alábbi táblázat felsorolja a megközelítéseket, összefoglalja azok működését, és útmutatást nyújt az egyes megközelítések használatának időpontjához:

Megközelítés Hogyan működik? Mikor érdemes használni?
Standard fájl I/O-kódtárak Operációsrendszer-szintű API-hívásokat használ az SMB vagy NFS használatával csatlakoztatott Azure-fájlmegosztásokon keresztül. Ha SMB/NFS használatával csatlakoztat egy fájlmegosztást, használhat fájl I/O-kódtárakat egy programozási nyelvhez vagy keretrendszerhez, például System.IO a .NET-hez. Rendelkezik olyan üzletági alkalmazásokkal, amelyek meglévő kóddal rendelkeznek, amelyek szabványos I/O-fájlt használnak, és nem szeretné átírni az alkalmazás kódját az Azure-fájlmegosztások használatához.
FileREST API Közvetlenül meghívja a HTTPS-végpontokat az Azure Filesban tárolt adatok kezeléséhez. Programozott vezérlést biztosít a fájlmegosztási erőforrások felett. Az Azure SDK biztosítja a FileREST API-ra épülő Fájlmegosztások ügyfélkódtárat (Azure.Storage.Files.Shares), amely lehetővé teszi a FileREST API-műveletek használatát a jól ismert .NET programozási nyelvi paradigmákon keresztül. Értéknövelő felhőszolgáltatásokat és alkalmazásokat hoz létre az ügyfelek számára, és olyan speciális funkciókat szeretne használni, amelyeken keresztül nem érhető el System.IO.
Storage-erőforrás-szolgáltató – REST API Az Azure Resource Manager (ARM) használatával kezeli a tárfiókokat és a fájlmegosztásokat. REST API-végpontokat hív meg különböző erőforrás-kezelési műveletekhez. Az alkalmazásnak vagy szolgáltatásnak erőforrás-kezelési feladatokat kell végrehajtania, például tárfiókokat vagy fájlmegosztásokat kell létrehoznia, törölnie vagy frissítenie.

Az ilyen megközelítésekkel kapcsolatos általános információkért tekintse meg az Azure Files alkalmazásfejlesztésének áttekintését.

Ez a cikk az Azure Files-erőforrások az alábbi módszerekkel történő használatát ismerteti:

Előfeltételek

Saját környezet beállítása

Ez a szakasz végigvezeti egy .NET-konzolalkalmazás Azure Files-beli használatához való előkészítésének lépésein.

A projekt létrehozása

Ha még nem rendelkezik .NET-alkalmazással, hozzon létre egyet a Visual Studióval vagy a .NET CLI-vel. Ebben a cikkben egy konzolalkalmazást hozunk létre az egyszerűség kedvéért.

  1. Indítsa el a Visual Studiót, és válassza az Új projekt létrehozása lehetőséget. Vagy ha a Visual Studióban van, lépjen a Fájl>Új>Projekt menüpontra.
  2. A párbeszédpanel ablakában válassza a C# konzolalkalmazást , és válassza a Tovább gombot.
  3. Adja meg a projekt nevét, hagyja meg az alapértelmezett értékeket, és válassza a Tovább gombot.
  4. Framework esetén válassza ki a .NET legújabb telepített verzióját. Hagyja meg a többi alapértelmezett beállítást, és válassza a Létrehozás lehetőséget.

A csomag telepítése

Ha a névtér használatával szeretné használni az System.IO Azure Filest, nem kell további csomagokat telepítenie. A System.IO névtér a .NET SDK része. Ha a .NET-hez készült Fájlmegosztások ügyfélkódtárat vagy a .NET-hez készült Azure Storage felügyeleti tárat szeretné használni, telepítse a csomagot a NuGet használatával.

  1. A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza a NuGet-csomagok kezelése lehetőséget.

  2. A NuGet Csomagkezelő válassza a Tallózás lehetőséget. Ezután keresse meg és válassza ki a megfelelő csomagot, és válassza a Telepítés lehetőséget. A Fájlmegosztások ügyfélkódtárhoz válassza az Azure.Storage.Files.Shares lehetőséget. Az Azure Storage felügyeleti könyvtárában válassza az Azure.ResourceManager.Storage lehetőséget. A jelszó nélküli kapcsolatokhoz szükséges Azure Identity-kódtárhoz válassza az Azure.Identity lehetőséget.

    Ez a lépés telepíti a csomagot és annak függőségeit.

Használati direktívák hozzáadása

Ha a System.IO névteret szeretné használni, adja hozzá a következő használati utasítást a Program.cs fájl tetejére:

using System.IO;

Ha a .NET-hez készült Fájlmegosztások ügyféloldali kódtárat szeretné használni, adja hozzá az alábbi irányelveket a Program.cs fájl tetejére:

using Azure.Storage.Files.Shares;

Ha a .NET-hez készült Azure Storage felügyeleti kódtárat szeretné használni, adja hozzá a következő használati utasítást a Program.cs fájl tetejére:

using Azure.ResourceManager;

Ha az Azure Identity-kódtárat szeretné használni az Azure-szolgáltatásokhoz való jelszó nélküli kapcsolatokhoz, adja hozzá a következő használati utasítást a Program.cs fájl tetejére:

using Azure.Identity;

System.IO-val az Azure Files dolgozása

A standard fájl-I/O-kódtárak az Azure Files-erőforrások elérésének és működésének leggyakoribb módjai. Amikor SMB vagy NFS használatával csatlakoztat egy fájlmegosztást, az operációs rendszer átirányítja a helyi fájlrendszer API-kéréseit. Ez a módszer lehetővé teszi, hogy szabványos fájl I/O-kódtárakat használjon, például System.IOa megosztásban lévő fájlokkal és könyvtárakkal való interakcióhoz.

Akkor érdemes használni System.IO , ha az alkalmazáshoz a következőre van szükség:

  • Alkalmazáskompatibilitás: Ideális olyan üzletági alkalmazásokhoz, amelyek már meglévő kódot használnak System.IO. Nem kell átírnia az alkalmazás kódját az Azure-fájlmegosztások használatához.
  • Egyszerű használat:System.IO jól ismert a fejlesztők és könnyen használható. Az Azure Files egyik fő értékajánlata, hogy natív fájlrendszer API-kat tesz elérhetővé SMB-n és NFS-n keresztül.

Ebben a szakaszban megtudhatja, hogyan használhatja a System.IO az Azure Files erőforrásokkal való munkához.

További információkat és példákat az alábbi forrásanyagokban talál:

Fájltároló csatlakoztatása

A System.IO használatához először egy fájlmegosztást kell csatlakoztatnia. A fájlmegosztás SMB vagy NFS használatával történő csatlakoztatásával kapcsolatos útmutatásért tekintse meg az alábbi forrásokat:

Ebben a cikkben a következő elérési utat használjuk egy csatlakoztatott SMB-fájlmegosztásra való hivatkozáshoz Windows rendszeren:

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

Példa: Csatlakozás fájlmegosztáshoz és könyvtárak számbavétele System.IO

Az alábbi példakód bemutatja, hogyan csatlakozhat egy fájlmegosztáshoz, és listázhatja a megosztásban lévő könyvtárakat:

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

Példa: Írj egy fájlba egy fájlmegosztásban a System.IO használatával.

Az alábbi példakód bemutatja, hogyan írhat és fűzhet hozzá szöveget az File osztályhoz:

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

Példa: Fájl zárolása fájlmegosztásban System.IO

A fájlmegosztásokat csatlakoztató SMB-ügyfelek fájlrendszer-zárolási mechanizmusokkal kezelhetik a megosztott fájlokhoz való hozzáférést.

Az alábbi példakód bemutatja, hogyan zárolhat egy fájlt egy fájlmegosztásban a megosztási Nonemód beállításával. Ez a megosztási mód a fájl bezárásáig elutasítja az aktuális fájl megosztását.

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

Az SMB és a FileREST API használatakor ne feledje, hogy a FileREST API bérleteket használ a fájlzárolások kezeléséhez, míg az SMB az operációs rendszer által felügyelt fájlrendszer-zárolásokat használja. Az SMB és a FileREST API közötti fájlzárolási interakciók kezeléséről további információt a Fájlzárolások kezelése című témakörben talál.

Példa: Fájl ACL-ek számbavétele System.IO használatával

Az alábbi példakód bemutatja, hogyan lehet számba adni a hozzáférés-vezérlési listákat (ACL-eket) egy fájlhoz:

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

}

Azure Files-adatok használata a .NET-hez készült Fájlmegosztások ügyfélkódtár használatával

A FileREST API programozott hozzáférést biztosít az Azure Fileshoz. Lehetővé teszi HTTPS-végpontok meghívását a fájlmegosztásokon, könyvtárakon és fájlokon végzett műveletek végrehajtásához. A FileREST API magas skálázhatóságra és olyan speciális funkciókra lett tervezve, amelyek natív protokollokkal nem érhetők el. Az Azure SDK olyan ügyfélkódtárakat biztosít, mint például a File Shares ügyfélkódtár a .NET-hez, amelyek a FileREST API-ra épülnek.

Fontolja meg a FileREST API és a Fájlmegosztás ügyfélkódtár használatát, ha az alkalmazás a következőket igényli:

  • Speciális funkciók: Natív protokollokkal nem elérhető műveletek és szolgáltatások elérése.
  • Egyéni felhőintegrációk: Egyéni értéknépszerűsítési szolgáltatásokat hozhat létre, például biztonsági mentést, víruskeresőt vagy adatkezelést, amelyek közvetlenül az Azure Files szolgáltatással kommunikálnak.
  • Teljesítményoptimalizálás: Kihasználhatja az adatsík-műveleteket használó nagy léptékű forgatókönyvek teljesítménybeli előnyeit.

A FileREST API erőforrások hierarchiájaként modellezi az Azure Filest, és ajánlott a címtár vagy a fájl szintjén végrehajtott műveletekhez. A tárolási erőforrás-szolgáltató REST API-t érdemes használni a fájlszolgáltatás vagy a fájlmegosztás szintjén végrehajtott műveletekhez.

Ebben a szakaszban megtudhatja, hogyan használhatja a Fájlmegosztások ügyfélkódtárat az Azure Files-erőforrások használatához.

További információkat és példákat az alábbi forrásanyagokban talál:

Hozzáférés engedélyezése és ügyfél létrehozása

Ha egy alkalmazást az Azure Fileshoz szeretne csatlakoztatni, hozzon létre egy objektumot ShareClient . Ez az objektum az Azure Files-erőforrások használatának kiindulópontja. Az alábbi példakód bemutatja, hogyan hozhat létre ShareClient objektumot különböző engedélyezési mechanizmusokkal.

A Microsoft Entra-azonosítóval való engedélyezéshez biztonsági azonosítót kell használnia. A szükséges biztonsági tag típusa attól függ, hogy hol fut az alkalmazás. Használja ezt a táblázatot útmutatóként.

Az alkalmazás futtatásának helye Biztonsági tag Útmutatás
Helyi gép (fejlesztés és tesztelés) Szolgáltatási főelem Az alkalmazás regisztrálásához, a Microsoft Entra-csoport beállításához, a szerepkörök hozzárendeléséhez és a környezeti változók konfigurálásához lásd : Hozzáférés engedélyezése fejlesztői szolgáltatásnevek használatával
Helyi gép (fejlesztés és tesztelés) Felhasználói azonosító A Microsoft Entra-csoport beállításáról, a szerepkörök hozzárendeléséről és az Azure-ba való bejelentkezésről további információt a hozzáférés engedélyezése fejlesztői hitelesítő adatokkal című témakörben talál .
Az Azure-ban üzemeltetve Felügyelt identitás A felügyelt identitás engedélyezéséről és a szerepkörök hozzárendeléséről további információt az Azure által üzemeltetett alkalmazások hozzáférésének engedélyezése felügyelt identitással című témakörben talál .
Az Azure-on kívül üzemeltetett (például helyszíni alkalmazások) Szolgáltatási főelem Az alkalmazás regisztrálásához, szerepkörök hozzárendeléséhez és környezeti változók konfigurálásához lásd : Hozzáférés engedélyezése helyszíni alkalmazásokból egy alkalmazásszolgáltatás-egyszerű használatával

A cikkben szereplő példakódok használatához rendelje hozzá az Azure RBAC beépített Storage File Data Privileged Contributor szerepkört a biztonsági objektumhoz. Ez a szerepkör teljes olvasási, írási, módosítási ACL-eket és törlési hozzáférést biztosít a megosztásokban lévő összes adathoz az összes konfigurált tárfiókhoz, függetlenül a beállított fájl-/könyvtárszintű NTFS-engedélyektől. További információ: Azure-fájlmegosztások elérése a Microsoft Entra-azonosítóval és az Azure Files OAuth-tal REST-en keresztül.

Hozzáférés engedélyezése a DefaultAzureCredential használatával

Az OAuth token megszerzése azzal, hogy létrehozunk egy DefaultAzureCredential példányt, egy egyszerű és biztonságos módja annak, hogy engedélyezzük a hozzáférést és csatlakozzunk az Azure Files-hoz. Ezután ezzel a hitelesítő adatok használatával létrehozhat egy objektumot ShareClient .

Az alábbi példa létrehoz egy `ShareClient` objektumot, amelyet `DefaultAzureCredential` segítségével jogosítanak fel, majd létrehoz egy `ShareDirectoryClient` objektumot, hogy a megosztásban lévő könyvtárral dolgozzon.

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

Ha pontosan tudja, hogy milyen hitelesítő adattípust használ a felhasználók hitelesítéséhez, oAuth-jogkivonatot szerezhet be a .NET-hez készült Azure Identity ügyfélkódtár más osztályai segítségével. Ezek az osztályok a TokenCredential osztályból származnak.

Ha többet szeretne megtudni ezekről az engedélyezési mechanizmusokról, olvassa el a fájladatokhoz való hozzáférés engedélyezésének módját ismertető témakört.

Példa: Fájlok másolása a Fájlmegosztások ügyfélkódtár használatával

A fájlmegosztáson belül vagy fájlmegosztások között a következő módszerrel másolhat fájlokat:

A célblobba a következő módszerrel másolhat fájlokat egy BlobClient objektumból:

Az alábbi példakód bemutatja, hogyan másolhat egy fájlt egy másik fájlmegosztásban lévő fájlba:

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

Példa: Fájl bérlése a Fájlmegosztási klienskönyvtár használatával

A bérlet létrehoz egy zárolást egy olyan fájlon, amelyet az Azure egy bérletazonosítón keresztül kezel. A bérlet egy olyan mechanizmust biztosít, amely koordinálja a fájlokhoz való hozzáférést több ügyfél között egy elosztott rendszerben. A fájlok bérlete kizárólagos írási és törlési hozzáférést biztosít. A bérletállapotokról és a műveletekről további információt a bérletfájlban talál.

Az alábbi példakód bemutatja, hogyan hozhat létre bérletügyfélt, hogyan szerezhet be végtelen időtartamú bérletet egy fájlon, és hogyan oldhatja fel a bérletet:

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

Az SMB és a FileREST API használatakor ne feledje, hogy a FileREST API bérleteket használ a fájlzárolások kezeléséhez, míg az SMB az operációs rendszer által felügyelt fájlrendszer-zárolásokat használja. Az SMB és a FileREST API közötti fájlzárolási interakciók kezeléséről további információt a Fájlzárolások kezelése című témakörben talál.

Példa: Megosztási pillanatképek létrehozása és listázása a Fájlmegosztások ügyfélkódtár használatával

A megosztási pillanatképek a fájlmegosztások írásvédett másolatai egy adott időpontban. Létrehozhat egy pillanatképet egy fájlmegosztásról, majd a pillanatkép használatával hozzáférhet a megosztás adataihoz a pillanatkép létrehozásakor. A fájlmegosztások összes pillanatképét listázhatja, és törölheti a megosztási pillanatképeket.

Az alábbi példakód bemutatja, hogyan hozhat létre megosztási pillanatképet, listázhatja egy fájlmegosztás pillanatképeit, és hogyan haladhat át a címtárfán egy megosztási pillanatképben:

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

Megjegyzés:

Az OAuth-tokenek, például azok, amelyeket a DefaultAzureCredential használata során szereznek, nem engedélyezettek a fájlmegosztás szintjén végzett adatsík műveletekhez. A megosztási pillanatképek használatához az ügyfélobjektumot a fiókkulcs használatával kell engedélyezni. Az ShareClient ebben a kód példában létrehozott objektum egy kapcsolati sztringet használ, amely tartalmazza a fiókkulcsot.

A fiókkulcsok vagy kapcsolati sztringek tárolása biztonsági kockázatot jelent. Csak akkor használja őket, ha a Microsoft Entra-hitelesítés nem érhető el. A fiókkulcsok Azure Key Vaultban való biztonságos tárolásáról további információt az Azure Key Vault felügyelt tárfiókkulcsairól szóló cikkben talál.

Azure Files-erőforrások kezelése az Azure Storage felügyeleti kódtárak használatával

Az Azure Storage kezelési könyvtárai az Azure Storage erőforrás-szolgáltató REST API-jára épülnek. Az Azure Storage-erőforrás-szolgáltató egy Azure Resource Manageren alapuló szolgáltatás, amely deklaratív (sablonok) és imperatív (közvetlen API-hívás) metódusokat is támogat. Az Azure Storage-erőforrás-szolgáltató REST API programozott hozzáférést biztosít az Azure Storage-erőforrásokhoz, beleértve a fájlmegosztásokat is. Az Azure SDK olyan felügyeleti kódtárakat biztosít, amelyek az Azure Storage-erőforrás-szolgáltató REST API-jára épülnek.

A felügyeleti kódtárak a fájlszolgáltatás vagy a fájlmegosztás szintjén végrehajtott műveletekhez ajánlottak. Ebben a szakaszban megtudhatja, hogyan kezelheti az Azure Files-erőforrásokat az Azure Storage felügyeleti kódtárai segítségével.

Példa: Fájlmegosztás létrehozása az Azure Storage felügyeleti kódtárával

Az alábbi példakód bemutatja, hogyan hozhat létre legfelső szintű ArmClient objektumot, regisztrálhatja a Storage-erőforrás-szolgáltatót egy előfizetéssel, és hogyan hozhat létre fájlmegosztást az Azure Storage felügyeleti kódtár használatával:

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;

A fájlmegosztási tulajdonságokat a FileShareData osztály használatával konfigurálhatja. Az előző példa bemutatja, hogyan állíthatja be a tulajdonságot ShareQuota .

Megjegyzés:

A regisztrációs művelet végrehajtásához engedélyekre van szüksége a következő Azure RBAC-művelethez: Microsoft.Storage/register/action. Ez az engedély szerepel a közreműködői és tulajdonosi beépített szerepkörökben.

Példa: Fájlmegosztások és pillanatképek listázása az Azure Storage felügyeleti kódtárával

Az alábbi példakód bemutatja, hogyan listázhatja a fájlmegosztásokat és a pillanatképeket egy tárfiókban:

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

Kapcsolódó tartalom

Az Azure Files használatával történő fejlesztéssel kapcsolatos további információkért tekintse meg a következő erőforrásokat: