Rövid útmutató: Azure Blob Storage-ügyfélkódtár Java SE-hez

Feljegyzés

A Build from Scratch opció vezet a projekt létrehozásán, csomagok telepítésén, kódíráson és egy egyszerű konzolos alkalmazás futtatásán. Válaszd ezt az opciót, hogy megértsd, hogyan hozz létre egy alkalmazást, amely csatlakozik az Azure Blob Storage-hez. A telepítési feladatok automatizálásához és a befejezett projekttel kezdéshez válassza a Start sablonnal opciót.

Feljegyzés

A Start with a template opció az Azure Developer CLI-t használja a telepítési feladatok automatizálására, és egy befejezett projektet biztosít. Ezt az opciót válaszd a kód felfedezésére anélkül, hogy befejeznéd a beállítási feladatokat. Az alkalmazás fejlesztéséhez lépésről lépésre útmutatóért válaszd a Build from Scratch opciót.

Ismerkedés a Java Azure Blob Storage ügyfélkódtárával a blobok és tárolók kezeléséhez.

Ebben a cikkben lépéseket követve telepítheti a csomagot, és kipróbálhatja az alapműveletek példakódját.

Ebben a cikkben az Azure Developer CLI használatával helyezhet üzembe Azure-erőforrásokat, és futtathat egy befejezett konzolalkalmazást néhány parancs használatával.

Tipp.

Olyan Spring alkalmazásokhoz, amelyek Azure Storage erőforrást használnak, érdemes a Spring Cloud Azure-t használni. Ez a nyílt forráskódú projekt integrálja a Springet az Azure szolgáltatásokkal. A Blob Storage-ra vonatkozó példáért lásd: Fájl feltöltése Azure Storage Blobba.

API-referenciadokumentáció | Kódtár forráskódja | Csomag (Maven) | Minták

Előfeltételek

Beállítás

Ez a szakasz végigvezeti egy projekt előkészítésén a Java Azure Blob Storage ügyfélkódtárával való együttműködésre.

A projekt létrehozása

Hozzon létre egy Blob-Quickstart nevű Java-alkalmazást.

  1. Egy konzolablakban (például a PowerShellben vagy a Bashben) a Maven használatával hozzon létre egy új, blob-gyorsútmutató nevű konzolalkalmazást. Írja be a következő mvn parancsot egy "Hello world!" Java-projekt létrehozásához.

    mvn archetype:generate `
    --define interactiveMode=n `
    --define groupId=com.blobs.quickstart `
    --define artifactId=blob-quickstart `
    --define archetypeArtifactId=maven-archetype-quickstart `
    --define archetypeVersion=1.4

  2. Nézze át a projekt generálásának eredményét.

    [INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.1.2:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.1.2:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.1.2:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: maven-archetype-quickstart:1.4
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.blobs.quickstart
[INFO] Parameter: artifactId, Value: blob-quickstart
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.blobs.quickstart
[INFO] Parameter: packageInPathFormat, Value: com/blobs/quickstart
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.blobs.quickstart
[INFO] Parameter: groupId, Value: com.blobs.quickstart
[INFO] Parameter: artifactId, Value: blob-quickstart
[INFO] Project created from Archetype in dir: C:\QuickStarts\blob-quickstart
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  7.056 s
[INFO] Finished at: 2019-10-23T11:09:21-07:00
[INFO] ------------------------------------------------------------------------
    ```

  3. Váltson az újonnan létrehozott blob-quickstart mappára.

    cd blob-quickstart

  4. A blob-quickstart könyvtárban hozz létre egy másik adatbázist, amelynek neve data. Ez a mappa az, ahol a blob adatfájlokat hozzák létre és tárolják.

    mkdir data

A csomagok telepítése

Nyissa meg a pom.xml fájlt a szövegszerkesztőben.

Az azure-sdk-bom hozzáadása a legújabb könyvtár verziótól való függőséghez. 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 megadnod az egyes függőségek egyedi 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>

Ezután adja hozzá a következő függőségi elemeket a függőségek csoportjához. Az Azure szolgáltatásokhoz jelszó nélküli kapcsolatokhoz Azure identitásfüggőségre van szükség.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-blob</artifactId>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
</dependency>

Az alkalmazás-keretrendszer beállítása

