Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Controllo di accesso ai contenitori BLOB di Azure con Java

Controllo di accesso ai contenitori BLOB di Azure con Java

Aggiornamento: maggio 2015

Questa guida illustra come eseguire attività comuni usando il servizio di archiviazione BLOB di Azure. Gli esempi sono scritti in Java e usano Azure SDK per Java. Gli scenari trattati includono operazioni di caricamento, visualizzazione di elenchi, download ed eliminazione di contenitori BLOB, BLOB e metadati. Il controllo di accesso è fondamentale per l'uso dell'archiviazione cloud in modo sicuro e produttivo nelle applicazioni Java. Gli esempi vengono quindi presentati in base al tipo di controllo di accesso illustrato: accesso pubblico, firme di accesso condiviso e criteri di accesso archiviati. Tutti gli esempi sono stati compilati ed eseguiti come applicazioni Java in Eclipse mediante Azure Toolkit per Eclipse.

Dopo avere eseguito gli esempi nella sezione relativa all'accesso pubblico, si dovrebbe essere in grado di eseguire le attività seguenti con Java.

  • Creare una stringa di connessione all'account di archiviazione nell'account di archiviazione di Azure.

  • Creare un nuovo contenitore BLOB nell'account di archiviazione.

  • Modificare l'accesso pubblico degli utenti anonimi a metadati del contenitore, contenuto del BLOB e metadati del BLOB.

  • Aggiungere metadati a un contenitore BLOB nell'account di archiviazione.

  • Caricare un BLOB dal computer locale in un contenitore BLOB di Azure.

  • Aggiungere metadati a un BLOB nell'account di archiviazione.

  • Leggere i metadati del contenitore come utente anonimo.

  • Visualizzare l'elenco di tutti i BLOB archiviati in un contenitore come utente anonimo.

  • Leggere i metadati del BLOB come utente anonimo.

  • Scaricare un BLOB da un account di archiviazione di Azure nel computer locale come utente anonimo.

Con l'applicazione Java è possibile creare un contenitore BLOB nell'archiviazione di Azure e specificare il livello di accesso pubblico in lettura ai BLOB e ai metadati salvati nel contenitore. L'accesso pubblico è il livello di autorizzazione di lettura concesso automaticamente a un utente anonimo che possiede l'URL di accesso pubblico per il contenitore o il BLOB. Non è possibile usare l'accesso pubblico per concedere autorizzazioni di scrittura per il contenitore agli utenti anonimi. Se è necessario concedere l'autorizzazione di scrittura agli utenti che non possiedono la chiave dell'account per l'account di archiviazione di Azure, si dovrà fornire a questi utenti un token sotto forma di URL che fa riferimento a una firma di accesso condiviso o a criteri di accesso condiviso.

Se l'accesso pubblico al contenitore BLOB non è attualmente disattivato (privato), gli utenti anonimi saranno in grado di leggere tutti i BLOB nel contenitore usando un URL di accesso pubblico come il seguente.

http://contoso.blob.core.windows.net/container1/image2.jpg

Anche se per un nuovo contenitore BLOB l'accesso pubblico è disattivato per impostazione predefinita, se viene riattivato nell'URL di accesso pubblico concederà agli utenti anonimi l'accesso in lettura al contenitore. Evitare di abilitare la lettura di un BLOB nel contenitore attivandone l'accesso pubblico, perché verrà attivato per l'intero contenitore. Un utente che conosce l'URL di accesso pubblico per un BLOB potrebbe essere in grado di indovinare e creare URL funzionanti per altri BLOB nel contenitore. L'accesso pubblico da solo è quindi un metodo vulnerabile da usare per controllare l'accesso ai contenitori BLOB. Se è necessario un controllo più avanzato dell'accesso al contenuto del BLOB e ai metadati del contenitore, si dovrà associare al contenitore una firma di accesso condiviso o criteri di accesso condiviso.

Per creare un nuovo contenitore BLOB nell'account di archiviazione di Azure o per modificare il livello di accesso pubblico per un contenitore BLOB esistente nell'account, sono necessari il nome dell'account e la chiave dell'account per tale account di archiviazione di Azure. Il nome e la chiave dell'account saranno necessari per creare una stringa di connessione di archiviazione. L'applicazione potrà usare codice Java analogo all'esempio seguente per creare e restituire una stringa di connessione di archiviazione. La stessa classe Account viene usata per tutti gli esempi di questa guida che devono fornire il nome e la chiave dell'account di archiviazione di Azure.

public class Account 
{
   private String storageConnectionString;
   public Account()
   {
      this.storageConnectionString =
         "DefaultEndpointsProtocol=http;" + 
         "AccountName=contoso;" + 
         "AccountKey=nPPnnnnPPPPb5nnPnnn5nn5nPnnPnn50P/nnPnPPnPn+PnPPnP/n2nnPPPPn
            Pn55555PPPPn/P5nnP5P+n5n==";
   }
   public String getstorageconnectionstring()
   {
      return storageConnectionString;
   }
} 

Con questa stringa dell'account di archiviazione, l'applicazione potrà quindi usare codice Java analogo al seguente per creare un nuovo contenitore BLOB denominato container1 con accesso pubblico impostato su OFF. Se container1 esiste già, l'esecuzione di questo codice reimposta il livello di accesso pubblico su OFF. Si noti che il nome del contenitore deve essere espresso in lettere minuscole.

