Hantera Azure-resursgrupper med TypeScript-funktions-API

Artikel
05/01/2024

I den här självstudien skapar du en lokal TypeScript Azure-funktionsapp med API:er för att hantera Azure-resursgrupper och distribuera appen till Azure.

Funktioner och funktioner:

Skapa ett lokalt TypeScript Azure Function-appprojekt i Visual Studio Code
Skapa funktions-API:ets exempelkod i Visual Studio Code
Distribuera till Azure Functions från Visual Studio Code
Skapa tjänstens huvudnamn med Azure CLI
Konfigurera lokala och fjärranslutna programinställningar med Visual Studio Code
Använd DefaultAzureCredential i både lokala och fjärranslutna miljöer för lösenordslösa anslutningar
Använda Azure Identity och Azure Resource Management SDK:er för att hantera Azure-resurser
Använd dina lokala API:er och moln-API:er för att skapa, ta bort och lista resursgrupper i din prenumeration

Källkoden är skriven med TypeScript, men källkoden är enkel. Om du är bekväm med modern JavaScript med hjälp av async/await är koden bekant för dig.

Skapa eller använda en befintlig Azure-prenumeration

Du behöver ett Azure-användarkonto med en aktiv prenumeration. Skapa en kostnadsfritt.

Förutsättningar

Node.js LTS 18+ och npm installerat på den lokala datorn. Din lokala utvecklingsmiljöversion av Node.js ska matcha en av de tillgängliga Azure Function-molnkörningsversionerna.
Visual Studio Code har installerats på din lokala dator.
- Azure Function-tillägget v1.10.4 eller senare.
Azure Functions Core Tools v4.0.5095 eller senare
Azure Cloud Shell eller Azure CLI har installerats på din lokala dator.

Programmets arkitektur

Appen tillhandahåller följande API-slutpunkter.

Metod	webbadress	beskrivning
POST,DELETE	http://localhost:7071/api/resourcegroup	Lägg till eller ta bort en resursgrupp. När du lägger till inkluderar du taggar (nyckel/värde-par) för att identifiera syftet med gruppen senare.
GET	http://localhost:7071/api/resourcegroups	Visa en lista över alla resursgrupper i prenumerationen.
GET	http://localhost:7071/api/resources	Visa en lista över alla resurser i en prenumeration eller resursgrupp.

Även om dessa slutpunkter är offentliga bör du skydda DINA API-slutpunkter med autentisering och auktorisering innan du distribuerar till din livemiljö.

Den här appen är begränsad till en prenumeration eftersom det är det omfång som anges när tjänstens huvudnamn skapas.

1. Förbereda din miljö

Du måste förbereda dina lokala miljöer och molnmiljöer för att använda Azure Identity SDK.

I en bash-terminal loggar du in på Azure CLI med följande kommando:

az login

Hämta ditt Azure-prenumerations-ID

I en bash-terminal hämtar du dina prenumerationer och hittar det prenumerations-ID som du vill använda. Följande fråga returnerar prenumerations-ID, prenumerationsnamn och klientorganisations-ID sorterat efter prenumerationsnamn.
```
az account list --query "sort_by([].{Name:name, SubscriptionId:id, TenantId:tenantId}, &Name)" --output table
```
Kopiera prenumerations-ID:t till den tidigare temporära filen. Du behöver den här inställningen senare.

Skapa Azure-tjänstens huvudnamn

Ett Huvudnamn för Azure-tjänsten ger åtkomst till Azure utan att behöva använda dina personliga användarautentiseringsuppgifter. I den här självstudien kan tjänstens huvudnamn användas både i dina lokala miljöer och molnmiljöer. I en företagsmiljö vill du ha separata tjänsthuvudnamn för varje miljö.

Fastställ ett namnformat för tjänstens huvudnamn så att du enkelt kan hitta tjänstens huvudnamn senare. Flera formatidéer är till exempel:
- Projektet och ägaren: resource-management-john-smith.
- Din avdelning och datum: IT-2021-September
- En unik identifierare: 00000000-0000-0000-0000-000000000000
I en bash-terminal skapar du tjänstens huvudnamn med az ad sp create-for-rbac. Ersätt <SUBSCRIPTION-ID> med ditt prenumerations-ID.
```
az ad sp create-for-rbac --name YOUR-SERVICE-PRINCIPAL-NAME --role Contributor --scopes /subscriptions/<SUBSCRIPTION-ID>
```

Kopiera hela utdataresultatet till en tillfällig fil. Du behöver de här inställningarna senare.

{
  "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. Skapa en lokal Azure-funktionsapp i Visual Studio Code

Skapa en Azure-funktionsapp i Visual Studio Code för att hantera Azure-resursgrupper.

Skapa funktionsappen

Använd Visual Studio Code för att skapa en lokal funktionsapp.

Skapa och ändra till en ny katalog i en bash-terminal:
```
mkdir my-function-app && cd my-function-app
```
Öppna Visual Studio Code i en bash-terminal:
```
code .
```
Öppna Visual Studio Code-kommandopaletten: Ctrl + Skift + p.

Ange Azure Functions: create new project. Använd följande tabell för att slutföra anvisningarna:

Prompt	Värde
Välj den mapp som ska innehålla funktionsprojektet	Välj standardkatalogen (aktuell)
Välj ett språk	Välj TypeScript.
Välj en TypeScript-programmeringsmodell	Välj Modell V4 (förhandsversion)
Välj en mall för projektets första funktion	Välj HTTP-utlösare.
Skapa ny HTTP-utlösare	Ange API-namnet på `resourcegroups`.
Auktoriseringsnivå	Välj anonym. Om du fortsätter med det här projektet efter den här artikeln ändrar du auktoriseringsnivån till funktionen. Läs mer om auktorisering på funktionsnivå.

Projekt pannplåten skapas och beroendena installeras.

Lägga till inställningar för tjänstens huvudnamn i local.settings.json fil

./local.settings.json Öppna filen i projektrotkatalogen och lägg till avsnittet VÄRDEN med följande fem miljövariabler.

{
  "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"
  }
}

Se inställningarna från föregående avsnitt för att lägga till värdena. Dessa miljövariabler krävs för att kontexten ska kunna använda DefaultAzureCredential.
- AZURE_TENANT_ID: tenant från utdata för tjänstens huvudnamn ovan.
- AZURE_CLIENT_ID: appId från utdata för tjänstens huvudnamn ovan.
- AZURE_CLIENT_SECRET: password från utdata för tjänstens huvudnamn ovan.
Du måste också ange prenumerations-ID:t. Du måste använda Azure SDK för resurshantering.
- AZURE_SUBSCRIPTION_ID: Din standardprenumeration som innehåller dina resursgrupper.

Den här local.settings.json filen ignoreras av din lokala git med flit så att du inte av misstag checkar in den i källkoden.

Installera npm-beroenden för Azure Identity and Resource Management

Installera Azure SDK-beroenden för Azure Identity and Resource Management i en integrerad Bash-terminal i Visual Studio Code.

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

Visa en lista över alla resursgrupper i en prenumeration med JavaScript

./src/functions/resourcegroups.ts Öppna filen och ersätt innehållet med följande:

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

Den här filen svarar på API-begäranden till /api/resourcegroups och returnerar en lista över alla resursgrupper i prenumerationen.

Skapa en underkatalog med src namnet lib och skapa en ny fil i katalogen med namnet azure-resource-groups.ts.

Kopiera följande kod till ./src/lib/azure-resource-groups.ts filen:

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

Den här filen slutför följande:

Hämtar prenumerations-ID
Skapar kontexten DefaultAzureCredential
Skapar resourcemanagementClient som krävs för att använda SDK:et för resurshantering.
Hämtar alla resursgrupper i prenumerationen.

Skapa en ny fil i katalogen ./src/lib med namnet environment-vars.ts och kopiera följande kod till filen.

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

Den här filen kontrollerar miljövariablerna innan du returnerar prenumerations-ID:t.

Skapa en ny fil i katalogen ./src/lib med namnet error.ts och kopiera följande kod till filen.

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

Den här filen returnerar ett 500-fel med felmeddelandet. Stacken returneras om variabeln NODE_ENV inte är inställd på production.

Testa lokala funktioner

Kör det lokala projektet i den integrerade Terminalen i Visual Studio Code:
```
npm start
```
Vänta tills den integrerade bash-terminalen visar den aktiva funktionens URL.
Öppna en andra integrerad bash-terminal i Visual Studio Code, Ctrl + Shift + 5, och använd följande GET cURL-kommando för att använda API:et:
```
curl http://localhost:7071/api/resourcegroups
```
Om du har många resursgrupper i din prenumeration kanske du vill skicka utdata till en fil för enklare granskning.
```
curl http://localhost:7071/api/resourcegroups > resourcegroups.json
```

Svaret innehåller subscriptionId och en list av alla resursgrupper i den prenumerationen.

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

Felsökning

Om du inte kunde slutföra den här artikeln kan du söka efter problem i följande tabell. Om problemet inte visas i tabellen öppnar du ett problem på den här dokumentationssidan.

Problem	Åtgärda
Appen startade inte.	Granska felen. Kontrollera att du har installerat nödvändiga beroenden.
Appen startade men du kan inte få något svar på 200.	Kontrollera att curl-kommandot begär från rätt lokal väg.
API:et returnerade ett 200-svar men returnerade inga resultat.	Använd Visual Studio Code-tillägget för Azure-resurser för att kontrollera att din prenumeration har några resursgrupper. Oroa dig inte om du inte ser några resursgrupper. Den här självstudien lägger till ett API för att skapa och ta bort resursgrupper i din prenumeration. Det här API:et läggs till efter den första distributionen av källkoden till Azure, så att du får lära dig hur du distribuerar om koden.

3. Skapa en molnbaserad Azure-funktionsapp

I Visual Studio Code väljer du Azure-ikonen för att öppna Azure Explorer.
+ Välj ikonen för att skapa en ny Azure-funktionsapp i Azure-molnet.
Välj Skapa funktionsapp i Azure.
Ange ett globalt unikt namn för den nya funktionsappen. Namnet måste vara unikt för alla Azure-funktioner. Exempel: jsmith-rg-management
Välj samma Node.js 18+ LTS-körning som du valde när du skapade din lokala funktionsapp.
Välj en geografisk plats nära dig, till exempel USA, västra 3.
Vänta tills resursen har skapats. Du kan titta på Aktivitetsloggen för Azure: för mer information.

4. Konfigurera molnbaserad Azure-funktionsapp

Du måste konfigurera dina Azure-appinställningar för att ansluta till Azure-funktionsappen. Lokalt finns de här inställningarna i filen local.settings.json . Den här processen lägger till dessa värden i din molnapp.

I Visual Studio Code i Azure Explorer går du till avsnittet Resurser och expanderar Funktionsapp och väljer sedan din funktionsapp.
Högerklicka på Program Inställningar och välj Lägg till ny inställning.
Lägg till de fyra värdena från din local.settings.json med exakt samma namn och värden.
- AZURE_TENANT_ID: tenant från utdata för tjänstens huvudnamn ovan.
- AZURE_CLIENT_ID: appId från utdata för tjänstens huvudnamn ovan.
- AZURE_CLIENT_SECRET: password från utdata för tjänstens huvudnamn ovan.
- AZURE_SUBSCRIPTION_ID: Din standardprenumeration som innehåller dina resursgrupper.
- AzureWebJobsFeatureFlags:EnableWorkerIndexing

Partiell skärmbild av Azure Explorer i Visual Studio Code som visar appinställningarna för fjärr-/molnfunktionen.

5. Distribuera Resource Manager-funktionsappen

Distribuera en Azure-funktionsapp i Visual Studio Code för att hantera Azure-resursgrupper.

Använda Visual Studio Code-tillägget för att distribuera till värdmiljön

Öppna filen i VS Code så att den local.settings.json visas. Detta gör nästa steg för att kopiera dessa namn och värden enklare.
Välj Azure-logotypen för att öppna Azure Explorer och välj sedan molnikonen för att distribuera din app under Funktioner.

Alternativt kan du distribuera genom att öppna kommandopaletten med Ctrl + Skift + p, ange deploy to function appoch köra kommandot Azure Functions: Deploy to Function App ( Distribuera till funktionsapp).
Välj Distribuera till funktionsapp.
Välj namnet på funktionsappen som du skapade i föregående avsnitt.
När du tillfrågas om du är säker på att du vill distribuera väljer du Distribuera.
Vs Code-utdatapanelen för Azure Functions visar förloppet. När du distribuerar distribueras hela Functions-programmet, så ändringar i alla enskilda funktioner distribueras samtidigt.

Kontrollera att Functions-appen är tillgänglig i webbläsaren

Medan du fortfarande är i Visual Studio Code använder du Azure Functions-utforskaren, expanderar noden för din Azure-prenumeration, expanderar noden för din Functions-app och expanderar sedan Functions (skrivskyddad). Högerklicka på funktionsnamnet och välj Kopiera funktions-URL:
Klistra in URL:en i en webbläsare och tryck på Retur för att begära resursgruppslistan från moln-API:et.

6. Lägg till API:er för att funktionsappen och distribuera om till Azure

Lägg till följande API:er och distribuera sedan om azure-funktionsappen i Visual Studio Code:

Lägga till och ta bort resursgrupper
Lista resurser i resursgrupp eller prenumeration.

Nu i självstudien skapade du en lokal funktionsapp med ett API för att lista din prenumerations resursgrupper och du distribuerade appen till Azure. Som Azure-utvecklare kanske du vill skapa eller ta bort resursgrupper som en del av din processautomatiseringspipeline.

Skapa resourcegroup API för din funktionsapp

Använd Visual Studio Code-tillägget för Azure Functions för att lägga till TypeScript-filerna i funktionsappen för att skapa och ta bort resursgrupper.

Öppna Visual Studio Code-kommandopaletten: Ctrl + Skift + p.
Retur Azure Functions: Create Function och tryck sedan på Retur för att påbörja processen.

Använd följande tabell för att skapa API:et /api/resourcegroup :

Prompt	Värde
Välj en mall för din funktion	HTTP-utlösare
Ange ett funktionsnamn	`resourcegroup`
Auktoriseringsnivå	Välj anonym. Om du fortsätter med det här projektet ändrar du auktoriseringsnivån till funktionen. Läs mer om auktorisering på funktionsnivå.

./src/functions/resourcegroup.ts Öppna och ersätt hela filen med följande källkod.

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

Filen ./src/lib/azure-resource-groups.ts innehåller redan koden för att lägga till och ta bort resursgrupper.

Skapa resurs-API för din funktionsapp

Använd Visual Studio Code-tillägget för Azure Functions för att lägga till TypeScript-filerna i funktionsappen för att visa en lista över resurser i en resursgrupp.

Öppna Visual Studio Code-kommandopaletten: Ctrl + Skift + p.
Retur Azure Functions: Create Function och tryck sedan på Retur för att påbörja processen.

Använd följande tabell för att skapa API:et /api/resources :

Prompt	Värde
Välj en mall för din funktion	HTTP-utlösare
Ange ett funktionsnamn	`resources`
Auktoriseringsnivå	Välj anonym. Om du fortsätter med det här projektet ändrar du auktoriseringsnivån till funktionen. Läs mer om auktorisering på funktionsnivå.

./src/functions/resources.ts Öppna och ersätt hela filen med följande källkod.

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

./src/lib/azure-resource.ts Skapa filen och kopiera följande kod till den för att visa en lista över resurserna i en resursgrupp.

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

Starta din lokala funktionsapp och testa det nya API:et

Kör det lokala projektet i den integrerade Terminalen i Visual Studio Code:
```
npm start
```
Vänta tills den integrerade bash-terminalen visar den aktiva funktionens URL.

Använd följande curl-kommandon i en annan integrerad bash-terminal för att anropa ditt API för att lägga till en resursgrupp i din prenumeration. Ändra namnet på resursgruppen så att du använder dina egna namngivningskonventioner.

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"}}'

Använd följande curl-kommando för att se den nya resursgruppen i din prenumeration.
```
curl http://localhost:7071/api/resource-groups
```

Använd följande curl-kommando för att ta bort den resursgrupp som du nyss lade till.

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

Distribuera om funktionsappen med nya API:er till Azure

I VS Code distribuerar du genom att öppna kommandopaletten med Ctrl + Skift + p, ange deploy to function appoch köra kommandot Azure Functions: Deploy to Function App ( Distribuera till funktionsapp).
Välj din funktionsapp i listan över appar.
Välj Distribuera i popup-fönstret.
Vänta tills distributionen är klar.

Verifiera funktions-API:er med webbläsare

Använd de tidigare cURL-kommandona och ersätt localhost-adressen http://localhost:7071 med ditt Azure Function-resursnamn, till exempel https://myfunction.azurewebsites.net.

7. Visa och fråga dina funktionsapploggar

Visa och fråga azure-funktionsapploggar i Azure-portalen.

Fråga dina Azure-funktionsloggar

Använd Azure-portalen för att visa och fråga dina funktionsloggar.

I VS Code väljer du Azure-logotypen för att öppna Azure Explorer. Högerklicka sedan på funktionsappen under Funktioner och välj sedan Öppna i portalen.

Då öppnas Azure-portalen för din Azure-funktion.
Välj Application Insights från Inställningar och välj sedan Visa Application Insights-data.

Den här länken tar dig till din separata måttresurs som du skapade när du skapade din Azure-funktion med VS Code.
Välj Loggar i avsnittet Övervakning. Om popup-fönstret Frågor visas väljer du X i det övre högra hörnet i popup-fönstret för att stänga det.
Dubbelklicka på spårningstabellen på fliken Tabeller i fönstret Schema och filter.

Detta anger Kusto-frågantraces i frågefönstret.

Redigera frågan för att söka efter API-anrop:

traces 
| where message startswith "Executing "

Markera Kör.

Om loggen inte visar några resultat kan det bero på att det är några minuters fördröjning mellan HTTP-begäran till Azure-funktionen och loggtillgängligheten i Kusto. Vänta några minuter och kör frågan igen.

Eftersom en Application Insights-resurs lades till åt dig när du skapade Azure-funktionsappen behövde du inte göra något extra för att få den här loggningsinformationen:
- Funktionsappen har lagt till Application Insights åt dig.
- Frågeverktyget ingår i Azure-portalen.
- Du kan välja traces i stället för att behöva lära dig att skriva en Kusto-fråga för att få minsta möjliga information från loggarna.

8. Rensa Azure-resurser

Ta bort resursgruppen

I VS Code väljer du Azure-logotypen för att öppna Azure Explorer. Högerklicka sedan på funktionsappen under Funktioner och välj sedan Öppna i portalen. Då öppnas Azure-portalen för din Azure-funktion.
I avsnittet Översikt letar du upp och väljer resursgruppens namn. Den här åtgärden tar dig till resursgruppen i Azure-portalen.
På resursgruppens sida visas alla resurser som är associerade med den här självstudien.
Välj Ta bort resursgrupp på menyn längst upp.
I sidomenyn anger du namnet på resursgruppen och väljer sedan Ta bort.

Ta bort tjänstens huvudnamn

Kör följande kommando för att ta bort tjänstens huvudnamn. Ersätt <YOUR-SERVICE-PRINCIPAL-NAME> med namnet på tjänstens huvudnamn.

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

Exempelkod

GitHub: Azure-Samples/azure-typescript-e2e-apps

Nästa steg

Konvertera text till tal i Express.js app

Hantera Azure-resursgrupper med TypeScript-funktions-API

Skapa eller använda en befintlig Azure-prenumeration

Förutsättningar

Programmets arkitektur

1. Förbereda din miljö

Hämta ditt Azure-prenumerations-ID

Skapa Azure-tjänstens huvudnamn

2. Skapa en lokal Azure-funktionsapp i Visual Studio Code

Skapa funktionsappen

Lägga till inställningar för tjänstens huvudnamn i local.settings.json fil

Installera npm-beroenden för Azure Identity and Resource Management

Visa en lista över alla resursgrupper i en prenumeration med JavaScript

Testa lokala funktioner

Felsökning

3. Skapa en molnbaserad Azure-funktionsapp

4. Konfigurera molnbaserad Azure-funktionsapp

5. Distribuera Resource Manager-funktionsappen

Använda Visual Studio Code-tillägget för att distribuera till värdmiljön

Kontrollera att Functions-appen är tillgänglig i webbläsaren

6. Lägg till API:er för att funktionsappen och distribuera om till Azure

Skapa resourcegroup API för din funktionsapp

Skapa resurs-API för din funktionsapp

Starta din lokala funktionsapp och testa det nya API:et

Distribuera om funktionsappen med nya API:er till Azure

Verifiera funktions-API:er med webbläsare

7. Visa och fråga dina funktionsapploggar

Fråga dina Azure-funktionsloggar

8. Rensa Azure-resurser

Ta bort resursgruppen

Ta bort tjänstens huvudnamn

Exempelkod

Nästa steg

Feedback

Feedback

Ytterligare resurser

Hantera Azure-resursgrupper med TypeScript-funktions-API

Skapa eller använda en befintlig Azure-prenumeration

Förutsättningar

Programmets arkitektur

1. Förbereda din miljö

Logga in på Azure CLI

Hämta ditt Azure-prenumerations-ID

Skapa Azure-tjänstens huvudnamn

2. Skapa en lokal Azure-funktionsapp i Visual Studio Code

Skapa funktionsappen

Lägga till inställningar för tjänstens huvudnamn i local.settings.json fil

Installera npm-beroenden för Azure Identity and Resource Management

Visa en lista över alla resursgrupper i en prenumeration med JavaScript

Testa lokala funktioner

Felsökning

3. Skapa en molnbaserad Azure-funktionsapp

4. Konfigurera molnbaserad Azure-funktionsapp

5. Distribuera Resource Manager-funktionsappen

Använda Visual Studio Code-tillägget för att distribuera till värdmiljön

Kontrollera att Functions-appen är tillgänglig i webbläsaren

6. Lägg till API:er för att funktionsappen och distribuera om till Azure

Skapa resourcegroup API för din funktionsapp

Skapa resurs-API för din funktionsapp

Starta din lokala funktionsapp och testa det nya API:et

Distribuera om funktionsappen med nya API:er till Azure

Verifiera funktions-API:er med webbläsare

7. Visa och fråga dina funktionsapploggar

Fråga dina Azure-funktionsloggar

8. Rensa Azure-resurser

Ta bort resursgruppen

Ta bort tjänstens huvudnamn

Exempelkod

Nästa steg

Feedback

Feedback

Ytterligare resurser