Verwalten von Azure-Ressourcengruppen mit der TypeScript-Funktions-API

  • Artikel

In diesem Lernprogramm erstellen Sie eine lokale TypeScript Azure Function-App mit APIs, um Azure-Ressourcengruppen zu verwalten und die App in Azure bereitzustellen.

Features und Funktionen:

  • Erstellen eines lokalen TypeScript Azure Function-App-Projekts in Visual Studio Code
  • Erstellen von Funktions-API-Codebausteinen in Visual Studio Code
  • Bereitstellen in Azure-Funktionen aus Visual Studio Code
  • Erstellen des Dienstprinzipals über die Azure-Befehlszeilenschnittstelle
  • Konfigurieren von lokalen und Remoteanwendungseinstellungen mit Visual Studio Code
  • Verwenden von DefaultAzureCredential in lokalen und Remoteumgebungen für kennwortlose Verbindungen
  • Verwenden von Azure Identity- und Azure Resource Management-SDKs zum Verwalten von Azure-Ressourcen
  • Verwenden Ihrer lokalen und cloudbasierten APIs zum Erstellen, Löschen und Auflisten von Ressourcengruppen in Ihrem Abonnement

Der Quellcode wird zwar mit TypeScript geschrieben, ist aber einfach. Wenn Sie mit modernem JavaScript mit async/await vertraut sind, ist ihnen der Code vertraut.

Erstellen oder Verwenden eines vorhandenen Azure-Abonnements

Sie benötigen ein Azure-Benutzerkonto mit einem aktiven Abonnement. Erstellen Sie ein kostenloses Konto.

Voraussetzungen

Anwendungsarchitektur

Die App stellt die folgenden API-Endpunkte bereit:

Methode URL Beschreibung
POST, DELETE http://localhost:7071/api/resourcegroup Hinzufügen oder Löschen einer Ressourcengruppe. Schließen Sie beim Hinzufügen Tags (Schlüssel-Wert-Paare) ein, um den Zweck der Gruppe später zu identifizieren.
GET http://localhost:7071/api/resourcegroups Auflisten aller Ressourcengruppen im Abonnement
GET http://localhost:7071/api/resources Auflisten aller Ressourcen in einem Abonnement oder einer Ressourcengruppe

Während diese Endpunkte öffentlich sind, sollten Sie Ihre API-Endpunkte mit Authentifizierung und Autorisierung sichern, bevor Sie sie in Ihrer Liveumgebung bereitstellen.

Diese App ist auf ein Abonnement beschränkt, da dies der Bereich ist, der beim Erstellen des Dienstprinzipals angegeben ist.

1. Vorbereiten Der Umgebung

Sie müssen Ihre lokalen und cloudbasierten Umgebungen für die Verwendung des Azure Identity SDK vorbereiten.

Anmelden bei der Azure-Befehlszeilenschnittstelle

Melden Sie sich in einem Bash-Terminal mit dem folgenden Befehl bei der Azure CLI an:

az login

Abrufen der Azure-Abonnement-ID

  1. Rufen Sie in einem Bash-Terminal Ihre Abonnements ab, und suchen Sie die Abonnement-ID, die Sie verwenden möchten. Die folgende Abfrage gibt die Abonnement-ID, den Abonnementnamen und die Mandanten-ID nach Abonnementname zurück.

    az account list --query "sort_by([].{Name:name, SubscriptionId:id, TenantId:tenantId}, &Name)" --output table

  2. Kopieren Sie die Abonnement-ID in die zuvor verwendete temporäre Datei. Sie benötigen diese Einstellung später.

Erstellen eines Azure-Dienstprinzipals

Ein Azure-Dienstprinzipal ermöglicht den Zugriff auf Azure, ohne dass dafür Ihre persönlichen Benutzeranmeldeinformationen verwendet werden müssen. In diesem Lernprogramm kann der Dienstprinzipal sowohl in Ihren lokalen als auch in Cloudumgebungen verwendet werden. In einer Unternehmensumgebung möchten Sie für jede Umgebung separate Dienstprinzipale verwenden.

  1. Legen Sie ein Format für den Dienstprinzipalnamen fest, damit Sie Ihren Dienstprinzipal später leicht finden können. Beispielformate:

    • Projekt und Besitzer: resource-management-john-smith
    • Abteilung und Datum: IT-2021-September
    • Eindeutiger Bezeichner: 1e8966d7-ba85-424b-9db4-c39e1ae9d0ca

  2. Erstellen Sie in einem Bash-Terminal Ihren Dienstprinzipal mit az ad sp create-for-rbac. Ersetzen Sie <SUBSCRIPTION-ID> durch Ihre Abonnement-ID.

    az ad sp create-for-rbac --name YOUR-SERVICE-PRINCIPAL-NAME --role Contributor --scopes /subscriptions/<SUBSCRIPTION-ID>

  3. Kopieren Sie die gesamten Ausgabeergebnisse in eine temporäre Datei. Sie benötigen diese Einstellungen später.

    {
  "appId": "YOUR-SERVICE-PRINCIPAL-ID",
  "displayName": "YOUR-SERVICE-PRINCIPAL-NAME",
  "name": "http://YOUR-SERVICE-PRINCIPAL-NAME",
  "password": "YOUR-SERVICE-PRINCIPAL-PASSWORD",
  "tenant": "YOUR-TENANT-ID"
}