public class MakeContainer
{
   public static void main(String[] args)
         throws InvalidKeyException, URISyntaxException, StorageException 
   {
      // Exposes the storage account’s secret key
      Account creds = new Account();
      final String storageConnectionString = creds.getstorageconnectionstring();
      CloudStorageAccount storageAccount =
            CloudStorageAccount.parse(storageConnectionString);
      CloudBlobClient blobClient = storageAccount.createCloudBlobClient();
      CloudBlobContainer container =
            blobClient.getContainerReference("container1");
      container.createIfNotExists();
      BlobContainerPermissions containerPermissions =
            new BlobContainerPermissions();
      // All anonymous public access to the container is OFF
      containerPermissions.setPublicAccess(BlobContainerPublicAccessType.OFF);
      container.uploadPermissions(containerPermissions);
      BlobContainerPublicAccessType access1 =
            containerPermissions.getPublicAccess();
      System.out.println("Public access to " + 
            container.getName() + 
            " is set to: " + access1);
   }
}

Con la stringa dell'account di archiviazione, un'applicazione può anche scrivere metadati nel contenitore nel formato di oggetto HashMap<String, String>. Ad esempio, il codice Java seguente aggiunge tre elementi ai metadati di container2.

public class AddMetadata
{
   public static void main(String[] args)
         throws InvalidKeyException, URISyntaxException, StorageException
   {
      Account creds = new Account();
      final String storageConnectionString = creds.getstorageconnectionstring();
      CloudStorageAccount storageAccount =
            CloudStorageAccount.parse(storageConnectionString);
      CloudBlobClient blobClient = storageAccount.createCloudBlobClient();
      CloudBlobContainer container = blobClient.getContainerReference("container2");
      container.createIfNotExists();
      HashMap<String, String> meta = new HashMap<String, String>();
      meta.put("city", "San Francisco");
      meta.put("desc", "Photos");
      meta.put("date", "June 2012");
      container.setMetadata(meta);
      container.uploadMetadata();
      System.out.println("Container metadata was added to " + container.getName());
   }
}

L'accesso pubblico per container1 è stato disattivato impostando il valore della proprietà publicAccess sulla costante appropriata dell'enumerazione BlobContainerPublicAccessType -OFF. Il valore della proprietà publicAccess può essere una delle tre costanti seguenti che specificano il livello di accesso pubblico in lettura.

  • BLOB: il pubblico può leggere il contenuto e i metadati dei BLOB all'interno del contenitore specificato, ma non può leggere i metadati del contenitore o visualizzare l'elenco dei BLOB all'interno del contenitore.

  • CONTAINER: il pubblico può leggere il contenuto e i metadati dei BLOB e i metadati del contenitore e può visualizzare l'elenco dei BLOB all'interno del contenitore.

  • OFF: indica nessun accesso pubblico. Solo il proprietario dell'account può leggere le risorse in questo contenitore.

Non è possibile concedere agli utenti anonimi l'autorizzazione di scrittura usando l'accesso pubblico. È comunque possibile concedere a un utente anonimo l'autorizzazione di lettura per il contenuto del BLOB, i metadati del BLOB e i metadati del contenitore usando l'accesso pubblico. Se l'accesso pubblico per container2 è stato impostato su CONTAINER, il codice Java seguente consente a un utente anonimo di leggere i metadati del contenitore. Si noti che per leggere i metadati del contenitore, è necessario chiamare downloadAttributes() sull'oggetto contenitore.

public class ReadMetadata
{
   public static void main(String[] args)
         throws InvalidKeyException, URISyntaxException, StorageException
   {
      //Get a reference to the blob container
      //This does not expose the storage account’s secret key
      URI baseuri = new URI("https://contoso.blob.core.windows.net/");
      CloudBlobClient blobclient = new CloudBlobClient(baseuri);
      CloudBlobContainer container = blobclient.getContainerReference("container2");
      container.createIfNotExists();
      //Must be called before reading metadata
      container.downloadAttributes();
      HashMap<String, String> meta = container.getMetadata();
      System.out.println(container.getName() + " contains this metadata." );
      System.out.println(meta.get("city"));
      System.out.println(meta.get("desc"));
      System.out.println(meta.get("date"));
   }
}

Tenere presente che l'accesso pubblico determina l'accesso pubblico in lettura per l'intero contenitore e se l'applicazione attiva l'accesso pubblico per abilitare la lettura di un BLOB, per il pubblico potrebbe diventare possibile visualizzare l'elenco e leggere tutti i BLOB nel contenitore. Ad esempio, il codice Java seguente carica il BLOB image4.jpg in container1 e modifica il livello di accesso pubblico da OFF a CONTAINER. Infine, il codice aggiunge alcuni metadati associati al BLOB image4.jpg. Il file image4.jpg viene inizialmente archiviato localmente nel computer del proprietario dell'account.

public class ChangeAccess
{
   public static void main(String[] args)
      throws InvalidKeyException, URISyntaxException,
      StorageException, FileNotFoundException, IOException
   {
      Account creds = new Account();
      final String storageConnectionString =
         creds.getstorageconnectionstring();
      CloudStorageAccount account =
         CloudStorageAccount.parse(storageConnectionString);
      CloudBlobClient serviceClient = account.createCloudBlobClient();
      CloudBlobContainer container =
         serviceClient.getContainerReference("container1");
      container.createIfNotExists();
      BlobContainerPermissions containerPermissions;
      containerPermissions = new BlobContainerPermissions();
      //Anonymous users can list blobs and read blobs and metadata
      containerPermissions.setPublicAccess(BlobContainerPublicAccessType.CONTAINER);
      container.uploadPermissions(containerPermissions);
      CloudBlockBlob blob = container.getBlockBlobReference("image4.jpg");
      //Local source file will be uploaded to blob-container in cloud
      File fileReference = new File ("c:\\myimages\\image4.jpg");
      blob.upload(new FileInputStream(fileReference), fileReference.length());
      BlobContainerPublicAccessType access1 =
         containerPermissions.getPublicAccess();
      System.out.println("Public access to "
         + container.getName() + " is set to: " + access1);
   }
}