A projektkönyvtárban kövesse az alábbi lépéseket az alkalmazás alapszintű szerkezetének létrehozásához:

  1. Lépjen a /src/main/java/com/blobs/quickstart könyvtárba
  2. Nyissa meg a App.java fájlt a szerkesztőben
  3. A sor törlése System.out.println("Hello world!");
  4. Adja hozzá a szükséges import irányelveket

A kódnak a következő keretrendszerhez kell hasonlítania:

package com.blobs.quickstart;

/**
 * Azure Blob Storage quickstart
 */
import com.azure.identity.*;
import com.azure.storage.blob.*;
import com.azure.storage.blob.models.*;
import java.io.*;

public class App
{
    public static void main(String[] args) throws IOException
    {
        // Quickstart code goes here
    }
}

Az Azure Developer CLI használatával létrehozhatsz egy tárolófiókot, és néhány parancsgal futtathatod a mintakódot. A projektet futtathatod a helyi fejlesztési környezetedben vagy egy DevContainerben.

Az Azure Developer CLI-sablon inicializálása és erőforrások üzembe helyezése

Egy üres könyvtárból kövesse az alábbi lépéseket a sablon inicializálásához, az azd Azure-erőforrások kiépítéséhez és a kód használatának megkezdéséhez:

  • Klónozza a GitHubról a quickstart adattári elemeket, és inicializálja helyben a sablont.

    azd init --template blob-storage-quickstart-java

    A rendszer a következő információkat kéri:

    • Környezet neve: Azure fejlesztői parancssori felület ezt az értéket használja előtagként az általa létrehozott összes Azure erőforráshoz. A névnek minden Azure előfizetésben egyedinek kell lennie, és 3 és 24 karakter közötti hosszúságúnak kell lennie. A név csak számokból és kisbetűkből állhat.

  • Jelentkezzen be az Azure-ba:

    azd auth login

  • Az erőforrások kiépítése és üzembe helyezése az Azure-ban:

    azd up

    A rendszer a következő információkat kéri:

    • Előfizetés: Az Azure előfizetés az erőforrások telepítéséhez.
    • Helyszín: Az erőforrások telepítéséhez szükséges Azure régió.

    Az üzembe helyezés végrehajtása eltarthat néhány percig. A parancs kimenete azd up tartalmazza az újonnan létrehozott tárfiók nevét, amelyre később szüksége lesz a kód futtatásához.

A mintakód futtatása

Ezen a ponton az erőforrások üzembe lesznek helyezve az Azure-ban, és a kód majdnem készen áll a futtatásra. Az alábbi lépéseket követve frissítse a tárfiók nevét a kódban, és futtassa a minta konzolalkalmazást:

  • Frissítse a tárfiók nevét:
    1. A helyi könyvtárban keresse meg a blob-quickstart/src/main/java/com/blobs/quickstart könyvtárat.
    2. Nyissa meg a App.java nevű fájlt a szerkesztőben. Keresse meg a <storage-account-name> helyőrzőt, és cserélje le a parancs által azd up létrehozott tárfiók tényleges nevére.
    3. Mentse el a módosításokat.
  • Futtassa a projektet:
    1. Lépjen a könyvtárba. A projekt összeállítása az alábbi mvn paranccsal: 
      mvn compile
    2. Csomagolja be a lefordított kódot terjeszthető formátumban: 
      mvn package
    3. Futtassa a következő mvn parancsot az alkalmazás végrehajtásához: 
      mvn exec:java
  • Figyelje meg a kimenetet: Ez az alkalmazás létrehoz egy tesztfájlt a helyi adatmappában , és feltölti azt a tárfiók egyik tárolójába. A példa ezután felsorolja a tárolóban lévő blobokat, és letölti a fájlt egy új névvel, hogy összehasonlíthassa a régi és az új fájlokat.

A mintakód működésével kapcsolatos további információkért lásd a példakódokat.

Ha végzett a kód tesztelésével, tekintse meg az Erőforrások törlése szakaszt a parancs által azd up létrehozott erőforrások törléséhez.

Objektummodell

Az Azure Blob Storage nagy mennyiségű strukturálatlan adat tárolására van optimalizálva. A strukturálatlan adatok nem igazodnak egy adott adatmodellhez vagy definícióhoz, például szöveghez vagy bináris adatokhoz. A Blob Storage háromféle erőforrást kínál:

  • A tárfiók
  • Tároló a tárolási fiókban
  • Blob a tárolóban

