Nelle pagine precedenti abbiamo scoperto come preparare l'ambiente di sviluppo per realizzare applicazioni Java per Windows Azure, quindi abbiamo scritto una semplice Web application "Hello World" e siamo poi riusciti a vederla in azione sia in locale, tramite l'ambiente di emulazione, che sulla piattaforma reale in the cloud.
In questo e nel prossimo appuntamento realizzeremo una semplice applicazione Web che sfrutta lo storage sul cloud offerto da Windows Azure, cominciando prima di tutto con i servizi di Blob Storage.
Blob, acronimo di "binary large object", rappresenta qualsiasi file binario, come immagini, video e documenti. File di questo tipo possono essere persistiti sullo storage in the cloud offerto da Windows Azure potendo approfittare delle sue caratteristiche di scalabilità, alta disponibilità e georeplicazione.
Tutti i dati sono sempre accessibili tramite chiamate REST al servizio, verso URL della forma:
http://myaccountname.blob.core.windows.net
permettendo di fatto di accedere utilizzando qualunque linguaggio e piattaforma di sviluppo che sia in grado di effettuare chiamate HTTP.
I file, inoltre, sono organizzati in "container" che rappresentano concettualmente le cartelle del file system.
Uno Storage Account per Java
Perché le nostre applicazioni Java possano utilizzare i servizi di storage di Windows Azure creiamo un nuovo Storage Service nella sottoscrizione. Dal portale di gestione di Windows Azure, clicchiamo sul pulsante "Nuovo account di archiviazione" in alto a sinistra, che aprirà un form per creare il nuovo storage account.
Scegliamo un nome univoco arbitrario per l'account, che sarà uno degli URL dai quali raggiungere il servizio di storage di Windows Azure, quindi selezioniamo il datacenter in cui vogliamo creare l'account e clicchiamo OK.
Dopo pochi secondi il servizio sarà pronto, e selezionandolo verrà mostrato in alto a destra un pulsante "Visualizza" per la chiave di accesso primaria che ci tornerà utile più avanti.
Le librerie Java per Windows Azure
Per interagire con i servizi offerti dalla piattaforma di Cloud Computing di Windows Azure è possibile fare uso di alcune librerie che rendono più semplice lo sviluppo.
È possibile ottenere queste librerie in due modi: tramite download manuale oppure in modo automatico utilizzando Maven.
Download manuale delle librerie
Nel primo caso, è necessario scaricare ed installare le librerie dai seguenti link:
- Windows Azure Libraries for Java JAR
- Dipendenze di terze parti:
- commons-lang3-3.1.jar
- commons-logging-1.1.1.jar
- jackson-core-asl-1.8.3.jar
- jackson-jaxrs-1.8.3.jar
- jackson-mapper-asl-1.8.3.jar
- jackson-xc-1.8.3.jar
- javax.inject-1.jar
- jaxb-impl-2.2.3-1.jar
- jersey-client-1.10-b02.jar
- jersey-core-1.10-b02.jar
- jersey-json-1.10-b02.jar
- jettison-1.1.jar
- stax-api-1.0.1.jar
- javax.mail.jar
Scaricare le librerie con Maven
Se invece il proprio progetto fa uso di Maven, è possibile aggiungere la seguente dipendenza al file pom.xml per automatizzare il processo di ottenimento delle librerie:
<dependency>
<groupId>com.microsoft.windowsazure</groupId>
<artifactId>microsoft-windowsazure-api</artifactId>
<version>0.2.1</version>
</dependency>AzurePhotos
Ora che il nostro account di storage è pronto e abbiamo a disposizione tutte le librerie per Windows Azure, possiamo cominciare a realizzare una semplice applicazione che ci permette di testare l'utilizzo dello storage di Windows Azure effettuando l'upload di un'immagine e leggendo l'elenco dei blob presenti.
Per prima cosa apriamo Eclipse e creiamo un nuovo progetto, avendo cura di aggiungere al build path tutte le librerie scaricate poco fa.
Aggiungiamo quindi alla cartella "src" una nuova Java Class di nome "AzureStorage", e cominciamo con l'aggiungere gli import necessari al nostro codice:
import java.io.*;
import java.net.*;
import java.util.UUID;
import com.microsoft.windowsazure.services.core.storage.*;
import com.microsoft.windowsazure.services.blob.client.*;Le prime tre librerie ci serviranno per gestire l'input e i file, e per generare nomi univoci per i blob nel cloud storage, mentre le ultime due permettono di utilizzare alcune API ad alto livello per interagire con i servizi di storage di Windows Azure.
Subito dopo la riga di inizio della classe mostrata qui di seguito:
public class AzureStorage {aggiungiamo una riga di codice che definisca una stringa di connessione verso lo storage nel cloud di Windows Azure:
public static final String storageConnectionString = "DefaultEndpointsProtocol=https; AccountName=my_account_name; AccountKey=my_account_key";In questa stringa sono presenti due "segnaposti" da sostituire con i propri valori reali, che sono:
my_account_name: il nome dell'account di Storage nel quale vogliamo andare ad inserire le foto che caricheremo: è il nome che abbiamo scelto al momento della creazione dell'account sul portale di gestione di Windows Azure, nel mio caso è "azurephotos"my_account_key: la chiave di accesso per l'utilizzo di questo storage account, che si può trovare sempre nel portale di gestione selezionando l'account e premendo il tasto "Visualizza" in alto a destra come indicato precedentemente
Aggiungere file al Blob Storage e visualizzarli
All'interno del metodo main() scriviamo subito le poche righe di codice che ci permettono di salvare file sul Blob Storage, aprirli nel browser di default dell'utente e mostrare l'URL a cui sono accessibili.
try
{
CloudBlobClient blobClient = CloudStorageAccount.parse(storageConnectionString).createCloudBlobClient();
CloudBlobContainer container = blobClient.getContainerReference("photos");
if (container.createIfNotExist()) {
BlobContainerPermissions containerPermissions;
containerPermissions = new BlobContainerPermissions();
containerPermissions.setPublicAccess(BlobContainerPublicAccessType.CONTAINER);
container.uploadPermissions(containerPermissions);
}
System.out.println("Inserisci il percorso del file da caricare:");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String filetoupload = br.readLine();
// Upload an image file.
File file = new File(filetoupload);
String fileextension = filetoupload.substring(filetoupload.lastIndexOf("."));
String blobname = UUID.randomUUID().toString() + fileextension;
CloudBlockBlob blob = container.getBlockBlobReference(blobname);
if (file.exists()) {
blob.upload(new FileInputStream(file), file.length());
java.awt.Desktop.getDesktop().browse(blob.getUri());
}
System.out.println("Puoi trovare la tua immagine a questo URL:");
System.out.println(blob.getUri());
System.out.println("Grazie e arrivederci!");
}
catch (Exception e)
{
System.out.println(e.getMessage());
System.exit(-1);
}Analizziamolo brevemente insieme:
- il codice deve essere racchiuso in un blocco
try..catchper la gestione delle eccezioni; - anzitutto otteniamo un oggetto
CloudBlobClientper l'accesso al Blob Storage, attraverso la stringa di connessione definita in cima alla classe; - tramite il metodo
createIfNotExistsci assicuriamo di creare il container per memorizzare i blob. Per default i container sono privati, e quindi utilizziamo l'oggettoBlobContainerPermissionsper impostarne i permessi a "container pubblico"; - chiediamo quindi all'utente di immettere il percorso di un'immagine da caricare sul Cloud;
- apriamo il file e otteniamo la sua estensione. Generiamo quindi un nuovo UUID (Universally Unique IDentifier) da utilizzare, insieme all'estensione, come nome per il blob sul cloud;
- carichiamo il file sul Cloud Storage attraverso il metodo
upload; - lanciamo l'URI del blob sul cloud all'interno del browser predefinito dell'utente per mostrargli il file su Internet, e stampiamo anche l'URL completo;
La nostra applicazione completa, lanciata nella console integrata di Eclipse, apparirà quindi in modo simile alla figura qui di seguito:
