Rozpoczynanie pracy z wdrażaniem usługi Azure CDN

Artykuł
03/22/2024

Node.js
.NET

Zestaw SDK usługi Azure CDN dla języka JavaScript umożliwia zautomatyzowanie tworzenia profilów i punktów końcowych usługi CDN oraz zarządzania nimi. W tym samouczku przedstawiono proces tworzenia prostej aplikacji konsolowej Node.js, która demonstruje kilka dostępnych operacji. Ten samouczek nie jest przeznaczony do opisania wszystkich aspektów zestawu AZURE CDN SDK dla języka JavaScript.

Aby ukończyć ten samouczek, musisz mieć już zainstalowany i skonfigurowany Node.js wersji 6.x.x lub nowszej. Możesz użyć dowolnego edytora tekstów, który chcesz utworzyć aplikację Node.js. Do pisania tego samouczka użyto programu Visual Studio Code.

Wymagania wstępne

Przed napisaniem kodu zarządzania usługą CDN należy wykonać pewne przygotowania, aby umożliwić kodzie interakcję z usługą Azure Resource Manager. Aby wykonać to przygotowanie, należy wykonać następujące czynności:

Tworzenie grupy zasobów zawierającej profil usługi CDN utworzony w tym samouczku
Konfigurowanie identyfikatora Entra firmy Microsoft w celu zapewnienia uwierzytelniania dla aplikacji
Zastosuj uprawnienia do grupy zasobów, aby tylko autoryzowani użytkownicy z dzierżawy firmy Microsoft Entra mogli wchodzić w interakcje z profilem usługi CDN

Tworzenie grupy zasobów

Zaloguj się do Portalu Azure.
Kliknij pozycję Utwórz zasób.
Wyszukaj pozycję Grupa zasobów i w okienku Grupa zasobów kliknij pozycję Utwórz.
Nadaj grupie zasobów nazwę CdnConsoleTutorial. Wybierz swoją subskrypcję i wybierz lokalizację w pobliżu. Jeśli chcesz, możesz kliknąć pole wyboru Przypnij do pulpitu nawigacyjnego, aby przypiąć grupę zasobów do pulpitu nawigacyjnego w portalu. Przypinanie ułatwia późniejsze znajdowanie. Po wybraniu opcji kliknij przycisk Utwórz.
Jeśli grupa zasobów nie została przypięta do pulpitu nawigacyjnego, możesz ją znaleźć, klikając pozycję Przeglądaj, a następnie pozycję Grupy zasobów. Aby go otworzyć, kliknij grupę zasobów. Zanotuj identyfikator subskrypcji. Potrzebujemy go później.

Tworzenie aplikacji Microsoft Entra i stosowanie uprawnień

Istnieją dwa podejścia do uwierzytelniania aplikacji za pomocą identyfikatora Entra firmy Microsoft: pojedynczych użytkowników lub jednostki usługi. Jednostka usługi jest podobna do konta usługi w systemie Windows. Zamiast udzielać określonych uprawnień użytkownika do interakcji z profilami CDN, uprawnienia są przyznawane jednostce usługi. Jednostki usługi są zwykle używane do zautomatyzowanych, nieinterakcyjnych procesów. Mimo że ten samouczek pisze interaktywną aplikację konsolową, skoncentrujemy się na podejściu jednostki usługi.

Tworzenie jednostki usługi składa się z kilku kroków, w tym tworzenia aplikacji firmy Microsoft Entra. Aby go utworzyć , użyjemy tego samouczka.

Ważne

Pamiętaj, aby wykonać wszystkie kroki opisane w połączonym samouczku. Ważne jest, aby ukończyć je dokładnie zgodnie z opisem. Pamiętaj, aby zanotować identyfikator dzierżawy, nazwę domeny dzierżawy (często domenę .onmicrosoft.com , chyba że określono domenę niestandardową), identyfikator klienta i klucz uwierzytelniania klienta, ponieważ te informacje będą potrzebne później. Należy zachować ostrożność, aby chronić identyfikator klienta i klucz uwierzytelniania klienta, ponieważ te poświadczenia mogą być używane przez wszystkich użytkowników do wykonywania operacji jako jednostki usługi.

Po wyświetleniu kroku o nazwie Configure multi-tenant application (Konfigurowanie aplikacji wielodostępnej) wybierz pozycję Nie.

Po przejściu do kroku Przypisz aplikację do roli użyj utworzonej wcześniej grupy zasobów CdnConsoleTutorial, ale zamiast roli Czytelnik przypisz rolę Współautor profilu usługi CDN. Po przypisaniu aplikacji roli Współautor profilu usługi CDN w grupie zasobów wróć do tego samouczka.

Po utworzeniu jednostki usługi i przypisaniu roli Współautor profilu usługi CDN blok Użytkownicy dla grupy zasobów powinien wyglądać podobnie jak na poniższej ilustracji.

Blok Użytkownicy

Interakcyjne uwierzytelnianie użytkowników

Jeśli zamiast jednostki usługi wolisz mieć interakcyjne uwierzytelnianie poszczególnych użytkowników, proces jest podobny do tego dla jednostki usługi. W rzeczywistości należy wykonać tę samą procedurę, ale wprowadzić kilka drobnych zmian.

Ważne

Wykonaj te następne kroki tylko wtedy, gdy zdecydujesz się używać uwierzytelniania poszczególnych użytkowników zamiast jednostki usługi.

Podczas tworzenia aplikacji zamiast aplikacji internetowej wybierz pozycję Aplikacja natywna.
Na następnej stronie zostanie wyświetlony monit o identyfikator URI przekierowania. Identyfikator URI nie zostanie zweryfikowany, ale pamiętaj, co wprowadzono. Potrzebujesz go później.
Nie ma potrzeby tworzenia klucza uwierzytelniania klienta.
Zamiast przypisywać jednostkę usługi do roli Współautor profilu cdN, przypiszemy poszczególnych użytkowników lub grup. W tym przykładzie widać, że przypisano użytkownika demonstracyjnego usługi CDN do roli Współautor profilu usługi CDN.

Tworzenie projektu i dodawanie zależności npm

Teraz, gdy utworzyliśmy grupę zasobów dla naszych profilów usługi CDN i nadaliśmy aplikacji Microsoft Entra uprawnienia do zarządzania profilami i punktami końcowymi usługi CDN w tej grupie, możemy rozpocząć tworzenie aplikacji.

Utwórz folder do przechowywania aplikacji. W konsoli z narzędziami Node.js w bieżącej ścieżce ustaw bieżącą lokalizację na ten nowy folder i zainicjuj projekt, wykonując następujące polecenie:

npm init

Następnie zostanie wyświetlona seria pytań do zainicjowania projektu. W przypadku punktu wejścia w tym samouczku jest używany app.js. Inne opcje można zobaczyć w poniższym przykładzie.

Zrzut ekranu przedstawiający dane wyjściowe inicjowania npm.

Nasz projekt jest teraz inicjowany przy użyciu pliku packages.json . Nasz projekt będzie używać niektórych bibliotek platformy Azure zawartych w pakietach npm. Użyjemy biblioteki do uwierzytelniania entra firmy Microsoft w Node.js (@Azure/identity) i biblioteki klienta usługi Azure CDN dla języka JavaScript (@Azure/Azure Resource Manager-cdn). Dodajmy te do projektu jako zależności.

npm install --save @azure/identity
npm install --save @azure/arm-cdn

Po zakończeniu instalowania pakietów plik package.json powinien wyglądać podobnie do tego przykładu (numery wersji mogą się różnić):

{
  "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": "^7.0.1",
    "@azure/identity": "^2.0.4"
  }
}

Na koniec za pomocą edytora tekstów utwórz pusty plik tekstowy i zapisz go w katalogu głównym folderu projektu jako app.js. Teraz możemy rozpocząć pisanie kodu.

Wymaga, stałe, uwierzytelnianie i struktura

Po otwarciu app.js w naszym edytorze uzyskamy podstawową strukturę naszego programu napisanego.

Dodaj "wymaga" dla naszych pakietów npm u góry z następującymi elementami:

const { DefaultAzureCredential } = require("@azure/identity");
const { CdnManagementClient } = require('@azure/arm-cdn');

Musimy zdefiniować pewne stałe, których będą używać nasze metody. Dodaj następujące polecenie. Pamiętaj, aby zastąpić symbole zastępcze, w tym <nawiasy kątowe, własnymi wartościami> zgodnie z potrzebami.

//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>";

Następnie utworzymy wystąpienie klienta zarządzania sieci CDN i przekażemy mu poświadczenia.

var credentials = new DefaultAzureCredential();
var cdnClient = new CdnManagementClient(credentials, subscriptionId);

Nasza aplikacja konsolowa Node.js podejmie pewne parametry wiersza polecenia. Sprawdźmy, czy przekazano co najmniej jeden parametr.

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

To prowadzi nas do głównej części naszego programu, gdzie odgałęziemy się do innych funkcji w oparciu o parametry, które zostały przekazane.

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

W kilku miejscach w naszym programie musimy upewnić się, że przekazano odpowiednią liczbę parametrów i wyświetlić pomoc, jeśli nie wyglądają prawidłowo. Utwórzmy w tym celu funkcje.

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

Na koniec funkcje, których będziemy używać na kliencie zarządzania sieci CDN, są asynchroniczne, więc potrzebują metody do wywołania z powrotem po zakończeniu. Utwórzmy taki, który może wyświetlać dane wyjściowe z klienta zarządzania sieci CDN (jeśli istnieje) i zamknąć program bezpiecznie.
```
function callback(err, result, request, response) {
    if (err) {
        console.log(err);
        process.exit(1);
    } else {
        console.log((result == null) ? "Done!" : result);
        process.exit(0);
    }
}
```

Teraz, gdy zostanie napisana podstawowa struktura naszego programu, powinniśmy utworzyć funkcje wywoływane na podstawie naszych parametrów.

Wyświetlanie listy profilów i punktów końcowych usługi CDN

Zacznijmy od kodu, aby wyświetlić listę istniejących profilów i punktów końcowych. Moje komentarze kodu zawierają oczekiwaną składnię, więc wiemy, gdzie idzie każdy parametr.

// 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(resourceGroupName, parms[2], callback);
            break;

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

Tworzenie profilów i punktów końcowych usługi CDN

Następnie napiszemy funkcje w celu utworzenia profilów i punktów końcowych.

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>
async function cdnCreateProfile() {
    requireParms(3);
    console.log("Creating profile...");
    var standardCreateParameters = {
        location: resourceLocation,
        sku: {
            name: 'Standard_Verizon'
        }
    };

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

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

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

Przeczyszczanie punktu końcowego

Zakładając, że punkt końcowy został utworzony, jednym z typowych zadań, które możemy wykonać w naszym programie, jest przeczyszczanie zawartości w naszym punkcie końcowym.

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

Usuwanie profilów i punktów końcowych usługi CDN

Ostatnia funkcja, która będzie obejmować usuwanie punktów końcowych i profilów.

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

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

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

Uruchamianie programu

Teraz możemy wykonać nasz Node.js program przy użyciu naszego ulubionego debugera lub w konsoli programu .

Napiwek

Jeśli używasz programu Visual Studio Code jako debugera, musisz skonfigurować środowisko, aby przekazać parametry wiersza polecenia. Program Visual Studio Code wykonuje to w pliku launch.json . Wyszukaj właściwość o nazwie args i dodaj tablicę wartości ciągów dla parametrów, aby wyglądała podobnie do następującej: "args": ["list", "profiles"].

Zacznijmy od wyświetlania listy naszych profilów.

Wyświetlanie listy profilów

Wróciliśmy do pustej tablicy. Ponieważ nie mamy żadnych profilów w naszej grupie zasobów, jest to oczekiwane. Utwórzmy teraz profil.

Teraz dodajmy punkt końcowy.

Tworzenie punktu końcowego

Na koniec usuńmy nasz profil.

Następne kroki

Aby zapoznać się z dokumentacją zestawu Azure CDN SDK dla języka JavaScript, wyświetl dokumentację.

Aby znaleźć dodatkową dokumentację dotyczącą zestawu Azure SDK dla języka JavaScript, zapoznaj się z pełną dokumentacją.

Zarządzanie zasobami usługi CDN za pomocą programu PowerShell.

Udostępnij za pośrednictwem