L'accesso pubblico impostato su CONTAINER consente agli utenti anonimi di accedere a tutti i BLOB nel contenitore, ma concede agli utenti anonimi anche l'autorizzazione per visualizzare l'elenco di tutti i BLOB nel contenitore e di leggere qualsiasi altro BLOB presente in quel contenitore. Il codice seguente consente a un utente anonimo di visualizzare l'elenco di tutti i BLOB.

public class EnableAnonymousList
{
   public static void main(String[] args)
      throws InvalidKeyException, URISyntaxException,
      StorageException, FileNotFoundException, IOException
   {
      URI baseuri = new URI("http://wingtiptoys.blob.core.windows.net");
      CloudBlobClient blobclient = new CloudBlobClient(baseuri);
      CloudBlobContainer container = blobclient.getContainerReference("container1");
      for (ListBlobItem blobItem : container.listBlobs())
      {
         System.out.println(blobItem.getUri());
      }
   }
}

Poiché l'accesso pubblico per container1 è impostato su CONTAINER, un utente anonimo può leggere i metadati e il contenuto di tutti i BLOB nel contenitore usando codice Java analogo al seguente. Per leggere i metadati dei BLOB, è necessario chiamare prima downloadAttributes() sull'oggetto BLOB.

public class ReadBlobs
{
   public static void main(String[] args)
      throws InvalidKeyException, URISyntaxException,
      StorageException, FileNotFoundException, IOException
   {
      URI baseuri = new URI("http://wingtiptoys.blob.core.windows.net");
      CloudBlobClient blobclient = new CloudBlobClient(baseuri);
      CloudBlobContainer container = blobclient.getContainerReference("container1");
      String blobName = "image4.jpg";
      CloudBlockBlob blob = container.getBlockBlobReference(blobName);
      // Required to read metadata
      blob.downloadAttributes();
      HashMap<String, String> user = new HashMap<String, String>();
      user = blob.getMetadata();
      String name = (user.get("firstname") + " " + user.get("lastname"));
      String age = ("age: " + user.get("age"));
      String present = ("Presenting talk? " + user.get("presenter"));
      System.out.println(name);
      System.out.println(age);
      System.out.println(present);
      // Image in cloud blob container will be downloaded to local file
      String localFileName = "c:\\myoutputimages\\" + blobName;
      File fileTarget = new File(localFileName);
      blob.download(new FileOutputStream(fileTarget));
      System.out.println("The blob at:\n"  + baseuri +  "/" + container.getName()
         + "/" + blobName + "\nwas downloaded from the cloud to local file:\n"
         + localFileName);
   }  
}

Anche se il controllo di accesso pubblico dei contenitori BLOB è relativamente facile da usare, è necessario implementare anche firme di accesso condiviso o criteri di accesso condiviso se l'applicazione Java deve eseguire una delle operazioni elencate di seguito.

  • Fornire l'accesso a specifici utenti non proprietari dell'account di archiviazione, senza esporre l'accesso a tutti gli utenti anonimi.

  • Concedere agli utenti non proprietari dell'account di archiviazione l'accesso temporaneo in scrittura, oltre che in lettura, ai contenitori BLOB.

  • Limitare l'accesso da parte degli utenti non proprietari dell'account di archiviazione a brevi periodi di tempo specificati.

  • Concedere l'accesso temporaneo a un contenitore ed essere in grado di revocarlo senza dover eliminare il contenitore o modificare la chiave dell'account di archiviazione.

Dopo avere eseguito gli esempi nella sezione relativa alle firme di accesso condiviso, si dovrebbe essere in grado di eseguire le attività seguenti con Java.

  • Generare una firma di accesso condiviso che fornisca l'accesso temporaneo al contenitore a uno o più utenti con firma di accesso condiviso.

  • Distribuire diverse autorizzazioni di accesso a diversi utenti, senza dover estendere l'accesso a tutti gli utenti anonimi.

  • Estendere l'accesso temporaneo in lettura, scrittura, visualizzazione dell'elenco o eliminazione a un solo contenitore BLOB, ma a nessun altro.

  • Accedere a un contenitore privato (accesso pubblico disattivato) senza conoscere la chiave dell'account di archiviazione di Azure.

  • Scaricare un BLOB da un contenitore BLOB privato tramite una firma di accesso condiviso di base.

  • Caricare un BLOB in un contenitore BLOB privato tramite una firma di accesso condiviso di base.

  • Visualizzare l'elenco o eliminare BLOB in un solo contenitore privato, ma in nessun altro.

  • Eseguire operazioni di lettura e scrittura sui metadati dei BLOB e del contenitore.

Una firma di accesso condiviso contiene tutte le informazioni necessarie per concedere a qualsiasi utente l'accesso controllato ai BLOB salvati in un contenitore BLOB di Azure. Una firma di accesso condiviso di base non è associata a criteri di accesso condiviso e fornirà l'accesso irrevocabile a qualsiasi utente che possiede una firma di accesso condiviso per un periodo di tempo limitato. Una firma di accesso condiviso di base è associata a una scadenza che non può essere estesa. Dopo la distribuzione di una firma di accesso condiviso, non sarà possibile annullarla e l'accesso al contenitore potrà essere revocato solo prima della scadenza tramite la modifica della chiave dell'account di archiviazione di Azure.

