Freigeben über

Verwalten von Azure-Ressourcengruppen mit einer TypeScript Funktions-API

  • Artikel

In diesem Tutorial 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 der Codebausteine für die Funktions-API in Visual Studio Code
  • Bereitstellen für Azure Functions aus Visual Studio Code
  • Erstellen des Dienstprinzipals über die Azure-Befehlszeilenschnittstelle
  • Konfigurieren von lokalen und Remoteanwendungseinstellungen mit Visual Studio Code
  • Verwenden von DefaultAzureCredential sowohl in lokalen als auch in Remoteumgebungen für kennwortlose Verbindungen
  • Verwenden von Azure Identity und Azure Resource Management SDKs zur Verwaltung von Azure-Ressourcen
  • Verwenden Ihrer lokalen und cloudbasierten APIs zum Erstellen, Löschen und Auflisten von Ressourcengruppen in Ihrem Abonnement

Warnung

Dieses Tutorial ist für die schnelle Einführung gedacht und erfüllt daher keine standardmäßigen Sicherheitsanforderungen. Weitere Informationen zu diesem Szenario mit einem standardmäßig sicheren Ziel finden Sie unter Sicherheitsaspekte.

Der Quellcode wird zwar mit TypeScript geschrieben, ist aber einfach. Wenn Sie sich mit modernem JavaScript mit async/await auskennen, wird Ihnen der Code vertraut sein.

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

Obwohl diese Endpunkte öffentlich sind, müssen Sie Ihre API-Endpunkte vor der Bereitstellung in Ihrer Liveumgebung mit Authentifizierung und Autorisierung schützen.

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

1. Vorbereiten Ihrer 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. Der Dienstprinzipal kann für dieses Tutorial sowohl in Ihrer lokalen Umgebung als auch in der Cloudumgebung verwendet werden. In einer Unternehmensumgebung sollten Sie für jede Umgebung separate Dienstprinzipale verwenden.

  1. Ermitteln Sie ein Dienstprinzipalnamenformat, damit Sie ihren Dienstprinzipal später problemlos finden können. Beispielformate:

    • Projekt und Besitzer: resource-management-john-smith
    • Abteilung und Datum: IT-2021-September

  2. Erstellen Sie in einem Bash-Terminal mit az ad sp create-for-rbac Ihren Dienstprinzipal. 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 enthalten soll. Wählen Sie das Standardverzeichnis (aktuelles Verzeichnis) 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 dieses Projekt nach diesem Artikel weiterverwenden möchten, ändern Sie die Autorisierungsebene in die Funktion. Informieren Sie sich ausführlicher über Autorisierung auf Funktionsebene.

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

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

  1. Öffnen Sie die Datei ./local.settings.json im Projektstammverzeichnis, und fügen Sie Ihren Abschnitt VALUES mit den folgenden fünf 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. Für die Ressourcenverwaltung muss das Azure SDK verwendet werden.

    • 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 mit dem Namen lib, 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 mit dem Namen 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 mit dem Namen 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 festgelegt ist.

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:

    Partieller Screenshot: Integriertes Bash-Terminal in Visual Studio Code, wenn die Azure-Funktion lokal ausgeführt und die lokale URL für die APIs in der Funktions-App angezeigt wird

  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 nutzen:

    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 list für alle 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. Dieses Tutorial fügt eine API zum Erstellen und Löschen von Ressourcengruppen in Ihrem Abonnement hinzu. 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 Function-App

  1. Wählen Sie in Visual Studio Code das Azure-Logo 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 des Azure-Explorers von Visual Studio Code mit dem hervorgehobenen Symbol der Azure Function-App.

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

  4. Geben Sie einen global eindeutigen Namen für die neue Function-App ein. Der Name muss in allen Azure Functions eindeutig sein. Beispiel: jsmith-rg-management.

  5. Wählen Sie dieselbe Node.js 18+ LTS-Laufzeit aus, die Sie beim Erstellen der lokalen Function-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 des Azure-Aktivitätsprotokolls von Visual Studio Code mit dem Status der Ressourcenerstellung

4. Konfigurieren der cloudbasierten Azure Function-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 Function-App, und wählen Sie dann Ihre Function-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

Partieller Screenshot: Azure Explorer in Visual Studio Code mit den App-Einstellungen der Remote-/Cloudfunktion

5. Bereitstellen einer Ressourcen-Manager-Function-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. Klicken Sie auf das Azure-Logo, um den Azure Explorer zu öffnen, und anschließend unter Funktionen auf das Cloud-Symbol, um Ihre App bereitzustellen.

    Screenshot des lokalen Arbeitsbereichs von Visual Studio Code mit hervorgehobenem Symbol für die Cloudbereitstellung

    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. Klicken Sie auf Deploy to Function App (In Function App bereitstellen).

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

  5. Wenn Sie gefragt werden, ob 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:

    Partieller Screenshot: Azure Explorer in Visual Studio Code mit der Darstellung, wo die URL der Funktion kopiert wird

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

