Gerencie grupos de recursos do Azure com a API do TypeScript Function

Artigo
10/15/2024

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

Recursos e funcionalidades:

Crie um projeto local de aplicativo do TypeScript Azure Function no Visual Studio Code
Crie um código clichê da API de função no Visual Studio Code
Implante no Azure Functions usando o Visual Studio Code
Criar entidade de serviço com a CLI do Azure
Defina configurações de aplicativos locais e remotos com o Visual Studio Code
Use DefaultAzureCredential em ambientes locais e remotos para conexões sem senha
Use os SDKs do Azure Identity e do Azure Resource Management para gerenciar os recursos do Azure
Use as APIs locais e de nuvem para criar, excluir e listar grupos de recursos na assinatura

Aviso

Este tutorial destina-se à 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 segura por padrão, acesse Considerações de segurança.

Embora o código-fonte seja escrito com TypeScript, ele é simples. Se você se sente confortável com o JavaScript moderno usando async/await, o código lhe será familiar.

Pré-requisitos

Uma conta de usuário e uma assinatura do Azure: crie uma assinatura gratuita.
Node.js LTS LTS instalado em sua máquina local. A versão do ambiente de desenvolvimento local do Node.js deve corresponder a uma das versões de runtime de nuvem do Azure Function disponíveis.
Visual Studio Code instalado no computador local.
- Extensão do Azure Function v1.10.4 ou superior.
Azure Functions Core Tools v4.0.5095 ou posterior
Azure Cloud Shell ou CLI do Azure instalado em seu computador local.

Arquitetura do aplicativo

O aplicativo fornece os seguintes pontos de extremidade de API.

Método	URL	Descrição
POST,DELETE	http://localhost:7071/api/resourcegroup	Adicione ou exclua um grupo de recursos. Ao adicionar, inclua tags (pares chave/valor) para identificar a finalidade do grupo posteriormente.
GET	http://localhost:7071/api/resourcegroups	Listar todos os grupos de recursos em uma assinatura.
GET	http://localhost:7071/api/resources	Listar todos os recursos em uma assinatura ou em um grupo de recursos.

Embora esses pontos de extremidade sejam públicos nesta série de artigos, você deve proteger os pontos de extremidade de API com autenticação e autorização antes de implantá-los no seu ambiente ao vivo.

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

1. Preparando seu ambiente

Você precisa preparar seus ambientes local e de nuvem para usar o SDK de identidade do Azure.

Em um terminal bash, faça logon na CLI do Azure com o seguinte comando:

az login

Obter sua ID de assinatura do Azure