2. Erstellen einer lokalen Azure-Funktions-App in Visual Studio Code

Erstellen Sie eine Azure Function-App in Visual Studio Code, um Azure-Ressourcengruppen zu verwalten.

Erstellen Ihrer ersten Funktion im Azure-Portal

Verwenden Sie Visual Studio Code zum Erstellen einer lokalen Funktions-App.

  1. Erstellen Sie in einem Bash-Terminal ein neues Verzeichnis, und wechseln Sie in dieses Verzeichnis:

    mkdir my-function-app && cd my-function-app

  2. Öffnen Sie Visual Studio Code in einem Bash-Terminal:

    code .

  3. Öffnen Sie die Visual Studio Code-Befehlspalette: STRG + UMSCHALT + P.

  4. Geben Sie Azure Functions: create new project ein. Gehen Sie bei den Aufforderungen gemäß der folgenden Tabelle vor:

    Prompt Wert
    Wählen Sie den Ordner aus, der Ihr Funktionsprojekt enthält. Wählen Sie das Standardverzeichnis (aktuell) aus.
    Sprache auswählen Wählen Sie TypeScript aus.
    Wählen Sie ein TypeScript-Programmiermodell aus. Modell V4 auswählen (Vorschau)
    Auswählen einer Vorlage für die erste Funktion Ihres Projekts Wählen Sie HTTP-Trigger aus.
    Create new HTTP trigger (Erstellen Sie einen neuen HTTP-Trigger.) Geben Sie den API-Namen resourcegroups ein.
    Autorisierungsstufe Wählen Sie Anonym aus. Wenn Sie mit diesem Projekt nach diesem Artikel fortfahren, ändern Sie die Autorisierungsstufe in die Funktion. Informieren Sie sich ausführlicher über Autorisierung auf Funktionsebene.

    Das Projektbaustein wird erstellt, und die Abhängigkeiten werden installiert.

Hinzufügen von Dienstprinzipaleinstellungen zur Datei „local.settings.json“

  1. Öffnen Sie die ./local.settings.json Datei im Projektstammverzeichnis, und fügen Sie den Abschnitt WERTE mit den fünf folgenden Umgebungsvariablen hinzu.

    {
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
    "AZURE_CLIENT_ID": "REPLACE-WITH-SERVICE-PRINCIPAL-APPID",
    "AZURE_CLIENT_SECRET": "REPLACE-WITH-SERVICE-PRINCIPAL-PASSWORD",
    "AZURE_SUBSCRIPTION_ID":"REPLACE-WITH-SUBSCRIPTION-ID",
    "AZURE_TENANT_ID":"REPLACE-WITH-SERVICE-PRINCIPAL-TENANT",
    "NODE_ENV":"development"
  }
}

  2. Verweisen Sie auf Ihre Einstellungen aus dem vorherigen Abschnitt, um die Werte hinzuzufügen. Diese Umgebungsvariablen sind für die Verwendung von „DefaultAzureCredential“ im Kontext ERFORDERLICH.

    • AZURE_TENANT_ID: tenant aus der obigen Dienstprinzipalausgabe
    • AZURE_CLIENT_ID: appId aus der obigen Dienstprinzipalausgabe
    • AZURE_CLIENT_SECRET: password aus der obigen Dienstprinzipalausgabe

  3. Außerdem müssen Sie die Abonnement-ID festlegen. Es ist erforderlich, das Azure SDK für die Ressourcenverwaltung zu verwenden.

    • AZURE_SUBSCRIPTION_ID: Ihr Standardabonnement, das Ihre Ressourcengruppen enthält

Die Datei local.settings.json wird von Ihrem lokalen Git-Repository absichtlich ignoriert, damit Sie sie nicht versehentlich in Ihrem Quellcode committen.

Installieren von npm-Abhängigkeiten für die Identitäts- und -Ressourcenverwaltung in Azure

Installieren Sie in einem integrierten Bash-Terminal in Visual Studio Code die Azure-SDK-Abhängigkeiten für die Identitäts- und -Ressourcenverwaltung in Azure.

