Partilhar via

Gerenciar grupos de recursos do Azure com a API de função TypeScript

  • Artigo

Neste tutorial, você criará um aplicativo TypeScript Azure Function local com APIs para gerenciar grupos de recursos do Azure e implantar o aplicativo no Azure.

Características e funcionalidades:

  • Criar projeto de aplicativo TypeScript Azure Function local no Visual Studio Code
  • Criar código clichê de API de função no Visual Studio Code
  • Implantar no Azure Functions a partir do Visual Studio Code
  • Criar principal de serviço com a CLI do Azure
  • Definir configurações de aplicativos locais e remotos com o Visual Studio Code
  • Use DefaultAzureCredential em ambientes locais e remotos para conexões sem senha
  • Usar o Azure Identity e os SDKs de Gerenciamento de Recursos do Azure para gerenciar recursos do Azure
  • Use suas APIs locais e na nuvem para criar, excluir e listar grupos de recursos em sua assinatura

Aviso

Este tutorial destina-se a uma adoção rápida e, como tal, não segue os requisitos de segurança por padrão. Para entender mais sobre esse cenário com uma meta de segurança por padrão, vá para Considerações de segurança.

Enquanto o código-fonte é escrito com TypeScript, o código-fonte é simples. Se você estiver confortável com JavaScript moderno usando async/await, o código será familiar para você.

Pré-requisitos

Arquitetura da aplicação

O aplicativo fornece os seguintes pontos de extremidade de API.

Método URL Description
POSTAR,EXCLUIR http://localhost:7071/api/resourcegroup Adicionar ou excluir um grupo de recursos. Ao adicionar, inclua tags (pares chave/valor) para identificar a finalidade do grupo posteriormente.
GET http://localhost:7071/api/resourcegroups Liste todos os grupos de recursos na assinatura.
GET http://localhost:7071/api/resources Liste todos os recursos em uma assinatura ou grupo de recursos.

Embora esses pontos de extremidade sejam públicos, você deve proteger seus pontos de extremidade de API com autenticação e autorização antes de implantar em seu ambiente ativo.

Este aplicativo é limitado a uma assinatura porque esse é o escopo especificado ao criar a entidade de serviço.

1. Preparando seu ambiente

Você deve preparar seus ambientes locais e de nuvem para usar o SDK do Azure Identity.

Iniciar sessão na CLI do Azure

Em um terminal bash, entre na CLI do Azure com o seguinte comando:

az login

Obter a sua ID de subscrição do Azure

  1. Num terminal bash, obtenha as suas subscrições e encontre o ID de subscrição que pretende utilizar. A consulta a seguir retorna a ID da assinatura, o nome da assinatura e a ID do locatário classificados por nome da assinatura.

    az account list --query "sort_by([].{Name:name, SubscriptionId:id, TenantId:tenantId}, &Name)" --output table

  2. Copie o ID da assinatura para o arquivo temporário anterior. Você precisará dessa configuração mais tarde.

Criar um principal de serviço do Azure

