Tutorial: Criar um aplicativo de função que se conecta aos serviços do Azure usando identidades em vez de segredos

Este tutorial mostra como configurar um aplicativo de função usando identidades do Microsoft Entra em vez de segredos ou cadeias de conexão, sempre que possível. O uso de identidades ajuda a evitar o vazamento acidental de segredos confidenciais e pode fornecer melhor visibilidade sobre como os dados são acessados. Para saber mais sobre conexões baseadas em identidade, consulte Configurar uma conexão baseada em identidade.

Embora os procedimentos mostrados funcionem geralmente para todos os idiomas, este tutorial atualmente oferece suporte a funções de biblioteca de classes C# no Windows especificamente.

Neste tutorial, irá aprender a:

Depois de concluir este tutorial, você deve concluir o tutorial de acompanhamento que mostra como [usar conexões baseadas em identidade em vez de segredos com gatilhos e associações].

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.

• O SDK do .NET 6.0

• As Ferramentas Principais do Azure Functions versão 4.x.

Porquê usar a identidade?

Gerenciar segredos e credenciais é um desafio comum para equipes de todos os tamanhos. Os segredos precisam ser protegidos contra roubo ou divulgação acidental, e podem precisar ser alternados periodicamente. Muitos serviços do Azure permitem que você use uma identidade na ID do Microsoft Entra para autenticar clientes e verificar as permissões, que podem ser modificadas e revogadas rapidamente. Isso permite um maior controle sobre a segurança do aplicativo com menos sobrecarga operacional. Uma identidade pode ser um usuário humano, como o desenvolvedor de um aplicativo, ou um aplicativo em execução no Azure com uma identidade gerenciada.

Como alguns serviços não oferecem suporte à autenticação do Microsoft Entra, seus aplicativos ainda podem exigir segredos em certos casos. No entanto, esses segredos podem ser armazenados no Cofre da Chave do Azure, o que ajuda a simplificar o ciclo de vida de gerenciamento de seus segredos. O acesso a um cofre de chaves também é controlado com identidades.

Ao entender como usar identidades em vez de segredos quando pode, e usar o Cofre de Chaves quando não pode, você reduz o risco, diminui a sobrecarga operacional e, geralmente, melhora a postura de segurança para seus aplicativos.

Crie um aplicativo de função que use o Cofre de Chaves para os segredos necessários

Os Arquivos do Azure são um exemplo de um serviço que ainda não oferece suporte à autenticação do Microsoft Entra para compartilhamentos de arquivos SMB (Server Message Block). O Azure Files é o sistema de arquivos padrão para implantações do Windows nos planos Premium e de Consumo. Embora possamos remover totalmente os Arquivos do Azure, isso introduz limitações que você pode não querer. Em vez disso, você move a cadeia de conexão Arquivos do Azure para o Cofre da Chave do Azure. Dessa forma, ele é gerenciado centralmente, com acesso controlado pela identidade.

Criar um Azure Key Vault

Primeiro você precisa de um cofre de chaves para armazenar segredos. Você o configura para usar o RBAC (controle de acesso baseado em função) do Azure para determinar quem pode ler segredos do cofre.

1. No portal do Azure, escolha Criar um recurso (+).

2. Na página Criar um recurso, selecione Cofre da Chave de Segurança>.

3. Na página Noções básicas, use a tabela a seguir para configurar o cofre de chaves.

   Opção	Valor sugerido	Description
   Subscrição	a sua subscrição	Subscrição ao abrigo da qual esta nova aplicação funcional é criada.
   Grupo de Recursos	myResourceGroup	Nome para o novo grupo de recursos onde você cria seu aplicativo de função.
   Nome do cofre da chave	Nome globalmente exclusivo	Nome que identifica o seu novo cofre de chaves. O nome do cofre deve conter apenas caracteres alfanuméricos e traços e não pode começar com um número.
   Escalão de Preço	Standard	Opções de faturação. Padrão é suficiente para este tutorial.
   Região	Região preferida	Escolha uma região perto de si ou perto de outros serviços a que as suas funções acedam.

   Use as seleções padrão para as seções "Opções de recuperação".

4. Anote o nome que você usou, para usar mais tarde.

5. Selecione Avançar: Política de Acesso para navegar até a guia Política de Acesso .

6. Em Modelo de permissão, escolha Controle de acesso baseado em função do Azure

7. Selecione Rever + criar. Reveja a configuração e, em seguida, selecione Criar.

Configurar uma identidade e permissões para o aplicativo