npm install @azure/identity @azure/arm-resources

Auflisten aller Ressourcengruppen im Abonnement mit JavaScript

  1. Öffnen Sie die Datei ./src/functions/resourcegroups.ts, und ersetzen Sie den Inhalt durch Folgendes:

    import { ResourceGroup } from '@azure/arm-resources';
import {
  app,
  HttpRequest,
  HttpResponseInit,
  InvocationContext
} from '@azure/functions';
import {
  createResourceGroup,
  deleteResourceGroup
} from '../lib/azure-resource-groups';
import { processError } from '../lib/error';

export async function resourcegroup(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  try {
    console.log(JSON.stringify(request.query));
    console.log(JSON.stringify(request.params));

    const name: string = request.query.get('name');
    const location: string = request.query.get('location');
    console.log(`name: ${name}`);
    console.log(`location: ${location}`);

    switch (request.method) {
      case 'POST': // wait for create to complete before returning
        if (!name || !location) {
          return { body: 'Missing required parameters.', status: 400 };
        }

        if (request.headers.get('content-type') === 'application/json') {
          // create with tags

          const body: Record<string, unknown> =
            (await request.json()) as Record<string, string>;
          const tags: Record<string, string> = body?.tags
            ? (body?.tags as Record<string, string>)
            : null;
          const resourceGroup: ResourceGroup = await createResourceGroup(
            name,
            location,
            tags
          );
          return { jsonBody: resourceGroup, status: 200 };
        } else {
          // create without tags

          const resourceGroup: ResourceGroup = await createResourceGroup(
            name,
            location,
            null
          );
          return { jsonBody: resourceGroup, status: 200 };
        }

      case 'DELETE': // wait for delete to complete before returning
        if (!name) {
          return { body: 'Missing required parameters.', status: 400 };
        }
        await deleteResourceGroup(name);
        return { status: 204 };
    }
  } catch (err: unknown) {
    return processError(err);
  }
}

app.http('resourcegroup', {
  methods: ['DELETE', 'POST'],
  authLevel: 'anonymous',
  handler: resourcegroup
});

    Diese Datei antwortet auf API-Anforderungen und /api/resourcegroups gibt eine Liste aller Ressourcengruppen im Abonnement zurück.

  2. Erstellen Sie ein Unterverzeichnis in src benanntem lib Namen, und erstellen Sie eine neue Datei in diesem Verzeichnis mit dem Namen azure-resource-groups.ts.

  3. Kopieren Sie den folgenden Code in die Datei ./src/lib/azure-resource-groups.ts:

    // Include npm dependencies
import {
  ResourceGroup, ResourceManagementClient
} from '@azure/arm-resources';
import { DefaultAzureCredential } from '@azure/identity';
import { getSubscriptionId } from './environment-vars';

const subscriptionId = getSubscriptionId();

// Create Azure authentication credentials
const credentials = new DefaultAzureCredential();

// Create Azure SDK client for Resource Management such as resource groups
const resourceManagement = new ResourceManagementClient(
  credentials,
  subscriptionId
);

// all resources groups in subscription
export const listResourceGroups = async (): Promise<{
  list: ResourceGroup[];
  subscriptionId: string;
}> => {
  const list: ResourceGroup[] = [];
  for await (const resourceGroup of resourceManagement.resourceGroups.list()) {
    list.push(resourceGroup);
  }
  return {
    subscriptionId,
    list
  };
};
export const createResourceGroup = async (
  resourceGroupName: string,
  location: string,
  tags: { [propertyName: string]: string }
): Promise<ResourceGroup> => {
  const resourceGroupParameters = {
    location: location,
    tags
  };

  return await resourceManagement.resourceGroups.createOrUpdate(
    resourceGroupName,
    resourceGroupParameters
  );
};
export const deleteResourceGroup = async (
  resourceGroupName: string
): Promise<void> => {
  return await resourceManagement.resourceGroups.beginDeleteAndWait(
    resourceGroupName
  );
};

    Diese Datei führt folgende Schritte aus:

    • Abrufen der Abonnement-ID
    • Erstellen des DefaultAzureCredential-Kontexts
    • Erstellen des ResourceManagementClient-Elements, das für die Verwendung des Ressourcenverwaltungs-SDK erforderlich ist
    • Abrufen aller Ressourcengruppen im Abonnement

  4. Erstellen Sie eine neue Datei im ./src/lib Verzeichnis namens environment-vars.ts , und kopieren Sie den folgenden Code in diese Datei.

    export const checkAzureAuth = () => {
  // The following code is only used to check you have environment
  // variables configured. The DefaultAzureCredential reads your
  // environment - it doesn't read these variables.
  const tenantId = process.env['AZURE_TENANT_ID'];
  if (!tenantId)
    throw Error('AZURE_TENANT_ID is missing from environment variables.');
  const clientId = process.env['AZURE_CLIENT_ID'];
  if (!clientId)
    throw Error('AZURE_CLIENT_ID is missing from environment variables.');
  const secret = process.env['AZURE_CLIENT_SECRET'];
  if (!secret)
    throw Error('AZURE_CLIENT_SECRET is missing from environment variables.');
};

