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

Fejlesztés az Azure Files szolgáltatáshoz Javával

Megtudhatja, hogyan fejleszthet olyan Java-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 java-beli fejlesztésének különböző megközelítéseit, és azt, 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:

Irányítási modell Számlázási modell Médiaréteg Redundancia SMB NFS
Microsoft.Storage Előre beállított v2 HDD (standard) Helyi (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) Helyi (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) Helyi (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

Java-alkalmazásfejlesztés az Azure Files használatával

Az Azure Files számos módot kínál a Java-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. Amikor SMB/NFS használatával csatlakoztat egy fájlmegosztást, használhat fájl I/O könyvtárakat egy programozási nyelvhez vagy keretrendszerhez, például java.io és java.nio a Java esetében. 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 (com.azure.storage.file.share), amely lehetővé teszi a FileREST API-műveletek használatát a jól ismert Java 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, amelyek nem érhetők el standard fájl-I/O-kódtárakon keresztül.
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

Megjegyzés:

Ez a cikk a Maven buildelési eszközével hozza létre és futtatja a mintakódot. Más buildelési eszközök, például a Gradle is együttműködnek a Java Azure SDK-val.

A Maven használatával hozzon létre egy új konzolalkalmazást, vagy nyisson meg egy meglévő projektet. A csomagok telepítéséhez és a szükséges import irányelvek hozzáadásához kövesse az alábbi lépéseket.

Csomagok telepítése

Nyissa meg a pom.xml fájlt a szövegszerkesztőben. Telepítse a csomagokat úgy, hogy beleérti a BOM-fájlt, vagy beleért egy közvetlen függőséget.

A BOM-fájl belefoglalása

Add hozzá az azure-sdk-bom-ot a könyvtár legújabb verziójának függőségéhez. Az alábbi kódrészletben cserélje le a {bom_version_to_target} helyőrzőt a verziószámra. Az Azure-sdk-bom használatával nem kell megadnia az egyes függőségek verzióját. A BOM-ról további információt az Azure SDK BOM README-ben talál.

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

Adja hozzá a következő függőségi elemeket a függőségek csoportjához. Az Azure-szolgáltatásokhoz való jelszó nélküli kapcsolatokhoz azure-identitásfüggőség szükséges. Vegye figyelembe, hogy a Resource Manager-összetevők nem szerepelnek a BOM-fájlban, ezért közvetlen függőségként kell őket hozzáadnia.

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

Közvetlen függőség belefoglalása

A kódtár egy adott verziójától való függőség felvételéhez adja hozzá a közvetlen függőséget a projekthez:

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

Importálási irányelvek belefoglalása

Ezután nyissa meg a kódfájlt, és adja hozzá a szükséges import irányelveket. Ebben a példában a következő irányelveket adjuk hozzá a App.java fájlhoz:

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.*;

Ha a Java-fájl I/O-kódtárait szeretné használni, a következő importálási irányelveket is hozzá kell adnia:

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

Az Azure Files használata Java-fájl I/O-kódtárak használatával

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 java.io és java.nio, hogy a megosztásban lévő fájlokkal és könyvtárakkal kommunikáljon.

Fontolja meg a Java-fájl I/O-kódtárak használatát, ha az alkalmazás a következőt igényli:

  • Alkalmazáskompatibilitás: Ideális olyan üzletági alkalmazásokhoz, amelyek már használnak Java-fájl I/O-kódtárakat tartalmazó meglévő kódot. Nem kell átírnia az alkalmazás kódját az Azure-fájlmegosztások használatához.
  • Egyszerű használat: A Java-fájl I/O-kódtárakat a fejlesztők jól ismerik, és könnyen használhatók. 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álhat Java-fájl I/O-kódtárakat az Azure Files-erőforrások használatához.

További információkért és példákért tekintse meg a következő erőforrást:

Fájltároló csatlakoztatása

Java-fájl I/O-kódtárak használatához először csatlakoztatnia kell egy fájlmegosztást. 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 Java-fájl I/O-kódtárak használatával

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

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

Példa: Írás fájlmegosztásban lévő fájlba Java-fájl I/O-kódtárak használatával

Az alábbi példakód bemutatja, hogyan írhat és fűzhet hozzá szöveget egy fájlhoz:

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

Példa: Fájl zárolása fájlmegosztásban Java-fájl I/O-kódtárak használatával

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:

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

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 Java-fájl I/O-kódtárak 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:

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

Az Azure Files-szal való munka a Java fájlmegosztásokhoz készült ügyfélkönyvtárral

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 a FileREST API-ra épülő ügyfélkódtárakat, például a Java Fájlmegosztások ügyfélkódtárát biztosítja.

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 Java Fájlmegosztások ügyfélkódtárát 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 ID használatával történő engedélyezéshez egy biztonsági főelemet kell használnia. Az, hogy milyen típusú biztonsági tagra van szüksége, attól függ, hogy hol fut az alkalmazás. A hitelesítési forgatókönyvekkel kapcsolatos további információkért tekintse meg a Java és az Azure Identity használatával történő Azure-hitelesítést.

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.

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

Ha pontosan tudja, hogy milyen hitelesítő adattípust használ a felhasználók hitelesítéséhez, oAuth-jogkivonatot szerezhet be a Java Azure Identity ügyfélkódtárában található más osztályok használatával. 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 BlockBlobClient 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:

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

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:

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

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:

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

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.

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ű AzureResourceManager 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:

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

A fájlmegosztási tulajdonságokat a FileShareInner osztály használatával konfigurálhatja. Az előző példa bemutatja, hogyan állíthatja be a megosztási kvótát a fájlmegosztás létrehozásakor. Meglévő fájlmegosztás frissítéséhez hívja meg fileShare.update() és adja át az FileShareInner objektumot a frissíteni kívánt tulajdonságokkal.

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:

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

Következő lépések

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:

  • Last updated on