Een blok-blob uploaden met Java

• .NET
• Java
• JavaScript
• Python
• Go

In dit artikel wordt beschreven hoe u een blok-blob uploadt met behulp van de Azure Storage-clientbibliotheek voor Java. U kunt gegevens uploaden naar een blok-blob vanuit een bestandspad, een stroom, een binair object of een tekenreeks. U kunt ook blobs uploaden met indextags.

Vereisten

• Azure-abonnement: u kunt een gratis abonnement nemen
• Azure Storage-account: maak een opslagaccount
• Java Development Kit (JDK) versie 8 of hoger (we raden versie 17 aan voor de beste ervaring)
• Apache Maven wordt in dit voorbeeld gebruikt voor projectbeheer

Uw omgeving instellen

Als u geen bestaand project hebt, ziet u in deze sectie hoe u een project instelt voor gebruik met de Azure Blob Storage-clientbibliotheek voor Java. Zie Aan de slag met Azure Blob Storage en Java voor meer informatie.

Als u wilt werken met de codevoorbeelden in dit artikel, volgt u deze stappen om uw project in te stellen.

Notitie

In dit artikel wordt het Maven-buildhulpprogramma gebruikt om de voorbeeldcode te bouwen en uit te voeren. Andere buildhulpprogramma's, zoals Gradle, werken ook met de Azure SDK voor Java.

Pakketten installeren

Open het pom.xml bestand in de teksteditor. Installeer de pakketten door het BOM-bestand op te slaan of door een directe afhankelijkheid op te slaan.

Importinstructies toevoegen

Voeg de volgende import instructies toe:

import com.azure.core.http.rest.*;
import com.azure.core.util.BinaryData;
import com.azure.storage.blob.*;
import com.azure.storage.blob.models.*;
import com.azure.storage.blob.options.BlobUploadFromFileOptions;
import com.azure.storage.blob.specialized.*;

import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.time.Duration;
import java.util.*;

Autorisatie

Het autorisatiemechanisme moet over de benodigde machtigingen beschikken om een blob te kunnen uploaden. Voor autorisatie met Microsoft Entra ID (aanbevolen) hebt u ingebouwde Azure RBAC-rol Opslagblobgegevensbijdrager of hoger nodig. Zie de autorisatierichtlijnen voor Put Blob (REST API) en Put Block (REST API) voor meer informatie.

Een clientobject maken

Als u een app wilt verbinden met Blob Storage, maakt u een exemplaar van BlobServiceClient.

In het volgende voorbeeld wordt BlobServiceClientBuilder gebruikt om een BlobServiceClient object te bouwen met behulp vanDefaultAzureCredential, en ziet u hoe u indien nodig container- en blobclients maakt:

// 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(new DefaultAzureCredentialBuilder().build())
        .buildClient();

// If needed, you can create a BlobContainerClient object from the BlobServiceClient
BlobContainerClient containerClient = blobServiceClient
        .getBlobContainerClient("<container-name>");

// If needed, you can create a BlobClient object from the BlobContainerClient
BlobClient blobClient = containerClient
        .getBlobClient("<blob-name>");

Zie Clientobjecten maken en beheren die interactie hebben met gegevensbronnen voor meer informatie over het maken en beheren van clientobjecten.

Gegevens uploaden naar een blok-blob

Als u een blok-blob wilt uploaden vanuit een stream of een binair object, gebruikt u de volgende methode:

• uploaden

Als u een blok-blob wilt uploaden vanuit een bestandspad, gebruikt u de volgende methode:

• uploadFromFile

Elk van deze methoden kan worden aangeroepen met behulp van een BlobClient-object of een BlockBlobClient-object .

Een blok-blob uploaden vanuit een lokaal bestandspad

In het volgende voorbeeld wordt een bestand geüpload naar een blok-blob met behulp van een BlobClient object:

public void uploadBlobFromFile(BlobContainerClient blobContainerClient) {
    BlobClient blobClient = blobContainerClient.getBlobClient("sampleBlob.txt");

    try {
        blobClient.uploadFromFile("filepath/local-file.png");
    } catch (UncheckedIOException ex) {
        System.err.printf("Failed to upload from file: %s%n", ex.getMessage());
    }
}

Een blok-blob uploaden vanuit een stream

In het volgende voorbeeld wordt een blok-blob geüpload door een ByteArrayInputStream object te maken en vervolgens dat streamobject te uploaden:

public void uploadBlobFromStream(BlobContainerClient blobContainerClient) {
    BlockBlobClient blockBlobClient = blobContainerClient.getBlobClient("sampleBlob.txt").getBlockBlobClient();
    String sampleData = "Sample data for blob";
    try (ByteArrayInputStream dataStream = new ByteArrayInputStream(sampleData.getBytes())) {
        blockBlobClient.upload(dataStream, sampleData.length());
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

Een blok-blob uploaden vanuit een BinaryData-object

In het volgende voorbeeld BinaryData wordt geüpload naar een blok-blob met behulp van een BlobClient object:

public void uploadDataToBlob(BlobContainerClient blobContainerClient) {
    // Create a BlobClient object from BlobContainerClient
    BlobClient blobClient = blobContainerClient.getBlobClient("sampleBlob.txt");
    String sampleData = "Sample data for blob";
    blobClient.upload(BinaryData.fromString(sampleData));
}

Een blok-blob uploaden met configuratieopties

U kunt configuratieopties voor clientbibliotheek definiëren bij het uploaden van een blob. Deze opties kunnen worden afgestemd om de prestaties te verbeteren, de betrouwbaarheid te verbeteren en de kosten te optimaliseren. In de volgende codevoorbeelden ziet u hoe u BlobUploadFromFileOptions gebruikt om configuratieopties te definiëren bij het aanroepen van een uploadmethode. Als u niet vanuit een bestand uploadt, kunt u vergelijkbare opties instellen met behulp van BlobParallelUploadOptions op een uploadmethode.

Opties voor gegevensoverdracht opgeven bij uploaden

U kunt waarden in ParallelTransferOptions configureren om de prestaties voor gegevensoverdrachtbewerkingen te verbeteren. De volgende waarden kunnen worden afgestemd op uploads op basis van de behoeften van uw app:

• blockSize: De maximale blokgrootte die moet worden overgedragen voor elke aanvraag. U kunt deze waarde instellen met behulp van de methode setBlockSizeLong .
• maxSingleUploadSize: Als de grootte van de gegevens kleiner is dan of gelijk is aan deze waarde, wordt deze geüpload in één put in plaats van opgesplitst in segmenten. Als de gegevens in één opname worden geüpload, wordt de blokgrootte genegeerd. U kunt deze waarde instellen met behulp van de methode setMaxSingleUploadSizeLong .
• maxConcurrency: Het maximum aantal parallelle aanvragen dat op een bepaald moment wordt uitgegeven als onderdeel van één parallelle overdracht. U kunt deze waarde instellen met behulp van de methode setMaxConcurrency .

Zorg ervoor dat u de volgende import instructie hebt om te gebruiken ParallelTransferOptions voor een upload:

import com.azure.storage.blob.models.*;

In het volgende codevoorbeeld ziet u hoe u waarden instelt voor ParallelTransferOptions en de opties opneemt als onderdeel van een BlobUploadFromFileOptions-exemplaar . De waarden in dit voorbeeld zijn niet bedoeld als aanbeveling. Als u deze waarden goed wilt afstemmen, moet u rekening houden met de specifieke behoeften van uw app.

public void uploadBlockBlobWithTransferOptions(BlobContainerClient blobContainerClient, Path filePath) {
    String fileName = filePath.getFileName().toString();
    BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

    ParallelTransferOptions parallelTransferOptions = new ParallelTransferOptions()
            .setBlockSizeLong((long) (4 * 1024 * 1024)) // 4 MiB block size
            .setMaxConcurrency(2)
            .setMaxSingleUploadSizeLong((long) 8 * 1024 * 1024); // 8 MiB max size for single request upload

    BlobUploadFromFileOptions options = new BlobUploadFromFileOptions(filePath.toString());
    options.setParallelTransferOptions(parallelTransferOptions);

    try {
        Response<BlockBlobItem> blockBlob = blobClient.uploadFromFileWithResponse(options, null, null);
    } catch (UncheckedIOException ex) {
        System.err.printf("Failed to upload from file: %s%n", ex.getMessage());
    }
}

Zie Prestaties afstemmen voor uploads en downloads met Java voor meer informatie over het afstemmen van opties voor het afstemmen van gegevensoverdracht.

Een blok-blob uploaden met indextags

Blob-indextags categoriseren gegevens in uw opslagaccount met behulp van tagkenmerken met sleutelwaarde. Deze tags worden automatisch geïndexeerd en weergegeven als doorzoekbare multidimensionale index om eenvoudig gegevens te vinden.

In het volgende voorbeeld wordt een blok-blob geüpload met indextags die zijn ingesteld met blobUploadFromFileOptions:

public void uploadBlockBlobWithIndexTags(BlobContainerClient blobContainerClient, Path filePath) {
    String fileName = filePath.getFileName().toString();
    BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

    Map<String, String> tags = new HashMap<String, String>();
    tags.put("Content", "image");
    tags.put("Date", "2022-01-01");

    Duration timeout = Duration.ofSeconds(10);

    BlobUploadFromFileOptions options = new BlobUploadFromFileOptions(filePath.toString());
    options.setTags(tags);

    try {
        // Create a new block blob, or update the content of an existing blob
        Response<BlockBlobItem> blockBlob = blobClient.uploadFromFileWithResponse(options, timeout, null);
    } catch (UncheckedIOException ex) {
        System.err.printf("Failed to upload from file: %s%n", ex.getMessage());
    }
}

De toegangslaag van een blob instellen bij uploaden

U kunt de toegangslaag van een blob instellen bij uploaden met behulp van de klasse BlobUploadFromFileOptions . In het volgende codevoorbeeld ziet u hoe u de toegangslaag instelt bij het uploaden van een blob:

public void uploadBlobWithAccessTier(BlobContainerClient blobContainerClient, Path filePath) {
    String fileName = filePath.getFileName().toString();
    BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

    BlobUploadFromFileOptions options = new BlobUploadFromFileOptions(filePath.toString())
            .setTier(AccessTier.COOL);

    try {
        Response<BlockBlobItem> blockBlob = blobClient.uploadFromFileWithResponse(options, null, null);
    } catch (UncheckedIOException ex) {
        System.err.printf("Failed to upload from file: %s%n", ex.getMessage());
    }
}

Het instellen van de toegangslaag is alleen toegestaan voor blok-blobs. U kunt de toegangslaag voor een blok-blob instellen op Hot, Coolof ArchiveCold. Als u de toegangslaag Coldwilt instellen, moet u een minimale clientbibliotheekversie van 12.21.0 gebruiken.

Zie het overzicht van Access-lagen voor meer informatie over toegangslagen.

Een blok-blob uploaden door blokken te faseren en doorvoeren

U kunt meer controle hebben over het verdelen van uploads in blokken door afzonderlijke gegevensblokken handmatig te faseren. Wanneer alle blokken waaruit een blob bestaat zijn gefaseerd, kunt u ze doorvoeren in Blob Storage. U kunt deze methode gebruiken om de prestaties te verbeteren door blokken parallel te uploaden.

public void uploadBlocks(BlobContainerClient blobContainerClient, Path filePath, int blockSize) throws IOException {
    String fileName = filePath.getFileName().toString();
    BlockBlobClient blobClient = blobContainerClient.getBlobClient(fileName).getBlockBlobClient();

    FileInputStream fileStream = new FileInputStream(filePath.toString());
    List<String> blockIDArrayList = new ArrayList<>();
    byte[] buffer = new byte[blockSize];
    int bytesRead;

    while ((bytesRead = fileStream.read(buffer, 0, blockSize)) != -1) {

        try (ByteArrayInputStream stream = new ByteArrayInputStream(buffer)) {
            String blockID = Base64.getEncoder().encodeToString(UUID.randomUUID().toString().getBytes(StandardCharsets.UTF_8));

            blockIDArrayList.add(blockID);
            blobClient.stageBlock(blockID, stream, buffer.length);
        }
    }

    blobClient.commitBlockList(blockIDArrayList);

    fileStream.close();
}

Resources

Zie de volgende resources voor meer informatie over het uploaden van blobs met behulp van de Azure Blob Storage-clientbibliotheek voor Java.

Codevoorbeelden

• Codevoorbeelden uit dit artikel weergeven (GitHub)

REST API-bewerkingen

De Azure SDK voor Java bevat bibliotheken die zijn gebaseerd op de Azure REST API, zodat u kunt communiceren met REST API-bewerkingen via bekende Java-paradigma's. De clientbibliotheekmethoden voor het uploaden van blobs gebruiken de volgende REST API-bewerkingen:

• Blob plaatsen (REST API)
• Put Block (REST API)

Clientbibliotheekbronnen

• Referentiedocumentatie voor clientbibliotheek
• Broncode van clientbibliotheek
• Pakket (Maven)

Zie ook

• Azure Blob-gegevens beheren en zoeken met blobindextags
• Blob-indextags gebruiken om gegevens te beheren en te zoeken in Azure Blob Storage

Gerelateerde inhoud

• Dit artikel maakt deel uit van de ontwikkelaarshandleiding voor Blob Storage voor Java. Zie de volledige lijst met artikelen over ontwikkelaarshandleidingen in Uw Java-app bouwen voor meer informatie.