export const getSubscriptionId = (): string => {
  checkAzureAuth();

  // Get subscription from environment variables
  const subscriptionId = process.env['AZURE_SUBSCRIPTION_ID'];
  if (!subscriptionId)
    throw Error('Azure Subscription is missing from environment variables.');
  return subscriptionId;
};

    Diese Datei überprüft die Umgebungsvariablen, bevor die Abonnement-ID zurückgegeben wird.

  5. Erstellen Sie eine neue Datei im ./src/lib Verzeichnis namens error.ts , und kopieren Sie den folgenden Code in diese Datei.

    export function processError(err: unknown): any {
  if (typeof err === 'string') {
    return { body: err.toUpperCase(), status: 500 };
  } else if (
    err['stack'] &&
    process.env.NODE_ENV.toLowerCase() !== 'production'
  ) {
    return { jsonBody: { stack: err['stack'], message: err['message'] } };
  } else if (err instanceof Error) {
    return { body: err.message, status: 500 };
  } else {
    return { body: JSON.stringify(err) };
  }
}

    Diese Datei gibt einen 500-Fehler mit der Fehlermeldung zurück. Der Stapel wird zurückgegeben, wenn die NODE_ENV Variable nicht auf production.

Testen lokaler Funktionen

  1. Führen Sie im integrierten Visual Studio Code-Terminal das lokale Projekt aus:

    npm start

  2. Warten Sie, bis im integrierten Bash-Terminal die URL der ausgeführten Funktion angezeigt wird:

    Partial screenshot of Visual Studio Code's integrated bash terminal when the Azure Function is running locally and displaying the local URL for the APIs in the Function app.

  3. Öffnen Sie ein zweites integriertes Bash-Terminal in Visual Studio Code, STRG + UMSCHALT + 5, und verwenden Sie den folgenden GET cURL-Befehl, um die API zu verwenden:

    curl http://localhost:7071/api/resourcegroups

    Wenn Sie über viele Ressourcengruppen in Ihrem Abonnement verfügen, sollten Sie die Ausgabe zur einfacheren Überprüfung an eine Datei weiterleiten.

    curl http://localhost:7071/api/resourcegroups > resourcegroups.json

  4. Die Antwort enthält subscriptionId und eine list aller Ressourcengruppen in diesem Abonnement.

    {
  "subscriptionId": "ABC123",
  "list": [
        {
          "id": "/subscriptions/ABC123/resourceGroups/vmagelo-cloudshell",
          "name": "jsmith-cloudshell",
          "type": "Microsoft.Resources/resourceGroups",
          "properties": {
            "provisioningState": "Succeeded"
          },
          "location": "westeurope"
        },
        ... REMOVED FOR BREVITY ...
    ]
}

Problembehandlung

Wenn Sie diesen Artikel nicht abschließen können, sehen Sie sich die Probleme in der folgenden Tabelle an. Wenn Ihr Problem nicht in der Tabelle aufgeführt ist, öffnen Sie ein Issue auf dieser Dokumentationsseite.

Problem Behebung
Die App wurde nicht gestartet. Überprüfen Sie die Fehler. Vergewissern Sie sich, dass Sie die erforderlichen Abhängigkeiten installiert haben.
Die App wurde gestartet, aber Sie erhalten nicht den Antwortcode „200“. Stellen Sie sicher, dass Ihr cURL-Befehl die richtige lokale Route für die Anforderung verwendet.
Die API hat den Antwortcode „200“, aber keine Ergebnisse zurückgegeben. Verwenden Sie die Visual Studio Code-Erweiterung für Azure-Ressourcen, um zu überprüfen, ob Ihr Abonnement Ressourcengruppen enthält. Wenn keine Ressourcengruppen angezeigt werden, machen Sie sich keine Sorgen. In diesem Lernprogramm wird eine API zum Erstellen und Löschen von Ressourcengruppen in Ihrem Abonnement hinzugefügt. Diese API wird nach der ersten Bereitstellung des Quellcodes in Azure hinzugefügt, damit Sie lernen, wie Sie Ihren Code erneut bereitstellen.