Em um terminal do Bash, obtenha suas assinaturas e encontre a ID da assinatura que você deseja usar. 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
```
Copie a ID da assinatura no arquivo temporário anterior. Você precisará dessa configuração mais tarde.

Criar uma entidade de serviço do Azure

Uma entidade de serviço do Azure fornece acesso ao Azure sem precisar usar suas credenciais pessoais do usuário. Para este tutorial, a entidade de serviço pode ser usada tanto em ambientes locais quanto em nuvem. Em um ambiente corporativo, você gostaria de entidades de serviço separadas para cada ambiente.

Determine um formato de nome de entidade de serviço para que você possa encontrar facilmente sua entidade de serviço mais tarde. Por exemplo, algumas ideias de formato são:
- O projeto e o proprietário: resource-management-john-smith.
- O departamento e a data: IT-2021-September
Em um terminal do Bash, crie a entidade de serviço com az ad sp create-for-rbac. Substitua <SUBSCRIPTION-ID> por sua ID da assinatura.
```
az ad sp create-for-rbac --name YOUR-SERVICE-PRINCIPAL-NAME --role Contributor --scopes /subscriptions/<SUBSCRIPTION-ID>
```

Copie os resultados da saída inteira 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 um aplicativo de funções do Azure local no Visual Studio Code

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

Como criar um aplicativo de função

Usar o Visual Studio Code para criar um aplicativo de funções local.

Em um terminal do Bash, crie um diretório e mude para ele:
```
mkdir my-function-app && cd my-function-app
```
Em um terminal do Bash, abra o Visual Studio Code:
```
code .
```
Abra a paleta de comandos do Visual Studio Code: Ctrl + Shift + p.

Digite Azure Functions: create new project. Use a seguinte tabela para concluir os prompts:

Prompt	Valor
Selecione a pasta que conterá o seu projeto de função	Selecione o diretório padrão (atual)
Selecionar um idioma	Selecione TypeScript.
Selecione um modelo de programação TypeScript	Selecione o modelo V4 (versão prévia)
Selecione um modelo para a primeira função do projeto	Selecione Gatilho HTTP.
Criar um gatilho HTTP	Insira o nome da API de `resourcegroups`.
Nível de autorização	Selecione anônimo. Se você continuar nesse projeto após este artigo, altere o nível de autorização para a função. Saiba mais sobre autorização em nível de função.

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

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

Abra o arquivo ./local.settings.json no diretório raiz do projeto e adicione a 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"
  }
}

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 da entidade de serviço acima.
- AZURE_CLIENT_ID: appId da saída da entidade de serviço acima.
- AZURE_CLIENT_SECRET: password da saída da entidade de serviço acima.
Você também precisa definir a 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.

Esse arquivo local.settings.json é ignorado pelo Git local propositalmente para que você não o confirme no código-fonte sem querer.

Instalar as dependências do npm para o gerenciamento de identidades e recursos do Azure

Em um terminal do Bash integrado do Visual Studio Code, instale as dependências do SDK do Azure para o gerenciamento de identidades e recursos do Azure.

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

Listar todos os grupos de recursos em uma assinatura com JavaScript

Abra o arquivo ./src/functions/resourcegroups.ts 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 /api/resourcegroups e retorna uma lista de todos os grupos de recursos na assinatura.

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

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

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

Esse arquivo conclui o seguinte:

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

Crie um arquivo no ./src/lib diretório named environment-vars.ts e copie o código a seguir nesse 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.

Crie um arquivo no ./src/lib diretório named error.ts e copie o código a seguir nesse 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 as funções locais

No terminal integrado do Visual Studio Code, execute o projeto local:
```
npm start
```
Aguarde até que o terminal do Bash integrado exiba a URL da função em execução.
Abra um segundo terminal do Bash integrado no Visual Studio Code, Ctrl + Shift + 5, e use o seguinte comando cURL GET para usar a API:
```
curl http://localhost:7071/api/resourcegroups
```
Se você tem muitos grupos de recursos na assinatura, canalize a saída para um arquivo a fim de facilitar a revisão.
```
curl http://localhost:7071/api/resourcegroups > resourcegroups.json
```

A resposta inclui subscriptionId e uma list de todos os grupos de recursos nesta 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 ...
    ]
}

Solução de problemas

Se você não conseguiu concluir este artigo, verifique os problemas na tabela a seguir. 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. Verifique se você instalou as dependências necessárias.
O aplicativo foi iniciado, mas você não consegue obter uma resposta 200.	Verifique se o comando cURL está fazendo a solicitação por meio da rota local correta.
A API retornou uma resposta 200, mas não retornou nenhum resultado.	Use a extensão do Visual Studio Code para recursos do Azure a fim de verificar se a assinatura tem algum grupo de recursos. Se não houver nenhum grupo de recursos, não se preocupe. Este tutorial adiciona uma API para criar e excluir grupos de recursos na sua assinatura. Essa API é adicionada após a primeira implantação do código-fonte no Azure, para que você aprenda como reimplantar o código.

3. Crie o aplicativo Azure Function baseado em nuvem

No Visual Studio Code, selecione o ícone do Azure para abrir o Azure Explorer.
Selecione o ícone + para criar um novo aplicativo Azure Function na nuvem do Azure.
Selecione Criar Aplicativo de Funções no Azure.
Insira um nome exclusivo globalmente para o novo aplicativo de funções. O nome precisa ser exclusivo em todas as funções do Azure. Por exemplo, jsmith-rg-management.
Selecione o mesmo runtime Node.js 18+ LTS que você selecionou ao criar seu aplicativo de funções local.
Selecione uma localização geográfica perto de você, como Oeste dos EUA 3.
Aguarde até que o recurso seja criado. Você pode assistir ao Azure: Activity Log para obter detalhes.

4. Configure o aplicativo Azure Function baseado em nuvem

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

No Visual Studio Code, no Azure Explorer, na seção Recursos, expanda o aplicativo Function e selecione seu aplicativo de funções.
Clique com o botão direito do mouse em Configurações de Aplicativo e selecione Adicionar Nova Configuração.
Adicione os quatro valores do seu local.settings.json com exatamente os mesmos nomes e valores.
- AZURE_TENANT_ID: tenant da saída da entidade de serviço acima.
- AZURE_CLIENT_ID: appId da saída da entidade de serviço acima.
- AZURE_CLIENT_SECRET: password da saída da entidade 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 Azure Explorer do Visual Studio Code mostrando as configurações do aplicativo de funções remoto/de nuvem.

5. Implante o aplicativo Function do gerenciador de recursos

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

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

No VS Code, abra o local.settings.json arquivo para que ele fique visível. Isso facilitará as próximas etapas de copiar esses nomes e valores.
Selecione o logotipo do Azure para abrir o Azure Explorer e, em Functions, selecione o ícone da nuvem para implantar seu aplicativo.

Como alternativa, você pode implantar abrindo a Paleta de Comandos com Ctrl + Shift + p, inserindo deploy to function app e executando o comando Azure Functions: fazer implantação no Aplicativo de Funções.
Selecione Implantar no aplicativo Function.
Selecione o nome do aplicativo Function criado na seção anterior.
Quando perguntado se você tem certeza de que deseja implantar, selecione Implantar.
O painel Saída do VS Code para o Azure Functions mostra o progresso. Durante a implantação, todo o aplicativo Functions é implantado, de modo que as alterações a todas as funções individuais sejam implantadas de uma só vez.

Verificar se o aplicativo de funções está disponível usando um navegador

Ainda no Visual Studio Code, use o explorador do Azure Functions, expanda o nó da sua assinatura do Azure, expanda o nó do seu 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:
Cole a URL em um navegador e pressione Enter para solicitar a lista de grupos de recursos da API de nuvem.

6. Adicionar APIs ao aplicativo de funções e fazer a reimplantação no Azure

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

Adicione e exclua grupos de recursos
Liste recursos em um grupo de recursos ou assinatura.

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

Crie API de grupo de recursos para seu aplicativo de funções

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

Abra a paleta de comandos do Visual Studio Code: Ctrl + Shift + p.
Digite Azure Functions: Create Function e pressione enter para iniciar o processo.

Use a seguinte tabela para criar a API /api/resourcegroup:

Prompt	Valor
Selecione um modelo para a função	Gatilho HTTP
Forneça um nome de função	`resourcegroup`
Nível de autorização	Selecione anônimo. Se você continuar nesse projeto, altere o nível de autorização para a função. Saiba mais sobre autorização em nível de função.

Abra o ./src/functions/resourcegroup.ts e substitua o arquivo inteiro 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
});

O arquivo ./src/lib/azure-resource-groups.ts já contém o código para adicionar e excluir grupos de recursos.

Crie a API dos recursos para seu aplicativo de funções

Utilize a extensão Visual Studio Code para o Azure Functions para adicionar os arquivos TypeScript ao seu aplicativo Function para listar recursos em um grupo de recursos.

Abra a paleta de comandos do Visual Studio Code: Ctrl + Shift + p.
Digite Azure Functions: Create Function e pressione enter para iniciar o processo.

Use a seguinte tabela para criar a API /api/resources:

Prompt	Valor
Selecione um modelo para a função	Gatilho HTTP
Forneça um nome de função	`resources`
Nível de autorização	Selecione anônimo. Se você continuar nesse projeto, altere o nível de autorização para a função. Saiba mais sobre autorização em nível de função.

Abra o ./src/functions/resources.ts e substitua o arquivo inteiro 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
});

Crie o arquivo ./src/lib/azure-resource.ts 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
  };
};

Iniciar o aplicativo de funções local e testar a nova API

No terminal integrado do Visual Studio Code, execute o projeto local:
```
npm start
```
Aguarde até que o terminal do Bash integrado exiba a URL da função em execução.

Use os comandos cURL a seguir em um terminal do Bash integrado diferente, para chamar sua API, para adicionar um grupo de recursos à sua assinatura. Altere o nome do grupo de recursos para usar as 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"}}'

Use o comando cURL a seguir para ver o novo grupo de recursos listado em sua assinatura.
```
curl http://localhost:7071/api/resource-groups
```

Use o comando cURL a seguir 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ções com novas APIs no Azure

No VS Code, implante abrindo a Paleta de Comandos com Ctrl + Shift + p, inserindo deploy to function app e executando o comando Azure Functions: Deploy to Function App.
Selecione seu aplicativo de funções na lista de aplicativos.
Selecione Implantar na janela pop-up.
Aguarde até a conclusão da implantação.

Verificar APIs de função com o navegador

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

7. Ver e consultar os logs do aplicativo de funções

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

Consultar os logs de Função do Azure

Use o portal do Azure para ver e consultar os logs de função.

No VS Code, selecione o logotipo do Azure para abrir o Azure Explorer e em Funções clique com o botão direito do mouse no aplicativo de funções e selecione Abrir no Portal.

Isso abre o portal do Azure para a Função do Azure.
Selecione Application Insights nas configurações e selecione Exibir dados do Application Insights.

Esse link direciona você para o recurso para separar métricas criado quando você criou a sua Função do Azure com o VS Code.
Selecione Logs na seção Monitoramento. Se uma janela pop-up de Consultas for exibida, selecione o X no canto superior direito para fechar.
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.

Edite a consulta para procurar chamadas à API:

traces 
| where message startswith "Executing "

Selecione Executar.

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

Como um recurso do Application Insights foi adicionado para você quando você criou o aplicativo Azure Function, você não precisou fazer nada extra para obter essas informações de log:
- O aplicativo de funções adicionou o Application Insights para você.
- A ferramenta de consulta está disponível no portal do Azure.
- Você pode selecionar traces em vez de precisar aprender a escrever uma consulta do Kusto para obter até mesmo as informações mínimas dos logs.

8. Limpar os recursos do Azure

Exclua o grupo de recursos

No VS Code, selecione o logotipo do Azure para abrir o Azure Explorer e, em Functions, clique com o botão direito do mouse no aplicativo de Functions e selecione Abrir no Portal. Isso abre o portal do Azure para seu Azure Function.
Na seção Visão geral, localize e selecione o nome do grupo de recursos. Essa ação leva você para o grupo de recursos no portal do Azure.
A página do grupo de recursos lista todos os recursos associados a este tutorial.
No menu do grupo, selecione Excluir grupo de recursos.
No menu lateral, insira o nome do grupo de recursos e selecione Excluir.

Exclua a entidade de serviço

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

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

Código de exemplo

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

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. Essa 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:

Azure Functions – Protegendo o Azure Functions
Armazenamento do Azure - Recomendações de segurança para o armazenamento de blobs

Próximas etapas

Converta texto em fala no aplicativo Express.js

Compartilhar via

Gerencie grupos de recursos do Azure com a API do TypeScript Function

Pré-requisitos

Arquitetura do aplicativo

1. Preparando seu ambiente

Obter sua ID de assinatura do Azure

Criar uma entidade de serviço do Azure

2. Criar um aplicativo de funções do Azure local no Visual Studio Code

Como criar um aplicativo de função

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

Instalar as dependências do npm para o gerenciamento de identidades e recursos do Azure

Listar todos os grupos de recursos em uma assinatura com JavaScript

Testar as funções locais

Solução de problemas

3. Crie o aplicativo Azure Function baseado em nuvem

4. Configure o aplicativo Azure Function baseado em nuvem

5. Implante o aplicativo Function do gerenciador de recursos

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

Verificar se o aplicativo de funções está disponível usando um navegador

6. Adicionar APIs ao aplicativo de funções e fazer a reimplantação no Azure

Crie API de grupo de recursos para seu aplicativo de funções

Crie a API dos recursos para seu aplicativo de funções

Iniciar o aplicativo de funções local e testar a nova API

Reimplantar seu aplicativo de funções com novas APIs no Azure

Verificar APIs de função com o navegador

7. Ver e consultar os logs do aplicativo de funções

Consultar os logs de Função do Azure

8. Limpar os recursos do Azure

Exclua o grupo de recursos

Exclua a entidade de serviço

Código de exemplo

Considerações de segurança

Próximas etapas

Comentários

Recursos adicionais

Compartilhar via

Gerencie grupos de recursos do Azure com a API do TypeScript Function

Pré-requisitos

Arquitetura do aplicativo

1. Preparando seu ambiente

Entrar na CLI do Azure

Obter sua ID de assinatura do Azure

Criar uma entidade de serviço do Azure

2. Criar um aplicativo de funções do Azure local no Visual Studio Code

Como criar um aplicativo de função

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

Instalar as dependências do npm para o gerenciamento de identidades e recursos do Azure

Listar todos os grupos de recursos em uma assinatura com JavaScript

Testar as funções locais

Solução de problemas

3. Crie o aplicativo Azure Function baseado em nuvem

4. Configure o aplicativo Azure Function baseado em nuvem

5. Implante o aplicativo Function do gerenciador de recursos

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

Verificar se o aplicativo de funções está disponível usando um navegador

6. Adicionar APIs ao aplicativo de funções e fazer a reimplantação no Azure

Crie API de grupo de recursos para seu aplicativo de funções

Crie a API dos recursos para seu aplicativo de funções

Iniciar o aplicativo de funções local e testar a nova API

Reimplantar seu aplicativo de funções com novas APIs no Azure

Verificar APIs de função com o navegador

7. Ver e consultar os logs do aplicativo de funções

Consultar os logs de Função do Azure

8. Limpar os recursos do Azure

Exclua o grupo de recursos

Exclua a entidade de serviço

Código de exemplo

Considerações de segurança

Próximas etapas

Comentários

Recursos adicionais