Verwenden von Azure-Clientbibliotheken für JavaScript und TypeScript

Verwenden Sie die Azure-Clientbibliotheken für JavaScript, um programmgesteuert auf Ihre Azure-Dienste zuzugreifen. In der Regel sind diese Bibliotheken auf den @azure npm-Paket-Scope festgelegt, der von Microsoft1es veröffentlicht wurde.

Unterschiede zwischen Clientbibliotheken und REST-APIs

Verwenden Sie die folgenden Informationen, um zu verstehen, wann welcher Zugriffstyp verwendet werden soll.

Die Azure-Clientbibliotheken sind die bevorzugte Methode für den Zugriff auf Ihren Azure-Dienst. Diese Bibliotheken abstrahieren den Boilerplate-Code, der erforderlich ist, um cloudbasierte Azure-Plattform-REST-Anforderungen wie Authentifizierung, Wiederholungen und Protokollierung zu handhaben.
Azure REST-APIs sind die bevorzugte Methode, wenn Sie:
- Arbeiten mit Vorschaudiensten, für die keine Azure-Clientbibliotheken verfügbar sind. Berücksichtigen Sie Ihren Code als Vorschau, der aktualisiert werden soll, wenn der Dienst allgemein in Clientbibliotheken verfügbar ist.
- Sie möchten REST-Aufrufe direkt ausführen, da sie nicht möchten, dass das gesamte SDK eine einzelne REST-API verwendet, oder Sie möchten eine tiefere Kontrolle über die HTTP-Anforderungen haben.

Azure-Client- und Verwaltungsbibliotheken

Die Versionen der Azure-Clientbibliothek sind verfügbar als:

Verwaltung: Mithilfe von Verwaltungsbibliotheken können Sie Azure-Ressourcen erstellen und verwalten. Sie können diese Bibliotheken anhand von arm- in ihren Paketnamen erkennen. Der Begriff arm gibt den Azure Resource Manager an.
- Dokumentation und Codebeispiele
Client: Da bereits eine Azure-Ressource vorhanden ist, verwenden Sie die Clientbibliotheken, um sie zu nutzen und damit zu interagieren.
- Jedes Paket README.md enthält Dokumentation und Beispiele.

Installieren von Azure npm-Paketen

Azure-Clientbibliotheken sind frei über NPM und Yarn verfügbar. Installieren Sie einzelne SDKs nach Bedarf. Jedes SDK stellt TypeScript-Definitionen bereit.

Für die Client-/Browserverwendung müssen Azure-Clientbibliotheken zu Ihrem Bündelungsprozess hinzugefügt werden.

Verwenden Sie den Beispielcode für das Azure npm-Paket

Jedes Paket enthält Dokumentationen, mit denen Sie schnell mit dem Paket beginnen können. In der Dokumentation des jeweiligen Pakets erfahren Sie, wie Sie sie verwenden.

Bereitstellen von Authentifizierungsanmeldeinformationen

Für die Azure-Clientbibliotheken sind Anmeldeinformationen erforderlich, um sich bei der Azure-Plattform zu authentifizieren. Anmeldeinformationsklassen, die von @azure/identity bereitgestellt werden, bieten mehrere Vorteile:

Schnelle Einarbeitung
Sicherste Methode
Trennen Sie den Authentifizierungsmechanismus vom Code. Auf diese Weise können Sie denselben Code lokal und auf der Azure-Plattform verwenden, während sich die Anmeldeinformationen unterscheiden.
Stellen Sie eine verkettete Authentifizierung bereit, damit mehrere Mechanismen verfügbar sein können.

Erstellen eines SDK-Clients und Aufrufmethoden

Nachdem Sie programmgesteuert eine Anmeldeinformation erstellt haben, übergeben Sie die Anmeldeinformationen an Ihren Azure-Client. Der Client benötigt möglicherweise zusätzliche Informationen, z. B. eine Abonnement-ID oder einen Dienstendpunkt. Diese Werte sind im Azure-Portal für Ihre Ressource verfügbar.

Das folgende Codebeispiel verwendet DefaultAzureCredential und die @azure/arm-resources-Clientbibliothek, um Ressourcengruppen aufzulisten, deren Lesezugriff durch diese Berechtigungen ermöglicht wird.

import { DefaultAzureCredential } from "@azure/identity";
import { ResourceManagementClient } from "@azure/arm-resources";

const subscriptionId = process.env.AZURE_SUBSCRIPTION_ID!;
if (!subscriptionId) {
  throw new Error("AZURE_SUBSCRIPTION_ID environment variable is not set.");
}

console.log(`Using Subscription ID: ${subscriptionId}`);

async function main() {

    const credential = new DefaultAzureCredential();
    const client = new ResourceManagementClient(credential, subscriptionId);

    let i=0;

    for await (const item of client.resourceGroups.list()) {
        console.log(`${++i}: ${item.name}`);
    }
    console.log(`Found ${i} resource group(s).`);
}

main().catch((err) => {
  console.error(err);
});

Asynchrones Paging von Ergebnissen

Eine SDK-Methode kann einen asynchronen Iterator , PagedAsyncIterableIterator, zurückgeben, um asynchrone Ergebnisse zu ermöglichen. Die Ergebnisse können Paging- und Fortsetzungstoken verwenden, um Resultsets aufzulösen.

Im folgenden JavaScript-Beispiel wird das asynchrone Paging veranschaulicht. Der Code legt eine künstlich kurze Paginggröße von 2 fest, um den Prozess schnell und visuell zu veranschaulichen, wenn Sie den Beispielcode im Debugvorgang ausführen.