3. Erstellen einer cloudbasierten Azure-Funktions-App

  1. Wählen Sie in Visual Studio Code das Azure-Symbol aus, um den Azure-Explorer zu öffnen.

  2. Wählen Sie das + Symbol aus, um eine neue Azure Function-App in der Azure-Cloud zu erstellen.

    Screenshot of Visual Studio Code's Azure Explorer with the Azure Function app icon highlighted.

  3. Wählen Sie " Funktions-App erstellen" in Azure aus.

  4. Geben Sie einen global eindeutigen Namen für die neue Funktions-App ein. Der Name muss für alle Azure-Funktionen eindeutig sein. Beispiel: jsmith-rg-management.

  5. Wählen Sie dieselbe Node.js 18+ LTS-Laufzeit aus, die Sie beim Erstellen der lokalen Funktions-App ausgewählt haben.

  6. Wählen Sie einen geografischen Standort in der Nähe von Ihnen aus, z . B. West US 3.

  7. Warten Sie, bis die Ressource erstellt wurde. Details finden Sie im Azure: Aktivitätsprotokoll .

    Screenshot of Visual Studio Code's Azure activity log showing the resource creation status.

4. Konfigurieren der cloudbasierten Azure-Funktions-App

Sie müssen die Azure-App-Einstellungen konfigurieren, um eine Verbindung mit der Azure-Funktions-App herzustellen. Lokal befinden sich diese Einstellungen in der Datei local.settings.json. Mit den folgenden Schritten werden Ihrer Cloud-App diese Werte hinzugefügt:

  1. Erweitern Sie in Visual Studio Code im Azure-Explorer im Abschnitt "Ressourcen" die Funktions-App, und wählen Sie dann Ihre Funktions-App aus.

  2. Klicken Sie mit der rechten Maustaste auf Anwendungseinstellungen, und wählen Sie Neue Einstellung hinzufügen aus.

  3. Fügen Sie die vier Werte aus local.settings.json mit exakt denselben Namen und Werten hinzu:

    • AZURE_TENANT_ID: tenant aus der obigen Dienstprinzipalausgabe
    • AZURE_CLIENT_ID: appId aus der obigen Dienstprinzipalausgabe
    • AZURE_CLIENT_SECRET: password aus der obigen Dienstprinzipalausgabe
    • AZURE_SUBSCRIPTION_ID: Ihr Standardabonnement, das Ihre Ressourcengruppen enthält
    • AzureWebJobsFeatureFlags:EnableWorkerIndexing

Partial screenshot of Visual Studio Code's Azure explorer showing the remote/cloud function's app settings.

5. Bereitstellen der Ressourcen-Manager-Funktions-App

Stellen Sie eine Azure Function-App in Visual Studio Code bereit, um Azure-Ressourcengruppen zu verwalten.

Verwenden der Visual Studio Code-Erweiterung zur Bereitstellung in der Hostingumgebung

  1. Öffnen Sie in VS Code die local.settings.json Datei, damit sie sichtbar ist. Dadurch werden die nächsten Schritte zum Kopieren dieser Namen und Werte vereinfacht.

  2. Wählen Sie das Azure-Logo aus, um den Azure-Explorer zu öffnen, und wählen Sie dann unter "Funktionen" das Cloudsymbol aus, um Ihre App bereitzustellen.

    Screenshot of Visual Studio Code's local Workspace area with the cloud deployment icon highlighted.

    Alternativ können Sie Ihre App bereitstellen, indem Sie die Befehlspalette mit STRG + UMSCHALT + P öffnen, deploy to function app eingeben und den Befehl Azure Functions: Deploy to Function App (Azure Functions: Für Funktions-App bereitstellen) ausführen.

  3. Wählen Sie "In Funktions-App bereitstellen" aus.

  4. Wählen Sie den Namen der Funktions-App aus, den Sie im vorherigen Abschnitt erstellt haben.

  5. Wenn Sie gefragt werden, ob Sie sicher sind, dass Sie bereitstellen möchten, wählen Sie "Bereitstellen" aus.

  6. Im Bereich Ausgabe von VS Code für Azure Functions wird der Fortschritt angezeigt. Bei der Bereitstellung wird die gesamte Functions-App bereitgestellt, sodass die Änderungen aller einzelnen Funktionen gleichzeitig bereitgestellt werden.

Überprüfen mit einem Browser, ob die Functions-App verfügbar ist

  1. Erweitern Sie in Visual Studio Code im Azure Functions-Explorer den Knoten für Ihr Azure-Abonnement, dann den Knoten für Ihre Funktions-App und anschließend Funktionen (schreibgeschützt). Klicken Sie mit der rechten Maustaste auf den Funktionsnamen, und wählen Sie Funktions-URL kopieren aus:

    Partial screenshot of Visual Studio Code's Azure explorer showing where to copy the Function's URL.

  2. Fügen Sie die URL in einen Browser ein, und drücken Sie die EINGABETASTE , um die Ressourcengruppenliste aus der Cloud-API anzufordern.

