Tutorial: Uso de una identidad administrada para conectar Key Vault a una aplicación web de Azure en .NET

  • Artículo

Azure Key Vault proporciona una manera de almacenar credenciales y otros secretos con mayor seguridad. Pero el código debe autenticarse en Key Vault para recuperarlos. En Identidades administradas para recursos de Azure se ayuda a resolver este problema al proporcionar a los servicios de Azure una identidad administrada automáticamente en Microsoft Entra ID. Puede usar esta identidad para autenticar cualquier servicio que admita la autenticación de Microsoft Entra, incluido Key Vault, sin necesidad de tener que mostrar las credenciales en el código.

En este tutorial, creará e implementará una aplicación web de Azure en Azure App Service. Usará una identidad administrada para autenticar la aplicación web de Azure con un almacén de claves de Azure mediante la biblioteca cliente de secretos de Azure Key Vault para .NET y la CLI de Azure. Se aplican los mismos principios básicos cuando se usa el lenguaje de desarrollo de su elección, Azure PowerShell o Azure Portal.

Para más información sobre las aplicaciones web de Azure App Service y la implementación presentada en este tutorial, consulte:

Prerrequisitos

Para completar este tutorial, necesita:

Si ya tiene la aplicación web implementada en Azure App Service, puede pasar directamente a configurar el acceso de la aplicación web a un almacén de claves y modificar las secciones del código de la aplicación web.

Creación de una aplicación .NET Core

En este paso, va a configurar el proyecto de .NET Core local.

En una ventana de terminal de la máquina, cree un directorio llamado akvwebapp y conviértalo en el directorio actual.

mkdir akvwebapp
cd akvwebapp

Cree una aplicación de .NET Core mediante el comando dotnet new web:

dotnet new web

Ejecute la aplicación localmente para que sepa cómo debe ser el aspecto cuando la implemente en Azure:

dotnet run

En un explorador web, vaya a la aplicación en http://localhost:5000.

Se mostrará el mensaje Hola mundo de la aplicación de ejemplo en la página.

Para más información sobre la creación de aplicaciones web para Azure, consulte Creación de una aplicación web de ASP.NET Core en Azure App Service.

Implementar la aplicación en Azure

En este paso, va a implementar la aplicación de .NET Core en Azure App Service mediante Git local. Para más información sobre cómo crear e implementar aplicaciones, consulte Creación de una aplicación web ASP.NET Core en Azure.

Configuración de la implementación de Git local

En la ventana de terminal, seleccione Ctrl + C para cerrar el servidor Web. Inicialice un repositorio de Git para el proyecto de .NET Core:

git init --initial-branch=main
git add .
git commit -m "first commit"

Puede utilizar FTP y Git local para implementar una aplicación web de Azure mediante un usuario de implementación. Después de configurar el usuario de implementación, podrá usarlo para todas las implementaciones de Azure. El nombre de usuario y la contraseña de implementación en el nivel de cuenta son diferentes de las credenciales de la suscripción de Azure.

Para configurar el usuario de implementación, ejecute el comando az webapp deployment user set. Elija un nombre de usuario y una contraseña que sigan estas siguientes directrices:

  • El nombre de usuario debe ser único en Azure. Para las inserciones locales de Git, no puede contener el símbolo de arroba (@).
  • La contraseña debe tener al menos ocho caracteres de longitud y contener dos de los tres elementos siguientes: letras, números y símbolos.
az webapp deployment user set --user-name "<username>" --password "<password>"

La salida JSON muestra la contraseña como null. Si se produce un error 'Conflict'. Details: 409, cambie el nombre de usuario. Si se produce un error 'Bad Request'. Details: 400, use una contraseña más segura.

Anote el nombre de usuario y la contraseña que se usarán para implementar las aplicaciones web.

Crear un grupo de recursos

Un grupo de recursos es un contenedor lógico en el que se implementan y se administran los recursos de Azure. Cree un grupo de recursos para contener tanto almacén de claves como la aplicación web mediante el comando az group create:

az group create --name "myResourceGroup" -l "EastUS"

Creación de un plan de App Service

Cree un plan de App Service mediante el comando az appservice plan create de la CLI de Azure. En el siguiente ejemplo, se crea un plan de App Service denominado myAppServicePlan con el plan de tarifa FREE:

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE

Cuando se ha creado el plan de App Service, la CLI de Azure muestra información similar a la que se ve aquí:

{ 
  "adminSiteName": null,
  "appServicePlanName": "myAppServicePlan",
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "app",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
}

Para más información, consulte Cambio de una aplicación a otro plan de App Service.

Creación de una aplicación web

Creación de una aplicación web de Azure en el plan de App Service myAppServicePlan.

Importante

Al igual que sucede con un almacén de claves, una aplicación web de Azure debe tener un nombre único. Reemplace <your-webapp-name> por el nombre de la aplicación web en los ejemplos siguientes.

az webapp create --resource-group "myResourceGroup" --plan "myAppServicePlan" --name "<your-webapp-name>" --deployment-local-git

Cuando se haya creado la aplicación web, la CLI de Azure mostrará una salida similar a la que se ve aquí:

Local git is configured with url of 'https://<username>@<your-webapp-name>.scm.azurewebsites.net/<ayour-webapp-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "clientCertExclusionPaths": null,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<your-webapp-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<your-webapp-name>.scm.azurewebsites.net/<your-webapp-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

La dirección URL de Git remoto se muestra en la propiedad deploymentLocalGitUrl, con el formato https://<username>@<your-webapp-name>.scm.azurewebsites.net/<your-webapp-name>.git. Guarde esta dirección URL. Lo necesitará más adelante.

Ahora configure la aplicación web para implementarla desde la rama main:

 az webapp config appsettings set -g MyResourceGroup --name "<your-webapp-name>" --settings deployment_branch=main

Vaya a la nueva aplicación con el siguiente comando. Reemplace <your-webapp-name> por el nombre de la aplicación.

https://<your-webapp-name>.azurewebsites.net

Verá la página web predeterminada de una nueva aplicación web de Azure.

Implementación de la aplicación local

En la ventana del terminal local, agregue una instancia remota de Azure al repositorio de Git local. En el siguiente comando, reemplace <deploymentLocalGitUrl-from-create-step> por la dirección URL de Git remoto que guardó en la sección Creación de una aplicación web.

git remote add azure <deploymentLocalGitUrl-from-create-step>

Realice la inserción en la instancia remota de Azure para implementar la aplicación con el comando siguiente. Cuando el administrador de credenciales de Git le solicite las credenciales, utilice las que creó en la sección Configuración de la implementación de Git local.

git push azure main

Este comando puede tardar unos minutos en ejecutarse. Mientras se ejecuta, muestra información similar a la que se ve aquí:

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 285 bytes | 95.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Deploy Async
remote: Updating branch 'main'.
remote: Updating submodules.
remote: Preparing deployment for commit id 'd6b54472f7'.
remote: Repository path is /home/site/repository
remote: Running oryx build...
remote: Build orchestrated by Microsoft Oryx, https://github.com/Microsoft/Oryx
remote: You can report issues at https://github.com/Microsoft/Oryx/issues
remote:
remote: Oryx Version      : 0.2.20200114.13, Commit: 204922f30f8e8d41f5241b8c218425ef89106d1d, ReleaseTagName: 20200114.13
remote: Build Operation ID: |imoMY2y77/s=.40ca2a87_
remote: Repository Commit : d6b54472f7e8e9fd885ffafaa64522e74cf370e1
.
.
.
remote: Deployment successful.
remote: Deployment Logs : 'https://<your-webapp-name>.scm.azurewebsites.net/newui/jsonviewer?view_url=/api/deployments/d6b54472f7e8e9fd885ffafaa64522e74cf370e1/log'
To https://<your-webapp-name>.scm.azurewebsites.net:443/<your-webapp-name>.git
   d87e6ca..d6b5447  main -> main

Vaya a la aplicación implementada, o actualícela, en el explorador web:

http://<your-webapp-name>.azurewebsites.net