Para usar o Cofre da Chave do Azure, seu aplicativo precisa ter uma identidade que possa receber permissão para ler segredos. Este aplicativo usa uma identidade atribuída pelo usuário para que as permissões possam ser configuradas antes mesmo de o aplicativo ser criado. Para obter mais informações sobre identidades gerenciadas para o Azure Functions, consulte Como usar identidades gerenciadas no Azure Functions.

1. No portal do Azure, escolha Criar um recurso (+).

2. Na página Criar um recurso, selecione Identidade Gerenciada Atribuída pelo Usuário de Identidade>.

3. Na página Noções básicas, use a tabela a seguir para configurar a identidade.

   Opção	Valor sugerido	Description
   Subscrição	a sua subscrição	Subscrição ao abrigo da qual esta nova aplicação funcional é criada.
   Grupo de Recursos	myResourceGroup	Nome para o novo grupo de recursos onde você cria seu aplicativo de função.
   Região	Região preferida	Escolha uma região perto de si ou perto de outros serviços a que as suas funções acedam.
   Nome	Nome globalmente exclusivo	Nome que identifica sua nova identidade atribuída pelo usuário.

4. Selecione Rever + criar. Reveja a configuração e, em seguida, selecione Criar.

5. Quando a identidade for criada, navegue até ela no portal. Selecione Propriedades e anote a ID do recurso para uso posterior.

6. Selecione Atribuições de Função do Azure e selecione Adicionar atribuição de função (Visualização).

7. Na página Adicionar atribuição de função (Visualização), use as opções conforme mostrado na tabela a seguir.

   Opção	Valor sugerido	Description
   Scope	Key Vault	Escopo é um conjunto de recursos ao qual a atribuição de função se aplica. O escopo tem níveis que são herdados em níveis mais baixos. Por exemplo, se você selecionar um escopo de assinatura, a atribuição de função se aplicará a todos os grupos de recursos e recursos na assinatura.
   Subscrição	a sua subscrição	Subscrição ao abrigo da qual esta nova aplicação funcional é criada.
   Recurso	O seu cofre de chaves	O cofre de chaves criado anteriormente.
   Função	Usuário do Key Vault Secrets	Uma função é uma coleção de permissões que estão sendo concedidas. Key Vault Secrets O usuário dá permissão para que a identidade leia valores secretos do vault.

8. Selecione Guardar. Pode levar um ou dois minutos para que a função apareça quando você atualizar a lista de atribuições de função para a identidade.

A identidade agora é capaz de ler segredos armazenados no cofre de chaves. Mais adiante no tutorial, você adiciona atribuições de função adicionais para finalidades diferentes.

Gerar um modelo para criar um aplicativo de função

Como a experiência do portal para criar um aplicativo funcional não interage com o Azure Key Vault, você precisa gerar e editar um modelo do Azure Resource Manager. Em seguida, você pode usar esse modelo para criar seu aplicativo de função fazendo referência à cadeia de conexão Arquivos do Azure a partir do seu cofre de chaves.

1. No portal do Azure, escolha Criar um recurso (+).

2. Na página Criar um recurso, selecione Aplicativo de função de computação>.

3. Na página Noções básicas, use a tabela a seguir para configurar o aplicativo de função.

   Opção	Valor sugerido	Description
   Subscrição	a sua subscrição	Subscrição ao abrigo da qual esta nova aplicação funcional é criada.
   Grupo de Recursos	myResourceGroup	Nome para o novo grupo de recursos onde você cria seu aplicativo de função.
   Nome da Aplicação de Funções	Nome globalmente exclusivo	Nome que identifica a sua aplicação Function App nova. Os carateres válidos são a-z (não sensível a maiúsculas e minúsculas), 0-9 e -.
   Publicar	Código	Escolha publicar arquivos de código ou um contêiner do Docker.
   Pilha de runtime	.NET	Este tutorial usa o .NET.
   Região	Região preferida	Escolha uma região perto de si ou perto de outros serviços a que as suas funções acedam.

4. Selecione Rever + criar. Seu aplicativo usa os valores padrão na página Hospedagem e Monitoramento . Revise as opções padrão, que estão incluídas no modelo ARM que você gera.

5. Em vez de criar seu aplicativo de função aqui, escolha Baixar um modelo para automação, que fica à direita do botão Avançar .

6. Na página do modelo, selecione Implantar e, em seguida, na página Implantação personalizada, selecione Editar modelo.

   

Editar o modelo

Agora você edita o modelo para armazenar a cadeia de conexão Arquivos do Azure no Cofre da Chave e permitir que seu aplicativo de função faça referência a ele. Certifique-se de que tem os seguintes valores das secções anteriores antes de continuar:

• A ID do recurso da identidade atribuída pelo usuário
• O nome do cofre da chave