const { BlobServiceClient } = require("@azure/storage-blob");

const blobAccountConnectionString = "REPLACE-WITH-YOUR-STORAGE-CONNECTION-STRING";
const blobAccountContainerName = "REPLACE-WITH-YOUR-STORAGE-CONTAINER-NAME";

const pageSize = 2;

const list = async () => {

  console.log(`List`);

  let continuationToken = "";
  let currentPage = 1;
  let containerClient=null;
  let currentItem = 1;

  // Get Blob Container - need to have items in container before running this code
  const blobServiceClient = BlobServiceClient.fromConnectionString(blobAccountConnectionString);
  containerClient = blobServiceClient.getContainerClient(blobAccountContainerName);

  do {

    // Get Page of Blobs
    iterator = (continuationToken != "") 
      ? containerClient.listBlobsFlat().byPage({ maxPageSize: pageSize, continuationToken }) 
      : containerClient.listBlobsFlat().byPage({ maxPageSize: pageSize });
    
    page = (await iterator.next()).value;

    // Display list
    if (page.segment?.blobItems) {
      console.log(`\tPage [${currentPage}] `);
      for (const blob of page.segment.blobItems) {
        console.log(`\t\tItem [${currentItem++}] ${blob.name}`);
      }
    };

    // Move to next page
    continuationToken = page.continuationToken;
    if (continuationToken) {
      currentPage++;
    }

  } while (continuationToken != "")
}

list(() => {
  console.log("done");
}).catch((ex) =>
  console.log(ex)
);

Erfahren Sie mehr über Paging und Iteratoren in Azure:

Asynchrone Iteratoren im Azure SDK für JavaScript/TypeScript

Lang andauernde Vorgänge

Eine SDK-Methode kann eine unformatierte Antwort (Long Running Operation, LRO) zurückgeben. Diese Antwort enthält Informationen, einschließlich:

Ihre Anforderung wurde abgeschlossen.
Ihre Anforderung wird noch verarbeitet.

Im folgenden JavaScript-Beispiel wird veranschaulicht, wie gewartet wird, bis ein LRO abgeschlossen ist, mit .pollUntildone(), bevor der Vorgang fortgesetzt wird.

const { BlobServiceClient } = require("@azure/storage-blob");

const blobAccountConnectionString = "REPLACE-WITH-YOUR-STORAGE-CONNECTION-STRING";
const blobAccountContainerName = `test-${Date.now().toString()}`;

const files = [
  {
    "url": "https://github.com/Azure/azure-sdk-for-js/blob/main/README.md",
    "fileName": "README.md"
  },
  {
    "url": "https://github.com/Azure/azure-sdk-for-js/blob/main/gulpfile.ts",
    "fileName": "gulpfile.ts"
  },
  {
    "url": "https://github.com/Azure/azure-sdk-for-js/blob/main/rush.json",
    "fileName": "rush.json"
  },  
  {
    "url": "https://github.com/Azure/azure-sdk-for-js/blob/main/package.json",
    "fileName": "package.json"
  },
  {
    "url": "https://github.com/Azure/azure-sdk-for-js/blob/main/tsdoc.json",
    "fileName": "tsdoc.json"
  },
];

const upload = async() => {

  // get container client
  const blobServiceClient = BlobServiceClient.fromConnectionString(blobAccountConnectionString);

  // get container's directory client
  const containerClient = blobServiceClient.getContainerClient(blobAccountContainerName);

  files.forEach(async(file) =>{
    await (

      await containerClient
        .getBlobClient(file.fileName)
        .beginCopyFromURL(file.url)
  
    ).pollUntilDone();
  })
}

upload(() => {
  console.log("done");
}).catch((ex) =>
  console.log(ex)
);

Erfahren Sie mehr über vorgänge mit langer Ausführung in Azure:

@azure/core-lro

Abbrechen asynchroner Vorgänge

Das @azure/abort-controller-Paket stellt AbortController- und AbortSignal-Klassen bereit. Verwenden Sie "AbortController", um ein AbortSignal zu erstellen, das dann an Azure SDK-Vorgänge übergeben werden kann, um ausstehende Arbeiten abzubrechen. Azure SDK-Vorgänge können folgendes sein:

Abgebrochen basierend auf Ihrer eigenen Logik
Abgebrochen aufgrund eines Timeout-Limits
Abgebrochen aufgrund des Signals einer Elternaufgabe
Abgebrochen aufgrund eines Signals einer übergeordneten Aufgabe oder einer Zeitüberschreitungsgrenze

Weitere Informationen:

Verwenden von Abbruchsignalen zum Abbrechen von Vorgängen im Azure SDK für JavaScript/TypeScript

Ausführliche Protokollierung aus dem SDK

Wenn Sie das Azure SDK verwenden, kann es vorkommen, dass Sie Ihre Anwendung debuggen müssen.

Um die Protokollierung zur Buildzeit zu aktivieren, legen Sie die AZURE_LOG_LEVEL Umgebungsvariable auf info.
Um die Protokollierung zur Laufzeit zu aktivieren, verwenden Sie das @azure/Logger-Paket :
```
import { setLogLevel } from "@azure/logger";

setLogLevel("info");
```

Bündelung

Erfahren Sie mehr über die Bündelung mit dem Azure SDK:

Nächste Schritte

Feedback

War diese Seite hilfreich?

Last updated on 2025-12-08