Azure-ügyfélkódtárak használata JavaScripthez és TypeScripthez

Az Azure-szolgáltatások programozott eléréséhez használja a JavaScripthez készült Azure-ügyfélkódtárakat. Ezek a kódtárak általában az microsoft1esáltal közzétett @azure npm-csomag hatókörébe tartoznak.

Az ügyfélkódtárak és a REST API-k közötti különbségek

Az alábbi információk segítségével megtudhatja, hogy mikor érdemes használni a hozzáférés típusát.

• Az Azure-szolgáltatás elérésének előnyben részesített módszere az Azure-ügyfélkönyvtárak. Ezek a kódtárak elvonják a felhőalapú Azure-platform REST-kéréseinek, például a hitelesítéshez, az újrapróbálkozásokhoz és a naplózáshoz szükséges sablonkódot.
• Az Azure REST API-k az előnyben részesített módszer, ha a következők:
  • Olyan előzetes verziójú szolgáltatások használata, amelyekhez nem érhetők el Azure-ügyfélkódtárak. Tekintsük előzetes verziónak a kódot, amelyet frissíteni kell, ha a szolgáltatás általánosan elérhető az ügyfélkódtárakkal.
  • Közvetlenül szeretne REST-hívásokat kezdeményezni, mert nem szeretné, hogy a teljes SDK egyetlen REST API-t használjon, vagy mélyebben szeretné szabályozni a HTTP-kérelmeket.

Azure-ügyfél- és felügyeleti kódtárak

Az Azure ügyfélkönyvtár kiadások a következőképpen érhetők el:

• Menedzsment: A menedzsment könyvtárak lehetővé teszik az Azure erőforrások létrehozását és kezelését. Ezeket a könyvtárakat a csomagnevekben a arm- alapján ismerheti fel. A arm kifejezés az Azure Resource Managert jelöli.
  • dokumentáció és kódminták
• ügyfél: Mivel már létezik Azure-erőforrás, használja a klienskönyvtárakat, hogy kezelje és használja azt.
  • Minden csomag README.md tartalmazza a dokumentációt és a mintákat.

Azure npm-csomagok telepítése

Az Azure-ügyfélkódtárak szabadon elérhetők NPM- és Yarn-. Szükség szerint telepítse az egyes SDK-kat. Minden SDK TypeScript-definíciókat biztosít.

Az ügyfél- és böngészőhasználat érdekében az Azure ügyfélkönyvtárakat hozzá kell adni a csomagolási folyamathoz.

Azure npm-csomagmintakód használata

Minden csomag tartalmaz dokumentációt a csomag használatának gyors megkezdéséhez. A használatuk megismeréséhez tekintse meg az adott csomag dokumentációját.

Hitelesítő adatok megadása

Az Azure-ügyfélkódtárakhoz hitelesítő adatokra van szükség az Azure-platformvaló hitelesítéshez. Hitelesítőadat-osztályok, amelyeket @azure/identity biztosít, számos előnyt kínálnak.

• Gyors beléptetés
• Legbiztonságosabb módszer
• Válassza el a hitelesítési mechanizmust a kódtól. Ez lehetővé teszi, hogy ugyanazt a kódot helyileg és az Azure-platformon használja, miközben a hitelesítő adatok eltérőek.
• Biztosítson láncolt hitelesítést, hogy több mechanizmus is elérhető legyen.

SDK-ügyfél és hívási metódusok létrehozása

Miután programozott módon létrehozott egy hitelesítő adatot, adja át a hitelesítő adatokat az Azure-ügyfélnek. Az ügyfél további információkat igényelhet, például előfizetés-azonosítót vagy szolgáltatásvégpontot. Ezek az értékek az Azure Portalon érhetők el az erőforráshoz.

Az alábbi kódpélda a DefaultAzureCredential és a arm előfizetési ügyfélkönyvtár használatával sorolja fel azokat az előfizetéseket, amelyekhez a hitelesítő rendelkezik olvasási hozzáféréssel.

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

Eredmények aszinkron lapozása

Az SDK-metódusok visszaadhatnak egy aszinkron iterátort, PagedAsyncIterableIterator, hogy lehetővé tegyék az aszinkron eredményeket. Az eredmények lapozás és folytatási tokenek segítségével bonthatják fel az eredményhalmazokat.

Az alábbi JavaScript-példa az aszinkron lapozást mutatja be. A kód egy 2-es, mesterségesen rövid lapozási méretet állít be, hogy gyorsan és vizuálisan szemléltethesse a folyamatot, amikor hibakeresésben futtatja a mintakódot.

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

További információ az Azure lapozásáról és iterátorairól:

• Async iterátorok az Azure SDK-ban JavaScript/TypeScript-hez

Hosszú ideig futó műveletek

Az SDK-metódusok hosszú ideig futó műveletet (LRO) adhatnak vissza, nyers válasz. Ez a válasz többek között a következőket tartalmazza:

• A kérés befejeződött
• A kérés még folyamatban van

Az alábbi JavaScript-példa bemutatja, hogyan várhatja meg az LRO befejezését .pollUntildone(), mielőtt folytatná.

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

További információ a hosszú ideig futó műveletekről az Azure-ban:

• @azure/core-lro

Aszinkron műveletek megszakítása

A @azure/abort-controller csomag AbortController és AbortSignal osztályokat biztosít. Az AbortController használatával hozzon létre egy AbortSignalt, amelyet aztán átadhat az Azure SDK-műveleteknek a függőben lévő munka megszakításához. Az Azure SDK-műveletek a következőek lehetnek:

• Megszakítva a saját logikád alapján
• Megszakítva időtúllépési korlát alapján
• Egy szülőfeladat jelzése miatt megszakítva
• Megszakítva egy szülőfeladat jelzése (vagy), illetve időkorlát elérése miatt

Tudj meg többet:

• Hogyan használjuk a megszakításjeleket műveletek megszakítására a JavaScript/TypeScript Azure SDK-ban

Részletes naplózás az SDK-ból

Amikor az Azure SDK-t használja, előfordulhat, hogy hibakeresést kell végeznie az alkalmazáson.

• Ha engedélyezni szeretné a naplózást a buildelési időben, állítsa be az AZURE_LOG_LEVEL környezeti változót info.

• Ha futásidejűszeretné engedélyezni a naplózást, használja a @azure/logger csomagot:

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

Csomagolás

További információ az Azure SDK-val való összekapcsolásról:

• Az Azure SDK-k csomagolása
• Mintaösszeállítások

Következő lépések

• @azure/arm-előfizetéssel SDK-
• Legutóbbi erőforrás-műveletek listázása az @azure/arm-monitor SDK-vel