Partilhar via

Autenticar aplicações C++ em serviços Azure durante o desenvolvimento local usando princípios de serviço

Durante o desenvolvimento local, os aplicativos precisam se autenticar no Azure para acessar vários serviços do Azure. Duas abordagens comuns para autenticação local são usar uma conta de programador ou um principal de serviço. Este artigo explica como usar um principal de serviço de aplicação. Nas seções a seguir, você aprende:

  • Como registrar um aplicativo no Microsoft Entra para criar uma entidade de serviço
  • Como usar grupos do Microsoft Entra para gerenciar permissões com eficiência
  • Como atribuir funções às permissões de âmbito
  • Como autenticar usando um principal de serviço a partir do código da sua aplicação

O uso de entidades de serviço de aplicativo dedicadas permite que você siga o princípio de menor privilégio ao acessar recursos do Azure. As permissões são limitadas aos requisitos específicos do aplicativo durante o desenvolvimento, impedindo o acesso acidental aos recursos do Azure destinados a outros aplicativos ou serviços. Essa abordagem também ajuda a evitar problemas quando o aplicativo é movido para produção, garantindo que ele não seja excessivamente privilegiado no ambiente de desenvolvimento.

Um diagrama que mostra como uma aplicação C++ local usa um principal de serviço para se ligar aos recursos Azure.

Quando a aplicação é registada no Azure, um principal de serviço de aplicação é criado. Para o desenvolvimento local:

  • Crie um registro de aplicativo separado para cada desenvolvedor que trabalha no aplicativo para garantir que cada desenvolvedor tenha sua própria entidade de serviço de aplicativo, evitando a necessidade de compartilhar credenciais.
  • Crie um registro de aplicativo separado para cada aplicativo para limitar as permissões do aplicativo apenas ao necessário.

Durante o desenvolvimento local, as variáveis de ambiente são definidas com a identidade principal do serviço do aplicativo. A biblioteca de Identidade do Azure lê essas variáveis de ambiente para autenticar o aplicativo nos recursos necessários do Azure.

Registrar o aplicativo no Azure

Os objetos principais do serviço de aplicativo são criados por meio de um registro de aplicativo no Azure usando o portal do Azure ou a CLI do Azure.

  1. No portal do Azure, utilize a barra de pesquisa para navegar até à página de Registo de Aplicações.

  2. Na página Registos de Aplicações, selecione + Novo registo.

  3. Na página de Registar uma candidatura

    • Para o campo Nome, insira um valor descritivo que inclua o nome do aplicativo e o ambiente de destino.
    • Para o Tipos de conta suportados, selecione Contas apenas neste diretório organizacional (Somente Liderado pelo Cliente Microsoft - Locatário único)ou a opção que melhor atenda às suas necessidades.

  4. Selecione Registrar para registar a sua aplicação e criar o principal de serviço.

    Uma captura de tela mostrando como criar um registro de aplicativo no portal do Azure.

  5. Na página de registro do aplicativo para seu aplicativo, copie o ID do aplicativo (cliente) e ID do diretório (locatário) e cole-os em um local temporário para uso posterior nas configurações de código do aplicativo.

  6. Selecione Adicionar um certificado ou secreto para configurar credenciais para seu aplicativo.

  7. Na página Certificados & segredos, selecione + Novo segredo de cliente.

  8. No Adicionar um segredo de cliente no painel suspenso que se abre:

    • Para a Descrição, insira um valor de Current.
    • Para o valor expira, deixe o valor padrão recomendado de 180 dias.
    • Selecione Adicionar para adicionar o segredo.

  9. Na página Certificados & segredos, copie a propriedade Value do segredo do cliente para uso em uma etapa futura.

    Observação

    O valor secreto do cliente só é exibido uma vez após a criação do registro do aplicativo. Você pode adicionar mais segredos de cliente sem invalidar esse segredo de cliente, mas não há como exibir esse valor novamente.

Criar um grupo do Microsoft Entra para desenvolvimento local