1. No editor, encontre onde a resources matriz começa. Antes da definição do aplicativo de função, adicione a seção a seguir, que coloca a cadeia de conexão Arquivos do Azure no Cofre da Chave. Substitua "VAULT_NAME" pelo nome do cofre de chaves.

   {
       "type": "Microsoft.KeyVault/vaults/secrets",
       "apiVersion": "2016-10-01",
       "name": "VAULT_NAME/azurefilesconnectionstring",
       "properties": {
           "value": "[concat('DefaultEndpointsProtocol=https;AccountName=',parameters('storageAccountName'),';AccountKey=',listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2019-06-01').keys[0].value,';EndpointSuffix=','core.windows.net')]"
       },
       "dependsOn": [
           "[concat('Microsoft.Storage/storageAccounts/', parameters('storageAccountName'))]"
       ]
   },
   

2. Na definição para o recurso de aplicativo de função (que foi type definido como Microsoft.Web/sites), adicione Microsoft.KeyVault/vaults/VAULT_NAME/secrets/azurefilesconnectionstring à dependsOn matriz. Novamente, substitua "VAULT_NAME" pelo nome do cofre de chaves. Isso impede que seu aplicativo seja criado antes que o segredo seja definido. A dependsOn matriz deve se parecer com o exemplo a seguir:

       {
           "type": "Microsoft.Web/sites",
           "apiVersion": "2018-11-01",
           "name": "[parameters('name')]",
           "location": "[parameters('location')]",
           "tags": null,
           "dependsOn": [
               "microsoft.insights/components/idcxntut",
               "Microsoft.KeyVault/vaults/VAULT_NAME/secrets/azurefilesconnectionstring",
               "[concat('Microsoft.Web/serverfarms/', parameters('hostingPlanName'))]",
               "[concat('Microsoft.Storage/storageAccounts/', parameters('storageAccountName'))]"
           ],
           // ...
       }
   

3. Adicione o identity bloco do exemplo a seguir à definição do recurso do aplicativo de função. Substitua "IDENTITY_RESOURCE_ID" pelo ID de recurso da sua identidade atribuída pelo usuário.

   {
       "apiVersion": "2018-11-01",
       "name": "[parameters('name')]",
       "type": "Microsoft.Web/sites",
       "kind": "functionapp",
       "location": "[parameters('location')]",
       "identity": {
           "type": "SystemAssigned,UserAssigned",
           "userAssignedIdentities": {
               "IDENTITY_RESOURCE_ID": {}
           }
       },
       "tags": null,
       // ...
   }
   

   Esse identity bloco também configura uma identidade atribuída ao sistema, que você usará posteriormente neste tutorial.

4. Adicione a keyVaultReferenceIdentity propriedade ao properties objeto para o aplicativo de função, como no exemplo a seguir. Substitua "IDENTITY_RESOURCE_ID" pelo ID de recurso da sua identidade atribuída pelo usuário.

   {
       // ...
        "properties": {
               "name": "[parameters('name')]",
               "keyVaultReferenceIdentity": "IDENTITY_RESOURCE_ID",
               // ...
        }
   }
   

   Você precisa dessa configuração porque um aplicativo pode ter várias identidades atribuídas pelo usuário configuradas. Sempre que quiser usar uma identidade atribuída pelo usuário, você deve especificá-la com uma ID. As identidades atribuídas ao sistema não precisam ser especificadas dessa forma, porque um aplicativo só pode ter uma. Muitos recursos que usam identidade gerenciada assumem que devem usar a identidade atribuída pelo sistema por padrão.

5. Encontre os objetos JSON que definem a configuração do WEBSITE_CONTENTAZUREFILECONNECTIONSTRING aplicativo, que deve se parecer com o exemplo a seguir:

   {
       "name": "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
       "value": "[concat('DefaultEndpointsProtocol=https;AccountName=',parameters('storageAccountName'),';AccountKey=',listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2019-06-01').keys[0].value,';EndpointSuffix=','core.windows.net')]"
   },
   

6. Substitua o value campo por uma referência ao segredo, conforme mostrado no exemplo a seguir. Substitua "VAULT_NAME" pelo nome do cofre de chaves.

   {
       "name": "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
       "value": "[concat('@Microsoft.KeyVault(SecretUri=', reference(resourceId('Microsoft.KeyVault/vaults/secrets', 'VAULT_NAME', 'azurefilesconnectionstring')).secretUri, ')')]"
   },
   

7. Selecione Salvar para salvar o modelo ARM atualizado.

Implantar o modelo modificado

1. Certifique-se de que as opções de criação, incluindo Grupo de Recursos, ainda estão corretas e selecione Rever + criar.

