Festlegen oder Ändern der Zugriffsebene eines Blockblobs mit JavaScript oder TypeScript

Artikel
11/04/2024

In diesem Artikel wird beschrieben, wie die Zugriffsebene eines Blobs für Blockblobs mithilfe der Azure Storage-Clientbibliothek für JavaScript festgelegt oder geändert wird.

Voraussetzungen

Bei den Beispielen in diesem Artikel wird davon ausgegangen, dass Sie bereits ein Projekt eingerichtet haben, das mit der Azure Blob Storage Clientbibliothek für JavaScript arbeitet. Wie Sie Ihr Projekt einrichten, einschließlich der Installation von Paketen, dem Import von Modulen und der Erstellung eines autorisierten Client-Objekts für die Arbeit mit Datenressourcen, erfahren Sie unter Erste Schritte mit Azure Blob Storage und JavaScript.
Der Autorisierungsmechanismus muss über Berechtigungen zum Festlegen der Zugriffsebene des Blobs verfügen. Weitere Informationen finden Sie im Autorisierungsleitfaden für die folgenden REST-API-Vorgänge:
- Set Blob Tier

Informationen zu Zugriffsebenen für Blockblobs

Um die Kosten für die Speicheranforderungen im Blick zu behalten, kann es hilfreich sein, die Daten anhand ihrer Zugriffshäufigkeit und Aufbewahrungsdauer zu organisieren. Azure Storage weist verschiedene Zugriffsebenen auf, sodass Sie Blobdaten basierend auf ihrer Verwendung auf die kostengünstigste Weise speichern können.

Zugriffsebenen für Blobdaten

Folgende Azure Storage-Zugriffsebenen stehen zur Verfügung:

Heiße Zugriffsebene: Onlineebene, die für die Speicherung von Daten optimiert ist, auf die häufig zugegriffen wird oder die häufig geändert werden. Die heiße Ebene hat die höchsten Speicherkosten, aber auch die niedrigsten Zugriffskosten.
Kalte Zugriffsebene: Onlineebene, die für die Speicherung von Daten optimiert ist, auf die nicht häufig zugegriffen wird oder die nicht häufig geändert werden. Daten auf der kalten Ebene sollten für mindestens 30 Tage gespeichert werden. Für die kalte Ebene fallen im Vergleich zur heißen Ebene niedrigere Speicherkosten, aber höhere Zugriffskosten an.
Ebene „Cold“ – Eine Onlineebene, die für die Speicherung von Daten optimiert ist, auf die nur selten zugegriffen wird oder die selten geändert werden. Daten auf der Ebene „Cold“ sollten für mindestens 90 Tage gespeichert werden. Für die Ebene „Cold“ fallen im Vergleich zur kalten Ebene niedrigere Speicherkosten und höhere Zugriffskosten an.
Archivebene – Eine Offline-Dienstebene, welche für die Speicherung von Daten optimiert ist, auf die nur selten zugegriffen wird und die flexible Wartezeitanforderungen in der Größenordnung von Stunden aufweist. Daten auf Archivzugriffsebene müssen mindestens 180 Tage lang gespeichert werden.

Weitere Informationen zu Zugriffsebenen finden Sie unter Zugriffsebenen für Blobdaten.

Während ein Blob sich auf der Archivebene befindet, wird es als offline betrachtet und kann nicht gelesen oder geändert werden. Wenn Daten in einem archivierten Blob gelesen oder geändert werden sollen, müssen Sie das Blob zuerst auf einer Onlineebene aktivieren. Weitere Informationen zum Aktivieren eines Blobs aus der Archivebene auf einer Onlineebene finden Sie unter Aktivierung von Blobs aus der Archivebene.

Beschränkungen

Das Festlegen der Zugriffsebene ist nur für Blockblobs gestattet. Weitere Informationen zu Einschränkungen beim Festlegen der Zugriffsebene eines Blockblobs finden Sie unter Festlegen der Blobebene (REST-API).

Hinweis

Um mithilfe von JavaScript die Zugriffsebene auf Cold festzulegen, müssen Sie mindestens die Version 12.13.0 der Clientbibliothek verwenden.

Festlegen der Zugriffsebene eines Blobs während dem Upload

Um ein Blob in eine bestimmte Zugriffsebene hochzuladen, verwenden Sie BlockBlobUploadOptions. Die Wahlmöglichkeiten für die tier-Eigenschaft sind: Hot, Cool, Cold oder Archive.

JavaScript
TypeScript

async function uploadWithAccessTier(containerClient, blobName) {

  const fileContentsAsString = `Hello from a string`

  // upload blob to `Cool` access tier
  const uploadOptions = {
    // 'Hot', 'Cool', 'Cold', or 'Archive'
    tier: 'Cool',
  }

  // Create blob client from container client
  const blockBlobClient = containerClient.getBlockBlobClient(blobName);

  // Upload string
  await blockBlobClient.upload(fileContentsAsString, fileContentsAsString.length, uploadOptions);

  // Return client to continue with other operations
  return blockBlobClient;
}

async function uploadWithAccessTier(
  containerClient: ContainerClient,
  blobName: string
): Promise<BlockBlobClient> {

  const fileContentsAsString = `Hello from a string`;

  // Upload blob to cool tier
  const uploadOptions: BlockBlobUploadOptions = {
    // 'Hot', 'Cool', 'Cold', or 'Archive'
    tier: 'Cool',
  };

  // Create blob client from container client
  const blockBlobClient: BlockBlobClient =  containerClient.getBlockBlobClient(blobName);

  // Upload string
  const uploadResult = await blockBlobClient.upload(
    fileContentsAsString,
    fileContentsAsString.length,
    uploadOptions
  );

  if (uploadResult.errorCode) throw Error(uploadResult.errorCode);

  // Return client to continue with other operations
  return blockBlobClient;
}

Ändern der Zugriffsebene eines Blobs nach dem Hochladen

Um die Zugriffsebene eines Blobs zu ändern, nachdem es in den Speicher hochgeladen wurde, verwenden Sie setAccessTier. Zusammen mit der Ebene können Sie die BlobSetTierOptions-Eigenschaft Aktivierungspriorität festlegen, um das Blockblob aus einem archivierten Zustand zu bringen. Mögliche Werte sind High oder Standard.

JavaScript
TypeScript

async function main(blockBlobClient) {

  // Get current access tier
  const { accessTier } = await blockBlobClient.getProperties();
  console.log(`Current access tier: ${accessTier}`);

  // 'Hot', 'Cool', or 'Archive'
  const newAccessTier = 'Cool';

  // Rehydrate priority: 'High' or 'Standard'
  const rehydratePriority = 'High';

  const result = await blockBlobClient.setAccessTier(
    newAccessTier,
    { rehydratePriority }
  );

  if (result?.errorCode == undefined) {
    console.log(`Change to access was successful`);
  } else {
    console.log(result);
  }
}

async function main(blockBlobClient: BlockBlobClient): Promise<void> {
  const options: BlobGetPropertiesOptions = {};

  // Get current access tier
  const { errorCode, accessTier } = await blockBlobClient.getProperties(
    options
  );
  if (!errorCode) {
    console.log(`Current access tier: ${accessTier}`);
  }

  // 'Hot', 'Cool', or 'Archive'
  const newAccessTier = 'Cool';

  // Rehydrate priority: 'High' or 'Standard'
  const tierOptions: BlobSetTierOptions = {
    rehydratePriority: 'High'
  };

  const result: BlobSetTierResponse = await blockBlobClient.setAccessTier(
    newAccessTier,
    tierOptions
  );

  if (!result?.errorCode) {
    console.log(`Change to access was successful`);
  } else {
    console.log(result);
  }
}

Kopieren eines Blobs in eine andere Zugriffsebene

Verwenden Sie die Methode BlobClient.beginCopyFromURL, um ein Blob zu kopieren. Um die Zugriffsebene während des Kopiervorgangs zu ändern, verwenden Sie die Eigenschaft BlobBeginCopyFromURLOptions tier, und geben Sie eine andere Zugriffsebene als für das Quellblob an.

JavaScript
TypeScript

async function copyBlobWithDifferentAccessTier(containerClient) {

  // create blob clients
  const sourceBlobClient = containerClient.getBlobClient(originalBlob);
  const destinationBlobClient = containerClient.getBlobClient(copyBlob);

  // start copy, access tiers include `Hot`, `Cool`, `Cold`, `Archive`
  const copyPoller = await destinationBlobClient.beginCopyFromURL(sourceBlobClient.url, { tier: 'Hot' });
  console.log('start copy from original to copy');

  // wait until done
  await copyPoller.pollUntilDone();
  console.log('copy finished')
}

async function copyBlobWithDifferentAccessTier(
  containerClient: ContainerClient
): Promise<void> {

  // create blob clients
  const sourceBlobClient: BlobClient = containerClient.getBlobClient(
    originalBlob
  );
  const destinationBlobClient: BlobClient = containerClient.getBlobClient(
    copyBlob
  );

  const copyOptions: BlobBeginCopyFromURLOptions = { tier: 'Hot' };

  // start copy, access tiers include `Hot`, `Cool`, `Cold`, `Archive`
  const copyPoller = await destinationBlobClient.beginCopyFromURL(
    sourceBlobClient.url,
    copyOptions
  );
  console.log('start copy from original to copy');

  // wait until done
  await copyPoller.pollUntilDone();
  console.log('copy finished');
}