Crie um grupo do Microsoft Entra para encapsular as funções (permissões) de que o aplicativo precisa no desenvolvimento local, em vez de atribuir as funções a objetos principais de serviço individuais. Esta abordagem oferece as seguintes vantagens:

  • Cada desenvolvedor tem as mesmas funções atribuídas no nível do grupo.
  • Se uma nova função for necessária para o aplicativo, ela só precisará ser adicionada ao grupo do aplicativo.
  • Se um novo programador ingressar na equipa, um novo principal de serviço da aplicação será criado para o programador e adicionado ao grupo, garantindo que o programador tenha as permissões certas para trabalhar na aplicação.

  1. Navegue até a página de visão geral do Microsoft Entra ID no portal do Azure.

  2. Selecione Todos os grupos no menu à esquerda.

  3. Na página Grupos , selecione Novo grupo.

  4. Na página Novo de grupo, preencha os seguintes campos de formulário:

    • Tipo de grupo: Selecione Segurança.
    • Nome do grupo: insira um nome para o grupo que inclua uma referência ao nome do aplicativo ou ambiente.
    • Descrição do grupo: insira uma descrição que explique a finalidade do grupo.

    Uma captura de tela mostrando como criar um grupo no portal do Azure.

  5. Selecione o link Sem membros selecionados em Membros para adicionar membros ao grupo.

  6. No painel suspenso que se abre, procure o principal de serviço que criou anteriormente e selecione-o nos resultados filtrados. Escolha o botão Selecionar na parte inferior do painel para confirmar sua seleção.

  7. Selecione Criar na parte inferior da página Novo grupo para criar o grupo e retornar à página Todos os grupos . Se não vir o novo grupo listado, aguarde um momento e atualize a página.

Atribuir funções ao grupo

Em seguida, determine quais funções (permissões) seu aplicativo precisa em quais recursos e atribua essas funções ao grupo do Microsoft Entra que você criou. Os grupos podem receber uma função em um recurso, num grupo de recursos ou no âmbito de uma assinatura. Este exemplo mostra como atribuir funções no escopo do grupo de recursos, já que a maioria dos aplicativos agrupa todos os seus recursos do Azure em um único grupo de recursos.

  1. No portal do Azure, navegue até a página Visão geral do grupo de recursos que contém seu aplicativo.

  2. Selecione Controle de acesso (IAM) na navegação à esquerda.

  3. Na página Controle de acesso (IAM), selecione + Adicionar e escolha Adicionar atribuição de função no menu suspenso. A página Adicionar atribuição de função fornece várias guias para configurar e atribuir funções.

  4. Na guia Função , use a caixa de pesquisa para localizar a função que você deseja atribuir. Selecione a função e, em seguida, escolha Avançar.

  5. Na aba Membros

    • Para o valor Atribuir acesso a , selecione Usuário, grupo ou entidade de serviço .
    • Para o valor Membros, escolha + Selecionar membros para abrir o painel flutuante Selecionar membros.
    • Procure o grupo do Microsoft Entra criado anteriormente e selecione-o nos resultados filtrados. Escolha e depois selecione para selecionar o grupo e fechar o painel de pop-up.
    • Selecione Revisar + atribuir no fundo do separador Membros.

    Uma captura de tela mostrando como atribuir uma função ao grupo Microsoft Entra.

  6. No separador Rever + atribuir, selecione Rever + atribuir na parte de baixo da página.

Definir as variáveis de ambiente do aplicativo

Em tempo de execução, certas credenciais da biblioteca Azure Identity, como DefaultAzureCredential, EnvironmentCredential e ClientSecretCredential, procuram por convenção as informações do principal de serviço nas variáveis de ambiente. Existem várias formas de configurar variáveis de ambiente dependendo das suas ferramentas e ambiente. Pode criar um .env ficheiro ou usar variáveis do ambiente do sistema para armazenar essas credenciais localmente durante o desenvolvimento.