Az alábbi ábra az ezen erőforrások közötti kapcsolatot mutatja be.

Ábra, amely egy tárolófiókot mutat, amely tartalmaz egy blob konténert és egy blobot.

Az alábbi Java-osztályok használatával kezelheti ezeket az erőforrásokat:

  • BlobServiceClient: Az BlobServiceClient osztály Azure Storage erőforrásait és blob konténereket kezeli. A tárfiók biztosítja a Blob szolgáltatás legfelső szintű névterét.
  • BlobServiceClientBuilder: Az BlobServiceClientBuilder osztály egy láncolható API-t biztosít a BlobServiceClient objektumok konfigurálásához és létrehozásához.
  • BlobContainerClient: Az BlobContainerClient osztály kezeli az Azure Storage konténereket és azok blobjait.
  • BlobClient: A BlobClient osztály kezeli az Azure Storage-blobokat.
  • BlobItem: Az BlobItem osztály a listBlobs hívásából visszaadott egyes blobokat jelöli.

Kódpéldák

Az alábbi példakódrészletek bemutatják, hogyan hajthatja végre a következő műveleteket a Java Azure Blob Storage ügyfélkódtárával:

Fontos

A kódminták használata előtt add hozzá az Beállítás részben ismertetett függőségeket és direktívákat.

Feljegyzés

Az Azure Developer CLI-sablon tartalmaz egy már meglévő mintakódot tartalmazó fájlt. Az alábbi példák részletesen ismertetik a mintakód egyes részeit. A sablon implementálja az ajánlott jelszó nélküli hitelesítési módszert a Hitelesítés az Azure-ba című szakaszban leírtak szerint. A kapcsolati sztring metódus alternatívaként jelenik meg, de nem használatos a sablonban, és nem ajánlott éles kódhoz.

Hitelesítés az Azure-ban és a blobadatokhoz való hozzáférés engedélyezése

Az Azure Blob Storage-ba irányuló alkalmazáskéréseket engedélyezni kell. DefaultAzureCredential Az Azure Identity-ügyfélkódtár által biztosított osztály használata ajánlott módszer az Azure-szolgáltatásokhoz való jelszó nélküli kapcsolatok implementálásához a kódban, beleértve a Blob Storage-t is.

Az Azure Blob Storage-ra irányuló kéréseket a fiók hozzáférési kulcsával is engedélyezheti. Ezt a megközelítést azonban körültekintően kell alkalmazni. A fejlesztőknek szorgalmasnak kell lenniük, hogy soha ne tegyék elérhetővé a hozzáférési kulcsot nem biztonságos helyen. Bárki, aki rendelkezik a hozzáférési kulccsal, engedélyezheti a tárfiókra irányuló kérelmeket, és hatékonyan hozzáférhet az összes adathoz. DefaultAzureCredential továbbfejlesztett felügyeleti és biztonsági előnyöket kínál a fiókkulcson keresztül a jelszó nélküli hitelesítés engedélyezéséhez. Az alábbi példában mindkét lehetőség látható.

DefaultAzureCredential A Java-hoz készült Azure Identity-ügyfélkódtár által biztosított osztály. DefaultAzureCredential több hitelesítési módszert támogat, és meghatározza, hogy melyik metódust használja futásidőben. Ez a megközelítés lehetővé teszi, hogy az alkalmazás különböző hitelesítési módszereket használjon különböző környezetekben (helyi és éles környezetben) környezetspecifikus kód implementálása nélkül.

Az Azure identitástár áttekintésében megtalálja azokat a sorrendeket és helyeket, ahol DefaultAzureCredential hitelesítő adatokat keres.

Például az alkalmazásod hitelesítést tud a Visual Studio Code bejelentkezési igazolványaid használatával helyi fejlesztés során. Az alkalmazásod ezután kezelt identitást használhat az Azure-ra történő telepítés után. Ehhez a váltáshoz nincs szükség kódmódosításra.

Szerepkörök hozzárendelése a Microsoft Entra felhasználói fiókjához

