Erste Schritte mit der Azure CDN-EntwicklungGet started with Azure CDN development

Sie können das Azure CDN SDK für Node.js verwenden, um die Erstellung und Verwaltung von CDN-Profilen und -Endpunkten zu automatisieren.You can use the Azure CDN SDK for Node.js to automate creation and management of CDN profiles and endpoints. In diesem Tutorial wird die Erstellung einer einfachen Node.js-Konsolenanwendung beschrieben, mit der einige verfügbare Vorgänge demonstriert werden.This tutorial walks through the creation of a simple Node.js console application that demonstrates several of the available operations. Dieses Tutorial dient nicht dazu, alle Aspekte des Azure CDN SDK für „Node.js“ ausführlich zu beschreiben.This tutorial is not intended to describe all aspects of the Azure CDN SDK for Node.js in detail.

Zum Durcharbeiten dieses Tutorials sollten Sie bereits Node.js 4.x.x oder höher installiert und konfiguriert haben.To complete this tutorial, you should already have Node.js 4.x.x or higher installed and configured. Sie können einen beliebigen Text-Editor verwenden, um die Node.js-Anwendung zu erstellen.You can use any text editor you want to create your Node.js application. Zum Schreiben dieses Tutorials habe ich Visual Studio Codeverwendet.To write this tutorial, I used Visual Studio Code.

Tipp

Das vervollständigte Projekt aus diesem Tutorial steht auf MSDN zum Download bereit.The completed project from this tutorial is available for download on MSDN.

VoraussetzungenPrerequisites

Bevor Sie CDN-Verwaltungscode schreiben können, müssen Sie einige Vorbereitungsschritte ausführen, damit der Code mit Azure Resource Manager interagieren kann.Before writing CDN management code, you must do some preparation to enable the code to interact with the Azure Resource Manager. Dies umfasst die folgenden Vorbereitungsmaßnahmen:To do this preparation, you need to:

  • Erstellen einer Ressourcengruppe für das CDN-Profil, das in diesem Tutorial erstellt wirdCreate a resource group to contain the CDN profile created in this tutorial
  • Konfigurieren von Azure Active Directory für die Authentifizierung der AnwendungConfigure Azure Active Directory to provide authentication for the application
  • Anwenden der Berechtigungen auf die Ressourcengruppe, sodass nur autorisierte Benutzer aus Ihrem Azure AD-Mandanten mit dem CDN-Profil interagieren könnenApply permissions to the resource group so that only authorized users from your Azure AD tenant can interact with the CDN profile

Erstellen der RessourcengruppeCreating the resource group

  1. Melden Sie sich beim Azure-Portalan.Sign in to the Azure Portal.

  2. Klicken Sie auf Ressource erstellen.Click Create a resource.

  3. Suchen Sie nach Ressourcengruppe, und klicken Sie im Bereich „Ressourcengruppe“ auf Erstellen.Search for Resource group and in the Resource group pane, click Create.

    Erstellen einer neuen Ressourcengruppe

  4. Benennen Sie die Ressourcengruppe CdnConsoleTutorial.Name your resource group CdnConsoleTutorial. Wählen Sie Ihr Abonnement aus, und wählen Sie einen Standort in Ihrer Nähe.Select your subscription and choose a location near you. Wenn Sie möchten, können Sie das Kontrollkästchen An Dashboard anheften aktivieren, um die Ressourcengruppe an das Dashboard im Portal anzuheften.If you wish, you can click the Pin to dashboard checkbox to pin the resource group to the dashboard in the portal. Durch das Anheften lässt sie sich später einfacher wiederfinden.Pinning makes it easier to find later. Nachdem Sie Ihre Auswahl getroffen haben, klicken Sie auf Erstellen.After you've made your selections, click Create.

    Benennen der Ressourcengruppe

  5. Wenn Sie die Ressourcengruppe nicht an Ihr Dashboard angeheftet haben, können Sie nach der Erstellung danach suchen, indem Sie auf Durchsuchen > Ressourcengruppen klicken.After the resource group is created, if you didn't pin it to your dashboard, you can find it by clicking Browse, then Resource Groups. Klicken Sie auf die Ressourcengruppe, um sie zu öffnen.To open it, click the resource group. Notieren Sie sich Ihre Abonnement-ID.Make a note of your Subscription ID. Sie benötigen sie später.We need it later.

    Benennen der Ressourcengruppe

Erstellen der Azure AD-Anwendung und Anwenden von BerechtigungenCreating the Azure AD application and applying permissions

Es gibt zwei Methoden der App-Authentifizierung mit Azure Active Directory: Als einzelner Benutzer oder Dienstprinzipal.There are two approaches to app authentication with Azure Active Directory: Individual users or a service principal. Ein Dienstprinzipal ähnelt einem Dienstkonto in Windows.A service principal is similar to a service account in Windows. Anstatt einem bestimmten Benutzer Berechtigungen für die Interaktion mit den CDN-Profilen zu gewähren, erteilen Sie die Berechtigungen dem Dienstprinzipal.Instead of granting a particular user permissions to interact with the CDN profiles, permissions are instead granted to the service principal. Dienstprinzipale werden im Allgemeinen für automatisierte, nicht interaktive Prozesse verwendet.Service principals are typically used for automated, non-interactive processes. Auch wenn in diesem Tutorial eine interaktive Konsolen-App erstellt wird, verwenden wir hier einen Dienstprinzipal.Even though this tutorial is writing an interactive console app, we'll focus on the service principal approach.

Die Erstellung eines Dienstprinzipals umfasst mehrere Schritte, einschließlich der Erstellung einer Azure Active Directory-Anwendung.Creating a service principal consists of several steps, including creating an Azure Active Directory application. Absolvieren Sie dieses Tutorial, um die Erstellung durchzuführen.To create it, we're going to follow this tutorial.

Wichtig