2. Depois que o modelo for validado, anote o Nome da sua conta de armazenamento, pois você usará essa conta mais tarde. Por fim, selecione Criar para criar seus recursos do Azure e implantar seu código no aplicativo de função.

3. Após a conclusão da implantação, selecione Ir para o grupo de recursos e, em seguida, selecione o novo aplicativo de função.

Parabéns! Você criou com êxito seu aplicativo de função para fazer referência à cadeia de conexão Arquivos do Azure do Cofre da Chave do Azure.

Sempre que seu aplicativo precisar adicionar uma referência a um segredo, você só precisará definir uma nova configuração de aplicativo apontando para o valor armazenado no Cofre da Chave. Para obter mais informações, consulte Referências do Cofre de Chaves para o Azure Functions.

Usar identidade gerenciada para AzureWebJobsStorage

Em seguida, use a identidade atribuída ao sistema que você configurou nas etapas anteriores para a AzureWebJobsStorage conexão. AzureWebJobsStorage é usado pelo tempo de execução do Functions e por vários gatilhos e ligações para coordenar entre várias instâncias em execução. É necessário para que seu aplicativo de função funcione e, como os Arquivos do Azure, é configurado com uma cadeia de conexão por padrão quando você cria um novo aplicativo de função.

Conceder à identidade atribuída pelo sistema acesso à conta de armazenamento

Semelhante às etapas que você seguiu anteriormente com a identidade atribuída pelo usuário e seu cofre de chaves, agora você cria uma atribuição de função concedendo à identidade atribuída pelo sistema acesso à sua conta de armazenamento.

1. No portal do Azure, navegue até a conta de armazenamento que foi criada com seu aplicativo de função anteriormente.

2. Selecione Controlo de Acesso (IAM). Esta página é onde você pode visualizar e configurar quem tem acesso ao recurso.

3. Selecione Adicionar e selecione adicionar atribuição de função.

4. Procure por Proprietário de Dados de Blob de Armazenamento, selecione-o e selecione Avançar

5. Na guia Membros, em Atribuir acesso a, escolha Identidade gerenciada

6. Selecione Selecionar membros para abrir o painel Selecionar identidades gerenciadas.

7. Confirme se a Subscrição é aquela na qual criou os recursos anteriormente.

8. No seletor de identidade gerenciada, escolha Aplicativo de função na categoria Identidade gerenciada atribuída pelo sistema. O rótulo Aplicativo de função pode ter um número entre parênteses ao lado, indicando o número de aplicativos na assinatura com identidades atribuídas pelo sistema.

9. Seu aplicativo deve aparecer em uma lista abaixo dos campos de entrada. Se não o vir, pode utilizar a caixa Selecionar para filtrar os resultados com o nome da sua aplicação.

10. Selecione a sua candidatura. Ele deve ser movido para baixo na seção Membros selecionados . Escolha Selecionar.

11. Na tela Adicionar atribuição de função, selecione Revisar + atribuir. Reveja a configuração e, em seguida, selecione Rever + atribuir.

Editar a configuração do AzureWebJobsStorage

Em seguida, você atualiza seu aplicativo de função para usar sua identidade atribuída pelo sistema quando ele usa o serviço de blob para armazenamento de host.

1. No portal do Azure, navegue até seu aplicativo de função.

2. Na sua aplicação de funções, expanda Definições e, em seguida, selecione Variáveis de ambiente.

3. Na guia Configurações do aplicativo , selecione a configuração do aplicativo AzureWebJobsStorage e edite-a de acordo com a tabela a seguir:

   Opção	Valor sugerido	Description
   Nome	AzureWebJobsStorage__accountName	Altere o nome de AzureWebJobsStorage para o nome AzureWebJobsStorage__accountNameexato . Essa configuração instrui o host a usar a identidade em vez de procurar um segredo armazenado. A nova configuração usa um sublinhado duplo (__), que é um caractere especial nas configurações do aplicativo.
   Valor	O nome da sua conta	Atualize o nome da cadeia de conexão para apenas o StorageAccountName.

   Essa configuração informa ao sistema para usar uma identidade para se conectar ao recurso.

4. Selecione Aplicar e, em seguida, selecione Aplicar e Confirmar para guardar as alterações e reiniciar a função da aplicação.

Agora você removeu o requisito de cadeia de conexão de armazenamento para AzureWebJobsStorage configurando seu aplicativo para, em vez disso, se conectar a blobs usando identidades gerenciadas.

Próximos passos

Este tutorial mostrou como criar um aplicativo de função sem armazenar segredos em sua configuração.

Avance para o próximo tutorial para aprender a usar identidades em conexões de gatilho e ligação.