Helyi fejlesztéskor győződjön meg arról, hogy a blobadatokhoz hozzáférő felhasználói fiók rendelkezik a megfelelő engedélyekkel. A blobadatok olvasásához és írásához szükség van a Storage Blob Data Contributor szerepkörre. Annak érdekében, hogy ezt a szerepkört kapja meg, rendeljenek Önhöz a Felhasználói hozzáférés rendszergazdája szerepkört, vagy egy másik szerepkört, amely magában foglalja a Microsoft.Authorization/roleAssignments/write műveletet. Azure RBAC-szerepköröket rendelhet egy felhasználóhoz az Azure Portal, az Azure CLI vagy az Azure PowerShell használatával. A Storage Blob Data Közreműködő szerepkörével kapcsolatos további információkért lásd: Storage Blob Data Közreműködő. A szerepkör-hozzárendelésekhez elérhető hatókörökről további információt az Azure RBAC hatókörének ismertetése című témakörben talál.

Ebben a forgatókönyvben engedélyeket rendel hozzá a felhasználói fiókjához, amely a tárfiókra terjed ki, hogy kövesse a minimális jogosultság elvét. Ez a gyakorlat csak a minimálisan szükséges engedélyeket biztosítja a felhasználóknak, és biztonságosabb éles környezeteket hoz létre.

Az alábbi példa a Storage Blob Data Contributor szerepkört rendeli hozzá a felhasználói fiókjához, amely olvasási és írási hozzáférést biztosít a tárfiók blobadataihoz.

Fontos

A szerepkör-hozzárendelés propagálása a legtöbb esetben egy-két percet vesz igénybe az Azure-ban, de ritkán akár nyolc percet is igénybe vehet. Ha hitelesítési hibákat kap a kód első futtatásakor, várjon néhány percet, és próbálkozzon újra.

  1. Az Azure Portalon keresse meg a tárfiókot a fő keresősávon vagy a bal oldali navigációs sávon.

  2. A tárfiók áttekintési lapján válassza a Hozzáférés-vezérlés (IAM) lehetőséget a bal oldali menüben.

  3. A Hozzáférés-vezérlés (IAM) lapon válassza a Szerepkör-hozzárendelések lapot.

  4. Válassza a +Hozzáadás lehetőséget a felső menüből, majd a szerepkör-hozzárendelés hozzáadása lehetőséget az eredményül kapott legördülő menüből.

    Képernyőkép egy szerepkör hozzárendeléséről.

  5. A keresőmezővel szűrheti az eredményeket a kívánt szerepkörre. Ebben a példában keresse meg a Storage Blob-adatszolgáltatót, és válassza ki a megfelelő eredményt, majd válassza a Tovább gombot.

  6. A Hozzáférés hozzárendelése területen válassza a Felhasználó, csoport vagy szolgáltatásnév lehetőséget, majd válassza a + Tagok kijelölése lehetőséget.

  7. A párbeszédpanelen keresse meg a Microsoft Entra-felhasználónevet (általában a user@domain e-mail-címét), majd válassza a Párbeszédpanel alján található Kiválasztás lehetőséget.

  8. Válassza a Véleményezés + hozzárendelés lehetőséget a végső lapra való ugráshoz, majd a folyamat befejezéséhez a Véleményezés + hozzárendelés lehetőséget.

Jelentkezzen be, és kapcsolja össze az alkalmazáskódot az Azure-ral a DefaultAzureCredential használatával

Engedélyezze a hozzáférést a tárolófiókja adataihoz az alábbi lépések követésével:

  1. Ugyanazzal a Microsoft Entra-fiókkal végezze a hitelesítést, amelyhez hozzárendelte a tárolófiók-szerepkört. Használd az Azure CLI-t, Visual Studio Code-ot vagy Azure PowerShell-et.

    Jelentkezzen be az Azure-ba az Azure CLI-vel az alábbi paranccsal:

    az login

  2. A DefaultAzureCredential használatához adja hozzá az azure-identity függőséget a(z) pom.xml elemhez:

    <dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-identity</artifactId>
</dependency>

  3. Adja hozzá ezt a kódot a main metódushoz. Amikor a kód a helyi munkaállomáson fut, a bejelentkezett prioritású eszköz fejlesztői hitelesítő adatait használja az Azure-hoz való hitelesítéshez, például az Azure CLI-t vagy a Visual Studio Code-ot.

    /*
 * The default credential first checks environment variables for configuration
 * If environment configuration is incomplete, it will try managed identity
 */
DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

// Azure SDK client builders accept the credential as a parameter
// TODO: Replace <storage-account-name> with your actual storage account name
BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
        .endpoint("https://<storage-account-name>.blob.core.windows.net/")
        .credential(defaultCredential)
        .buildClient();

  4. Frissítse a BlobServiceClient URI-jében a tárolási fiók nevét. Keresse meg a tárolófiók nevét az Azure portál áttekintési oldalán.

    Képernyőkép a tárfiók nevének megkereséséről.

    Feljegyzés

    Az Azure-ban való üzembe helyezéskor ugyanezzel a kóddal engedélyezheti az Azure Storage-ra irányuló kéréseket egy Azure-ban futó alkalmazásból. Azonban engedélyeznie kell az Azure-ban a felügyelt identitást az alkalmazásához. Ezután konfigurálja a tárfiókot úgy, hogy lehetővé tegye a felügyelt identitás csatlakozását. Az Azure-szolgáltatások közötti kapcsolat konfigurálásával kapcsolatos részletes utasításokért tekintse meg az Azure által üzemeltetett alkalmazások hitelesítési útmutatójában.

Tároló létrehozása

Hozzon létre egy új tárolót a tárfiókban a createBlobContainer metódus meghívásával az blobServiceClient objektumon. Ebben a példában a kód hozzáfűz egy GUID értéket a tároló nevéhez, hogy biztosan egyedi legyen.

Adja hozzá ezt a kódot a metódus végéhez main :

// Create a unique name for the container
String containerName = "quickstartblobs" + java.util.UUID.randomUUID();

// Create the container and return a container client object
BlobContainerClient blobContainerClient = blobServiceClient.createBlobContainer(containerName);

További információkért és példákért lásd: Létrehozni egy blob konténer Java-val.

Fontos

A tárolók nevei csak kisbetűket tartalmazhatnak. A tárolók és blobok elnevezésével kapcsolatos további információkért lásd a tárolók, blobok és metaadatok elnevezését és hivatkozását.

Blobok feltöltése tárolóba

Töltsön fel egy blobot egy tárolóba az uploadFromFile metódus meghívásával. A példakód létrehoz egy szövegfájlt a helyi adatkönyvtárban a tárolóba való feltöltéshez.

Adja hozzá ezt a kódot a metódus végéhez main :

// Create the ./data/ directory and a file for uploading and downloading
String localPath = "./data/";
new File(localPath).mkdirs();
String fileName = "quickstart" + java.util.UUID.randomUUID() + ".txt";

// Get a reference to a blob
BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

// Write text to the file
FileWriter writer = null;
try
{
    writer = new FileWriter(localPath + fileName, true);
    writer.write("Hello, World!");
    writer.close();
}
catch (IOException ex)
{
    System.out.println(ex.getMessage());
}

System.out.println("\nUploading to Blob storage as blob:\n\t" + blobClient.getBlobUrl());

// Upload the blob
blobClient.uploadFromFile(localPath + fileName);

További információkért és példákért lásd: Feltöltés egy blob Java-val.

Tárolóban lévő blobok kilistázása

Sorolja fel a tárolóban lévő blobokat a listBlobs metódus meghívásával. Ebben az esetben csak egy foltot adtál hozzá a konténerhez, így a listázási művelet csak azt az egy foltot adja vissza.

Adja hozzá ezt a kódot a metódus végéhez main :

System.out.println("\nListing blobs...");

// List the blob(s) in the container.
for (BlobItem blobItem : blobContainerClient.listBlobs()) {
    System.out.println("\t" + blobItem.getName());
}

További információkért és példákért lásd: Blobok listázása Javával.

Blobok letöltése

Töltse le a korábban létrehozott blobot a downloadToFile metódus meghívásával. A példakód hozzáad egy utótagot a DOWNLOAD fájl nevéhez, így mindkét fájlt láthatod a helyi fájlrendszerben.

Adja hozzá ezt a kódot a metódus végéhez main :

// Download the blob to a local file

// Append the string "DOWNLOAD" before the .txt extension for comparison purposes
String downloadFileName = fileName.replace(".txt", "DOWNLOAD.txt");