6. Hinzufügen von APIs zur Funktions-App und erneute Bereitstellung in Azure

Fügen Sie die folgenden APIs hinzu, und stellen Sie dann Ihre Azure Function-App in Visual Studio Code erneut zur Anwendung:

  • Hinzufügen und Löschen von Ressourcengruppen
  • Auflisten von Ressourcen in Ressourcengruppe oder Abonnement.

An diesem Punkt im Lernprogramm haben Sie eine lokale Funktions-App mit einer API erstellt, um die Ressourcengruppen Ihres Abonnements auflisten und diese App in Azure bereitgestellt haben. Als Azure-Entwickler können Sie Ressourcengruppen im Rahmen Ihrer Prozessautomatisierungspipeline erstellen oder löschen.

Erstellen der Ressourcengruppen-API für Ihre Funktions-App

Verwenden Sie die Visual Studio Code-Erweiterung für Azure Functions, um ihrer Funktions-App die TypeScript-Dateien hinzuzufügen, um Ressourcengruppen zu erstellen und zu löschen.

  1. Öffnen Sie die Visual Studio Code-Befehlspalette: STRG + UMSCHALT + P.

  2. Geben Sie Azure Functions: Create Function ein, und drücken Sie dann die EINGABETASTE, um den Prozess zu starten.

  3. Verwenden Sie die folgende Tabelle, um die API "/api/resourcegroup " zu erstellen:

    Prompt Wert
    „Select a template for your function“ (Wählen Sie eine Vorlage für Ihre Funktion aus.) HTTP-Trigger
    Angeben eines Funktionsnamens resourcegroup
    Autorisierungsstufe Wählen Sie Anonym aus. Wenn Sie mit diesem Projekt fortfahren, ändern Sie die Autorisierungsstufe in die Funktion. Informieren Sie sich ausführlicher über Autorisierung auf Funktionsebene.

  4. Öffnen Sie die ./src/functions/resourcegroup.ts gesamte Datei, und ersetzen Sie sie durch den folgenden Quellcode.

    import { ResourceGroup } from '@azure/arm-resources';
import {
  app,
  HttpRequest,
  HttpResponseInit,
  InvocationContext
} from '@azure/functions';
import {
  createResourceGroup,
  deleteResourceGroup
} from '../lib/azure-resource-groups';
import { processError } from '../lib/error';

export async function resourcegroup(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  try {
    console.log(JSON.stringify(request.query));
    console.log(JSON.stringify(request.params));

    const name: string = request.query.get('name');
    const location: string = request.query.get('location');
    console.log(`name: ${name}`);
    console.log(`location: ${location}`);

    switch (request.method) {
      case 'POST': // wait for create to complete before returning
        if (!name || !location) {
          return { body: 'Missing required parameters.', status: 400 };
        }

        if (request.headers.get('content-type') === 'application/json') {
          // create with tags

          const body: Record<string, unknown> =
            (await request.json()) as Record<string, string>;
          const tags: Record<string, string> = body?.tags
            ? (body?.tags as Record<string, string>)
            : null;
          const resourceGroup: ResourceGroup = await createResourceGroup(
            name,
            location,
            tags
          );
          return { jsonBody: resourceGroup, status: 200 };
        } else {
          // create without tags

          const resourceGroup: ResourceGroup = await createResourceGroup(
            name,
            location,
            null
          );
          return { jsonBody: resourceGroup, status: 200 };
        }

      case 'DELETE': // wait for delete to complete before returning
        if (!name) {
          return { body: 'Missing required parameters.', status: 400 };
        }
        await deleteResourceGroup(name);
        return { status: 204 };
    }
  } catch (err: unknown) {
    return processError(err);
  }
}

app.http('resourcegroup', {
  methods: ['DELETE', 'POST'],
  authLevel: 'anonymous',
  handler: resourcegroup
});

  5. Die ./src/lib/azure-resource-groups.ts Datei enthält bereits den Code zum Hinzufügen und Löschen von Ressourcengruppen.

Erstellen der Ressourcen-API für Ihre Funktions-App

