Azure SDK's gebruiken voor JavaScript en TypeScript

Artikel
12/03/2021
5 minuten om te lezen

Als u programmatisch toegang wilt krijgen tot uw Azure-services, gebruikt u de Azure SDK's voor JavaScript. Normaal gesproken worden deze SDK's gebereikt met het @azure npm-pakketbereik dat is gepubliceerd door azure-sdk.

Verschillen tussen SDK's en REST API's

Gebruik de volgende tabel om te begrijpen wanneer u welk type toegangsmechanisme moet gebruiken.

Azure SDK's (aanbevolen)	Azure REST API's
De Azure SDK's zijn de voorkeursmethode voor toegang tot uw Azure-service. Met de Azure-SDK's wordt de standaardcode verwijderd die nodig is voor het beheren van REST-aanvragen voor het Azure-platform in de cloud, zoals verificatie, nieuwe aanvragen en logboekregistratie.	Azure REST API's zijn de voorkeursmethode als u: Werken met preview-services die geen Azure SDK's beschikbaar hebben. Overweeg uw code als preview, die moet worden bijgewerkt wanneer de service algemeen beschikbaar is met SDK's. U wilt RECHTSTREEKS REST-aanroepen doen omdat u niet wilt dat de hele SDK één REST API of u meer controle wilt over de HTTP-aanvragen.

Azure-client- en beheerbibliotheken

De Azure SDK-releases zijn beschikbaar als:

Beheer-SDK's:met beheerbibliotheken kunt u Azure-resources inrichten en beheren via de Azure Resource Manager (ARM). U kunt deze bibliotheken herkennen aan @azure/arm- de pakketnamen.
- Documentatie en codevoorbeelden
Client-SDK's:als er al een Azure-resource bestaat, gebruikt u de clientbibliotheken om deze te gebruiken en mee te werken.
- Elk pakket README.md bevat documentatie en voorbeelden.

Azure npm-pakketten installeren

Azure SDK's zijn vrij beschikbaar via NPM. Installeer de benodigde afzonderlijke SDK's. Elke SDK biedt TypeScript-definities.

Voor client-/browsergebruik moeten Azure-SDK's worden toegevoegd aan uw bundelingsproces.

Voorbeeldcode van Azure npm-pakket gebruiken

Elk pakket bevat documentatie om snel aan de slag te gaan met het pakket. Raadpleeg de specifieke NPM-pakketten die u gebruikt om te leren hoe u deze kunt gebruiken.

Verificatiereferenties verstrekken

Voor de Azure-SDK's zijn referenties vereist voor verificatie bij het Azure-platform. Referentieklassen die door @azure/identiteit worden geleverd, bieden verschillende voordelen:

Snelle onboarding
Veiligste methode
Scheid het verificatiemechanisme van de code. Hierdoor kunt u dezelfde code lokaal en op het Azure-platform gebruiken terwijl de referenties verschillen.
Ketenverificatie bieden zodat er verschillende mechanismen beschikbaar kunnen zijn

Een SDK-client maken en methoden aanroepen

Nadat u programmatisch een referentie hebt aangeslagen, moet u de referentie doorgeven aan de client van uw Azure SDK. De client heeft mogelijk aanvullende informatie nodig, zoals een abonnements-id of service-URL. Deze waarden zijn beschikbaar in de Azure Portal, voor uw resource.

Vermeld abonnementen waarvoor deze referentie toegang heeft om te lezen.

const { ClientSecretCredential, DefaultAzureCredential } = require("@azure/identity");
const { SubscriptionClient } = require("@azure/arm-subscriptions");

let credentials = null;

const tenantId = process.env["AZURE_TENANT_ID"] || "REPLACE-WITH-YOUR-TENANT-ID"; 
const clientId = process.env["AZURE_CLIENT_ID"] || "REPLACE-WITH-YOUR-CLIENT-ID"; 
const secret = process.env["AZURE_CLIENT_SECRET"] || "REPLACE-WITH-YOUR-CLIENT-SECRET";


if(process.env.production){

  // production
  credentials = new DefaultAzureCredential();

}else{

  // development
  credentials = new ClientSecretCredential(tenantId, clientId, secret);
  console.log("development");
}

// use credential to authenticate with Azure SDKs
let client = new SubscriptionClient(credentials);

const subscriptions = async() =>{

  // get list of Azure subscriptions
  const listOfSubscriptions = await client.subscriptions.list();
  
  // get details of each subscription
  for (const item of listOfSubscriptions) {
  
      const subscriptionDetails = await client.subscriptions.get(item.subscriptionId);
  
      /*
    
      Each item looks like:
    
      {
        id: '/subscriptions/123456',
        subscriptionId: '123456',
        displayName: 'YOUR-SUBSCRIPTION-NAME',
        state: 'Enabled',
        subscriptionPolicies: {
          locationPlacementId: 'Internal_2014-09-01',
          quotaId: 'Internal_2014-09-01',
          spendingLimit: 'Off'
        },
        authorizationSource: 'RoleBased'
      },
    
      */
  
      console.log(subscriptionDetails)
  }
}

subscriptions()
.then(()=>console.log("done"))
.catch(ex=>console.log(ex))

Asynchrone paginering van resultaten

Een SDK-methode kan een asynchrone iterator PagedAsyncIterableIteratorretourneren om asynchrone resultaten mogelijk te maken. De resultaten kunnen paginerings- en vervolgtokens gebruiken om resultatensets op te breken.

In het volgende JavaScript-voorbeeld wordt asynchrone paginering gedemonstreerd. De code stelt een kunstmatig korte pagineringsgrootte van 2 in om het proces snel en visueel te demonstreren wanneer u de voorbeeldcode voor foutopsporing uit te voeren.

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

Meer informatie over paginering en iterators in Azure:

Async Iterators in de Azure SDK voor JavaScript/TypeScript

Langlopende bewerkingen

Een SDK-methode kan een langlopende bewerkingsreactie (LRO) retourneren. Dit antwoord bevat informatie zoals:

Uw aanvraag is voltooid
Uw aanvraag wordt nog verwerkt

In het volgende JavaScript-voorbeeld wordt gedemonstreerd hoe u wacht tot een LRO is voltooid, met , voordat u doorgaat.

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

Meer informatie over langlopende bewerkingen in Azure:

@azure/core-lro

Async-bewerkingen annuleren

Het pakket @azure/abort-controller biedt de klassen AbortController en AbortSignal. Gebruik AbortController om een AbortSignal te maken, die vervolgens kan worden doorgegeven aan Azure SDK-bewerkingen om wachtend werk te annuleren. Azure SDK-bewerkingen kunnen zijn:

Afgebroken op basis van uw eigen logica
Afgebroken op basis van een time-outlimiet
Afgebroken op basis van het signaal van een bovenliggende taak
Afgebroken op basis van het signaal van een bovenliggende taak of een time-outlimiet

Meer informatie:

Afbrekende signalen gebruiken om bewerkingen in de Azure SDK voor JavaScript/TypeScript te annuleren

Uitgebreide logboekregistratie van de SDK

Wanneer u een Azure SDK gebruikt, kan het zijn dat u fouten in uw toepassing moet opsporen.

Als u logboekregistratie tijdens de build wilt inschakelen,stelt u AZURE_LOG_LEVEL omgevingsvariabele in op .
Als u logboekregistratie tijdens run time wilt inschakelen,gebruikt u het @azure/loggerpakket:
```
import { setLogLevel } from "@azure/logger";

setLogLevel("info");
```

Bundeling

Meer informatie over bundeling met de Azure SDK: