Hantera Azure-resursgrupper med TypeScript-funktions-API
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
Varning
Den här självstudien är avsedd för snabb implementering och följer därför inte kraven för säker som standard. Om du vill veta mer om det här scenariot med ett säkert som standardmål går du till Säkerhetsöverväganden.
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.
Förutsättningar
- Ett Azure-användarkonto och en prenumeration: skapa en kostnadsfri prenumeration.
- 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.
Logga in på Azure CLI
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
- Projektet och ägaren:
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
namnetlib
och skapa en ny fil i katalogen med namnetazure-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 namnetenvironment-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 namneterror.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 enlist
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å Programinstä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
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 app
och 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 app
och 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 i 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ågan
traces
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
Säkerhetsfrågor
Den här lösningen, som en nybörjarkurs, visar inte säkra metoder som standard. Detta är avsiktligt för att du ska kunna distribuera lösningen. Nästa steg efter den lyckade distributionen är att skydda resurserna. Den här lösningen använder tre Azure-tjänster, var och en har sina egna säkerhetsfunktioner och överväganden för säker konfiguration som standard:
- Azure Functions – Skydda Azure Functions
- Azure Storage – säkerhetsrekommendationer för Blob Storage