Condividi tramite

Automatizzare la rotazione di un segreto per le risorse che usano un set di credenziali di autenticazione

Il modo migliore per eseguire l'autenticazione ai servizi di Azure consiste nell'usare un'identità managed identity, ma esistono alcuni scenari in cui non è un'opzione. In questi casi vengono usate chiavi di accesso o segreti. È consigliabile ruotare periodicamente le chiavi di accesso o i segreti.

Questa esercitazione illustra come automatizzare la rotazione periodica dei segreti per database e servizi che usano un set di credenziali di autenticazione. Per una panoramica completa dei concetti e dei vantaggi dell'autorotazione in diversi tipi di asset, vedere Informazioni sull'autorotazione in Azure Key Vault.

In particolare, questa esercitazione ruota le password di SQL Server archiviate in Azure Key Vault utilizzando una funzione attivata da una notifica di Griglia di eventi di Azure.

Diagramma della soluzione di rotazione

  1. Trenta giorni prima della data di scadenza di un segreto, Key Vault pubblica l'evento "near expiry" in Griglia di eventi.
  2. Griglia di eventi controlla le sottoscrizioni di eventi e, tramite POST HTTP, chiama l'endpoint app per le funzioni che ha sottoscritto questo evento.
  3. L'app per le funzioni riceve le informazioni segrete, genera una nuova password casuale e crea una nuova versione per il segreto con la nuova password in Key Vault.
  4. L'app per le funzioni aggiorna SQL Server con la nuova password.

Annotazioni

Potrebbe esserci un ritardo tra i passaggi 3 e 4. Durante questo periodo, il segreto in Key Vault non sarà in grado di eseguire l'autenticazione per SQL Server. In caso di errore in uno dei passaggi, Event Grid ripete l'operazione per due ore.

Prerequisiti

Se non sono presenti Key Vault e SQL Server esistenti, è possibile usare questo collegamento alla distribuzione:

Image che mostra un pulsante con l'etichetta

  1. In Gruppo di risorse selezionare Crea nuovo. Assegnare un nome al gruppo, viene usato akvrotation in questa esercitazione.
  2. In Account di accesso amministratore SQL digitare il nome dell'account di accesso dell'amministratore SQL.
  3. Selezionare Rivedi e crea.
  4. Selezionare Crea

Creare un gruppo di risorse

A questo punto si avrà un Key Vault e un'istanza di SQL Server. È possibile verificare questa configurazione nel interfaccia della riga di comando di Azure eseguendo il comando seguente:

az resource list -o table -g akvrotation

Il risultato avrà un aspetto simile all'output seguente:

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

Creare e distribuire la funzione di rotazione delle password di SQL Server

Importante

Questo modello richiede che il key vault, il server SQL e la funzione Azure si trovino nello stesso gruppo di risorse.

Successivamente, creare un'app per le funzioni con un'identità gestita dal sistema, oltre agli altri componenti necessari e distribuire le funzioni di rotazione delle password di SQL Server

L'app per le funzioni richiede questi componenti:

  • Un piano di Servizio app di Azure
  • Un'app per le funzioni con le funzioni di rotazione delle password di SQL con trigger di evento e trigger HTTP
  • Un account di archiviazione necessario per la gestione dei trigger dell'app per le funzioni
  • Assegnazione di un ruolo Azure RBAC per l'identità dell'app delle funzioni per accedere ai segreti in Key Vault
  • Sottoscrizione di eventi di Event Grid per l'evento SecretNearExpiry

  1. Selezionare il collegamento di distribuzione del modello di Azure:

    Image che mostra un pulsante con l'etichetta

  2. Nell'elenco Gruppo di risorse selezionare akvrotation.

  3. Nella SQL Server Name, digitare il nome del SQL Server e la password per ruotarla

  4. Nella Nome Key Vault, digitare il nome del Key Vault

  5. In Nome dell'app per le funzioni digitare il nome dell'app per le funzioni

  6. In Nome segreto digitare il nome del segreto in cui verrà archiviata la password

  7. Nell'URL del repository, digitare la posizione GitHub del codice della funzione (https://github.com/Azure-Samples/KeyVault-Rotation-SQLPassword-Csharp.git)

  8. Selezionare Rivedi e crea.

  9. Fare clic su Crea.

Selezionare Rivedi e crea.

Dopo aver completato i passaggi precedenti, si avrà un account di archiviazione, una server farm e un'app per le funzioni. È possibile verificare questa configurazione nel interfaccia della riga di comando di Azure eseguendo il comando seguente:

az resource list -o table -g akvrotation

Il risultato sarà simile all'output seguente:

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

Per informazioni su come creare un'app per le funzioni e usare l'identità gestita per accedere alle Key Vault, vedere Creare un'app per le funzioni dal portale di Azure, Come usare l'identità gestita per il servizio app e Funzioni di Azure e Provide l'accesso a Key Vault con Azure controllo degli accessi in base al ruolo.

Funzione di Rotazione

La funzione distribuita nel passaggio precedente usa un evento per attivare la rotazione di un segreto aggiornando Key Vault e il database SQL.

Evento di attivazione della funzione

Questa funzione legge i dati dell'evento ed esegue la logica di rotazione:

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

Logica di rotazione del segreto

Questo metodo di rotazione legge le informazioni del database dal segreto, crea una nuova versione del segreto e aggiorna il database con il nuovo segreto:

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

Il codice completo è disponibile in GitHub.

Aggiungere il segreto a Key Vault

Impostare i criteri di accesso per concedere le autorizzazioni di gestione dei segreti agli utenti:

az role assignment create --role "Key Vault Secrets Officer" --assignee <email-address-of-user> --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.KeyVault/vaults/akvrotation-kv

Creare un nuovo segreto con tag che contengono l'ID risorsa SQL Server, il nome di accesso SQL Server e il periodo di validità per il segreto in giorni. Specificare il nome del segreto, la password iniziale del database SQL (nell'esempio "Simple123") e includere una data di scadenza impostata per domani.

$tomorrowDate = (get-date).AddDays(+1).ToString("yyyy-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 creazione di un segreto con una data di scadenza breve pubblicherà un SecretNearExpiry evento entro 15 minuti, che a sua volta attiverà la funzione per ruotare il segreto.

Prova e verifica

Per verificare che il segreto sia ruotato, passare a Key Vault>Secrets:

Screenshot che illustra come accedere a Key Vault > Secrets.

Aprire il segreto sqlPassword e visualizzare le versioni originali e ruotate:

Passare a segreti

Creare un'app Web

Per verificare le credenziali SQL, creare un'app Web. Questa app Web otterrà il segreto da Key Vault, estrae le informazioni e le credenziali del database SQL dal segreto e verificherà la connessione a SQL Server.

L'app Web richiede questi componenti:

  • Un'app Web con identità gestita dal sistema
  • Criteri di accesso per accedere ai segreti in Key Vault tramite l'identità gestita dell'app Web

  1. Selezionare il collegamento di distribuzione del modello di Azure:

    Image che mostra un pulsante con l'etichetta

  2. Selezionare il gruppo di risorse akvrotation .

  3. Nella SQL Server Name digitare il nome del SQL Server insieme alla password per cambiare

  4. Nella Nome della chiave vault digitare il nome della chiave vault

  5. In Nome segreto digitare il nome del segreto in cui è archiviata la password

  6. Nell'URL Repo, digitare la localizzazione del codice dell'app Web su GitHub (https://github.com/Azure-Samples/KeyVault-Rotation-SQLPassword-Csharp-WebApp.git)

  7. Selezionare Rivedi e crea.

  8. Fare clic su Crea.

Aprire l'app Web

Passare all'URL dell'applicazione distribuita:

"https://akvrotation-app.azurewebsites.net/"

Quando l'applicazione viene aperta nel browser, verrà visualizzato il valore del segreto generato e il valore Database Connesso impostato su true.

Usare l'intelligenza artificiale per personalizzare la funzione di rotazione per il database

Questa esercitazione illustra la rotazione dei segreti per SQL Server, ma è possibile adattare la funzione di rotazione per altri tipi di database. GitHub Copilot in VS Code consente di modificare il codice della funzione di rotazione in modo che funzioni con il database o il tipo di credenziale specifico.

I'm using the Azure Key Vault secret rotation tutorial for SQL Server. Help me modify the rotation function to work with PostgreSQL instead. The function should:
1. Generate a new secure password
2. Update the PostgreSQL database user password
3. Store the new password in Key Vault
Show me the changes needed to the C# function code, including the correct PostgreSQL connection library and password update command.

Copilot consente anche di adattare questo modello per altri tipi di credenziali, ad esempio chiavi API, stringhe di connessione o password dell'account del servizio.

GitHub Copilot è basato sull'IA, quindi sono possibili sorprese ed errori. Per altre informazioni, vedere Copilot domande frequenti.

Ulteriori informazioni

  • Last updated on