Un'applicazione che possiede la chiave di archiviazione di Azure può generare una firma di accesso condiviso di base per controllare l'accesso a un contenitore BLOB salvato nell'account di archiviazione, specificando una o più delle costanti seguenti nell'enumerazione SharedAccessBlobPermissions di un oggetto SharedAccessBlobPolicy. Una firma di accesso condiviso controlla l'accesso a livello di contenitore e concede lo stesso accesso a tutti i BLOB nel contenitore.

  • READ: lettura di contenuto, proprietà, metadati o elenco bloccato di tutti i BLOB nel contenitore. Uso di qualsiasi BLOB incluso nel contenitore come origine di un'operazione di copia.

  • WRITE: creazione o scrittura di contenuto, proprietà, metadati o elenco bloccato per tutti i BLOB nel contenitore. Creazione di snapshot o impostazione di lease del BLOB. Ridimensionamento del BLOB (solo BLOB di pagine). Nota: non è possibile concedere autorizzazioni di lettura o scrittura delle proprietà o dei metadati di un contenitore.

  • DELETE: eliminazione di tutti i BLOB nel contenitore. Nota: non è possibile concedere autorizzazioni per l'eliminazione di un intero contenitore.

  • LIST: visualizzazione dell'elenco dei BLOB nel contenitore.

Ad esempio, la stringa seguente rappresenta una firma di accesso condiviso di base che contiene tutte le informazioni necessarie per accedere al contenitore.

sp=rwdl&sr=c&sv=2012-02-12&se=2013-03-27T20%3A20%3A21Z&st=2013-03-27T19%3A20%3A21Z&sig=nn5PPPnnPPnPPnnPP%5PPPnnP55P5nnPP5nPn%5P5nnPPn5%5P

La firma di accesso condiviso può essere aggiunta alla fine dell'URL per il BLOB sotto forma di parametri di query per creare un URL di firma di accesso condiviso. Poiché la firma di accesso condiviso contiene tutte le informazioni necessarie, tutti gli utenti che possiedono questo URL potranno accedere. Si noti che per creare un URL funzionante è necessario specificare un simbolo di query (?) tra l'URL di accesso pubblico e la firma di accesso condiviso.

http://contoso.blob.core.windows.net/container1/image3.jpg?sp=rwdl&sr=c&sv=2012-02-12&se=2013-03-27T20%3A20%3A21Z&st=2013-03-27T19%3A20%3A21Z&sig=nn5PPPnnPPnPPnnPP%5PPPnnP55P5nnPP5nPn%5P5nnPPn5%5P

Dopo la distribuzione dell'URL, non sarà possibile annullarlo o estenderlo oltre la scadenza. Può concedere a tutte le applicazioni che lo ottengono l'accesso in lettura, scrittura, visualizzazione dell'elenco ed eliminazione per tutti i BLOB nel contenitore. Smette di funzionare dopo la scadenza e non può essere riattivato.

Il codice Java seguente crea un contenitore BLOB denominato container1, se non esiste già. Imposta il livello di accesso pubblico di container1 su OFF. Genera una stringa di firma di accesso condiviso di base con un intervallo di tempo applicabile pari a un'ora. È possibile specificare un intervallo di tempo maggiore di 1 ora. Il periodo di applicabilità inizia immediatamente e scade dopo un'ora. Durante l'intervallo di tempo applicabile, tutti gli utenti che possiedono la firma di accesso condiviso hanno autorizzazioni di accesso di tipo READ, WRITE, DELETE, e LIST per il contenitore. Una seconda esecuzione del codice prima della prima scadenza non permette di revocare le autorizzazioni concesse dalla prima firma di accesso condiviso e gli URL basati sulla firma di accesso condiviso precedente continueranno a funzionare. Dopo la scadenza, un URL a cui è stata aggiunta la firma di accesso condiviso scaduta non funzionerà. Se il codice viene eseguito di nuovo dopo la scadenza, genererà una nuova firma di accesso condiviso valida che può concedere autorizzazioni per un'altra ora, ma la firma di accesso condiviso precedente non verrà riattivata. Tutte le volte che un utente anonimo accede al contenitore, viene controllato tramite il livello di accesso pubblico specificato.

public class BasicSAS
{
   public static void main(String[] args)
      throws InvalidKeyException, URISyntaxException, StorageException
   {
      // Account key required to create SAS
      Account creds = new Account();
      final String storageConnectionString = creds.getstorageconnectionstring();
      CloudStorageAccount storageAccount =
         CloudStorageAccount.parse(storageConnectionString);
      CloudBlobClient blobClient = storageAccount.createCloudBlobClient();
      CloudBlobContainer container = blobClient.getContainerReference("container1");
      container.createIfNotExists();
      SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy();
      GregorianCalendar calendar =
         new GregorianCalendar(TimeZone.getTimeZone("UTC"));
      calendar.setTime(new Date());
      // Immediately applicable
      policy.setSharedAccessStartTime(calendar.getTime());
      // Applicable time span is 1 hour
      calendar.add(Calendar.HOUR, 1);
      policy.setSharedAccessExpiryTime(calendar.getTime());
      // SAS grants all access privileges
      policy.setPermissions(EnumSet.of(SharedAccessBlobPermissions.READ,
         SharedAccessBlobPermissions.WRITE, SharedAccessBlobPermissions.DELETE,
         SharedAccessBlobPermissions.LIST));
      BlobContainerPermissions containerPermissions =
         new BlobContainerPermissions();
      // Private blob-container with no access for anonymous users
      containerPermissions.setPublicAccess(BlobContainerPublicAccessType.OFF);
      container.uploadPermissions(containerPermissions);
      String sas = container.generateSharedAccessSignature(policy,null);
      System.out.println("The basic shared access signature :");
      System.out.println(sas);
   }
}

Durante l'intervallo di un'ora di applicabilità della firma di accesso condiviso, un'applicazione che possiede l'URL della firma di accesso condiviso per il contenitore BLOB potrà scrivere un BLOB in container1 usando codice Java analogo al seguente. Tenere presente che agli utenti anonimi (accesso pubblico) non può essere concessa l'autorizzazione in scrittura ai contenitori BLOB. Infine, alcune informazioni sull'autore dell'immagine vengono scritte sotto forma di metadati salvati con il BLOB. La firma di accesso condiviso non abilita l'accesso in scrittura ai metadati del contenitore.

Il codice Java seguente permette a un utente che possiede la firma di accesso condiviso di scrivere un BLOB senza conoscere la chiave dell'account di archiviazione di Azure.

public class SASBlober
{
   public static void main(String[] args)
      throws URISyntaxException, FileNotFoundException, StorageException, IOException
   {
      // This does not reveal the secret storage account key
      URI baseuri = new URI("http://wingtiptoys.blob.core.windows.net");
      CloudBlobClient blobclient = new CloudBlobClient(baseuri);
      MyUploadBlob("container1",
         "sp=rwdl&sr=c&sv=2012-02-12&se=2013-03-27T20%3A20%3A21Z&st=2013-03-27T19%3A20%3A21Z&sig=nn5PPPnnPPnPPnnPP%5PPPnnP55P5nnPP5nPn%5P5nnPPn5%5P",
         blobclient);
   }
   
   public static void MyUploadBlob(String containerName, String containerSAS,
      CloudBlobClient blobClient) throws URISyntaxException, StorageException,
      FileNotFoundException, IOException
   {
      //Uploads a local file to blob-container in cloud
      String blobName = "image3.jpg";
      String localFileName = "c:\\myimages\\image3.jpg";
      URI uri = new URI(blobClient.getEndpoint().toString() + "/" +
         containerName + "/" + blobName + "?" + containerSAS);
      CloudBlockBlob sasBlob = new CloudBlockBlob(uri, blobClient);
      HashMap<String, String> user = new HashMap<String, String>();
      user.put("firstname", "Joe");
      user.put("lastname", "Brown" );
      user.put("age", "28");
      user.put("presenter", "no");
      sasBlob.setMetadata(user);
      File fileReference = new File(localFileName);
      sasBlob.upload(new FileInputStream(fileReference), fileReference.length());
      System.out.println("The blob: " + blobName + " has been uploaded to:");
      System.out.println(uri);
   }
}

Poiché READ è inclusa nelle autorizzazioni associate alla firma di accesso condiviso di esempio, un'applicazione che possiede l'URL della firma di accesso condiviso potrà leggere un BLOB in container1 e quindi scrivere il contenuto in un file locale usando codice Java analogo al seguente e senza conoscere la chiave dell'account di archiviazione di Azure. Infine, il codice legge e visualizza i metadati archiviati con il BLOB.

public class SASread
{
   public static void main(String[] args)
      throws URISyntaxException, FileNotFoundException, StorageException, IOException
   {
      URI baseuri = new URI("http://wingtiptoys.blob.core.windows.net");
      CloudBlobClient blobclient = new CloudBlobClient(baseuri);
      MyDownloadBlob("container1",
         "sp=rwdl&sr=c&sv=2012-02-12&se=2013-03-27T20%3A20%3A21Z&st=2013-03-27T19%3A20%3A21Z&sig=nn5PPPnnPPnPPnnPP%5PPPnnP55P5nnPP5nPn%5P5nnPPn5%5P",
         blobclient);
   }
   
   public static void MyDownloadBlob(String containerName, String containerSAS, CloudBlobClient blobClient)
      throws URISyntaxException, StorageException, FileNotFoundException, IOException
   {
      //Downloads blob in cloud to local file
      String blobName = "image3.jpg";
      String localFileName = "c:\\myoutputimages\\image3.jpg";
      URI uri = new URI(blobClient.getEndpoint().toString() + "/" +
         containerName + "/" + blobName + "?" + containerSAS);
      CloudBlockBlob sasBlob = new CloudBlockBlob(uri, blobClient);
      File fileTarget = new File(localFileName);
      sasBlob.download(new FileOutputStream(fileTarget));
      HashMap<String, String> user = new HashMap<String, String>();
      user = sasBlob.getMetadata();
      String name = (user.get("firstname") + " " + user.get("lastname"));
      String age = ("age: " + user.get("age"));
      String present = ("Presenting talk? " + user.get("presenter"));
      System.out.println(name);
      System.out.println(age);
      System.out.println(present);
      System.out.println("The blob at:\n"  + uri
         + "\nwas downloaded from the cloud to local file:\n" + localFileName);
   }
}

Tenere presente che gli utenti anonimi non possono visualizzare l'elenco dei BLOB in container1 se l'accesso pubblico è stato impostato su OFF. Poiché LIST è stata inclusa con le autorizzazioni associate alla firma di accesso condiviso, un utente che possiede l'URL della firma di accesso condiviso potrà usare il codice Java seguente per visualizzare l'elenco dei BLOB nel contenitore senza conoscere la chiave dell'account di archiviazione di Azure.

public class ListBlobs 
{
   public static void main(String[] args)
      throws URISyntaxException,StorageException
   {
      URI baseuri = new URI("http://wingtiptoys.blob.core.windows.net");
      CloudBlobClient serviceclient = new CloudBlobClient(baseuri);
      MyList("container1",
         "sp=rwdl&sr=c&sv=2012-02-12&se=2013-03-27T20%3A20%3A21Z&st=2013-03-27T19%3A20%3A21Z&sig=nn5PPPnnPPnPPnnPP%5PPPnnP55P5nnPP5nPn%5P5nnPPn5%5P",
         serviceclient);
   }
   
   public static void MyList(String containerName,
      String containerSAS, CloudBlobClient serviceClient)
      throws URISyntaxException, StorageException
   {
      URI uri = new URI(serviceClient.getEndpoint().toString() + "/"
         + containerName + "?" + containerSAS);
      CloudBlobContainer container = new CloudBlobContainer(uri, serviceClient);
      for (ListBlobItem blobItem : container.listBlobs())
      {
         System.out.println(blobItem.getUri());
      }
   }  
}

Poiché DELETE è inclusa nelle autorizzazioni associate alla firma di accesso condiviso, un utente che possiede l'URL della firma di accesso condiviso potrà eliminare i BLOB in container1. Non è possibile concedere a un utente l'autorizzazione per eliminare il contenitore BLOB dall'account di archiviazione. Durante l'intervallo di applicabilità della firma di accesso condiviso, il codice Java seguente elimina un BLOB esistente nel contenitore.

public class SASDelete
{
   public static void main(String[] args)
      throws URISyntaxException, FileNotFoundException, StorageException, IOException
   {
      URI baseuri = new URI("http://wingtiptoys.blob.core.windows.net");
      CloudBlobClient blobclient = new CloudBlobClient(baseuri);
      MyDeleteBlob("container1",
         "sp=rwdl&sr=c&sv=2012-02-12&se=2013-03-27T20%3A20%3A21Z&st=2013-03-27T19%3A20%3A21Z&sig=nn5PPPnnPPnPPnnPP%5PPPnnP55P5nnPP5nPn%5P5nnPPn5%5P",
         blobclient);
   }
   public static void MyDeleteBlob(String containerName,
      String containerSAS, CloudBlobClient serviceClient)
      throws URISyntaxException, FileNotFoundException, IOException, StorageException
   {
      String blobName = "image4.jpg";
      URI uri = new URI(serviceClient.getEndpoint().toString() + "/" +
         containerName + "/" + blobName + "?" + containerSAS);
      CloudBlockBlob sasBlob = new CloudBlockBlob(uri, serviceClient);
      try
      {
         sasBlob.delete();
         System.out.println(blobName + " was deleted");
      }
      catch (StorageException storageException)
      {
         System.out.println(storageException.getMessage());
         System.exit(-1);
      }
   } 
}

Attenersi a queste procedure consigliate quando si usano firme di accesso condiviso, per assicurare che l'accesso sia quanto più possibile limitato, sia nelle autorizzazioni di accesso che per l'intervallo applicabile. Tenere presente che, mentre l'accesso pubblico concede semplicemente l'accesso in lettura a contenitori e BLOB, le firme di accesso condiviso possono consentire l'accesso in scrittura e di eliminazione alle risorse basate sul cloud. L'eventuale diffusione accidentale dell'URL di una firma di accesso condiviso a utenti non previsti potrebbe comportare l'eliminazione delle risorse archiviate nell'account di archiviazione.

  • Le firme di accesso condiviso dovrebbero essere sempre create con il minor livello di diritti necessario. In altri termini, se è necessario solo l'accesso READ, non distribuire una firma di accesso condiviso che conceda anche privilegi LIST, WRITE e DELETE.

  • Se a una firma di accesso condiviso sono associati diritti non destinati al pubblico in generale, distribuire la firma di accesso condiviso a utenti designati mediante HTTPS, perché le richieste HTTP renderebbero visibile su Internet l'URL completo della firma di accesso condiviso.

  • Poiché non è possibile revocare una firma di accesso condiviso di base, eseguire sempre il passaggio aggiuntivo per generare una firma di accesso condiviso associata a criteri di accesso archiviati a livello di contenitore. Una firma di accesso condiviso creata con criteri di accesso archiviati può essere revocata prima della scadenza senza dover modificare la chiave dell'account di Azure.

Dopo avere eseguito gli esempi nella sezione relativa ai criteri di accesso archiviati, si dovrebbe essere in grado di eseguire le attività seguenti con Java.

  • Generare una firma di accesso condiviso con criteri che concede l'accesso a un contenitore e che può essere revocata, estesa o aggiornata.

  • Annullare tutti gli URL del contenitore dopo la distribuzione, senza modificare la chiave di archiviazione di Azure.

  • Riattivare una firma di accesso condiviso con criteri dopo la scadenza.

  • Revocare o aggiornare gli URL in base a una firma di accesso condiviso con criteri in qualsiasi momento e modificare il comportamento degli URL precedenti.

  • Creare più criteri per un singolo contenitore.

  • Usare la firma di accesso condiviso con criteri insieme alla firma di accesso condiviso di base per offrire la massima flessibilità del controllo di accesso a livello di contenitore.

L'applicazione può esercitare un maggiore controllo di accesso a livello di contenitore usando una firma di accesso condiviso con criteri, invece della firma di accesso condiviso di base. Una firma di accesso condiviso di base ha un intervallo di tempo di applicabilità limitato e non può essere estesa o annullata dopo la distribuzione. Una firma di accesso condiviso con criteri può essere impostata su una durata di validità qualsiasi e può essere annullata o modificata in qualsiasi momento. Poiché i criteri vengono salvati con il contenitore invece che insieme all'URL della firma di accesso condiviso, sarà possibile aggiornarli senza dovere modificare la stringa della firma di accesso condiviso o gli URL distribuiti agli utenti. Quando i criteri per il contenitore vengono aggiornati, tutti gli URL precedenti creati usando la firma di accesso condiviso con criteri verranno riattivati con i criteri aggiornati.

Il codice Java seguente crea il contenitore BLOB container1 con un criterio denominato heath, se container1 non esiste già. Questo codice imposta il livello di accesso pubblico di container1 su OFF. Genera una stringa di firma di accesso condiviso con criteri con un intervallo di tempo applicabile pari a 3 ore. Il periodo di applicabilità inizia immediatamente e scade dopo tre ore. Durante l'intervallo di tempo applicabile, tutti gli utenti che possiedono la firma di accesso condiviso con criteri possono accedere in modalità READ, WRITE, DELETE e LIST al contenitore. Dopo la scadenza, un URL a cui è stata aggiunta la firma di accesso condiviso scaduta funzionerà solo dopo la riattivazione da parte del proprietario dell'account di archiviazione mediante la chiave dell'account di archiviazione. Tutte le volte che un utente anonimo accede al contenitore, viene controllato tramite il livello di accesso pubblico.

Se container1 esiste già, il codice aggiunge il criterio heath al contenitore. Un contenitore BLOB non può avere più di quattro criteri di accesso archiviati simultanei. Il codice che mostra come assegnare più criteri di accesso archiviati a un contenitore è riportato più avanti. Poiché una firma di accesso condiviso di base salva tutte le rispettive informazioni nella stringa della firma di accesso condiviso e la firma di accesso condiviso con criteri salva le rispettive informazioni insieme al contenitore, l'aggiunta o la modifica di una firma di accesso condiviso con criteri non influisce sui diritti di accesso degli URL delle firme di accesso condiviso di base non scadute. Non è possibile revocare una firma di accesso condiviso di base che è già stata distribuita creando una firma di accesso condiviso con criteri per il contenitore.

Per revocare e annullare tutti gli URL distribuiti con la firma di accesso condiviso con criteri heath, eseguire di nuovo il codice con una scadenza precedente l'ora di inizio. Ad esempio, sostituire il codice seguente per revocare la firma di accesso condiviso con criteri e annullare tutte le autorizzazioni per gli URL distribuiti agli utenti.

policy.setSharedAccessStartTime(calendar.getTime());
calendar.add(Calendar.HOUR, -1); //Expiration time is earlier than start time
policy.setSharedAccessExpiryTime(calendar.getTime());

È anche possibile revocare una firma di accesso condiviso con criteri dopo la distribuzione rimuovendo o sostituendo i criteri nel contenitore. Se il codice viene eseguito di nuovo su container1, cambiando il nome del criterio da heath a baxter, il nuovo criterio baxter sovrascriverà il criterio heath precedente. Verranno annullati tutti gli URL già distribuiti con una firma di accesso condiviso con criteri heath. È tuttavia possibile riattivare gli URL precedenti associati al criterio heath eseguendo di nuovo il codice una terza volta cambiando il criterio da baxter a heath, in modo da annullare tutti gli URL baxter.

Se il codice Java seguente viene eseguito di nuovo prima o dopo la scadenza della firma di accesso condiviso con criteri, tale firma di accesso condiviso con criteri heath verrà rinnovata per altre 3 ore e verranno riattivati eventuali URL heath revocati o scaduti già distribuiti. È anche possibile aggiornare le autorizzazioni, ad esempio aggiungere o rimuovere autorizzazioni di accesso, in qualsiasi momento tramite la modifica e la riesecuzione del codice.

public class PolicySAS
{
   public static void main(String[] args)
      throws InvalidKeyException, URISyntaxException, StorageException
   {
      // Account key required to create SAS
      Account creds = new Account();
      final String storageConnectionString = creds.getstorageconnectionstring();
      CloudStorageAccount storageAccount =
         CloudStorageAccount.parse(storageConnectionString);
      CloudBlobClient blobClient = storageAccount.createCloudBlobClient();
      CloudBlobContainer container = blobClient.getContainerReference("container1");
      container.createIfNotExists();
      SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy();
      GregorianCalendar calendar =
         new GregorianCalendar(TimeZone.getTimeZone("UTC"));
      calendar.setTime(new Date());
      // Immediately applicable
      policy.setSharedAccessStartTime(calendar.getTime());
      // Applicable time-span is 3 hours
      calendar.add(Calendar.HOUR, 3);
      policy.setSharedAccessExpiryTime(calendar.getTime());
      policy.setPermissions(EnumSet.of(SharedAccessBlobPermissions.READ,
            SharedAccessBlobPermissions.WRITE,
            SharedAccessBlobPermissions.DELETE,
            SharedAccessBlobPermissions.LIST));
      BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
      //Private container with no access for anonymous users
      containerPermissions.setPublicAccess(BlobContainerPublicAccessType.OFF);
      //Name the shared access policy: heath
      containerPermissions.getSharedAccessPolicies().put("heath", policy);
      container.uploadPermissions(containerPermissions);
      //Generate the policy SAS string for heath access
      String sas = container.generateSharedAccessSignature(
         new SharedAccessBlobPolicy(),"heath");
      System.out.println("The stored access policy signature:");
      System.out.println(sas);
   } 
}

La firma di accesso condiviso con criteri può essere aggiunta alla fine dell'URL di base per il BLOB sotto forma di parametri di query per creare un URL decorato con le autorizzazioni controllate, in modo analogo a una firma di accesso condiviso di base. Si noti che la firma di accesso condiviso generata dal codice precedente non include il simbolo di query (?) obbligatorio tra l'URL di base e la firma di accesso condiviso con criteri. Ad esempio, la stringa per il BLOB image3.jpg sarà analoga al codice seguente.

http://contoso.blob.core.windows.net/container1/image3.jpg?sr=c&sv=2012-02-12&sig=nnPn5P5nnPPnn5Pnn5PPnPPPnPPP5PPPPPP%5PPnn5PPn%55&si=heath

Le applicazioni possono usare la firma di accesso condiviso con criteri esattamente nello stesso modo in cui usano una firma di accesso condiviso di base. È sufficiente inserire la stringa della firma di accesso condiviso con criteri al posto della stringa della firma di accesso condiviso di base negli esempi precedenti, in modo da usare i criteri di accesso condiviso per controllare l'accesso a livello di contenitore. Le applicazioni con firma di accesso condiviso con criteri possono eseguire operazioni di lettura, scrittura, visualizzazione dell'elenco o eliminazione sui BLOB nel contenitore, senza conoscere la chiave dell'account di archiviazione di Azure.

Un modello utile per implementare il controllo di accesso flessibile a livello di contenitore consiste nello specificare quattro criteri di accesso archiviati per il contenitore che concedano rispettivamente l'accesso in lettura, scrittura, visualizzazione dell'elenco ed eliminazione. Questo approccio permette comunque di distribuire anche URL di firma di accesso condiviso di base di breve durata per il contenitore, in base alla necessità. Gli URL di firma di accesso condiviso di base possono concedere autorizzazioni di accesso indipendenti dai criteri. Il codice Java seguente illustra come salvare quattro criteri di accesso archiviati per un singolo contenitore.

public class StoredAccessPolicies
{
   public static void main(String[] args)
      throws InvalidKeyException, URISyntaxException, StorageException
   {
      Account creds = new Account();
      final String storageConnectionString = creds.getstorageconnectionstring();
      CloudStorageAccount storageAccount =
         CloudStorageAccount.parse(storageConnectionString);
      CloudBlobClient blobClient = storageAccount.createCloudBlobClient();
      CloudBlobContainer container = blobClient.getContainerReference("container1");
      container.createIfNotExists();
      BlobContainerPermissions containerPermissions =
         new BlobContainerPermissions();
      containerPermissions.setPublicAccess(BlobContainerPublicAccessType.OFF);
      SharedAccessBlobPolicy read = new SharedAccessBlobPolicy();
      SharedAccessBlobPolicy write = new SharedAccessBlobPolicy();
      SharedAccessBlobPolicy list = new SharedAccessBlobPolicy();
      SharedAccessBlobPolicy delete = new SharedAccessBlobPolicy();
      GregorianCalendar calendar =
         new GregorianCalendar(TimeZone.getTimeZone("UTC"));
      SharedAccessBlobPolicy[] policies =
         new SharedAccessBlobPolicy[]
         {read, write, list, delete};
      calendar.setTime(new Date());
      for(SharedAccessBlobPolicy policy : policies)
      {
         policy.setSharedAccessStartTime(calendar.getTime());
      }
      calendar.add(Calendar.HOUR, 1);
      for(SharedAccessBlobPolicy policy : policies)
      {
         policy.setSharedAccessExpiryTime(calendar.getTime());
      }
      read.setPermissions(EnumSet.of(SharedAccessBlobPermissions.READ));
      write.setPermissions(EnumSet.of(SharedAccessBlobPermissions.WRITE));
      list.setPermissions(EnumSet.of(SharedAccessBlobPermissions.LIST));
      delete.setPermissions(EnumSet.of(SharedAccessBlobPermissions.READ,
         SharedAccessBlobPermissions.DELETE));
      containerPermissions.getSharedAccessPolicies().put("r", read );
      containerPermissions.getSharedAccessPolicies().put("w", write);
      containerPermissions.getSharedAccessPolicies().put("l", list);
      containerPermissions.getSharedAccessPolicies().put("d", delete);
      container.uploadPermissions(containerPermissions);
      String[] pr = new String[]{"r", "w", "l", "d"};
      for(String p : pr)
      {
         System.out.println(
            container.generateSharedAccessSignature(new SharedAccessBlobPolicy(),p));
      }
   }
}

Durante l'intervallo di tempo applicabile della firma di accesso condiviso con criteri, tutte le applicazioni che possiedono la firma di accesso condiviso con criteri e l'URL di base per il contenitore BLOB possono usare le autorizzazioni associate al criterio di accesso archiviato heath. L'applicazione può usare la firma di accesso condiviso con criteri esattamente nello stesso modo in cui usa una firma di accesso condiviso di base. È sufficiente inserire la stringa della firma di accesso condiviso con criteri al posto della stringa della firma di accesso condiviso di base negli esempi precedenti per controllare l'accesso a livello di contenitore a container1 mediante il criterio heath.

Vedere anche

Mostra:
© 2015 Microsoft