System.out.println("\nDownloading blob to\n\t " + localPath + downloadFileName);

blobClient.downloadToFile(localPath + downloadFileName);

További információkért és példákért lásd: Töltsd le a blobot Java-val.

Törölj egy tárolót

A következő kód az alkalmazás által létrehozott erőforrásokat tisztítja azzal, hogy a delete módszerrel eltávolítja az egész konténert. Emellett törli az alkalmazás által létrehozott helyi fájlokat is.

Az alkalmazás az System.console().readLine() meghívásával szünetelteti a felhasználói bevitelt, mielőtt törölné a blobot, a tárolót és a helyi fájlokat. Ez a szünet lehetőséget ad arra, hogy ellenőrizd, az alkalmazás helyesen hozta létre az erőforrásokat, mielőtt törölné őket.

Adja hozzá ezt a kódot a metódus végéhez main :

File downloadedFile = new File(localPath + downloadFileName);
File localFile = new File(localPath + fileName);

// Clean up resources
System.out.println("\nPress the Enter key to begin clean up");
System.console().readLine();

System.out.println("Deleting blob container...");
blobContainerClient.delete();

System.out.println("Deleting the local source and downloaded files...");
localFile.delete();
downloadedFile.delete();

System.out.println("Done");

További információkért és példákért lásd: Blobtároló törlése és visszaállítása Java használatával.

A kód futtatása

Ez az alkalmazás létrehoz egy tesztfájlt a helyi mappában, és feltölti azt a Blob Storage-ba. A példa ezután felsorolja a tárolóban lévő blobokat, és letölti a fájlt egy új névvel, hogy összehasonlíthassa a régi és az új fájlokat.

Kövesse ezeket a lépéseket a kód fordításához, csomagolásához és futtatásához:

  1. Keresse meg a fájlt tartalmazó pom.xml könyvtárat, és fordítsa le a projektet az alábbi mvn paranccsal: 
    mvn compile
  2. Csomagolja be a lefordított kódot terjeszthető formátumban: 
    mvn package
  3. Futtassa a következő mvn parancsot az alkalmazás végrehajtásához: 
    mvn exec:java -D exec.mainClass=com.blobs.quickstart.App -D exec.cleanupDaemonThreads=false
    A futtatás lépésének egyszerűsítése érdekében add exec-maven-pluginpom.xml hozzá és konfiguráld a következő kód szerint: 
    <plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.4.0</version>
  <configuration>
    <mainClass>com.blobs.quickstart.App</mainClass>
    <cleanupDaemonThreads>false</cleanupDaemonThreads>
  </configuration>
</plugin>
    Ezzel a konfigurációval futtassa az alkalmazást a következő paranccsal: 
    mvn exec:java

Az alkalmazás kimenete hasonló az alábbi példához (az olvashatóság érdekében kihagyott UUID-értékek):

Azure Blob Storage - Java quickstart sample

Uploading to Blob storage as blob:
        https://mystorageacct.blob.core.windows.net/quickstartblobsUUID/quickstartUUID.txt

Listing blobs...
        quickstartUUID.txt

Downloading blob to
        ./data/quickstartUUIDDOWNLOAD.txt

Press the Enter key to begin clean up

Deleting blob container...
Deleting the local source and downloaded files...
Done

A törlési folyamat megkezdése előtt ellenőrizze a két fájl adatmappáját . Összehasonlíthatja őket, és megfigyelheti, hogy azonosak.

Az erőforrások megtisztítása

Miután ellenőrizte a fájlokat, és befejezte a tesztelést, az Enter billentyűt lenyomva törölheti a tesztfájlokat a tárfiókban létrehozott tárolóval együtt. Az Azure CLI használatával is törölheti az erőforrásokat.

Ha végzett a rövid útmutatóval, törölje a létrehozott erőforrásokat az alábbi parancs futtatásával:

azd down

Értesítést kapsz a források törlésének megerősítésére. Adja meg y a megerősítéshez.

Következő lépés

Azure Storage-minták és fejlesztői útmutatók Java-hozRövid útmutató: Quarkus-bővítmény az Azure Blob Storage-hozA Spring Boot használata fájl feltöltéséhez az Azure Blob Storage-ba

  • Last updated on