Verwenden eines Batches zum Ändern der Zugriffsebene für mehrere Blobs

Der Batch stellt einen aggregierten Satz von Vorgängen für Blobs dar, z. B, löschen oder Zugriffsebene festlegen. Sie müssen die korrekten Anmeldeinformationen übergeben, um jeden Vorgang erfolgreich ausführen zu können. In diesem Beispiel werden die gleichen Anmeldeinformationen für eine Gruppe von Blobs im selben Container verwendet.

Erstellen eines BlobBatchClient. Verwenden Sie den Client, um einen Batch mit der Methode createBatch() zu erstellen. Wenn der Batch bereit ist, übermitteln Sie ihn zur Verarbeitung. Verwenden Sie die zurückgegebene Struktur, um zu überprüfen, ob der Vorgang jedes Blobs erfolgreich war.

JavaScript
TypeScript

async function main(containerClient) {

  // Prep array
  const blockBlobCount = 3;
  const blockBlobClients = new Array(blockBlobCount);

  // Create container and blobs in `Hot` tier
  await prepContainer(containerClient, blockBlobCount, blockBlobClients);

  // Blob batch client and batch
  const containerScopedBatchClient = containerClient.getBlobBatchClient();
  const blobBatch = containerScopedBatchClient.createBatch();

  // Assemble batch to set tier to `Cool` tier
  for (let i = 0; i < blockBlobCount; i++) {
    await blobBatch.setBlobAccessTier(blockBlobClients[i].url, sharedKeyCredential, "Cool", {});
  }

  // Submit batch request and verify response
  const resp = await containerScopedBatchClient.submitBatch(blobBatch, {});
  console.log(`Requested ${blockBlobCount}, batched ${resp.subResponses.length}, success ${resp.subResponsesSucceededCount}, failure ${resp.subResponsesFailedCount}`);

  // Examine each batch item
  for (let i = 0; i < blockBlobCount; i++) {

    // Check blob tier set properly
    const resp2 = await blockBlobClients[i].getProperties();
    console.log(`[${i}] access tier ${resp2.accessTier}, status ${resp.subResponses[i].status}, message ${resp.subResponses[i].statusMessage}`)
  }
}

async function batchChangeAccessTier(
  containerClient: ContainerClient
): Promise<void> {
  // Prep array
  const blockBlobCount = 3;
  const blockBlobClients: BlockBlobClient[] = new Array(blockBlobCount);

  // Create container and blobs in `Hot` tier
  await prepContainer(containerClient, blockBlobCount, blockBlobClients);

  // Blob batch client and batch
  const containerScopedBatchClient: BlobBatchClient =
    containerClient.getBlobBatchClient();
  const blobBatch: BlobBatch = containerScopedBatchClient.createBatch();

  // Assemble batch to set tier to `Cool` tier
  for (let i = 0; i < blockBlobCount; i++) {
    await blobBatch.setBlobAccessTier(
      blockBlobClients[i].url,
      sharedKeyCredential,
      'Cool',
      {}
    );
  }

  // Submit batch request and verify response
  const resp = await containerScopedBatchClient.submitBatch(blobBatch, {});

  if (resp.errorCode) throw Error(resp.errorCode);

  console.log(
    `Requested ${blockBlobCount}, batched ${resp.subResponses.length}, success ${resp.subResponsesSucceededCount}, failure ${resp.subResponsesFailedCount}`
  );

  // Examine each batch item
  for (let i = 0; i < blockBlobCount; i++) {
    // Check blob tier set properly
    const resp2 = await blockBlobClients[i].getProperties();

    if (resp2.errorCode) throw Error(resp2.errorCode);

    console.log(
      `[${i}] access tier ${resp2.accessTier}, status ${resp.subResponses[i].status}, message ${resp.subResponses[i].statusMessage}`
    );
  }
}

Codebeispiele

Festlegen der Zugriffsebene eines Blobs während des Uploads für JavaScript oder TypeScript
Ändern der Zugriffsebene eines Blobs nach dem Upload für JavaScript oder TypeScript
Kopieren eines Blobs auf eine andere Zugriffsebene für JavaScript oder TypeScript
Verwenden eines Batches zum Ändern der Zugriffsebene für viele Blobs für JavaScript oder TypeScript

Freigeben über