Automatiser la rotation des secrets pour les ressources utilisant un ensemble de données d'authentification

La meilleure façon de s’authentifier auprès des services Azure consiste à utiliser une identité managée, mais il existe certains scénarios où cela n’est pas une option. Dans ce cas, les clés d’accès ou les secrets sont utilisés. Vous devez faire pivoter périodiquement les clés d’accès ou les secrets.

Ce tutoriel montre comment automatiser la rotation périodique des secrets pour les bases de données et les services qui utilisent un ensemble d’informations d’identification d’authentification. Pour obtenir une vue d’ensemble complète des concepts et avantages de l’autorotation entre différents types de ressources, consultez Présentation de l’autorotation dans Azure Key Vault.

Plus précisément, ce tutoriel fait pivoter les mots de passe SQL Server stockés dans Azure Key Vault à l’aide d’une fonction déclenchée par la notification Azure Event Grid :

1. Trente jours avant la date d’expiration d’un secret, Key Vault publie l’événement « Expiration proche » sur Event Grid.
2. Event Grid vérifie les abonnements aux événements et utilise HTTP POST pour appeler le point de terminaison de l’application de fonction abonné à l’événement.
3. L'application fonctionnelle reçoit les informations secrètes, génère un nouveau mot de passe aléatoire et crée une nouvelle version pour le secret avec le nouveau mot de passe dans Key Vault.
4. L’application de fonction met à jour SQL Server avec le nouveau mot de passe.

Conditions préalables

• Un abonnement Azure - En créer un gratuitement
• Azure Key Vault
• Serveur SQL

Si vous n’avez pas de coffre de clés et SQL Server existants, vous pouvez utiliser ce lien de déploiement :

1. Sous Groupe de ressources, sélectionnez Créer. Donnez un nom au groupe, nous allons utiliser akvrotation dans ce tutoriel.
2. Sous Connexion d’administrateur SQL, tapez le nom de connexion de l’administrateur SQL.
3. Sélectionnez Vérifier + créer.
4. Sélectionnez Créer

Vous disposez maintenant d’un coffre de clés et d’une instance SQL Server. Vous pouvez vérifier cette configuration dans Azure CLI en exécutant la commande suivante :

az resource list -o table -g akvrotation

Le résultat doit ressembler à la sortie suivante :

Name                     ResourceGroup         Location    Type                               Status
-----------------------  --------------------  ----------  ---------------------------------  --------
akvrotation-kv           akvrotation      eastus      Microsoft.KeyVault/vaults
akvrotation-sql          akvrotation      eastus      Microsoft.Sql/servers
akvrotation-sql/master   akvrotation      eastus      Microsoft.Sql/servers/databases
akvrotation-sql2         akvrotation      eastus      Microsoft.Sql/servers
akvrotation-sql2/master  akvrotation      eastus      Microsoft.Sql/servers/databases

Créer et déployer une fonction de rotation de mot de passe SQL Server

Ensuite, créez une application de fonction avec une identité managée par le système, en plus des autres composants requis et déployez des fonctions de rotation de mot de passe SQL Server

L’application de fonction nécessite ces composants :

• Un plan Azure App Service
• Application de fonction avec fonctions de rotation de mot de passe SQL avec déclencheur d’événement et déclencheur http
• Un compte de stockage est requis pour gérer les déclencheurs de fonction.
• Une stratégie d’accès pour que l’identité Function App accède aux secrets dans Key Vault
• Un abonnement aux événements Event Grid pour l’événement SecretNearExpiry

1. Sélectionnez le lien de déploiement de modèle Azure :

   

2. Dans la liste des groupes de ressources, sélectionnez akvrotation.

3. Dans le Nom du serveur SQL, tapez le nom du serveur SQL avec le mot de passe pour procéder à la rotation.

4. Dans le nom du coffre de clés, tapez le nom du coffre de clés

5. Dans le nom de l’application de fonction, tapez le nom de l’application de fonction

6. Dans le nom du secret, tapez le nom du secret dans lequel le mot de passe sera stocké.

7. Dans l’URL du dépôt, tapez l’emplacement GitHub du code de fonction (https://github.com/Azure-Samples/KeyVault-Rotation-SQLPassword-Csharp.git)

8. Sélectionnez Vérifier + créer.

9. Cliquez sur Créer.

Une fois les étapes précédentes effectuées, vous disposez d’un compte de stockage, d’une batterie de serveurs et d’une application de fonction. Vous pouvez vérifier cette configuration dans Azure CLI en exécutant la commande suivante :

az resource list -o table -g akvrotation

Le résultat ressemble à la sortie suivante :

Name                     ResourceGroup         Location    Type                               Status
-----------------------  --------------------  ----------  ---------------------------------  --------
akvrotation-kv           akvrotation       eastus      Microsoft.KeyVault/vaults
akvrotation-sql          akvrotation       eastus      Microsoft.Sql/servers
akvrotation-sql/master   akvrotation       eastus      Microsoft.Sql/servers/databases
cfogyydrufs5wazfunctions akvrotation       eastus      Microsoft.Storage/storageAccounts
akvrotation-fnapp        akvrotation       eastus      Microsoft.Web/serverFarms
akvrotation-fnapp        akvrotation       eastus      Microsoft.Web/sites
akvrotation-fnapp        akvrotation       eastus      Microsoft.insights/components

Pour plus d’informations sur la création d’une application de fonction et l’utilisation d’une identité managée pour accéder à Key Vault, consultez Créer une application de fonction à partir du portail Azure, Comment utiliser une identité managée pour App Service et Azure Functions, et affecter une stratégie d’accès Key Vault à l’aide du portail Azure.

Fonction de rotation

Déployée dans l’étape précédente, la fonction utilise un événement pour déclencher la permutation d’un secret en mettant à jour Key Vault et la base de données SQL.

Événement de déclenchement de fonction

Cette fonction lit les données d’événement et exécute la logique de rotation :

public static class SimpleRotationEventHandler
{
   [FunctionName("AKVSQLRotation")]
   public static void Run([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
   {
      log.LogInformation("C# Event trigger function processed a request.");
      var secretName = eventGridEvent.Subject;
      var secretVersion = Regex.Match(eventGridEvent.Data.ToString(), "Version\":\"([a-z0-9]*)").Groups[1].ToString();
      var keyVaultName = Regex.Match(eventGridEvent.Topic, ".vaults.(.*)").Groups[1].ToString();
      log.LogInformation($"Key Vault Name: {keyVaultName}");
      log.LogInformation($"Secret Name: {secretName}");
      log.LogInformation($"Secret Version: {secretVersion}");

      SecretRotator.RotateSecret(log, secretName, keyVaultName);
   }
}

Logique de permutation du secret

Cette méthode de rotation lit les informations de base de données à partir du secret, crée une nouvelle version du secret et met à jour la base de données avec le nouveau secret :

    public class SecretRotator
    {
		private const string CredentialIdTag = "CredentialId";
		private const string ProviderAddressTag = "ProviderAddress";
		private const string ValidityPeriodDaysTag = "ValidityPeriodDays";

		public static void RotateSecret(ILogger log, string secretName, string keyVaultName)
        {
            //Retrieve Current Secret
            var kvUri = "https://" + keyVaultName + ".vault.azure.net";
            var client = new SecretClient(new Uri(kvUri), new DefaultAzureCredential());
            KeyVaultSecret secret = client.GetSecret(secretName);
            log.LogInformation("Secret Info Retrieved");

            //Retrieve Secret Info
            var credentialId = secret.Properties.Tags.ContainsKey(CredentialIdTag) ? secret.Properties.Tags[CredentialIdTag] : "";
            var providerAddress = secret.Properties.Tags.ContainsKey(ProviderAddressTag) ? secret.Properties.Tags[ProviderAddressTag] : "";
            var validityPeriodDays = secret.Properties.Tags.ContainsKey(ValidityPeriodDaysTag) ? secret.Properties.Tags[ValidityPeriodDaysTag] : "";
            log.LogInformation($"Provider Address: {providerAddress}");
            log.LogInformation($"Credential Id: {credentialId}");

            //Check Service Provider connection
            CheckServiceConnection(secret);
            log.LogInformation("Service  Connection Validated");
            
            //Create new password
            var randomPassword = CreateRandomPassword();
            log.LogInformation("New Password Generated");

            //Add secret version with new password to Key Vault
            CreateNewSecretVersion(client, secret, randomPassword);
            log.LogInformation("New Secret Version Generated");

            //Update Service Provider with new password
            UpdateServicePassword(secret, randomPassword);
            log.LogInformation("Password Changed");
            log.LogInformation($"Secret Rotated Successfully");
        }
}

Vous trouverez le code complet sur GitHub.

Ajouter le secret à Key Vault

Définissez votre stratégie d’accès pour accorder des autorisations de gestion des secrets aux utilisateurs :

az keyvault set-policy --upn <email-address-of-user> --name akvrotation-kv --secret-permissions set delete get list

Créez un secret avec des balises qui contiennent l’ID de ressource SQL Server, le nom de connexion SQL Server et la période de validité du secret en jours. Indiquez le nom du secret, mot de passe initial de la base de données SQL (dans notre exemple « Simple123 ») et incluez une date d’expiration définie pour demain.

$tomorrowDate = (get-date).AddDays(+1).ToString("yyy-MM-ddThh:mm:ssZ")
az keyvault secret set --name sqlPassword --vault-name akvrotation-kv --value "Simple123" --tags "CredentialId=sqlAdmin" "ProviderAddress=<sql-database-resource-id>" "ValidityPeriodDays=90" --expires $tomorrowDate

La création d’un secret avec une date d’expiration proche entraîne la publication d’un événement SecretNearExpiry dans un délai de 15 minutes, qui déclenche à son tour la fonction de rotation du secret.

Tester et vérifier

Pour vérifier que le secret a permuté, accédez à Key Vault>Secrets :

Ouvrez le secret sqlPassword et affichez les versions d’origine et pivotées :

Créer une application web

Pour vérifier les informations d’identification SQL, créez une application web. Cette application web obtient le secret de Key Vault, extrait les informations et les informations d’identification de la base de données SQL à partir du secret et teste la connexion à SQL Server.

L’application web nécessite ces composants :

• Une application web avec une identité managée par le système
• Stratégie d’accès pour accéder aux secrets dans Key Vault via une identité managée d’application web

1. Sélectionnez le lien de déploiement de modèle Azure :

   

2. Sélectionnez le groupe de ressources akvrotation .

3. Dans le Nom du serveur SQL, tapez le nom du serveur SQL avec le mot de passe pour procéder à la rotation.

4. Dans le nom du coffre de clés, tapez le nom du coffre de clés

5. Dans le nom du secret, tapez le nom du secret dans lequel le mot de passe est stocké

6. Dans l’URL du dépôt, tapez l’emplacement GitHub du code de l’application web (https://github.com/Azure-Samples/KeyVault-Rotation-SQLPassword-Csharp-WebApp.git)

7. Sélectionnez Vérifier + créer.

8. Cliquez sur Créer.

Ouvrir l’application web

Accédez à l’URL de l’application déployée :

« https://akvrotation-app.azurewebsites.net/ »

Lorsque l’application s’ouvre dans le navigateur, vous verrez la valeur secrète générée et une valeur connectée à la base de donnéestrue.

Pour en savoir plus

• Rotation des ressources avec deux ensembles d'identifiants
• Présentation de l’autorotation dans Azure Key Vault
• Surveillance de Key Vault avec Azure Event Grid
• Recevoir un e-mail lorsqu’un secret de coffre de clés change
• Schéma d’événement Azure Event Grid pour Azure Key Vault