Stellen Sie sicher, dass Sie alle Schritte in diesem Tutorialausführen.Be sure to follow all the steps in the linked tutorial. Es ist von großer Bedeutung, dass Sie die Schritte genau wie beschrieben ausführen.It is important that you complete it exactly as described. Notieren Sie sich die folgenden Angaben, da Sie diese später benötigen werden: Mandanten-ID, Domänenname des Mandanten (üblicherweise eine .onmicrosoft.com-Domäne, sofern Sie keine benutzerdefinierte Domäne angegeben haben), Client-ID und Clientauthentifizierungsschlüssel.Make sure to note your tenant ID, tenant domain name (commonly a .onmicrosoft.com domain unless you've specified a custom domain), client ID, and client authentication key, as we need this information later. Schützen Sie die Client-ID und den Clientauthentifizierungsschlüssel sorgfältig, da diese Anmeldeinformationen verwendet werden können, um Vorgänge als Dienstprinzipal auszuführen.Be careful to guard your client ID and client authentication key, as these credentials can be used by anyone to execute operations as the service principal.

Wenn Sie zum Schritt „Mehrinstanzenfähige Anwendung konfigurieren“ gelangen, wählen Sie Nein aus.When you get to the step named Configure multi-tenant application, select No.

Im Schritt Zuweisen einer Anwendung zur Rolle verwenden Sie die zuvor erstellte Ressourcengruppe CdnConsoleTutorial, weisen Sie ihr aber nicht die Rolle Leser, sondern die Rolle Mitwirkender für das CDN-Profil zu.When you get to the step Assign the application to a role, use the resource group created earlier, CdnConsoleTutorial, but instead of the Reader role, assign the CDN Profile Contributor role. Nachdem Sie die Anwendung in Ihrer Ressourcengruppe der Rolle Mitwirkender von CDN-Profil zugewiesen haben, kehren Sie zu diesem Tutorial zurück.After you assign the application the CDN Profile Contributor role on your resource group, return to this tutorial.

Nachdem Sie den Dienstprinzipal erstellt und die Rolle Mitwirkender von CDN-Profil zugewiesen haben, sollte das Blatt Benutzer für Ihre Ressourcengruppe in etwa wie in der folgenden Abbildung aussehen.Once you've created your service principal and assigned the CDN Profile Contributor role, the Users blade for your resource group should look similar to the following image.

Blatt „Benutzer“

Interaktive BenutzerauthentifizierungInteractive user authentication

Wenn Sie statt eines Dienstprinzipals lieber eine interaktive individuelle Benutzerauthentifizierung einrichten möchten, ähnelt der Prozess dem der Erstellung eines Dienstprinzipals.If, instead of a service principal, you'd rather have interactive individual user authentication, the process is similar to that for a service principal. Sie wenden im Grunde das gleiche Verfahren an, nehmen aber einige kleinere Änderungen vor.In fact, you need to follow the same procedure, but make a few minor changes.

Wichtig

Führen Sie die nächsten Schritte nur aus, wenn Sie die individuelle Benutzerauthentifizierung anstelle eines Dienstprinzipals verwenden möchten.Only follow these next steps if you are choosing to use individual user authentication instead of a service principal.

  1. Wählen Sie beim Erstellen der Anwendung anstelle von Webanwendung die Option Native Anwendung aus.When creating your application, instead of Web Application, choose Native application.

    Native Anwendung

  2. Auf der nächsten Seite werden Sie zur Eingabe eines Umleitungs-URI aufgefordert.On the next page, you are prompted for a redirect URI. Der URI wird nicht überprüft, merken Sie sich jedoch, was Sie eingegeben haben.The URI won't be validated, but remember what you entered. Sie benötigen ihn später.You need it later.

  3. Sie müssen keinen Clientauthentifizierungsschlüsselerstellen.There is no need to create a client authentication key.

  4. Anstatt der Rolle Mitwirkender von CDN-Profil einen Dienstprinzipal zuzuweisen, weisen Sie einzelne Benutzer oder Gruppen zu.Instead of assigning a service principal to the CDN Profile Contributor role, we're going to assign individual users or groups. In diesem Beispiel sehen Sie, dass ich den Benutzer CDN-Demobenutzer der Rolle Mitwirkender von CDN-Profil zugewiesen habe.In this example, you can see that I've assigned CDN Demo User to the CDN Profile Contributor role.

    Individueller Benutzerzugriff

Erstellen des Projekts und Hinzufügen von NPM-AbhängigkeitenCreate your project and add NPM dependencies

Nachdem Sie nun eine Ressourcengruppe für Ihre CDN-Profile erstellt und der Azure AD-Anwendung die Berechtigung zum Verwalten von CDN-Profilen und -Endpunkten innerhalb dieser Gruppe erteilt haben, können Sie damit beginnen, Ihre Anwendung zu erstellen.Now that we've created a resource group for our CDN profiles and given our Azure AD application permission to manage CDN profiles and endpoints within that group, we can start creating our application.

Erstellen Sie einen Ordner zum Speichern der Anwendung.Create a folder to store your application. Legen Sie in einer Konsole mit den Node.js-Tools im aktuellen Pfad den aktuellen Speicherort auf diesen neuen Ordner fest, und initialisieren Sie Ihr Projekt, indem Sie Folgendes ausführen:From a console with the Node.js tools in your current path, set your current location to this new folder and initialize your project by executing:

npm init

Ihnen werden dann verschiedene Fragen zur Initialisierung des Projekts gestellt.You will then be presented a series of questions to initialize your project. Als Einstiegspunktwird in diesem Tutorial app.jsverwendet.For entry point, this tutorial uses app.js. Meine anderen gewählten Optionen sehen Sie im folgenden Beispiel:You can see my other choices in the following example.

NPM-Initialisierungsausgabe

Unser Projekt wird jetzt mit der Datei packages.json initialisiert.Our project is now initialized with a packages.json file. Im Projekt werden einige Azure-Bibliotheken verwendet, die in NPM-Paketen enthalten sind.Our project is going to use some Azure libraries contained in NPM packages. Wir verwenden die Azure-Clientlaufzeit für Node.js (ms-rest-azure) und die Azure CDN-Clientbibliothek für Node.js (azure-arm-cd).We'll use the Azure Client Runtime for Node.js (ms-rest-azure) and the Azure CDN Client Library for Node.js (azure-arm-cd). Diese Komponenten fügen wir dem Projekt nun als Abhängigkeiten hinzu.Let's add those to the project as dependencies.

npm install --save ms-rest-azure
npm install --save azure-arm-cdn

Nachdem die Installation der Pakete abgeschlossen ist, sollte die Datei package.json in etwa wie folgendes Beispiel aussehen (Versionsnummern können abweichen):After the packages are done installing, the package.json file should look similar to this example (version numbers may differ):

{
  "name": "cdn_node",
  "version": "1.0.0",
  "description": "Azure CDN Node.js tutorial project",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Cam Soper",
  "license": "MIT",
  "dependencies": {
    "azure-arm-cdn": "^0.2.1",
    "ms-rest-azure": "^1.14.4"
  }
}

Erstellen Sie abschließend mit dem Text-Editor eine leere Textdatei, und speichern Sie sie im Stamm Ihres Projektordners als app.js.Finally, using your text editor, create a blank text file and save it in the root of our project folder as app.js. Wir können nun mit dem Schreiben von Code beginnen.We're now ready to begin writing code.

„Requires“, Konstanten, Authentifizierung und StrukturRequires, constants, authentication, and structure

Bei geöffneter Datei app.js im Editor schreiben wir die Grundstruktur unseres Programms.With app.js open in our editor, let's get the basic structure of our program written.

  1. Fügen Sie die „Requires“-Elemente für unsere NPM-Pakete oben wie folgt hinzu:Add the "requires" for our NPM packages at the top with the following:

    var msRestAzure = require('ms-rest-azure');
    var cdnManagementClient = require('azure-arm-cdn');
    
  2. Sie müssen einige Konstanten definieren, die von den Methoden verwendet werden.We need to define some constants our methods will use. Fügen Sie Folgendes hinzu.Add the following. Ersetzen Sie die Platzhalter einschließlich der <spitzen Klammern> nach Bedarf durch Ihre eigenen Werte.Be sure to replace the placeholders, including the <angle brackets>, with your own values as needed.

    //Tenant app constants
    const clientId = "<YOUR CLIENT ID>";
    const clientSecret = "<YOUR CLIENT AUTHENTICATION KEY>"; //Only for service principals
    const tenantId = "<YOUR TENANT ID>";
    
    //Application constants
    const subscriptionId = "<YOUR SUBSCRIPTION ID>";
    const resourceGroupName = "CdnConsoleTutorial";
    const resourceLocation = "<YOUR PREFERRED AZURE LOCATION, SUCH AS Central US>";
    
  3. Als Nächstes instanziieren wir den CDN-Verwaltungsclient und stellen unsere Anmeldeinformationen bereit.Next, we'll instantiate the CDN management client and give it our credentials.

    var credentials = new msRestAzure.ApplicationTokenCredentials(clientId, tenantId, clientSecret);
    var cdnClient = new cdnManagementClient(credentials, subscriptionId);
    

    Wenn Sie die individuelle Benutzerauthentifizierung verwenden, sehen diese beiden Zeilen etwas anders aus.If you are using individual user authentication, these two lines will look slightly different.

    Wichtig

    Verwenden Sie dieses Codebeispiel nur, wenn Sie die individuelle Benutzerauthentifizierung anstelle eines Dienstprinzipals verwenden möchten.Only use this code sample if you are choosing to have individual user authentication instead of a service principal. Schützen Sie Ihre individuellen Anmeldeinformationen, und halten Sie sie geheim.Be careful to guard your individual user credentials and keep them secret.

    var credentials = new msRestAzure.UserTokenCredentials(clientId, 
        tenantId, '<username>', '<password>', '<redirect URI>');
    var cdnClient = new cdnManagementClient(credentials, subscriptionId);
    

    Stellen Sie sicher, dass Sie die Elemente in <spitzen Klammern> durch die richtigen Informationen ersetzen.Be sure to replace the items in <angle brackets> with the correct information. Verwenden Sie für <redirect URI>den Umleitungs-URI, den Sie bei der Registrierung der Anwendung in Azure AD eingegeben haben.For <redirect URI>, use the redirect URI you entered when you registered the application in Azure AD.

  4. Für unsere Node.js-Konsolenanwendung benötigen wir einige Befehlszeilenparameter.Our Node.js console application is going to take some command-line parameters. Wir vergewissern uns, dass mindestens ein Parameter übergeben wurde.Let's validate that at least one parameter was passed.

    //Collect command-line parameters
    var parms = process.argv.slice(2);
    
    //Do we have parameters?
    if(parms == null || parms.length == 0)
    {
        console.log("Not enough parameters!");
        console.log("Valid commands are list, delete, create, and purge.");
        process.exit(1);
    }
    
  5. Hiermit gelangen wir zum Hauptteil unseres Programms, in dem wir basierend auf den übergebenen Parametern zu anderen Funktionen verzweigen.That brings us to the main part of our program, where we branch off to other functions based on what parameters were passed.

    switch(parms[0].toLowerCase())
    {
        case "list":
            cdnList();
            break;
    
        case "create":
            cdnCreate();
            break;
    
        case "delete":
            cdnDelete();
            break;
    
        case "purge":
            cdnPurge();
            break;
    
        default:
            console.log("Valid commands are list, delete, create, and purge.");
            process.exit(1);
    }
    
  6. Wir müssen an mehreren Stellen im Programm sicherstellen, dass die richtige Anzahl von Parametern übergeben wurde, und Hilfe anzeigen, wenn sie nicht richtig erscheinen.At several places in our program, we'll need to make sure the right number of parameters were passed in and display some help if they don't look correct. Hierfür erstellen wir Funktionen.Let's create functions to do that.

    function requireParms(parmCount) {
        if(parms.length < parmCount) {
            usageHelp(parms[0].toLowerCase());
            process.exit(1);
        }
    }
    
    function usageHelp(cmd) {
        console.log("Usage for " + cmd + ":");
        switch(cmd)
        {
            case "list":
                console.log("list profiles");
                console.log("list endpoints <profile name>");
                break;
    
            case "create":
                console.log("create profile <profile name>");
                console.log("create endpoint <profile name> <endpoint name> <origin hostname>");
                break;
    
            case "delete":
                console.log("delete profile <profile name>");
                console.log("delete endpoint <profile name> <endpoint name>");
                break;
    
            case "purge":
                console.log("purge <profile name> <endpoint name> <path>");
                break;
    
            default:
                console.log("Invalid command.");
        }
    }
    
  7. Außerdem sind die Funktionen, die wir auf dem CDN-Verwaltungsclient verwenden, asynchron. Sie müssen also über eine Methode zum Durchführen eines Rückrufs nach Abschluss des Vorgangs verfügen.Finally, the functions we'll be using on the CDN management client are asynchronous, so they need a method to call back when they're done. Wir erstellen eine Methode, mit der die Ausgabe des CDN-Verwaltungsprogramms (falls vorhanden) angezeigt und das Programm richtig beendet werden kann.Let's make one that can display the output from the CDN management client (if any) and exit the program gracefully.

    function callback(err, result, request, response) {
        if (err) {
            console.log(err);
            process.exit(1);
        } else {
            console.log((result == null) ? "Done!" : result);
            process.exit(0);
        }
    }
    

Nachdem wir die Grundstruktur für unser Programm nun geschrieben haben, sollten wir die Funktionen erstellen, die basierend auf unseren Parametern aufgerufen werden.Now that the basic structure of our program is written, we should create the functions called based on our parameters.

Auflisten von CDN-Profilen und -EndpunktenList CDN profiles and endpoints

Wir beginnen mit Code zum Auflisten der vorhandenen Profile und Endpunkte.Let's start with code to list our existing profiles and endpoints. Meine Codekommentare enthalten die erwartete Syntax, damit wir wissen, welcher Parameter an welche Stelle gehört.My code comments provide the expected syntax so we know where each parameter goes.

// list profiles
// list endpoints <profile name>
function cdnList(){
    requireParms(2);
    switch(parms[1].toLowerCase())
    {
        case "profiles":
            console.log("Listing profiles...");
            cdnClient.profiles.listByResourceGroup(resourceGroupName, callback);
            break;

        case "endpoints":
            requireParms(3);
            console.log("Listing endpoints...");
            cdnClient.endpoints.listByProfile(parms[2], resourceGroupName, callback);
            break;

        default:
            console.log("Invalid parameter.");
            process.exit(1);
    }
}

Erstellen von CDN-Profilen und -EndpunktenCreate CDN profiles and endpoints

Als Nächstes schreiben wir die Funktionen zum Erstellen von Profilen und Endpunkten.Next, we'll write the functions to create profiles and endpoints.

function cdnCreate() {
    requireParms(2);
    switch(parms[1].toLowerCase())
    {
        case "profile":
            cdnCreateProfile();
            break;

        case "endpoint":
            cdnCreateEndpoint();
            break;

        default:
            console.log("Invalid parameter.");
            process.exit(1);
    }
}

// create profile <profile name>
function cdnCreateProfile() {
    requireParms(3);
    console.log("Creating profile...");
    var standardCreateParameters = {
        location: resourceLocation,
        sku: {
            name: 'Standard_Verizon'
        }
    };

    cdnClient.profiles.create(parms[2], standardCreateParameters, resourceGroupName, callback);
}

// create endpoint <profile name> <endpoint name> <origin hostname>        
function cdnCreateEndpoint() {
    requireParms(5);
    console.log("Creating endpoint...");
    var endpointProperties = {
        location: resourceLocation,
        origins: [{
            name: parms[4],
            hostName: parms[4]
        }]
    };

    cdnClient.endpoints.create(parms[3], endpointProperties, parms[2], resourceGroupName, callback);
}

Bereinigen eines EndpunktsPurge an endpoint

Eine häufige Aufgabe, die Sie nach der Erstellung des Endpunkts auch in Ihr Programm aufnehmen sollten, ist das Löschen von Inhalten auf dem Endpunkt.Assuming the endpoint has been created, one common task that we might want to perform in our program is purging content in our endpoint.

// purge <profile name> <endpoint name> <path>
function cdnPurge() {
    requireParms(4);
    console.log("Purging endpoint...");
    var purgeContentPaths = [ parms[3] ];
    cdnClient.endpoints.purgeContent(parms[2], parms[1], resourceGroupName, purgeContentPaths, callback);
}

Löschen von CDN-Profilen und -EndpunktenDelete CDN profiles and endpoints

Mit der letzten Funktion, die wir einfügen, werden Endpunkte und Profile gelöscht.The last function we will include deletes endpoints and profiles.

function cdnDelete() {
    requireParms(2);
    switch(parms[1].toLowerCase())
    {
        // delete profile <profile name>
        case "profile":
            requireParms(3);
            console.log("Deleting profile...");
            cdnClient.profiles.deleteIfExists(parms[2], resourceGroupName, callback);
            break;

        // delete endpoint <profile name> <endpoint name>
        case "endpoint":
            requireParms(4);
            console.log("Deleting endpoint...");
            cdnClient.endpoints.deleteIfExists(parms[3], parms[2], resourceGroupName, callback);
            break;

        default:
            console.log("Invalid parameter.");
            process.exit(1);
    }
}

Ausführen des ProgrammsRunning the program

Wir können unser Node.js-Programm jetzt ausführen, indem wir unseren bevorzugten Debugger oder die Konsole verwenden.We can now execute our Node.js program using our favorite debugger or at the console.

Tipp

Wenn Sie Visual Studio Code als Debugger verwenden, müssen Sie Ihre Umgebung so einrichten, dass die Befehlszeilenparameter übergeben werden.If you're using Visual Studio Code as your debugger, you'll need to set up your environment to pass in the command-line parameters. Visual Studio Code verwendet hierfür die Datei launch.json.Visual Studio Code does this in the launch.json file. Suchen Sie nach einer Eigenschaft mit dem Namen args, und fügen Sie ein Array mit Zeichenfolgenwerten für Ihre Parameter hinzu, um in etwa Folgendes zu erhalten: "args": ["list", "profiles"].Look for a property named args and add an array of string values for your parameters, so that it looks similar to this: "args": ["list", "profiles"].

Als Erstes listen wir unsere Profile auf.Let's start by listing our profiles.

Profile auflisten

Wir erhalten ein leeres Array zurück.We got back an empty array. Dies war zu erwarten, da unsere Ressourcengruppe keine Profile enthält.Since we don't have any profiles in our resource group, that's expected. Als Nächstes erstellen wir ein Profil.Let's create a profile now.

Profil erstellen

Nun fügen wir einen Endpunkt hinzu.Now, let's add an endpoint.

Endpunkt erstellen

Abschließend löschen wir das Profil.Finally, let's delete our profile.

Profil löschen

Nächste SchritteNext Steps

Laden Sie das Beispiel herunter, um sich das abgeschlossene Projekt dieser exemplarischen Vorgehensweise anzusehen.To see the completed project from this walkthrough, download the sample.

Lesen Sie die Referenzzum Azure CDN SDK für Node.js durch.To see the reference for the Azure CDN SDK for Node.js, view the reference.

Weitere Teile der Dokumentation zum Azure SDK für Node.js finden Sie in der vollständigen Referenz.To find additional documentation on the Azure SDK for Node.js, view the full reference.

Verwalten Sie Ihre CDN-Ressourcen mit PowerShell.Manage your CDN resources with PowerShell.