Verwenden Sie die Visual Studio Code-Erweiterung für Azure Functions, um ihrer Funktions-App die TypeScript-Dateien hinzuzufügen, um Ressourcen in einer Ressourcengruppe aufzulisten.

  1. Öffnen Sie die Visual Studio Code-Befehlspalette: STRG + UMSCHALT + P.

  2. Geben Sie Azure Functions: Create Function ein, und drücken Sie dann die EINGABETASTE, um den Prozess zu starten.

  3. Verwenden Sie die folgende Tabelle, um die API "/api/resources " zu erstellen:

    Prompt Wert
    „Select a template for your function“ (Wählen Sie eine Vorlage für Ihre Funktion aus.) HTTP-Trigger
    Angeben eines Funktionsnamens resources
    Autorisierungsstufe Wählen Sie Anonym aus. Wenn Sie mit diesem Projekt fortfahren, ändern Sie die Autorisierungsstufe in die Funktion. Informieren Sie sich ausführlicher über Autorisierung auf Funktionsebene.

  4. Öffnen Sie die ./src/functions/resources.ts gesamte Datei, und ersetzen Sie sie durch den folgenden Quellcode.

    import {
  app,
  HttpRequest,
  HttpResponseInit,
  InvocationContext
} from '@azure/functions';
import {
  listResourceByResourceGroup, listResourceBySubscription
} from '../lib/azure-resource';
import { processError } from '../lib/error';

export async function resources(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  try {
    const resourceGroupName: string = request.query.get('resourceGroupName');
    context.log(`resourceGroupName: '${resourceGroupName}'`);

    if (resourceGroupName) {
      const resourcesByName = await listResourceByResourceGroup(
        resourceGroupName
      );
      return { jsonBody: resourcesByName };
    } else {
      const resourcesBySubscription = await listResourceBySubscription();
      return { jsonBody: resourcesBySubscription };
    }
  } catch (err: unknown) {
    return processError(err);
  }
}
app.http('resources', {
  methods: ['GET'],
  authLevel: 'anonymous',
  handler: resources
});

  5. Erstellen Sie die ./src/lib/azure-resource.ts Datei, und kopieren Sie den folgenden Code darin, um die Ressourcen in einer Ressourcengruppe auflisten zu können.

    // Include npm dependencies
import { Resource, ResourceManagementClient } from '@azure/arm-resources';
import { DefaultAzureCredential } from '@azure/identity';
import { getSubscriptionId } from './environment-vars';

const subscriptionId = getSubscriptionId();

// Create Azure authentication credentials
const credentials = new DefaultAzureCredential();

// Create Azure SDK client for Resource Management such as resource groups
const resourceManagement = new ResourceManagementClient(
  credentials,
  subscriptionId
);

// all resources groups in subscription
export const listResourceBySubscription = async (): Promise<{
  list: Resource[];
  subscriptionId: string;
}> => {
  const list: Resource[] = [];

  for await (const resource of resourceManagement.resources.list()) {
    list.push(resource);
  }

  return {
    subscriptionId,
    list
  };
};
// all resources groups in resource group
export const listResourceByResourceGroup = async (
  resourceGroupName: string
): Promise<{
  list: Resource[];
  subscriptionId: string;
  resourceGroupName: string;
}> => {
  const list: Resource[] = [];

  for await (const resource of resourceManagement.resources.listByResourceGroup(
    resourceGroupName
  )) {
    list.push(resource);
  }

  return {
    subscriptionId,
    resourceGroupName,
    list
  };
};

Starten Ihrer lokalen Funktions-App und Testen der neuen API

  1. Führen Sie im integrierten Visual Studio Code-Terminal das lokale Projekt aus:

    npm start

  2. Warten Sie, bis im integrierten Bash-Terminal die URL der ausgeführten Funktion angezeigt wird:

    Partial screenshot of Visual Studio Code's integrated bash terminal when the Azure Function is running locally and displaying the local URLs for the APIs in the Function app.

  3. Verwenden Sie die folgenden curl-Befehle in einem anderen integrierten Bash-Terminal, um Ihre API aufzurufen, um Ihrem Abonnement eine Ressourcengruppe hinzuzufügen. Ändern Sie den Namen der Ressourcengruppe, um Ihre eigenen Namenskonventionen zu verwenden.

    curl -X POST 'http://localhost:7071/api/resourcegroup?name=my-test-1&location=westus'

curl -X POST 'http://localhost:7071/api/resourcegroup?name=my-test-1&location=westus' \
  -H 'content-type: application/json' \
  -d '{"tags": {"a":"b"}}'

  4. Verwenden Sie den folgenden cURL-Befehl, um die neue Ressourcengruppe in Ihrem Abonnement anzuzeigen:

    curl http://localhost:7071/api/resource-groups

  5. Verwenden Sie den folgenden cURL-Befehl, um die soeben hinzugefügte Ressourcengruppe zu löschen:

    curl -X DELETE 'http://localhost:7071/api/resourcegroup?name=my-test-1' \
  -H 'Content-Type: application/json'