Independentemente da abordagem que escolher, defina as seguintes variáveis de ambiente para um principal de serviço:

  • AZURE_CLIENT_ID: Usado para identificar o aplicativo registrado no Azure.
  • AZURE_TENANT_ID: O ID do tenant do Microsoft Entra.
  • AZURE_CLIENT_SECRET: A credencial secreta que foi gerada para o aplicativo.

Para aplicações C++, pode definir estas variáveis de ambiente de várias formas. Podes carregá-los a partir de um .env ficheiro no teu código, ou podes defini-los no ambiente do teu sistema. Os seguintes exemplos mostram como definir as variáveis de ambiente em diferentes shells:

export AZURE_CLIENT_ID=<your-client-id>
export AZURE_TENANT_ID=<your-tenant-id>
export AZURE_CLIENT_SECRET=<your-client-secret>

Autenticar nos serviços do Azure a partir da sua aplicação

A biblioteca Azure Identity fornece várias credenciais — implementações do TokenCredential adaptadas para suportar diferentes cenários e fluxos de autenticação Microsoft Entra. Utilize a classe ClientSecretCredential quando trabalhar com princípios de serviço localmente e em produção. Neste cenário, ClientSecretCredential lê as variáveis de ambiente AZURE_CLIENT_ID, AZURE_TENANT_ID e AZURE_CLIENT_SECRET para obter a informação sobre o principal do serviço da aplicação e ligar-se ao Azure.

  1. Adicione o pacote azure-identity-cpp à sua aplicação usando vcpkg.

    vcpkg add port azure-identity-cpp

  2. Adicione as seguintes linhas no seu ficheiro CMake:

    find_package(azure-identity-cpp CONFIG REQUIRED)
target_link_libraries(<your project name> PRIVATE Azure::azure-identity)

  3. Para qualquer código C++ que crie um objeto cliente Azure SDK na sua aplicação:

    1. Inclua o azure/identity.hpp cabeçalho.
    2. Crie uma instância de ClientSecretCredential.
    3. Passar a instância de ClientSecretCredential para o construtor cliente do Azure SDK.

    Um exemplo é mostrado no seguinte segmento de código:

    #include <azure/identity.hpp>
#include <azure/storage/blobs.hpp>
#include <iostream>
#include <memory>

// The following environment variables must be set before running the sample.
// * AZURE_TENANT_ID: Tenant ID for the Azure account.
// * AZURE_CLIENT_ID: The Client ID to authenticate the request.
// * AZURE_CLIENT_SECRET: The client secret.
std::string GetTenantId() { return std::getenv("AZURE_TENANT_ID"); }
std::string GetClientId() { return std::getenv("AZURE_CLIENT_ID"); }
std::string GetClientSecret() { return std::getenv("AZURE_CLIENT_SECRET"); }

int main() {
    try {
        // Create a credential - this will automatically read the environment variables
        // AZURE_CLIENT_ID, AZURE_TENANT_ID, and AZURE_CLIENT_SECRET
        auto credential = std::make_shared<Azure::Identity::ClientSecretCredential>(GetTenantId(), GetClientId(), GetClientSecret());

        // Create a client for the specified storage account
        std::string accountUrl = "https://<replace_with_your_storage_account_name>.blob.core.windows.net/";
        Azure::Storage::Blobs::BlobServiceClient blobServiceClient(accountUrl, credential);

        // Get a reference to a container
        std::string containerName = "sample-container";
        auto containerClient = blobServiceClient.GetBlobContainerClient(containerName);

        // Get a reference to a blob
        std::string blobName = "sample-blob";
        auto blobClient = containerClient.GetBlobClient(blobName);

        // TODO: perform some action with the blob client
        // auto downloadResult = blobClient.DownloadTo("path/to/local/file");

        std::cout << "Successfully authenticated and created Azure clients." << std::endl;

    } catch (const std::exception& ex) {
        std::cout << "Exception: " << ex.what() << std::endl;
        return 1;
    }

    return 0;
}
  • Last updated on