Använda Azure-klientbibliotek för JavaScript och TypeScript

Om du vill komma åt dina Azure-tjänster programmatiskt använder du Azure-klientbiblioteken för JavaScript. Vanligtvis är dessa bibliotek begränsade med det @azure npm-paketomfånget som publicerats av azure-sdk.

Skillnader mellan klientbibliotek och REST-API:er

Använd följande information för att förstå när du ska använda vilken typ av åtkomst.

• Azure-klientbiblioteken är den bästa metoden för att komma åt din Azure-tjänst. Dessa bibliotek abstraherar bort den exempelkod som krävs för att hantera molnbaserade REST-begäranden för Azure-plattformen, till exempel autentisering, återförsök och loggning.
• Azure REST-API:er är den bästa metoden om du är:
  • Arbeta med förhandsgranskningstjänster som inte har tillgängliga Azure-klientbibliotek. Tänk på din kod som förhandsversion, som bör uppdateras när tjänsten är allmänt tillgänglig med klientbibliotek.
  • Vill du göra REST-anrop direkt eftersom du inte vill att hela SDK:n ska använda ett enda REST-API eller om du vill ha djupare kontroll över HTTP-begäranden.

Azure-klient- och hanteringsbibliotek

Versioner av Azure-klientbiblioteket är tillgängliga som:

• Hantering: Med hanteringsbibliotek kan du skapa och hantera Azure-resurser. Du kan känna igen dessa bibliotek med arm- i deras paketnamn. Termen ARM anger Azure Resource Manager.
  • Dokumentation och kodexempel
• Klient: Med tanke på att det redan finns en Azure-resurs använder du klientbiblioteken för att använda den och interagera med den.
  • Varje paket README.md innehåller dokumentation och exempel.

Installera Azure npm-paket

Azure-klientbibliotek är fritt tillgängliga från NPM. Installera enskilda SDK:er efter behov. Varje SDK innehåller TypeScript-definitioner.

För klient-/webbläsaranvändning måste Azure-klientbibliotek läggas till i paketeringsprocessen.

Använda Azure npm-paketexempelkod

Varje paket innehåller dokumentation för att snabbt komma igång med paketet. Se de specifika NPM-paket som du använder för att lära dig hur du använder dem.

Ange autentiseringsuppgifter

Azure-klientbiblioteken kräver autentiseringsuppgifter för att autentisera till Azure-plattformen. Autentiseringsklasser som tillhandahålls av @azure/identitet ger flera fördelar:

• Snabb registrering
• Säkraste metoden
• Separera autentiseringsmekanismen från koden. På så sätt kan du använda samma kod lokalt och på Azure-plattformen medan autentiseringsuppgifterna skiljer sig åt.
• Tillhandahåll länkad autentisering så att flera mekanismer kan vara tillgängliga.

Skapa en SDK-klient och anropsmetoder

När du har skapat en autentiseringsuppgift programmatiskt skickar du autentiseringsuppgifterna till Din Azure-klient. Klienten kan kräva ytterligare information, till exempel ett prenumerations-ID eller en tjänstslutpunkt. Dessa värden är tillgängliga i Azure-portalen för din resurs.

I följande kodexempel används StandardAzureCredential och prenumerationsklientbiblioteket arm för att lista prenumerationer som den här autentiseringsuppgiften har åtkomst till att läsa.

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

let credentials = null;

const tenantId = process.env["AZURE_TENANT_ID"];
const clientId = process.env["AZURE_CLIENT_ID"];
const secret = process.env["AZURE_CLIENT_SECRET"];

if (process.env.NODE_ENV && process.env.NODE_ENV === "production") {
  // production
  credentials = new DefaultAzureCredential();
} else {
  // development
  if (tenantId && clientId && secret) {
    console.log("development");
    credentials = new ClientSecretCredential(tenantId, clientId, secret);
  } else {
    credentials = new DefaultAzureCredential();
  }
}

async function listSubscriptions() {
  try {
    // use credential to authenticate with Azure SDKs
    const client = new SubscriptionClient(credentials);

    // get details of each subscription
    for await (const item of client.subscriptions.list()) {
      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);
    }
  } catch (err) {
    console.error(JSON.stringify(err));
  }
}

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

Asynkron växling av resultat

En SDK-metod kan returnera en asynkron iterator, PagedAsyncIterableIterator, för att tillåta asynkrona resultat. Resultaten kan använda växlings- och fortsättningstoken för att dela upp resultatuppsättningar.

Följande JavaScript-exempel visar asynkron växling. Koden anger en artificiellt kort växlingsstorlek på 2 för att snabbt och visuellt demonstrera processen när du kör exempelkoden i felsökningen.

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

Läs mer om växling och iteratorer i Azure:

• Async Iterators i Azure SDK för JavaScript/TypeScript

Långvariga åtgärder

En SDK-metod kan returnera ett LRO-svar (long running operation). Det här svaret innehåller information som:

• Din begäran har slutförts
• Din begäran pågår fortfarande

Följande JavaScript-exempel visar hur du väntar på att en LRO ska slutföras, med .pollUntildone(), innan du fortsätter.

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

Läs mer om tidskrävande åtgärder i Azure:

• @azure/core-lro

Avbryta asynkrona åtgärder

Paketet @azure/abort-controller tillhandahåller klasser för AbortController och AbortSignal. Använd AbortController för att skapa en AbortSignal, som sedan kan skickas till Azure SDK-åtgärder för att avbryta väntande arbete. Azure SDK-åtgärder kan vara:

• Avbröts baserat på din egen logik
• Avbröts baserat på en tidsgräns
• Avbröts baserat på en överordnad uppgifts signal
• Avbröts baserat på en överordnad aktivitets signal eller en tidsgräns

Läs mer:

• Så här använder du avbrutna signaler för att avbryta åtgärder i Azure SDK för JavaScript/TypeScript

Utförlig loggning från SDK

När du använder en Azure SDK kan det finnas tillfällen då du behöver felsöka ditt program.

• Om du vill aktivera loggning vid byggtiden anger du miljövariabeln AZURE_LOG_LEVEL till info.

• Om du vill aktivera loggning vid körning använder du paketet @azure/logger :

  import { setLogLevel } from "@azure/logger";
  
  setLogLevel("info");
  

Kombinationserbjudanden

Lär dig mer om paketering med Azure SDK:

• Så här paketar du Azure SDK:er
• Paketeringsexempel

Nästa steg

• Lista prenumerationer med SDK för @azure/arm-prenumerationer
• Visa en lista över de senaste resursåtgärderna med @azure/arm-monitor SDK