War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
Exportieren (0) Drucken
Alle erweitern

Steuern des Zugriffs auf Azure-BLOB-Container mit Java

Letzte Aktualisierung: Mai 2015

In diesem Leitfaden erfahren Sie, wie übliche Aufgaben mit dem Azure-BLOB-Speicherdienst ausgeführt werden. Die Beispiele sind in Java geschrieben, und in ihnen wird das Azure SDK für Java verwendet. Die behandelten Szenarien umfassen Hochladen, Auflisten, Herunterladen und Löschen von BLOB-Containern, BLOBs und Metadaten. Die Zugriffssteuerung ist elementar für eine sichere und produktive Verwendung von Cloudspeicher in Ihren Java-Anwendungen. Daher werden die Beispiele entsprechend dem veranschaulichten Typ der Zugriffssteuerung vorgestellt: öffentlicher Zugriff, SAS (Shared Access Signature, Signatur für freigegebenen Zugriff) und gespeicherte Zugriffsrichtlinie. Die Beispiele wurden alle mit dem Azure-Toolkit für Eclipse in Eclipse kompiliert und als Java-Anwendungen ausgeführt.

Nachdem Sie die Beispiele im Abschnitt über öffentlichen Zugriff ausgeführt haben, sollten Sie die folgenden Aufgaben mit Java erledigen können.

  • Erstellen einer Speicherkonto-Verbindungszeichenfolge zu Ihrem Azure-Speicherkonto

  • Erstellen eines neuen BLOB-Containers in Ihrem Speicherkonto

  • Anpassen des öffentlichen Zugriffs, den anonyme Benutzer auf die Containermetadaten, den BLOB-Inhalt und die BLOB-Metadaten haben

  • Hinzufügen von Metadaten zu einem BLOB-Container in Ihrem Speicherkonto

  • Hochladen eines BLOBs von Ihrem Computer in einen Azure-BLOB-Container

  • Hinzufügen von Metadaten zu einem BLOB in Ihrem Speicherkonto

  • Lesen von Containermetadaten als anonymer Benutzer

  • Auflisten aller BLOBs, die in einem Container gespeichert sind, als anonymer Benutzer

  • Lesen von BLOB-Metadaten als anonymer Benutzer

  • Herunterladen eines BLOBs aus einem Azure-Speicherkonto auf Ihren Computer als anonymer Benutzer

Ihre Java-Anwendung kann einen BLOB-Container in Azure-Speicher erstellen. Sie kann auch die Stufe des öffentlichen Lesezugriffs auf die BLOBs und die Metadaten angeben, die im Container gespeichert sind. Öffentlicher Zugriff ist die Leseberechtigungsstufe, die ein anonymer Benutzer automatisch erhält, der die öffentliche Zugriff-URL für den Container oder das BLOB besitzt. Sie können öffentlichen Zugriff nicht dazu verwenden, anonymen Benutzern Schreibberechtigungen für den Container einzuräumen. Müssen Sie Benutzern, die den Kontoschlüssel Ihres Azure-Speicherkontos nicht besitzen, Schreibberechtigung erteilen, müssen Sie diesen Benutzern ein Token in Form einer URL bereitstellen, die auf eine SAS (Shared Access Signature) oder eine SAS-Richtlinie verweist.

Ist der öffentliche Zugriff auf den BLOB-Container aktuell nicht deaktiviert (privat), kann ein anonymer Benutzer über eine öffentliche Zugriffs-URL wie die folgende alle BLOBs im Container lesen.

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

Obwohl der öffentliche Zugriff für einen neuen BLOB-Container standardmäßig deaktiviert ist, erhalten anonyme Benutzer Lesezugriff auf den Container, wenn der öffentliche Zugriff auf die URL für öffentlichen Zugriff zurückgeführt wird. Sie sollten nicht versuchen, Benutzern das Lesen eines BLOBs in Ihrem Container zu ermöglichen, indem Sie öffentlichen Zugriff aktivieren, denn dadurch wird öffentlicher Zugriff für den gesamten Container aktiviert. Ein Benutzer, der die URL für öffentlichen Zugriff für ein BLOB weiß, kann möglicherweise funktionierende URLs für andere BLOBs im Container erraten und erstellen. Öffentlicher Zugriff allein ist daher eine schwache Methode, um den Zugriff auf Ihre BLOB-Container zu steuern. Wenn Sie eine stärkere Kontrolle über den Zugriff auf BLOB-Inhalte und Containermetadaten benötigen, müssen Sie dem Container eine SAS oder eine SAS-Richtlinie zuordnen.

Um einen neuen BLOB-Container in Ihrem Azure-Speicherkonto zu erstellen oder die Stufe des öffentlichen Zugriffs auf einen vorhandenen BLOB-Container in Ihrem Konto zu ändern, benötigen den Kontonamen und den Kontoschlüssel für Ihr Azure-Speicherkonto. Sie müssen den Kontonamen und den Schlüssel verwenden, um eine Speicherverbindungszeichenfolge zu erstellen. In Ihrer Anwendung kann Java-Code, der dem folgenden Beispiel ähnelt, verwendet werden, um eine Speicherverbindungszeichenfolge zu erstellen und zurückzugeben. In diesem Leitfaden wird diese Account-Klasse in allen Beispielen verwendet, in denen der Kontoname und der Zugriffsschlüssel des Azure-Speichers bereitgestellt werden müssen.

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

Mit dieser Speicherkontozeichenfolge können Sie dann in Ihrer Anwendung Java-Code wie den folgenden verwenden, um einen neuen BLOB-Container namens "container1" zu erstellen, für den der öffentliche Zugriff deaktiviert (OFF) ist. Ist "container1" bereits vorhanden, wird beim Ausführen dieses Codes die Stufe des öffentlichen Zugriffs auf OFF zurückgesetzt. Beachten Sie, dass ein Containernamen in Kleinbuchstaben geschrieben sein muss.

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

Mit der Speicherkontozeichenfolge kann eine Anwendung außerdem Metadaten in Form eines HashMap<Zeichenfolge, Zeichenfolge>-Objekts in den Container schreiben. Im folgenden Java-Code werden den "container2"-Metadaten beispielsweise drei Elemente hinzugefügt.

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

Der öffentliche Zugriff für "container1" wurde deaktiviert, indem der Wert der "publicAccess"-Eigenschaft auf die entsprechende Konstante der "BlobContainerPublicAccessType"-Enumeration festgelegt wurde: OFF. Der Wert der "publicAccess"-Eigenschaft kann eine der folgenden drei Konstanten sein, die die Stufe des öffentlichen Lesezugriffs angeben.

  • BLOB – Ein öffentlicher Benutzer kann die Inhalte und Metadaten von BLOBs in diesem Container lesen, kann aber weder Containermetadaten lesen noch die BLOBs im Container auflisten.

  • CONTAINER – Ein öffentlicher Benutzer kann BLOB-Inhalte und -Metadaten sowie Containermetadaten lesen und kann die BLOBs im Container auflisten.

  • OFF – Deaktiviert den öffentlichen Zugriff. Nur der Kontobesitzer kann Ressourcen in diesem Container lesen.

Sie können öffentlichen Zugriff nicht dazu verwenden, anonymen Benutzern Schreibberechtigung zu erteilen. Sie können öffentlichen Zugriff aber dazu verwenden, einem anonymen Benutzer Leseberechtigung für BLOB-Inhalte, BLOB-Metadaten und Containermetadaten zu gewähren. Ist der öffentliche Zugriff für "container2" auf CONTAINER festgelegt, wird es einem anonymen Benutzers mit folgendem Java-Code ermöglicht, die Containermetadaten zu lesen. Sie müssen "downloadAttributes()" für das Containerobjekt aufrufen, um die Containermetadaten zu lesen.

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

Es sie daran erinnert, dass der öffentliche Zugriff den öffentlichen Lesezugriff für den gesamten Container bestimmt, d. h., wenn Ihre Anwendung öffentlichen Zugriff aktiviert, um das Lesen eines BLOBs zu ermöglichen, erhalten öffentliche Benutzer eventuell die Möglichkeit, alle BLOBs im Container aufzulisten und zu lesen. Der folgende Java-Code lädt beispielsweise das BLOB "image4.jpg" in den "container1" hoch und ändert die Stufe des öffentlichen Zugriffs von OFF in CONTAINER. Schließlich fügt der Code einige Metadaten hinzu, die für das BLOB "image4.jpg" vorgesehen sind. Die Datei "image4.jpg" ist zunächst lokal auf dem Computer des Kontobesitzers gespeichert.

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

Der öffentliche Zugriff CONTAINER ermöglicht es anonymen Benutzern, auf alle Blobs im Container zuzugreifen, und gibt anonymen Benutzern die Berechtigung, alle BLOBs im Container aufzulisten sowie alle weiteren BLOBs zu lesen, die in diesem Container vorhanden sind. Der folgende Code ermöglicht es einem anonymen Benutzer, die BLOBs aufzulisten.

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

Weil der öffentliche Zugriff für "container1" auf CONTAINER festgelegt ist, kann ein anonymer Benutzer die Metadaten und die Inhalte aller BLOBs im Container mithilfe von Java-Code lesen, der wie folgt aussieht. Sie müssen zuerst "downloadAttributes()" für das BLOB aufrufen, um die BLOB-Metadaten zu lesen.

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

Obwohl sich der öffentliche Zugriff auf BLOB-Container relativ einfach steuern lässt, müssen Sie auch SAS oder SAS-Richtlinien implementieren, wenn in Ihrer Java-Anwendung eine der folgenden Aktionen ausgeführt werden muss.

  • Gewähren von Zugriff für ausgewählte Nicht-Eigentümer des Speicherkontos, ohne allen anonymen Benutzern Zugriff verfügbar zu machen

  • Gewähren von temporärem Schreibzugriff sowie von Lesezugriff auf BLOB-Container für Nicht-Eigentümer des Speicherkontos

  • Einschränken des Zugriffs für Nicht-Eigentümer des Speicherkontos auf angegebene kurze Zeitspannen

  • Gewähren von temporärem Zugriff auf einen Container und dann die Möglichkeit zum Entziehen des Zugriffs, ohne den Container löschen oder den Speicherkontoschlüssel ändern zu müssen

Nachdem Sie die Beispiele im Abschnitt über SAS (Shared Access Signatures) ausgeführt haben, sollten Sie die folgenden Aufgaben mit Java erledigen können.

  • Generieren einer SAS, die mindestens einem Benutzer temporären Containerzugriff gewährt

  • Verteilen unterschiedlicher Berechtigungen an unterschiedliche Benutzer, ohne Zugriff für alle anonymen Benutzer zu gewähren

  • Gewähren von temporärem Lese-, Schreib- oder Löschzugriff auf einen BLOB-Container, aber auf keine anderen Container

  • Zugreifen auf einen privaten Container (öffentlicher Zugriff ist deaktiviert), ohne den Azure-Speicherkontoschlüssel zu wissen

  • Herunterladen eines BLOBs aus einem privaten BLOB-Container mit einer Einfach-SAS

  • Hochladen eines BLOBs in einen privaten BLOB-Container mit einer Einfach-SAS

  • Auflisten oder Löschen aller BLOBs in einem privaten Container, aber in keinem sonstigen Container

  • Lesen und Schreiben von Container- und BLOB-Metadaten

Eine SAS (Shared Access Signature, Signatur für gemeinsamen Zugriff) enthält alle Informationen, die erforderlich sind, um einem Benutzer kontrollierten Zugriff auf BLOBs zu gewähren, die in einem Azure-BLOB-Container gespeichert sind. Eine Einfach-SAS ist nicht mit einer SAS-Richtlinie verknüpft und bietet jedem Benutzer, der die SAS besitzt, für einen begrenzten Zeitraum unwiderruflichen Zugriff. Eine Einfach-SAS hat eine Ablaufzeit, die nicht verlängert werden kann. Sobald eine Einfach-SAS verteilt wurde, kann sie nicht mehr annulliert werden. Zugriff auf den Container kann vor der Ablaufzeit nur entzogen werden, indem der Azure-Speicherkontoschlüssel geändert wird.

Eine Anwendung, die den Azure-Speicherschlüssel besitzt, kann eine Einfach-SAS generieren, mit der Zugriff auf einen BLOB-Container gesteuert wird, der im Speicherkonto gespeichert ist. Dazu muss in ihr mindestens eine der folgenden Konstanten in der "SharedAccessBlobPermissions"-Enumeration eines "SharedAccessBlobPolicy"-Objekts angegeben sein. Eine SAS steuert den jeweiligen Zugriff auf Containerebene und gewährt denselben Zugriff auf alle BLOBs im Container.

  • READ – Lesen von Inhalten, Eigenschaften, Metadaten oder Sperrlisten eines beliebigen BLOBs im Container. Verwenden eines beliebigen BLOBs im Container als Quelle eines Kopiervorgangs.

  • WRITE – Erstellen oder Schreiben von Inhalten, Eigenschaften, Metadaten oder Sperrlisten für einen beliebigen BLOB im Container. Momentaufnahme oder Leasen des BLOBs. Ändern der BLOB-Größe (nur Seitenblob). Hinweis: Sie können keine Berechtigungen erteilen, um Containereigenschaften oder Metadaten zu lesen oder zu schreiben.

  • DELETE – Löschen eines beliebigen BLOBs im Container. Hinweis: Sie können keine Berechtigungen zum Löschen eines gesamten Containers gewähren.

  • LIST – Auflisten von BLOBs im Container.

Beispielsweise entspricht die folgende Zeichenfolge einer Einfach-SAS, die alle Informationen enthält, die für einen Zugriff auf den Container erforderlich sind.

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

Die SAS kann an die URL für öffentlichen Zugriff für das BLOB als Abfrageparameter angefügt werden, um eine SAS-URL zu erstellen. Da die SAS alle erforderlichen Informationen enthält, hat jeder Benutzer Zugriff, der diese URL besitzt. Beachten Sie, dass zum Erstellen einer funktionierenden URL ein Abfragesymbol (?) zwischen der URL für öffentlichen Zugriff und der SAS erforderlich ist.

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

Sobald diese URL verteilt ist, kann sie weder annulliert noch über die Ablaufzeit hinaus verlängert werden. Sie kann jeder Anwendung, die die URL erhält, Lese-, Schreib-, Auflist- und Löschzugriff auf die BLOBs im Container gewähren. Nach der Ablaufzeit funktioniert die URL nicht mehr, und es nicht möglich, sie erneut zu aktivieren.

Im folgende Java-Code erstellt einen BLOB-Container namens "container1", wenn dieser nicht bereits vorhanden ist. Im Code wird die Stufe des öffentlichen Zugriffs von "container1" auf OFF festgelegt. Der Code generiert eine Einfach-SAS-Zeichenfolge mit einer anwendbaren Zeitspanne von einer Stunde. Sie können eine Zeitspanne angeben, die länger ist als eine Stunde. Die Anwendbarkeitsspanne beginnt sofort und läuft eine Stunde später ab. Während der anwendbaren Zeitspanne hat jeder Benutzer, der die SAS besitzt, die folgenden Zugriffsberechtigungen für den Container: Lesen (READ), Schreiben (WRITE), Löschen (DELETE) und Auflisten (LIST). Wird dieser Code erneut ausgeführt, bevor die erste Ablaufzeit erreicht ist, werden die Berechtigungen, die die erste SAS erteilt hat, nicht widerrufen, und URLs, die auf der alten SAS basieren, funktionieren weiterhin. Nach der Ablaufzeit funktioniert eine URL, die mit der abgelaufenen SAS angefügt wird, nicht mehr. Wird dieser Code nach der Ablaufzeit erneut ausgeführt, generiert er eine neue gültige SAS, die Berechtigungen für eine weitere Stunde erteilen kann, die alte SAS wird aber nicht erneut aktiviert. Zu jeder Zeit wird der Zugriff anonymer Benutzer auf den Container durch die angegebene Stufe für den öffentlichen Zugriff gesteuert.

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

Während der einstündigen Zeitspanne der SAS-Anwendbarkeit kann eine Anwendung, die die SAS-URL für den BLOB-Container besitzt, mit Java-Code wie dem folgenden ein BLOB in "container1" schreiben. Es sei daran erinnert, dass anonymen Benutzern (öffentlicher Zugriff) keine Schreibberechtigung für BLOB-Container erteilt werden kann. Schließlich werden einige Informationen über den Autor des Bilds als Metadaten geschrieben, die mit dem BLOB gespeichert werden. Die SAS gewährt keinen Schreibzugriff auf die Containermetadaten.

Der folgende Java-Code ermöglicht es einem Benutzer, der die SAS besitzt, ein BLOB zu schreiben, ohne den Azure-Speicherkontoschlüssel zu wissen.

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

Eine Anwendung, die die SAS-URL besitzt, kann, weil zu den Berechtigungen der Beispiel-SAS auch die Leseberechtigung (READ) gehört, ein BLOB in "container1" lesen und den Inhalt dann mit Java-Code wie dem folgenden in eine lokale Datei schreiben, ohne den Azure-Speicherkontoschlüssel zu wissen. Schließlich liest der Code die Metadaten, die mit dem BLOB gespeichert wurden, und zeigt diese an.

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

Wie bereits beschrieben, können anonyme Benutzer die BLOBs in "container1" nicht auflisten, wenn der öffentliche Zugriff auf OFF festgelegt ist. Da LIST zu den Berechtigungen gehört, die der SAS zugeordnet sind, kann ein Benutzer, der die SAS-URL besitzt, mit folgendem Java-Code die BLOBs im Container auflisten, ohne den Azure-Speicherkontoschlüssel zu wissen.

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

Da DELETE zu den Berechtigungen gehört, die der SAS zugeordnet sind, kann ein Benutzer, der die SAS-URL besitzt, BLOBs in "container1" löschen. Es ist zu beachten, dass Sie einem Benutzer nicht die Berechtigung erteilen können, den BLOB-Container aus dem Speicherkonto zu löschen. Während der Zeitspanne der SAS-Anwendbarkeit kann der folgende Java-Code dazu verwendet werden, ein vorhandenes BLOB im Container zu löschen.

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

Folgen Sie diesen Empfehlungen, wenn Sie SAS (Shared Access Signatures, Signaturen für freigegebenen Zugriff) verwenden. Damit ist sichergestellt, dass der Zugriff sowohl in den Zugriffsberechtigungen als auch in der anwendbaren Zeitspanne so weit wie möglich eingeschränkt ist. Beachten Sie, dass SAS im Gegensatz zu öffentlichem Zugriff, der lediglich Lesezugriff auf Container und BLOBs ermöglicht, Lese- und Löschzugriff Ihre cloudbasierten Ressourcen erteilen kann. Wenn die SAS-URL in die Hände von nicht vorgesehenen Benutzern gerät, kann dies zur Zerstörung von Ressourcen in Ihrem Speicherkonto führen.

  • SAS sollten immer nur mit den Rechten erstellt werden, die mindestens erforderlich sind. Das heißt, ist nur Lesezugriff (READ) erforderlich, verteilen Sie keine SAS, die auch die Rechte zum Auflisten (LIST), Schreiben (WRITE) und Löschen (DELETE) gewährt.

  • Wenn eine SAS Berechtigungen hat, die nicht für die allgemeine Öffentlichkeit bestimmt sind, sollten Sie die SAS über HTTPS an die vorgesehenen Benutzer verteilen, denn HTTP-Anforderungen würden die vollständige SAS-URL über das Internet offenlegen.

  • Weil eine Einfach-SAS nicht annulliert werden kann, sollten Sie immer den zusätzlichen Schritt ausführen, eine SAS zu generieren, die einer auf Containerebene gespeicherten Zugriffsrichtlinie zugeordnet ist. Eine SAS, die mit einer gespeicherten Zugriffsrichtlinie erstellt wurde, kann vor der Ablaufzeit annulliert werden, ohne dass Ihr Azure-Kontoschlüssel geändert werden muss.

Nachdem Sie die Beispiele im Abschnitt über eine gespeicherte Zugriffsrichtlinie ausgeführt haben, sollten Sie die folgenden Aufgaben mit Java erledigen können.

  • Generieren einer Richtlinien-SAS, die Containerzugriff gewährt, der annulliert, erweitert oder aktualisiert werden kann

  • Annullieren aller Container-URLs nach der Verteilung ohne Änderung des Azure-Speicherschlüssels

  • Erneutes Aktivieren einer Richtlinien-SAS nach deren Ablaufzeit

  • Annullieren oder Aktualisieren von URLs anhand einer Richtlinien-SAS zu jedem Zeitpunkt und Ändern des Verhaltens alter URLs

  • Erstellen mehrerer Richtlinien für einen einzelnen Container

  • Gemeinsames Verwenden einer Richtlinien-SAS und einer Einfach-SAS für maximale Flexibilität der Zugriffssteuerung auf Containerebene

Ihre Anwendung kann eine umfassendere Zugriffssteuerung auf Containerebene haben, wenn in ihr eine Richtlinien-SAS statt einer Einfach-SAS verwendet wird. Eine Einfach-SAS hat eine begrenzte Zeitspanne für Anwendbarkeit und kann weder verlängert noch annulliert werden, nachdem sie verteilt wurde. Eine Richtlinien-SAS kann so angegeben werden, dass sie für unbestimmte Zeit gültig bleibt, und kann jederzeit annulliert oder geändert werden. Da die jeweilige Richtlinie nicht mit der SAS-URL, sondern mit dem Container gespeichert wird, kann die Richtlinie aktualisiert werden, ohne dass die SAS-Zeichenfolge (oder die an Benutzer verteilten URLs) geändert werden muss. Wenn die Richtlinie für den Container aktualisiert wurde, werden alle alten URLs, die mithilfe der Richtlinien-SAS erstellt wurden, erneut mit der aktualisierten Richtlinie aktiviert.

Der folgende Java-Code erstellt den BLOB-Container "container1" mit einer Richtlinie namens "heath", wenn "container1" nicht bereits vorhanden ist. In diesem Code wird die Stufe des öffentlichen Zugriffs von "container1" auf OFF festgelegt. Der Code generiert eine Richtlinien-SAS-Zeichenfolge mit einer anwendbaren Zeitspanne von drei Stunden. Die Anwendbarkeitsspanne beginnt sofort und läuft drei Stunden später ab. Während der anwendbaren Zeitspanne hat jeder Benutzer, der die Richtlinien-SAS besitzt, Lese- (READ), Schreib- (WRITE), Lösch- (DELETE) und Auflistzugriff (LIST) auf den Container. Nach der Ablaufzeit funktioniert eine mit der abgelaufenen SAS angefügte URL solange nicht, bis sie vom Besitzer des Speicherkontos mithilfe des Speicherkontoschlüssels erneut aktiviert wurde. Zu jeder Zeit wird der Zugriff anonymer Benutzer auf den Container durch die Stufe für den öffentlichen Zugriff gesteuert.

Wenn "container1" vorhanden ist, fügt dieser Code die Richtlinie "heath" dem Container hinzu. Ein BLOB-Container kann maximal vier gleichzeitige gespeicherte Zugriffsrichtlinien haben. Code, in dem veranschaulicht wird, wie einem Container mehrere gespeicherte Zugriffsrichtlinien zugeordnet werden, ist weiter unten gezeigt. Da eine Einfach-SAS ihre Informationen in der SAS-Zeichenfolge und eine Richtlinien-SAS ihre Informationen mit dem Container speichert, gibt es keine Auswirkungen auf die Zugriffsrechte von abgelaufenen Einfach-SAS-URLs, wenn eine Richtlinien-SAS hinzugefügt oder geändert wird. Sie können eine Einfach-SAS, die bereits verteilt wurde, nicht dadurch widerrufen, dass Sie eine Richtlinien-SAS für den Container erstellen.

Wenn Sie alle URLs, die mit der Richtlinien-SAS "heath" verteilt wurden, widerrufen und annullieren möchten, führen Sie den Code erneut mit einer Ablaufzeit aus, die vor der Startzeit liegt. Verwenden Sie beispielsweise den folgenden Code, um die Richtlinien-SAS zu widerrufen und alle Berechtigungen für URLs zu annullieren, die an Benutzer verteilt wurden.

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

Sie können auch eine Richtlinien-SAS nach deren Verteilung widerrufen, indem Sie die Richtlinie aus dem Container entfernen oder in ihm ersetzen. Wird der Code erneut für "container1" ausgeführt, wobei der Name der Richtlinie von "heath" in "baxter" geändert ist, wird die alte Richtlinie "heath" durch die neue Richtlinie "baxter" überschrieben. Dadurch werden alle URLs annulliert, die bereits mit der Richtlinien-SAS "heath" verteilt wurden. Allerdings können die alten URLs, die der Richtlinie "heath" zugeordnet sind, erneut aktiviert werden, indem der Code ein drittes Mal ausgeführt wird, wobei die Richtlinie von "baxter" in "heath" geändert wird (wodurch alle "baxter"-URLs annulliert werden).

Wird der folgende Java-Code vor oder nach der Ablaufzeit der Richtlinien-SAS erneut ausgeführt, wird die Richtlinien-SAS "heath" für weitere drei Stunden erneuert und werden alle widerrufenen oder abgelaufenen "heath"-URLs, die verteilt wurden, erneut aktiviert. Sie können die Berechtigungen auch jederzeit aktualisieren (d. h. Hinzufügen oder Entfernen von Zugriffsberechtigungen), indem Sie diesen Code bearbeiten und erneut ausführen.

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

Die Richtlinien-SAS kann an die Einfach-URL für das BLOB als Abfrageparameter angefügt werden, um auf gleiche Weise wie bei einer Einfach-SAS eine vollständige URL mit den gesteuerten Berechtigungen zu erstellen. Beachten Sie, dass die durch diesen Code generierte SAS nicht das Abfragesymbol (?) enthält, das zwischen der Einfach-URL und der Richtlinien-SAS erforderlich ist. Beispielsweise würde die Zeichenfolge für das BLOB "image3.jpg" in etwa wie folgt aussehen.

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

Anwendungen können die Richtlinien-SAS auf genau die gleiche Weise wie eine Einfach-SAS verwenden. Ersetzen Sie einfach die Richtlinien-SAS-Zeichenfolge durch die Einfach-SAS-Zeichenfolge in den vorherigen Beispielen, um die SAS-Richtlinie zum Steuern des Zugriffs auf Containerebene zu verwenden. Anwendungen, die eine Richtlinien-SAS haben, können Lese-, Schreib-, Auflist- oder Löschvorgänge für BLOBs im Container ausführen, ohne dass ihnen der Azure-Speicherkontoschlüssel bekannt ist.

Ein nützliches Muster für ein Implementieren einer flexiblen Zugriffssteuerung auf Containerebene besteht darin, vier gespeicherte Zugriffsrichtlinien für den Container zu verwenden, die Lese-, Schreib-, Auflist- bzw. Löschzugriff gewähren. Dieser Ansatz bietet weiterhin die Möglichkeit, auch kurzlebige Einfach-SAS-URLs für den Container nach Bedarf zu verteilen. Mit den Einfach-SAS-URLs können unabhängig von der Richtlinie Zugriffsberechtigungen erteilt werden. Im folgenden Java-Code wird veranschaulicht, wie vier gespeicherte Zugriffsrichtlinien für einen einzelnen Container gespeichert werden können.

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

Während der anwendbaren Zeitspanne der Richtlinien-SAS kann jede Anwendung, die die Richtlinien-SAS und die Einfach-URL für den BLOB-Container besitzt, die Berechtigungen verwenden, die der gespeicherten Zugriffsrichtlinie "heath" zugeordnet wurden. Ihre Anwendung kann die Richtlinien-SAS auf genau die gleiche Weise wie eine Einfach-SAS verwenden. Ersetzen Sie einfach in den zuvor bereitgestellten Beispielen die Richtlinien-SAS-Zeichenfolge durch die Einfach-SAS-Zeichenfolge, damit Ihre Anwendung Zugriff auf Containerebene auf "container1" mithilfe der Richtlinie "heath" steuert.

Siehe auch

Anzeigen:
© 2015 Microsoft