Gestire i gruppi di risorse di Azure con l'API per le funzioni TypeScript
In questa esercitazione si creerà un'app per le funzioni di Azure TypeScript locale con API per gestire i gruppi di risorse di Azure e distribuire l'app in Azure.
Funzionalità e funzionalità:
- Creare un progetto di app per le funzioni di Azure TypeScript locale in Visual Studio Code
- Creare codice boilerplate dell'API per le funzioni in Visual Studio Code
- Eseguire la distribuzione in Funzioni di Azure da Visual Studio Code
- Creare un'entità servizio con l'interfaccia della riga di comando di Azure
- Configurare le impostazioni dell'applicazione locale e remota con Visual Studio Code
- Usare DefaultAzureCredential in ambienti locali e remoti per le connessioni senza password
- Usare Azure Identity and Azure Resource Management SDK per gestire le risorse di Azure
- Usare le API locali e cloud per creare, eliminare ed elencare i gruppi di risorse nella sottoscrizione
Avviso
Questa esercitazione è destinata all'adozione rapida e, di conseguenza, non segue i requisiti sicuri per impostazione predefinita. Per altre informazioni su questo scenario con un obiettivo sicuro per impostazione predefinita, vedere Considerazioni sulla sicurezza.
Mentre il codice sorgente viene scritto con TypeScript, il codice sorgente è semplice. Se si ha familiarità con JavaScript moderno con async/await, il codice sarà familiare.
Creare o usare una sottoscrizione di Azure esistente
È necessario un account utente di Azure con una sottoscrizione attiva. Crearne una gratuitamente.
Prerequisiti
- Node.js LTS 18+ e npm installati nel computer locale. La versione dell'ambiente di sviluppo locale di Node.js deve corrispondere a una delle versioni di runtime cloud per le funzioni di Azure disponibili.
- Visual Studio Code installato nel computer locale.
- Estensione della funzione di Azure v1.10.4 o successiva.
- Funzioni di Azure Core Tools v4.0.5095 o versione successiva
- Azure Cloud Shell o l'interfaccia della riga di comando di Azure installata nel computer locale.
Architettura dell'applicazione
L'app fornisce gli endpoint API seguenti.
metodo | URL | Descrizione |
---|---|---|
POST, DELETE | http://localhost:7071/api/resourcegroup | Aggiungere o eliminare un gruppo di risorse. Durante l'aggiunta, includere tag (coppie chiave/valore) per identificare lo scopo del gruppo in un secondo momento. |
GET | http://localhost:7071/api/resourcegroups | Elencare tutti i gruppi di risorse nella sottoscrizione. |
GET | http://localhost:7071/api/resources | Elencare tutte le risorse in una sottoscrizione o in un gruppo di risorse. |
Anche se questi endpoint sono pubblici, è consigliabile proteggere gli endpoint API con autenticazione e autorizzazione prima della distribuzione nell'ambiente live.
Questa app è limitata a una sottoscrizione perché è l'ambito specificato durante la creazione dell'entità servizio.
1. Preparazione dell'ambiente
È necessario preparare gli ambienti locali e cloud per usare Azure Identity SDK.
Accedere all'interfaccia della riga di comando di Azure
In un terminale bash accedere all'interfaccia della riga di comando di Azure con il comando seguente:
az login
Ottenere l'ID della sottoscrizione di Azure
In un terminale bash ottenere le sottoscrizioni e trovare l'ID sottoscrizione da usare. La query seguente restituisce l'ID sottoscrizione, il nome della sottoscrizione e l'ID tenant ordinati in base al nome della sottoscrizione.
az account list --query "sort_by([].{Name:name, SubscriptionId:id, TenantId:tenantId}, &Name)" --output table
Copiare l'ID sottoscrizione nel file temporaneo precedente. Questa impostazione sarà necessaria in un secondo momento.
Creare un'entità servizio di Azure
Un'entità servizio di Azure consente l'accesso ad Azure senza dover usare le credenziali utente personali. Per questa esercitazione, l'entità servizio può essere usata sia negli ambienti locali che nel cloud. In un ambiente aziendale è necessario separare le entità servizio per ogni ambiente.
Determinare un formato di nome dell'entità servizio in modo da trovare facilmente l'entità servizio in un secondo momento. Ad esempio, diverse idee di formato sono:
- Il progetto e il proprietario:
resource-management-john-smith
. - Reparto e data:
IT-2021-September
- Identificatore univoco:
00000000-0000-0000-0000-000000000000
- Il progetto e il proprietario:
In un terminale bash creare l'entità servizio con az ad sp create-for-rbac. Sostituire
<SUBSCRIPTION-ID>
con l'ID della sottoscrizione.az ad sp create-for-rbac --name YOUR-SERVICE-PRINCIPAL-NAME --role Contributor --scopes /subscriptions/<SUBSCRIPTION-ID>
Copiare l'intero output in un file temporaneo. Queste impostazioni saranno necessarie in un secondo momento.
{ "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. Creare un'app per le funzioni di Azure locale in Visual Studio Code
Creare un'app per le funzioni di Azure in Visual Studio Code per gestire i gruppi di risorse di Azure.
Creare un'app per le funzioni
Usare Visual Studio Code per creare un'app per le funzioni locale.
In un terminale bash creare e modificare in una nuova directory:
mkdir my-function-app && cd my-function-app
In un terminale bash aprire Visual Studio Code:
code .
Aprire il riquadro comandi di Visual Studio Code: CTRL + MAIUSC + P.
Immetti
Azure Functions: create new project
. Usare la tabella seguente per completare le richieste:Richiesta Valore Selezionare la cartella che conterrà il progetto di funzione Selezionare la directory predefinita (corrente) Selezionare una lingua Selezionare TypeScript. Selezionare un modello di programmazione TypeScript Selezionare il modello V4 (anteprima) Selezionare un modello per la prima funzione del progetto Selezionare Trigger HTTP. Creare un nuovo trigger HTTP Immettere il nome dell'API . resourcegroups
Livello di autorizzazione Selezionare anonimo. Se si continua con questo progetto dopo questo articolo, impostare il livello di autorizzazione sulla funzione . Altre informazioni sull'autorizzazione a livello di funzione. Viene creato il boilerplate del progetto e le dipendenze vengono installate.
Aggiungere le impostazioni dell'entità servizio al file local.settings.json
Aprire il
./local.settings.json
file nella directory radice del progetto e aggiungere la sezione VALUES con le cinque variabili di ambiente seguenti.{ "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" } }
Fare riferimento alle impostazioni della sezione precedente per aggiungere i valori. Queste variabili di ambiente sono REQUIRED per il contesto per l'uso di DefaultAzureCredential.
AZURE_TENANT_ID
:tenant
dall'output dell'entità servizio precedente.AZURE_CLIENT_ID
:appId
dall'output dell'entità servizio precedente.AZURE_CLIENT_SECRET
:password
dall'output dell'entità servizio precedente.
È anche necessario impostare l'ID sottoscrizione. È necessario usare Azure SDK per la gestione delle risorse.
AZURE_SUBSCRIPTION_ID
: sottoscrizione predefinita contenente i gruppi di risorse.
Questo local.settings.json
file viene ignorato dal git locale a scopo, in modo da non eseguirne accidentalmente il commit nel codice sorgente.
Installare le dipendenze npm per Gestione delle identità e delle risorse di Azure
In un terminale Bash integrato di Visual Studio Code installare le dipendenze di Azure SDK per Gestione delle identità e delle risorse di Azure.
npm install @azure/identity @azure/arm-resources
Elencare tutti i gruppi di risorse nella sottoscrizione con JavaScript
Aprire il
./src/functions/resourcegroups.ts
file e sostituire il contenuto con quanto segue: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 });
Questo file risponde alle richieste API a
/api/resourcegroups
e restituisce un elenco di tutti i gruppi di risorse nella sottoscrizione.Creare una sottodirectory in
src
denominatalib
e creare un nuovo file nella directory denominataazure-resource-groups.ts
.Copiare il codice seguente nel
./src/lib/azure-resource-groups.ts
file :// 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 ); };
Questo file completa le operazioni seguenti:
- Ottiene l'ID sottoscrizione
- Crea il contesto DefaultAzureCredential
- Crea ResourceManagementClient necessario per usare Resource Management SDK.
- Ottiene tutti i gruppi di risorse nella sottoscrizione.
Creare un nuovo file nella
./src/lib
directory denominataenvironment-vars.ts
e copiare il codice seguente in tale file.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; };
Questo file controlla le variabili di ambiente prima di restituire l'ID sottoscrizione.
Creare un nuovo file nella
./src/lib
directory denominataerror.ts
e copiare il codice seguente in tale file.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) }; } }
Questo file restituisce un errore 500 con il messaggio di errore. Lo stack viene restituito se la
NODE_ENV
variabile non è impostata suproduction
.
Testare le funzioni locali
Nel terminale integrato di Visual Studio Code eseguire il progetto locale:
npm start
Attendere che il terminale Bash integrato visualizzi l'URL della funzione in esecuzione.
Aprire un secondo terminale Bash integrato in Visual Studio Code, CTRL + MAIUSC + 5 e usare il comando GET cURL seguente per usare l'API:
curl http://localhost:7071/api/resourcegroups
Se nella sottoscrizione sono presenti molti gruppi di risorse, è possibile inviare tramite pipe l'output a un file per una revisione più semplice.
curl http://localhost:7071/api/resourcegroups > resourcegroups.json
La risposta include
subscriptionId
e unlist
di tutti i gruppi di risorse in tale sottoscrizione.{ "subscriptionId": "ABC123", "list": [ { "id": "/subscriptions/ABC123/resourceGroups/vmagelo-cloudshell", "name": "jsmith-cloudshell", "type": "Microsoft.Resources/resourceGroups", "properties": { "provisioningState": "Succeeded" }, "location": "westeurope" }, ... REMOVED FOR BREVITY ... ] }
Risoluzione dei problemi
Se non è stato possibile completare questo articolo, vedere la tabella seguente per verificare la presenza di problemi. Se il problema non è elencato nella tabella, aprire un problema in questa pagina della documentazione.
Problema | Correzione |
---|---|
L'app non è stata avviata. | Esaminare gli errori. Assicurarsi di aver installato le dipendenze necessarie. |
L'app è stata avviata, ma non è possibile ottenere una risposta 200. | Assicurarsi che il comando curl richieda la route locale corretta. |
L'API ha restituito una risposta 200 ma non ha restituito risultati. | Usare l'estensione di Visual Studio Code per le risorse di Azure per verificare che la sottoscrizione abbia gruppi di risorse. Se non vengono visualizzati gruppi di risorse, non preoccuparti. Questa esercitazione aggiunge un'API per creare ed eliminare gruppi di risorse nella sottoscrizione. Questa API viene aggiunta dopo la prima distribuzione del codice sorgente in Azure, in modo da imparare a ridistribuire il codice. |
3. Creare un'app per le funzioni di Azure basata sul cloud
In Visual Studio Code selezionare l'icona di Azure per aprire Azure Explorer.
Selezionare l'icona + per creare una nuova app per le funzioni di Azure nel cloud di Azure.
Selezionare Crea app per le funzioni in Azure.
Immettere un nome univoco globale per la nuova app per le funzioni. Il nome deve essere univoco in tutte le funzioni di Azure. Ad esempio:
jsmith-rg-management
.Selezionare lo stesso runtime Node.js 18+ LTS selezionato al momento della creazione dell'app per le funzioni locale.
Selezionare una località geografica vicina, ad esempio Stati Uniti occidentali 3.
Attendere che la risorsa venga creata. Per informazioni dettagliate, vedere Azure : Log attività.
4. Configurare l'app per le funzioni di Azure basata sul cloud
È necessario configurare le impostazioni dell'app di Azure per connettersi all'app per le funzioni di Azure. In locale, queste impostazioni si trovano nel local.settings.json
file. Questo processo aggiunge tali valori all'app cloud.
In Visual Studio Code, in Azure Explorer, nella sezione Risorse espandere App per le funzioni e quindi selezionare l'app per le funzioni.
Fare clic con il pulsante destro del mouse su Impostazioni applicazione e scegliere Aggiungi nuova impostazione.
Aggiungere i quattro valori dell'oggetto
local.settings.json
con lo stesso nome e gli stessi valori.AZURE_TENANT_ID
:tenant
dall'output dell'entità servizio precedente.AZURE_CLIENT_ID
:appId
dall'output dell'entità servizio precedente.AZURE_CLIENT_SECRET
:password
dall'output dell'entità servizio precedente.AZURE_SUBSCRIPTION_ID
: sottoscrizione predefinita contenente i gruppi di risorse.AzureWebJobsFeatureFlags
:EnableWorkerIndexing
5. Distribuire l'app per le funzioni di Resource Manager
Distribuire un'app per le funzioni di Azure in Visual Studio Code per gestire i gruppi di risorse di Azure.
Usare l'estensione di Visual Studio Code per eseguire la distribuzione nell'ambiente host
In VS Code aprire il
local.settings.json
file in modo che sia visibile. In questo modo sarà più semplice copiare i nomi e i valori successivi.Selezionare il logo di Azure per aprire Azure Explorer, quindi in Funzioni selezionare l'icona cloud per distribuire l'app.
In alternativa, è possibile eseguire la distribuzione aprendo il riquadro comandi con CTRL + MAIUSC + p, immettendo
deploy to function app
ed eseguendo il comando Funzioni di Azure: Deploy to Function App ( Distribuisci nell'app per le funzioni).Selezionare Distribuisci nell'app per le funzioni.
Selezionare il nome dell'app per le funzioni creato nella sezione precedente.
Quando viene chiesto se si è certi di voler distribuire, selezionare Distribuisci.
Il pannello Output di VS Code per Funzioni di Azure mostra lo stato di avanzamento. Durante la distribuzione, viene distribuita l'intera applicazione Funzioni, quindi le modifiche a tutte le singole funzioni vengono distribuite contemporaneamente.
Verificare che l'app Funzioni sia disponibile con il browser
Anche se ancora in Visual Studio Code, usare lo strumento di esplorazione di Funzioni di Azure, espandere il nodo per la sottoscrizione di Azure, espandere il nodo per l'app Funzioni, quindi espandere Funzioni (sola lettura). Fare clic con il pulsante destro del mouse sul nome della funzione e scegliere Copy Function Url (Copia l'URL della funzione):
Incollare l'URL in un browser e premere INVIO per richiedere l'elenco di gruppi di risorse dall'API cloud.
6. Aggiungere API all'app per le funzioni e ridistribuire in Azure
Aggiungere le API seguenti e quindi ridistribuire l'app per le funzioni di Azure in Visual Studio Code:
- Aggiungere ed eliminare gruppi di risorse
- Elencare le risorse nel gruppo di risorse o nella sottoscrizione.
A questo punto dell'esercitazione è stata creata un'app per le funzioni locale con un'API per elencare i gruppi di risorse della sottoscrizione e l'app è stata distribuita in Azure. Gli sviluppatori di Azure possono voler creare o eliminare gruppi di risorse come parte della pipeline di automazione dei processi.
Creare l'API resourcegroup per l'app per le funzioni
Usare l'estensione di Visual Studio Code per Funzioni di Azure per aggiungere i file TypeScript all'app per le funzioni per creare ed eliminare gruppi di risorse.
Aprire il riquadro comandi di Visual Studio Code: CTRL + MAIUSC + P.
Immettere
Azure Functions: Create Function
quindi premere INVIO per avviare il processo.Usare la tabella seguente per creare l'API /api/resourcegroup :
Richiesta Valore Selezionare un modello per la funzione Trigger HTTP Specificare un nome di funzione resourcegroup
Livello di autorizzazione Selezionare anonimo. Se si continua con questo progetto, modificare il livello di autorizzazione impostando la funzione . Altre informazioni sull'autorizzazione a livello di funzione. ./src/functions/resourcegroup.ts
Aprire e sostituire l'intero file con il codice sorgente seguente.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 });
Il
./src/lib/azure-resource-groups.ts
file contiene già il codice per aggiungere ed eliminare gruppi di risorse.
Creare l'API delle risorse per l'app per le funzioni
Usare l'estensione di Visual Studio Code per Funzioni di Azure per aggiungere i file TypeScript all'app per le funzioni per elencare le risorse in un gruppo di risorse.
Aprire il riquadro comandi di Visual Studio Code: CTRL + MAIUSC + P.
Immettere
Azure Functions: Create Function
quindi premere INVIO per avviare il processo.Usare la tabella seguente per creare l'API /api/resources :
Richiesta Valore Selezionare un modello per la funzione Trigger HTTP Specificare un nome di funzione resources
Livello di autorizzazione Selezionare anonimo. Se si continua con questo progetto, modificare il livello di autorizzazione impostando la funzione . Altre informazioni sull'autorizzazione a livello di funzione. ./src/functions/resources.ts
Aprire e sostituire l'intero file con il codice sorgente seguente.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 });
Creare il
./src/lib/azure-resource.ts
file e copiare il codice seguente in esso per elencare le risorse in un gruppo di risorse.// 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 }; };
Avviare l'app per le funzioni locale e testare la nuova API
Nel terminale integrato di Visual Studio Code eseguire il progetto locale:
npm start
Attendere che il terminale Bash integrato visualizzi l'URL della funzione in esecuzione.
Usare i comandi curl seguenti in un terminale Bash integrato diverso per chiamare l'API per aggiungere un gruppo di risorse alla sottoscrizione. Modificare il nome del gruppo di risorse per usare le convenzioni di denominazione personalizzate.
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"}}'
Usare il comando curl seguente per visualizzare il nuovo gruppo di risorse elencato nella sottoscrizione.
curl http://localhost:7071/api/resource-groups
Usare il comando curl seguente per eliminare il gruppo di risorse appena aggiunto.
curl -X DELETE 'http://localhost:7071/api/resourcegroup?name=my-test-1' \ -H 'Content-Type: application/json'
Ridistribuire l'app per le funzioni con nuove API in Azure
In VS Code, eseguire la distribuzione aprendo il riquadro comandi con CTRL + MAIUSC + p, immettendo
deploy to function app
ed eseguendo il comando Funzioni di Azure: Deploy to Function App (Distribuisci nell'app per le funzioni).Selezionare l'app per le funzioni dall'elenco delle app.
Selezionare Distribuisci nella finestra popup.
Attendere il completamento della distribuzione.
Verificare le API della funzione con il browser
Usare i comandi cURL precedenti, sostituendo l'indirizzo localhost, http://localhost:7071
con il nome della risorsa della funzione di Azure, https://myfunction.azurewebsites.net
ad esempio .
7. Visualizzare ed eseguire query sui log dell'app per le funzioni
Visualizzare ed eseguire query sui log dell'app per le funzioni di Azure nella portale di Azure.
Eseguire query sui log delle funzioni di Azure
Usare il portale di Azure per visualizzare ed eseguire query sui log delle funzioni.
In VS Code selezionare il logo di Azure per aprire Azure Explorer, quindi in Funzioni fare clic con il pulsante destro del mouse sull'app per le funzioni e quindi scegliere Apri nel portale.
Verrà aperto il portale di Azure alla funzione di Azure.
Selezionare Application Insights nelle impostazioni e quindi selezionare Visualizza dati di Application Insights.
Questo collegamento consente di passare alla risorsa di metriche separata creata al momento della creazione della funzione di Azure con VS Code.
Selezionare Log nella sezione Monitoraggio. Se viene visualizzata una finestra popup Query , selezionare la X nell'angolo superiore destro del popup per chiuderla.
Nel riquadro Schema e filtro fare doppio clic sulla tabella delle tracce nella scheda Tabelle.
Viene immessa la query Kusto nella
traces
finestra di query.Modificare la query per cercare le chiamate API:
traces | where message startswith "Executing "
Selezionare Esegui.
Se il log non visualizza risultati, potrebbe verificarsi un ritardo di alcuni minuti tra la richiesta HTTP alla funzione di Azure e la disponibilità dei log in Kusto. Attendere alcuni minuti ed eseguire di nuovo la query.
Poiché una risorsa di Application Insights è stata aggiunta automaticamente quando è stata creata l'app per le funzioni di Azure, non è necessario eseguire alcuna operazione aggiuntiva per ottenere queste informazioni di registrazione:
- L'app per le funzioni ha aggiunto Application Insights.
- Lo strumento Query è incluso nella portale di Azure.
- È possibile selezionare
traces
invece di dover imparare a scrivere una query Kusto per ottenere anche le informazioni minime dai log.
8. Pulire le risorse di Azure
Eliminare il gruppo di risorse
In VS Code selezionare il logo di Azure per aprire Azure Explorer, quindi in Funzioni fare clic con il pulsante destro del mouse sull'app per le funzioni e quindi scegliere Apri nel portale. Verrà aperto il portale di Azure alla funzione di Azure.
Nella sezione Panoramica trovare e selezionare il nome del gruppo di risorse. Questa azione consente di accedere al gruppo di risorse nel portale di Azure.
La pagina del gruppo di risorse elenca tutte le risorse associate a questa esercitazione.
Selezionare Elimina gruppo di risorse nel menu in alto.
Nel menu laterale immettere il nome del gruppo di risorse e quindi selezionare Elimina.
Eliminare l'entità servizio
Per eliminare l'entità servizio, eseguire il comando seguente. Sostituire <YOUR-SERVICE-PRINCIPAL-NAME>
con il nome dell'entità servizio.
az ad sp delete --id <YOUR-SERVICE-PRINCIPAL-NAME>
Codice di esempio
Considerazioni sulla sicurezza
Questa soluzione, come esercitazione per principianti, non illustra procedure sicure per impostazione predefinita. Questo è intenzionale per consentire la corretta distribuzione della soluzione. Il passaggio successivo dopo la corretta distribuzione consiste nel proteggere le risorse. Questa soluzione usa tre servizi di Azure, ognuno ha le proprie funzionalità di sicurezza e considerazioni per la configurazione sicura per impostazione predefinita:
- Funzioni di Azure - Protezione delle Funzioni di Azure
- Archiviazione di Azure - Raccomandazioni sulla sicurezza per l'archiviazione BLOB
- Servizi cognitivi di Azure - Funzionalità di sicurezza dei servizi di intelligenza artificiale di Azure