Uma entidade de serviço do Azure fornece acesso ao Azure sem ter de utilizar as suas credenciais de utilizador pessoais. Para este tutorial, a entidade de serviço pode ser usada em seus ambientes locais e de nuvem. Em um ambiente corporativo, você desejaria entidades de serviço separadas para cada ambiente.

  1. Determine um formato de nome da entidade de serviço para que você possa encontrar facilmente a entidade de serviço mais tarde. Por exemplo, várias ideias de formato são:

    • Seu projeto e proprietário: resource-management-john-smith.
    • O seu departamento e data: IT-2021-September

  2. Em um terminal bash, crie sua entidade de serviço com az ad sp create-for-rbac. Substitua <SUBSCRIPTION-ID> pelo seu ID de subscrição.

    az ad sp create-for-rbac --name YOUR-SERVICE-PRINCIPAL-NAME --role Contributor --scopes /subscriptions/<SUBSCRIPTION-ID>

  3. Copie todos os resultados de saída para um arquivo temporário. Você precisará dessas configurações mais tarde.

    {
  "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. Criar aplicativo Azure Function local no Visual Studio Code

Crie um aplicativo Azure Function no Visual Studio Code para gerenciar grupos de recursos do Azure.

Criar a aplicação de funções

Use o Visual Studio Code para criar um aplicativo de função local.

  1. Em um terminal bash, crie e mude para um novo diretório:

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

  2. Em um terminal bash, abra o Visual Studio Code:

    code .

  3. Abra a paleta de comandos Código do Visual Studio: Ctrl + Shift + p.

  4. Introduzir Azure Functions: create new project. Use a tabela a seguir para concluir os prompts:

    Pedido Value
    Selecione a pasta que conterá seu projeto de função Selecione o diretório padrão (atual)
    Escolha um idioma Selecione TypeScript.
    Selecione um modelo de programação TypeScript Selecionar Modelo V4 (Pré-visualização)
    Selecione um modelo para a primeira função do seu projeto Selecione Acionador HTTP.
    Criar novo gatilho HTTP Digite o nome da API de resourcegroups.
    Nível de autorização Selecione anônimo. Se você continuar com este projeto após este artigo, altere o nível de autorização para a função. Saiba mais sobre a autorização no nível da função.

    O clichê do projeto é criado e as dependências são instaladas.

Adicionar configurações da entidade de serviço ao local.settings.json arquivo

  1. Abra o ./local.settings.json arquivo no diretório raiz do projeto e adicione sua seção VALUES com as cinco variáveis de ambiente a seguir.

    {
  "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. Consulte as configurações da seção anterior para adicionar os valores. Essas variáveis de ambiente são NECESSÁRIAS para que o contexto use DefaultAzureCredential.

    • AZURE_TENANT_ID: tenant da saída do principal de serviço acima.
    • AZURE_CLIENT_ID: appId da saída do principal de serviço acima.
    • AZURE_CLIENT_SECRET: password da saída do principal de serviço acima.

  3. Você também precisa definir o ID da assinatura. É necessário usar o SDK do Azure para gerenciamento de recursos.

    • AZURE_SUBSCRIPTION_ID: Sua assinatura padrão que contém seus grupos de recursos.

Este local.settings.json arquivo é ignorado pelo seu git local de propósito para que você não o confirme acidentalmente em seu código-fonte.

Instalar dependências npm para gerenciamento de Identidade e Recursos do Azure

Em um terminal bash integrado do Visual Studio Code, instale as dependências do SDK do Azure para gerenciamento de Identidade e Recursos do Azure.

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

Listar todos os grupos de recursos em assinatura com JavaScript

  1. Abra o ./src/functions/resourcegroups.ts arquivo e substitua o conteúdo pelo seguinte:

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

    Esse arquivo responde às solicitações de API e /api/resourcegroups retorna uma lista de todos os grupos de recursos na assinatura.

  2. Crie um subdiretório em src nomeado lib e crie um novo arquivo nesse diretório chamado azure-resource-groups.ts.

  3. Copie o seguinte código para o ./src/lib/azure-resource-groups.ts arquivo:

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

    Este ficheiro completa o seguinte:

    • Obtém o ID da subscrição
    • Cria o contexto DefaultAzureCredential
    • Cria o ResourceManagementClient necessário para usar o SDK de gerenciamento de recursos.
    • Obtém todos os grupos de recursos na assinatura.

  4. Crie um novo arquivo no ./src/lib diretório chamado environment-vars.ts e copie o código a seguir para esse arquivo.

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

    Esse arquivo verifica as variáveis de ambiente antes de retornar a ID da assinatura.

  5. Crie um novo arquivo no ./src/lib diretório chamado error.ts e copie o código a seguir para esse arquivo.

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

    Esse arquivo retorna um erro 500 com a mensagem de erro. A pilha será retornada se a NODE_ENV variável não estiver definida como production.

Testar funções locais

  1. No terminal integrado do Visual Studio Code, execute o projeto local:

    npm start

  2. Aguarde até que o terminal bash integrado exiba o URL da função em execução.

    Captura de tela parcial do terminal bash integrado do Visual Studio Code quando a Função do Azure está sendo executada localmente e exibindo a URL local para as APIs no aplicativo Função.

  3. Abra um segundo terminal bash integrado no Visual Studio Code, Ctrl + Shift + 5, e use o seguinte comando GET cURL para usar a API:

    curl http://localhost:7071/api/resourcegroups

    Se você tiver muitos grupos de recursos em sua assinatura, convém canalizar a saída para um arquivo para facilitar a revisão.

    curl http://localhost:7071/api/resourcegroups > resourcegroups.json

  4. A resposta inclui subscriptionId e um list de todos os grupos de recursos nessa assinatura.

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

Resolução de Problemas

Se você não conseguiu concluir este artigo, verifique a tabela a seguir para problemas. Se o problema não estiver listado na tabela, abra um problema nesta página de documentação.

Problema Correção
O aplicativo não foi iniciado. Analise os erros. Certifique-se de que instalou as dependências necessárias.
O aplicativo foi iniciado, mas você não pode obter uma resposta 200. Certifique-se de que seu comando curl está solicitando a rota local correta.
A API retornou uma resposta 200, mas não retornou nenhum resultado. Use a extensão de código do Visual Studio para Recursos do Azure para verificar se sua assinatura tem grupos de recursos. Se você não vir nenhum grupo de recursos, não se preocupe. Este tutorial adiciona uma API para criar e excluir grupos de recursos em sua assinatura. Essa API é adicionada após a primeira implantação do código-fonte no Azure, para que você aprenda a reimplantar seu código.

3. Criar aplicativo Azure Function baseado em nuvem

  1. No Visual Studio Code, selecione o ícone do Azure para abrir o Azure Explorer.

  2. Selecione o + ícone para criar um novo aplicativo Azure Function na nuvem do Azure.

    Captura de ecrã do Azure Explorer do Visual Studio Code com o ícone da aplicação Azure Function realçado.

  3. Selecione Criar aplicativo de função no Azure.

  4. Insira um nome globalmente exclusivo para o novo aplicativo de função. O nome deve ser exclusivo em todas as funções do Azure. Por exemplo, jsmith-rg-management.

  5. Selecione o mesmo tempo de execução Node.js 18+ LTS que você selecionou quando criou seu aplicativo de função local.

  6. Selecione uma localização geográfica perto de você, como West US 3.

  7. Aguarde até que o recurso seja criado. Você pode assistir ao Azure: Activity Log para obter detalhes.

    Captura de tela do log de atividades do Azure do Visual Studio Code mostrando o status de criação do recurso.

4. Configurar o aplicativo Azure Function baseado em nuvem

Você precisa definir as configurações do aplicativo do Azure para se conectar ao aplicativo Azure Function. Localmente, essas configurações estão no seu local.settings.json arquivo. Esse processo adiciona esses valores ao seu aplicativo na nuvem.

  1. No Visual Studio Code, no explorador do Azure, na secção Recursos , expanda Function App e, em seguida, selecione a sua aplicação de função.

  2. Clique com o botão direito do mouse em Configurações do aplicativo e selecione Adicionar nova configuração.

  3. Adicione os quatro valores do seu local.settings.json com exatamente o mesmo nome e valores.

    • AZURE_TENANT_ID: tenant da saída do principal de serviço acima.
    • AZURE_CLIENT_ID: appId da saída do principal de serviço acima.
    • AZURE_CLIENT_SECRET: password da saída do principal de serviço acima.
    • AZURE_SUBSCRIPTION_ID: Sua assinatura padrão que contém seus grupos de recursos.
    • AzureWebJobsFeatureFlags:EnableWorkerIndexing

Captura de tela parcial do explorador do Azure do Visual Studio Code mostrando as configurações do aplicativo da função remota/nuvem.

5. Implantar o aplicativo de função Gerenciador de Recursos

Implante um aplicativo do Azure Function no Visual Studio Code para gerenciar grupos de recursos do Azure.

Use a extensão Visual Studio Code para implantar no ambiente de hospedagem

  1. No VS Code, abra o local.settings.json arquivo para que ele fique visível. Isso facilitará as próximas etapas de cópia desses nomes e valores.

  2. Selecione o logotipo do Azure para abrir o Azure Explorer e, em Funções, selecione o ícone de nuvem para implantar seu aplicativo.

    Captura de tela da área de espaço de trabalho local do Visual Studio Code com o ícone de implantação de nuvem realçado.

    Como alternativa, você pode implantar abrindo a Paleta de Comandos com Ctrl + Shift + p, inserindo deploy to function appe executando o comando Azure Functions: Deploy to Function App.

  3. Selecione Implantar no aplicativo Função.

  4. Selecione o nome do aplicativo de função que você criou na seção anterior.

  5. Quando perguntado se você tem certeza de que deseja implantar, selecione Implantar.

  6. O painel Saída do VS Code para o Azure Functions mostra o progresso. Durante a implantação, todo o aplicativo Functions é implantado, portanto, as alterações em todas as funções individuais são implantadas de uma só vez.

Verifique se o aplicativo Funções está disponível com o navegador

  1. Ainda no Visual Studio Code, use o explorador do Azure Functions, expanda o nó da sua assinatura do Azure, expanda o nó do aplicativo Functions e expanda Functions (somente leitura). Clique com o botão direito do mouse no nome da função e selecione Copiar URL da função:

    Captura de tela parcial do explorador do Azure do Visual Studio Code mostrando onde copiar a URL da Função.

  2. Cole o URL em um navegador e pressione Enter para solicitar a lista de grupos de recursos da API na nuvem.

6. Adicionar APIs ao aplicativo funcional e reimplantar no Azure

Adicione as seguintes APIs e reimplante seu aplicativo Azure Function no Visual Studio Code:

  • Adicionar e excluir grupos de recursos
  • Listar recursos no grupo de recursos ou assinatura.

Neste ponto do tutorial, você criou um aplicativo de função local com uma API para listar os grupos de recursos da sua assinatura e implantou esse aplicativo no Azure. Como desenvolvedor do Azure, talvez você queira criar ou excluir grupos de recursos como parte do pipeline de automação de processos.

Criar API de grupo de recursos para seu aplicativo de função

Use a extensão de código do Visual Studio para Azure Functions para adicionar os arquivos TypeScript ao seu aplicativo de função para criar e excluir grupos de recursos.

  1. Abra a paleta de comandos Código do Visual Studio: Ctrl + Shift + p.

  2. Enter Azure Functions: Create Function e pressione enter para iniciar o processo.

  3. Use a tabela a seguir para criar a API /api/resourcegroup :

    Pedido Value
    Selecione um modelo para a sua função Acionador HTTP
    Fornecer um nome de função resourcegroup
    Nível de autorização Selecione anônimo. Se você continuar com este projeto, altere o nível de autorização para a função. Saiba mais sobre a autorização no nível da função.

  4. Abra o e substitua ./src/functions/resourcegroup.ts todo o arquivo pelo seguinte código-fonte.

    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. O ./src/lib/azure-resource-groups.ts arquivo já contém o código para adicionar e excluir grupos de recursos.

Criar API de recursos para seu aplicativo de função

Use a extensão de código do Visual Studio para Azure Functions para adicionar os arquivos TypeScript ao seu aplicativo de função para listar recursos em um grupo de recursos.

  1. Abra a paleta de comandos Código do Visual Studio: Ctrl + Shift + p.

  2. Enter Azure Functions: Create Function e pressione enter para iniciar o processo.

  3. Use a tabela a seguir para criar a API /api/resources :

    Pedido Value
    Selecione um modelo para a sua função Acionador HTTP
    Fornecer um nome de função resources
    Nível de autorização Selecione anônimo. Se você continuar com este projeto, altere o nível de autorização para a função. Saiba mais sobre a autorização no nível da função.

  4. Abra o e substitua ./src/functions/resources.ts todo o arquivo pelo seguinte código-fonte.

    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. Crie o ./src/lib/azure-resource.ts arquivo e copie o código a seguir para listar os recursos em um grupo de recursos.

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

Inicie seu aplicativo de função local e teste a nova API

  1. No terminal integrado do Visual Studio Code, execute o projeto local:

    npm start

  2. Aguarde até que o terminal bash integrado exiba o URL da função em execução.

    Captura de tela parcial do terminal bash integrado do Visual Studio Code quando a Função do Azure está sendo executada localmente e exibindo as URLs locais para as APIs no aplicativo Função.

  3. Use os seguintes comandos curl em um terminal bash integrado diferente, para chamar sua API, para adicionar um grupo de recursos à sua assinatura. Altere o nome do grupo de recursos para usar suas próprias convenções de nomenclatura.

    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. Use o seguinte comando curl para ver o novo grupo de recursos listado em sua assinatura.

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

  5. Use o seguinte comando curl para excluir o grupo de recursos que você acabou de adicionar.

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

Reimplantar seu aplicativo de função com novas APIs no Azure

  1. No VS Code, implante abrindo a Paleta de Comandos com Ctrl + Shift + p, inserindo deploy to function appe executando o comando Azure Functions: Deploy to Function App.

  2. Selecione seu aplicativo de função na lista de aplicativos.

  3. Selecione Implantar na janela pop-up.

  4. Aguarde até que a implantação seja concluída.

Verificar APIs de função com o navegador

Use os comandos cURL anteriores, substituindo o endereço localhost, pelo nome do recurso da Função do Azure, http://localhost:7071 como https://myfunction.azurewebsites.net.

7. Visualize e consulte os logs do aplicativo Function

Exiba e consulte os logs do aplicativo Azure Function no portal do Azure.

Consultar seus logs do Azure Function

Use o portal do Azure para exibir e consultar seus logs de função.

  1. No VS Code, selecione o logótipo do Azure para abrir o Azure Explorer e, em Funções, clique com o botão direito do rato na sua aplicação de função e, em seguida, selecione Abrir no Portal.

    Isso abre o portal do Azure para sua Função do Azure.

  2. Selecione Application Insights nas Configurações e, em seguida, selecione Exibir dados do Application Insights.

    Captura de tela do navegador mostrando as opções de menu. Selecione Application Insights nas Configurações e, em seguida, selecione Exibir dados do Application Insights.

    Este link leva você ao seu recurso de métricas separado criado para você quando você criou sua Função do Azure com o VS Code.

  3. Selecione Logs na seção Monitoramento . Se aparecer uma janela pop-up Consultas , selecione o X no canto superior direito do pop-up para fechá-la.

  4. No painel Esquema e Filtro, na guia Tabelas, clique duas vezes na tabela de rastreamentos.

    Isso insere a consulta Kusto, traces na janela de consulta.

  5. Edite a consulta para procurar chamadas de API:

    traces 
| where message startswith "Executing "

  6. Selecione Executar.

    Se o log não exibir nenhum resultado, pode ser porque há um atraso de alguns minutos entre a solicitação HTTP para a Função do Azure e a disponibilidade do log no Kusto. Aguarde alguns minutos e execute a consulta novamente.

    Captura de tela do navegador mostrando o resultado da consulta Kusto do portal do Azure para a tabela Rastreamento.

    Como um recurso do Application Insights foi adicionado para você quando você criou o aplicativo Azure Function, não foi necessário fazer nada a mais para obter essas informações de log:

    • O aplicativo Function adicionou o Application Insights para você.
    • A ferramenta Consulta está incluída no portal do Azure.
    • Você pode selecionar traces em vez de ter que aprender a escrever uma consulta Kusto para obter até mesmo as informações mínimas de seus logs.

8. Limpar recursos do Azure

Eliminar o grupo de recursos

  1. No VS Code, selecione o logótipo do Azure para abrir o Azure Explorer e, em Funções, clique com o botão direito do rato na sua aplicação de função e, em seguida, selecione Abrir no Portal. Isso abre o portal do Azure para sua Função do Azure.

  2. Na seção Visão geral, localize e selecione o nome do grupo de recursos. Esta ação leva você ao grupo de recursos no portal do Azure.

  3. A página do grupo de recursos lista todos os recursos associados a este tutorial.

  4. No menu superior, selecione Excluir grupo de recursos.

  5. No menu lateral, digite o nome do grupo de recursos e selecione Excluir.

Excluir a entidade de serviço

Para excluir a entidade de serviço, execute o seguinte comando. Substitua <YOUR-SERVICE-PRINCIPAL-NAME> pelo nome da entidade de serviço.

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

Código de exemplo

Considerações de segurança

Esta solução, como um tutorial para iniciantes, não demonstra práticas seguras por padrão. Isso é intencional para permitir que você seja bem-sucedido na implantação da solução. A próxima etapa após essa implantação bem-sucedida é proteger os recursos. Esta solução usa três serviços do Azure, cada um com seus próprios recursos de segurança e considerações para configuração segura por padrão:

Próximos passos