Verá el mensaje "Hola mundo" que vio anteriormente cuando visitó http://localhost:5000.

Para más información sobre la implementación de una aplicación web con Git, consulte Implementación de Git local en Azure App Service.

Configuración de la aplicación web para conectarse a Key Vault

En esta sección va a configurar el acceso web a Key Vault y a actualizar el código de la aplicación para recuperar un secreto desde Key Vault.

Creación y asignación de una identidad administrada

En este tutorial usaremos una identidad administrada para la autenticación en Key Vault. La identidad administrada administra automáticamente las credenciales de la aplicación.

Para crear la identidad de la aplicación, ejecute el comando az webapp-identity assign en la CLI de Azure:

az webapp identity assign --name "<your-webapp-name>" --resource-group "myResourceGroup"

El comando devolverá este fragmento de código JSON:

{
  "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "tenantId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "type": "SystemAssigned"
}

Para conceder permisos a la aplicación web para realizar operaciones get y list en el almacén de claves, pase el valor de principalId al comando az keyvault set-policy de la CLI de Azure:

az keyvault set-policy --name "<your-keyvault-name>" --object-id "<principalId>" --secret-permissions get list

También puede asignar directivas de acceso mediante Azure Portal o PowerShell.

Modificación de la aplicación para acceder al almacén de claves

En este tutorial, usará la biblioteca cliente de secretos de Azure Key Vault con fines de demostración. También puede usar la biblioteca cliente de certificados de Azure Key Vault o la biblioteca cliente de claves de Azure Key Vault.

Instalación de los paquetes

En la ventana de terminal, instale los paquetes de la biblioteca cliente de secretos de Azure Key Vault para .NET y la biblioteca cliente Azure Identity:

dotnet add package Azure.Identity
dotnet add package Azure.Security.KeyVault.Secrets

Actualización del código

Busque y abra el archivo Startup.cs para .NET 5.0 o versiones anteriores, o program.cs para .NET 6.0 en el proyecto de akvwebapp.

Agregue estas líneas al encabezado:

using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using Azure.Core;

Agregue las líneas siguientes antes de la llamada a app.UseEndpoints (.NET 5.0 o anterior) o app.MapGet (.NET 6.0), y actualice el identificador URI para que refleje el valor de vaultUri del almacén de claves. Este código usa DefaultAzureCredential() para autenticarse en Key Vault, que usa un token de la identidad administrada para la autenticación. Para más información sobre la autenticación en Key Vault, consulte Guía del desarrollador de Azure Key Vault. El código también utiliza el retroceso exponencial para los reintentos en el caso de que se limite el almacén de claves. Para más información sobre los límites de transacciones de Key Vault, consulte Guía de las limitaciones de Azure Key Vault.

SecretClientOptions options = new SecretClientOptions()
    {
        Retry =
        {
            Delay= TimeSpan.FromSeconds(2),
            MaxDelay = TimeSpan.FromSeconds(16),
            MaxRetries = 5,
            Mode = RetryMode.Exponential
         }
    };
var client = new SecretClient(new Uri("https://<your-unique-key-vault-name>.vault.azure.net/"), new DefaultAzureCredential(),options);

KeyVaultSecret secret = client.GetSecret("<mySecret>");

string secretValue = secret.Value;
.NET 5.0 o anterior

Actualice la línea await context.Response.WriteAsync("Hello World!"); para que tenga el aspecto de esta línea:

await context.Response.WriteAsync(secretValue);
.NET 6.0

Actualice la línea app.MapGet("/", () => "Hello World!"); para que tenga el aspecto de esta línea:

app.MapGet("/", () => secretValue);

Asegúrese de guardar los cambios antes de continuar con el siguiente paso.

Nueva implementación de la aplicación web

Ahora que ha actualizado el código, puede volver a implementarlo en Azure mediante estos comandos de Git:

git add .
git commit -m "Updated web app to access my key vault"
git push azure main

Ir a la aplicación web completada

http://<your-webapp-name>.azurewebsites.net

Donde antes aparecía "Hola mundo!", ahora debería ver que se muestra el valor del secreto.

Pasos siguientes