6. Hinzufügen von APIs zur Funktions-App und erneutes Bereitstellen in Azure

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

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

An diesem Punkt im Tutorial haben Sie eine lokale Function App mit einer API zum Auflisten der Ressourcengruppen Ihres Abonnements erstellt und diese App in Azure bereitgestellt. Als Azure-Entwickler können Sie Ressourcengruppen im Rahmen Ihrer Prozessautomatisierungspipeline erstellen oder löschen.

Erstellen einer Ressourcengruppen-API für Ihre Function App

Verwenden Sie die Visual Studio Code-Erweiterung für Azure Functions, um Ihrer Function App die TypeScript-Dateien hinzuzufügen und so 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. Erstellen Sie die API /api/resourcegroup anhand der folgenden Tabelle:

    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 dieses Projekt weiterverwenden möchten, ändern Sie die Autorisierungsebene in die Funktion. Informieren Sie sich ausführlicher über Autorisierung auf Funktionsebene.

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

    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 einer Ressourcen-API für Ihre Function-App

Verwenden Sie die Visual Studio Code-Erweiterung für Azure Functions, um Ihrer Function-App die TypeScript-Dateien hinzuzufügen und so Ressourcen in einer Ressourcengruppe aufzuführen.

  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. Erstellen Sie die API /api/resources anhand der folgenden Tabelle:

    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 dieses Projekt weiterverwenden möchten, ändern Sie die Autorisierungsebene in die Funktion. Informieren Sie sich ausführlicher über Autorisierung auf Funktionsebene.

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

    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:

    Partieller Screenshot: Integriertes Bash-Terminal in Visual Studio Code, wenn die Azure-Funktion lokal ausgeführt und die lokalen URLs für die APIs in der Funktions-App angezeigt werden

  3. Verwenden Sie die folgenden curl-Befehle in einem anderen integrierten Bash-Terminal, um Ihre API aufzurufen und 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 Ihre App in VS Code bereit, 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 Function-App bereitstellen) ausführen.

  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. B. https://myfunction.azurewebsites.net.

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.

    Browserscreenshot mit Menüoptionen: Wählen Sie unter „Einstellungen“ die Option „Application Insights“ und dann „Application Insights-Daten anzeigen“ aus.

    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-Abfrage traces wird in das Abfragefenster eingegeben.

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

    traces 
| where message startswith "Executing "

  6. Klicken Sie auf Run (Ausführen).

    Falls im Protokoll keine Ergebnisse angezeigt werden, kann dies daran liegen, dass es zwischen dem Senden der HTTP-Anforderung an die Azure-Funktion und der Verfügbarkeit des Protokolls in Kusto zu einer Verzögerung von einigen Minuten kommt. Warten Sie einige Minuten, und führen Sie die Abfrage dann erneut durch.

    Browserscreenshot: Ergebnis der Kusto-Abfrage für die Tabelle „traces“ im Azure-Portal

    Da beim Erstellen der Azure Function-App eine Application Insights-Ressource für Sie hinzugefügt wurde, mussten Sie keine zusätzlichen Schritte ausführen, um diese Protokollierungsinformationen zu erhalten:

    • Die Funktions-App hat Application Insights für Sie hinzugefügt.
    • Das Abfragetool ist im Azure-Portal enthalten.
    • Sie können stattdessen traces auswählen und müssen nicht lernen, eine Kusto-Abfrage zu schreiben, um auch nur ein Minimum an Informationen aus Ihren Protokollen zu erhalten.

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, klicken Sie dann unter Funktionen mit der rechten Maustaste auf Ihre Funktions-App, und wählen Sie dann Im Portal öffnen aus. Dadurch wird das 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. Mit dieser Aktion gelangen Sie zur Ressourcengruppe im Azure-Portal.

  3. Auf der Seite „Ressourcengruppe“ werden alle Ressourcen aufgelistet, die diesem Tutorial zugeordnet sind.

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

  5. Geben Sie im Seitenmenü den Namen der Ressourcengruppe ein, und klicken Sie dann auf Löschen.

Löschen des Dienstprinzipals

Führen Sie den folgenden Befehl aus, um den Dienstprinzipal zu löschen. Ersetzen Sie <YOUR-SERVICE-PRINCIPAL-NAME> durch den Namen Ihres Dienstprinzipals.

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

Beispielcode

Sicherheitshinweise

Diese Lösung, als Anfänger-Tutorial, veranschaulicht keine standardmäßig sicheren Methoden. Dies ist beabsichtigt, damit Sie die Lösung erfolgreich bereitstellen können. Der nächste Schritt nach der erfolgreichen Bereitstellung besteht darin, die Ressourcen zu sichern. Diese Lösung verwendet drei Azure-Dienste, die jeweils über eigene Sicherheitsfeatures und Überlegungen für die sichere standardmäßige Konfiguration verfügen:

Nächste Schritte