Gestire i gruppi di risorse di Azure con l'API per le funzioni TypeScript

  • Articolo

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

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

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

  1. 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

  2. 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.

  1. 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

  2. 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>

  3. 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.

  1. In un terminale bash creare e modificare in una nuova directory:

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

  2. In un terminale bash aprire Visual Studio Code:

    code .

  3. Aprire il riquadro comandi di Visual Studio Code: CTRL + MAIUSC + P.

  4. 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

  1. 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"
  }
}

  2. 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.

  3. È 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

  1. 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.

  2. Creare una sottodirectory in src denominata lib e creare un nuovo file nella directory denominata azure-resource-groups.ts.

  3. 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.

  4. Creare un nuovo file nella ./src/lib directory denominata environment-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.

  5. Creare un nuovo file nella ./src/lib directory denominata error.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 su production.

Testare le funzioni locali

  1. Nel terminale integrato di Visual Studio Code eseguire il progetto locale:

    npm start

  2. Attendere che il terminale Bash integrato visualizzi l'URL della funzione in esecuzione.

    Screenshot parziale del terminale Bash integrato di Visual Studio Code quando la funzione di Azure è in esecuzione in locale e visualizza l'URL locale per le API nell'app per le funzioni.

  3. 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

  4. La risposta include subscriptionId e un list 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

  1. In Visual Studio Code selezionare l'icona di Azure per aprire Azure Explorer.

  2. Selezionare l'icona + per creare una nuova app per le funzioni di Azure nel cloud di Azure.

    Screenshot di Azure Explorer di Visual Studio Code con l'icona dell'app per le funzioni di Azure evidenziata.

  3. Selezionare Crea app per le funzioni in Azure.

  4. 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.

  5. Selezionare lo stesso runtime Node.js 18+ LTS selezionato al momento della creazione dell'app per le funzioni locale.

  6. Selezionare una località geografica vicina, ad esempio Stati Uniti occidentali 3.

  7. Attendere che la risorsa venga creata. Per informazioni dettagliate, vedere Azure : Log attività.

    Screenshot del log attività di Azure di Visual Studio Code che mostra lo stato di creazione della risorsa.

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.

  1. In Visual Studio Code, in Azure Explorer, nella sezione Risorse espandere App per le funzioni e quindi selezionare l'app per le funzioni.

  2. Fare clic con il pulsante destro del mouse su Application Impostazioni e scegliere Aggiungi nuova impostazione.

  3. 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

Screenshot parziale di Esplora risorse di Visual Studio Code che mostra le impostazioni dell'app delle funzioni remote/cloud.

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

  1. 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.

  2. Selezionare il logo di Azure per aprire Azure Explorer, quindi in Funzioni selezionare l'icona cloud per distribuire l'app.

    Screenshot dell'area di lavoro locale di Visual Studio Code con l'icona di distribuzione cloud evidenziata.

    In alternativa, è possibile eseguire la distribuzione aprendo il riquadro comandi con CTRL + MAIUSC + p, immettendo deploy to function apped eseguendo il comando Funzioni di Azure: Deploy to Function App ( Distribuisci nell'app per le funzioni).

  3. Selezionare Distribuisci nell'app per le funzioni.

  4. Selezionare il nome dell'app per le funzioni creato nella sezione precedente.

  5. Quando viene chiesto se si è certi di voler distribuire, selezionare Distribuisci.

  6. 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

  1. 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):

    Screenshot parziale dello strumento di esplorazione di Azure di Visual Studio Code che mostra dove copiare l'URL della funzione.

  2. 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.

  1. Aprire il riquadro comandi di Visual Studio Code: CTRL + MAIUSC + P.

  2. Immettere Azure Functions: Create Function quindi premere INVIO per avviare il processo.

  3. Usare la tabella seguente per creare l'API /api/resourcegroup :

    Richiesta Valore
    Select a template for your function (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.

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

  5. 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.

  1. Aprire il riquadro comandi di Visual Studio Code: CTRL + MAIUSC + P.

  2. Immettere Azure Functions: Create Function quindi premere INVIO per avviare il processo.

  3. Usare la tabella seguente per creare l'API /api/resources :

    Richiesta Valore
    Select a template for your function (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.

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

  5. 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

  1. Nel terminale integrato di Visual Studio Code eseguire il progetto locale:

    npm start

  2. Attendere che il terminale Bash integrato visualizzi l'URL della funzione in esecuzione.

    Screenshot parziale del terminale Bash integrato di Visual Studio Code quando la funzione di Azure è in esecuzione in locale e visualizza gli URL locali per le API nell'app per le funzioni.

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

  4. Usare il comando curl seguente per visualizzare il nuovo gruppo di risorse elencato nella sottoscrizione.

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

  5. 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

  1. In VS Code, eseguire la distribuzione aprendo il riquadro comandi con CTRL + MAIUSC + p, immettendo deploy to function apped eseguendo il comando Funzioni di Azure: Deploy to Function App (Distribuisci nell'app per le funzioni).

  2. Selezionare l'app per le funzioni dall'elenco delle app.

  3. Selezionare Distribuisci nella finestra popup.

  4. 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.netad 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.

  1. 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.

  2. Selezionare Application Insights nel Impostazioni e quindi selezionare Visualizza dati di Application Insights.

    Screenshot del browser che mostra le opzioni di menu. Selezionare Application Insights nel 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.

  3. Selezionare Log nella sezione Monitoraggio. Se viene visualizzata una finestra popup Query , selezionare la X nell'angolo superiore destro del popup per chiuderla.

  4. 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.

  5. Modificare la query per cercare le chiamate API:

    traces 
| where message startswith "Executing "

  6. 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.

    Screenshot del browser che mostra portale di Azure risultato della query Kusto per la tabella di traccia.

    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

  1. 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.

  2. 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.

  3. La pagina del gruppo di risorse elenca tutte le risorse associate a questa esercitazione.

  4. Selezionare Elimina gruppo di risorse nel menu in alto.

  5. 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

Passaggi successivi