Erneutes Bereitstellen Ihrer Funktions-App mit neuen APIs in Azure

  1. Stellen Sie in VS Code bereit, indem Sie die Befehlspalette mit STRG + UMSCHALT P + öffnen, die Azure-Funktionen eingeben deploy to function appund ausführen: In Funktions-App-Befehl bereitstellen.

  2. Wählen Sie Ihre Funktions-App in der App-Liste aus.

  3. Wählen Sie im Popupfenster Bereitstellen aus.

  4. Warten Sie, bis die Bereitstellung abgeschlossen ist.

Überprüfen von Funktions-APIs mit dem Browser

Verwenden Sie die vorherigen cURL-Befehle, und ersetzen Sie die localhost-Adresse http://localhost:7071 durch ihren Azure Function-Ressourcennamen, z https://myfunction.azurewebsites.net. B. .

7. Anzeigen und Abfragen ihrer Funktions-App-Protokolle

Anzeigen und Abfragen von Azure Function-App-Protokollen im Azure-Portal.

Abfragen Ihrer Azure-Funktionsprotokolle

Verwenden Sie das Azure-Portal, um Ihre Funktionsprotokolle anzuzeigen und abzufragen.

  1. Wählen Sie in VS Code das Azure-Logo aus, um Azure Explorer zu öffnen. Klicken Sie anschließend unter Funktionen mit der rechten Maustaste auf die Funktions-App, und wählen Sie die Option Im Portal öffnen aus.

    Das Azure-Portal wird mit Ihrer Azure-Funktion geöffnet.

  2. Wählen Sie unter „Einstellungen“ die Option Application Insights und dann Application Insights-Daten anzeigen aus.

    Browser screenshot showing menu choices. Select Application Insights from the Settings, then select View Application Insights data.

    Mit diesem Link gelangen Sie zu Ihrer separaten Metrikressource, die für Sie erstellt wurde, als Sie Ihre Azure-Funktion mit VS Code erstellt haben.

  3. Wählen Sie im Abschnitt „Überwachung“ die Option Protokolle aus. Wählen Sie im angezeigten Popupfenster Abfragen oben rechts das X aus, um das Fenster zu schließen.

  4. Doppelklicken Sie im Bereich Schema und Filter auf der Registerkarte Tabellen auf die Tabelle traces.

    Die Kusto-Abfragetraces wird in das Abfragefenster eingegeben.

  5. Bearbeiten Sie die Abfrage, um nach API-Aufrufen zu suchen:

    traces 
| where message startswith "Executing "

  6. Ausführen auswählen.

    Wenn das Protokoll keine Ergebnisse anzeigt, liegt dies möglicherweise daran, dass zwischen der HTTP-Anforderung an die Azure-Funktion und der Protokollverfügbarkeit in Kusto einige Minuten verzögerung. Warten Sie einige Minuten, und führen Sie die Abfrage dann erneut durch.

    Browser screenshot showing Azure portal Kusto query result for Trace table.

    Da beim Erstellen der Azure Function-App eine Application Insights-Ressource hinzugefügt wurde, müssen Sie keine zusätzlichen Schritte ausführen, um diese Protokollierungsinformationen abzurufen:

    • Die Funktions-App hat Application Insights für Sie hinzugefügt.
    • Das Abfragetool ist im Azure-Portal enthalten.
    • Sie können auswählen traces , anstatt zu lernen, eine Kusto-Abfrage zu schreiben, um sogar die Mindestinformationen aus Ihren Protokollen abzurufen.

8. Bereinigen von Azure-Ressourcen

Löschen der Ressourcengruppe

  1. Wählen Sie in VS Code das Azure-Logo aus, um den Azure-Explorer zu öffnen, und klicken Sie dann unter "Funktionen" mit der rechten Maustaste auf Ihre Funktions-App, und wählen Sie dann "Im Portal öffnen" aus. Dadurch wird die Azure-Portal für Ihre Azure-Funktion geöffnet.

  2. Suchen Sie im Abschnitt "Übersicht " den Namen der Ressourcengruppe, und wählen Sie sie aus. Diese Aktion führt Sie zur Ressourcengruppe im Azure-Portal.

  3. Auf der Seite "Ressourcengruppe" werden alle Ressourcen aufgelistet, die diesem Lernprogramm zugeordnet sind.

  4. Wählen Sie im oberen Menü Ressourcengruppe löschen aus.

  5. Geben Sie im Seitenmenü den Namen der Ressourcengruppe ein, und wählen Sie dann "Löschen" aus.

Löschen des Dienstprinzipals

Führen Sie zum Löschen des Dienstprinzipals den folgenden Befehl aus. Ersetzen Sie den <YOUR-SERVICE-PRINCIPAL-NAME> Namen des Dienstprinzipals.

az ad sp delete --id <YOUR-SERVICE-PRINCIPAL-NAME>

Beispielcode

Nächste Schritte