Esercizio - Usare criteri di accesso archiviati per delegare l'accesso ad Archiviazione di Azure

Completato

Invece di creare varie firme di accesso condiviso singolarmente, ciascuna con autorizzazioni di accesso e date di scadenza specifiche, è possibile associarvi un criterio di accesso archiviato. La modifica del criterio influisce su tutte le firme di accesso condiviso associate.

A questo punto è chiaro che esiste un modo migliore per creare e gestire le firme di accesso condiviso dell'azienda. È possibile aggiornare le nuove pagine di test per usare i criteri di accesso archiviati.

In questo esercizio l'app Web verrà aggiornata per creare firme di accesso condiviso con criteri di accesso archiviati. Si useranno quindi i comandi dell'interfaccia della riga di comando di Azure per modificare i criteri e verificare che l'accesso venga revocato.

Aggiungere un metodo per creare criteri di accesso archiviati

1. In Azure Cloud Shell modificare il file PatientRecordController.cs.

   code ~/sas/Controllers/PatientRecordController.cs
   

2. Alla fine della classe, sotto il metodo GetBlobSas, scrivere un metodo per creare criteri di accesso archiviati.

   // Use a stored access policy for the SAS
   private void CreateStoredAccessPolicy()
   {
       // Create a stored access policy for our blobs
       BlobSignedIdentifier identifier = new BlobSignedIdentifier
       {
           Id = _storedPolicyID,
           AccessPolicy = new BlobAccessPolicy
           {
               ExpiresOn = DateTimeOffset.UtcNow.AddHours(1),
               Permissions = "r"
           }
       };
   
       _container.SetAccessPolicy(permissions: new BlobSignedIdentifier[] { identifier });
   } 
   

3. Questo metodo usa una variabile globale per l'identificatore dei criteri di accesso. Aggiungere questa variabile nella parte superiore della classe sotto la dichiarazione per la variabile BlobContainerClient denominata _container.

   private String _storedPolicyID = "patient-images-policy";
   

4. Il criterio di accesso archiviato viene usato per ogni token di firma di accesso condiviso generato, quindi chiamare il nuovo metodo nel codice di creazione di un'istanza della classe. Aggiungere una chiamata alla fine del metodo.

   public PatientRecordsController(ILogger<PatientRecordsController> logger, IConfiguration iconfiguration)
   {
       _logger = logger;
       _iconfiguration = iconfiguration; 
       _container = new BlobContainerClient(
           _iconfiguration.GetValue<string>("StorageAccount:ConnectionString"),
           _iconfiguration.GetValue<string>("StorageAccount:Container")
       );
       CreateStoredAccessPolicy();
   }
   

5. È ora possibile semplificare GetBlobSas per usare il criterio di accesso. Modificare il metodo per usarlo.

    // Build a SAS token for the given blob
    private string GetBlobSas()
    {
        // Create a user SAS that only allows reading for a minute
        BlobSasBuilder sas = new BlobSasBuilder 
        {
            Identifier = _storedPolicyID,
            BlobContainerName = _iconfiguration.GetValue<string>("StorageAccount:Container")
        };
   
        // Use the shared key to access the blob
        var storageSharedKeyCredential = new StorageSharedKeyCredential(
            _iconfiguration.GetValue<string>("StorageAccount:AccountName"),
            _iconfiguration.GetValue<string>("StorageAccount:AccountKey")
        );
   
        return '?' + sas.ToSasQueryParameters(storageSharedKeyCredential).ToString();
    }
   

6. Il codice che gestisce le richieste di token di firma di accesso condiviso necessita di una piccola correzione per chiamare il metodo aggiornato.

   // GET PatientRecord/patient-nnnnnn/secure
   [HttpGet("{Name}/{secure}")]
   public PatientRecord Get(string name, string flag)
   {
       BlobClient blob = _container.GetBlobClient(name);
       return new PatientRecord { name=blob.Name, imageURI=blob.Uri.AbsoluteUri, sasToken=GetBlobSas() };
   }
   

7. Salvare le modifiche al codice selezionando CTRL+S e quindi selezionare CTRL+Q.

Testare il nuovo codice

1. In Cloud Shell compilare l'app.

   cd ~/sas/
   dotnet build
   

2. Nel caso la porta sia stata chiusa dopo aver completato l'esercizio precedente, eseguire il comando curl per aprirla di nuovo.

   curl -X POST http://localhost:8888/openPort/8000;
   

3. Eseguire l'app Web aggiornata.

   dotnet run
   

4. Passare all'URL dell'app Web, assicurandosi che termini con una barra (/).

5. Nella home page selezionare Get all patients.

6. Copiare il nome di file di un'immagine. Ad esempio, patient-32589.jpg.

7. Nel menu nella parte superiore della pagina selezionare External companies.

8. Incollare il nome del file di immagine nel campo Patient image filename.

9. Selezionare Get Key per popolare il token di firma di accesso condiviso.

10. Selezionare View scan per visualizzare l'immagine.

Modificare il criterio di accesso archiviato

1. Accedere al portale di Azure usando le stesse credenziali con cui è stata attivata la sandbox.

2. Selezionare Tutte le risorse nel menu delle risorse del portale di Azure.

3. Nell'elenco di risorse selezionare l'account di archiviazione medical records.

4. Nel riquadro Panoramica selezionare Contenitori e quindi selezionare patient-images.

5. Nel menu immagini del paziente, in Impostazioni selezionare Criteri di accesso.

6. Si noti che l'app Web ha creato il criterio di accesso archiviato patient-images-policy.

7. A destra selezionare il menu ... e quindi scegliere Modifica dal menu a comparsa.

8. In Modifica criterio modificare Autorizzazione da lettura a elenco e selezionare OK per confermare.

9. Selezionare Salva nel riquadro patient-images | Criteri di accesso.

Testare una nuova firma di accesso condiviso

1. Tornare all'app Web. Nella pagina External companies creare un nuovo token di firma di accesso condiviso selezionando Get Key.

2. Selezionare View scan.

   

L'immagine non verrà restituita dall'archiviazione di Azure e verrà visualizzato un errore di autenticazione 403.