• Cloud, Open Source
• 27 Luglio 2016

Pochi giorni fa, il team di Azure ha annunciato il rilascio della beta di Azure Management Libraries for Java. Attraverso questa potente SDK, utilizzando semplici istruzioni Java, è possibile interagire con il Portale di Azure e avviare tutte le procedure classiche per la creazione o la gestione di un’infrastruttura cloud.

L’introduzione di questa SDK apre nuovi scenari e moltiplica le possibilità di un servizio che si arricchisce giorno per giorno: basti pensare alla creazione di una batteria di Macchine Virtuali attraverso un semplice “ciclo for” o far sì che la propria applicazione web possa modificare la configurazione di una Virtual Network. Questi sono solo alcuni esempi che è possibile realizzare. In particolare, in ambito di integrazioni tra sistemi eterogenei, la facilità del linguaggio Java unita alla potenza dei servizi di Azure possono portare alla realizzazione di nuove soluzioni ibride tra il mondo Dev e ITPro.

Vediamo ora come realizzare un piccolo progetto per testare le funzionalità di base di questa SDK.

Prerequisiti:

• Accesso ad Azure Service Principal
• A Java Developer Kit (JDK), v 1.7 o successive
• Eclipse o altro IDE per Java con il supporto Maven

Gestire l’accesso di Azure Service Principal

Il primo passo per permettere alla Azure Management Libraries for Java di accedere alla nostra sottoscrizione Azure è quello consentire l’accesso ad Azure Service Principal.

Effettuiamo l’accesso al portale di Azure e cliccando su Esplora provvederemo a cercare e selezionare la funzionalità di Active Directory.

Dopo aver cliccato su Active Directory, verremo dunque reindirizzati sul vecchio portale di Azure.

Quest’area ci mostra tutte le opzioni relative all’Active Directory di base della nostra sottoscrizione.

Per permettere l’accesso è necessario configurare una nuova applicazione, pertanto clicchiamo su Applicazioni e successivamente su Aggiungi.

Apparirà un popup con una scelta: dobbiamo selezionare Aggiungi un’applicazione che l’organizzazione sta sviluppando in quanto andremo a fornire le grant per l’accesso ad un’applicazione custom.

Nel popup successivo è necessario inserire un Nome che identificherà l’applicazione e selezionare l’Applicazione web e/o api web, indipendentemente dal fatto che l’applicazione sarà per il web o per client, in quanto l’SDK si comporta come se fosse un’applicazione web. Fare clic sulla freccia per passare alla fase successiva.

Il passaggio successivo richiede l’inserimento di una Url di accesso. Nel caso la nostra applicazione fosse una webapp, possiamo inserire l’indirizzo, altrimenti possiamo inserire http://localhost. Come URI ID App è necessario specificare un nome univoco della nostra applicazione.

Ultimata l’aggiunta dell’applicazione ad Azure Service Principal è necessario cliccare su Configura per recuperare i parametri per l’accesso.

Per prima cosa impostiamo la durata della Chiave dal menu a tendina. La Chiave verrà mostrata dopo aver salvato le impostazioni tramite il pulsante Salva che apparirà nella barra grigia in basso.

Dopo aver completato questa configurazione è necessario annotare 3 parametri:

• ID Client
  
• Chiave
  
• Tenant

Quest’ultimo è presente nella URL che visualizziamo nel browser ed è la parte che compare dopo la dicitura Directory/

Per concedere i privilegi di accesso alla nostra sottoscrizione torniamo sul Nuovo Portale di Azure e clicchiamo su Sottoscrizioni presente nel menu a sinistra. Prendiamo nota dell’ID della Sottoscrizione che servirà insieme ai 3 parametri che abbiamo recuperato nel passo precedente. Successivamente clicchiamo sulla Sottoscrizione.

All’interno del pannello della sottoscrizione, clicchiamo Tutte le impostazioni poi selezioniamo Utenti per accedere al pannello di gestione dei ruoli.

Nella lista degli Utenti, clicchiamo in alto sul pulsante Aggiungi, clicchiamo su Selezionare un ruolo e selezioniamo Proprietario.

Ci apparirà un campo di ricerca. All’interno di esso digitiamo il nome dell’applicazione che abbiamo creato negli step precedenti. Clicchiamo sul nome dell’applicazione, selezioniamola attraverso il pulsante Seleziona e confermiamo attraverso il pulsante OK.

Ritroveremo la nostra applicazione nella lista degli utenti con tutti i permessi assegnati.

Configurazione dell’ambiente di sviluppo

Passiamo ora alla parte più Dev della guida. Azure Management Libraries for Java mette a disposizione alcuni esempi di codice da cui partire per creare le proprie applicazioni. (https://github.com/Azure/azure-sdk-for-java).

Tra le funzionalità di base presenti nella SDK troviamo:

• Gestione della macchina virtuale
• Gestione dei set di disponibilità
• Elenco delle immagini delle macchine virtuali
• Gestione degli account di archiviazione
• Gestione delle reti virtuali
• Gestione delle interfacce di rete
• Gestione dei gruppi di sicurezza di rete
• Gestione degli indirizzi IP
• Gestione di gruppi di risorse
• Distribuzione di risorse con i modelli ARM

Vediamo come configurare il primo esempio relativo alla Gestione delle macchine virtuali (https://github.com/Azure-Samples/compute-java-manage-vm).

In questa guida utilizzeremo come ambiente di sviluppo Eclipse IDE for Java EE Developers (https://www.eclipse.org).

Una volta scaricato il progetto, è necessario estrarre il contenuto in una directory. In Eclipse, facciamo click destro nell’area del Project Explorer, selezioniamo Import e nel sottomenu selezioniamo di nuovo Import.

Nella finestra di Select, selezioniamo General, successivamente Project from Folder or Archive e clicchiamo su Next.

Nella finestra di Import Project from File System or Archive, attraverso il pulsante Directory, selezioniamo il percorso della cartella del progetto che abbiamo precedentemente scaricato ed estratto. Una volta selezionato facciamo click su Finish.

Il progetto importato riporta alcuni errori. Per correggerli è necessario cliccare con il tasto destro sul package, selezionare Refactor e poi Rename. Nella schermata successiva cancelliamo “main.java.” dal nome e clicchiamo su OK. Durante l’operazione di refactoring potrebbe apparire una finestra di conferma. In tal caso basta cliccare sul pulsante Continue. L’operazione di ridenominazione va effettuata su entrambi i package.

La fase successiva prevede la modifica del file pom.xml. Dobbiamo inserire all’interno del tag <dependencies> le seguenti dipendenze:

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.5</version>
</dependency>

Una volta salvato il file aggiorniamo le dipendenze del progetto. Clicchiamo con il tasto destro sul progetto, selezioniamo Maven e poi Update Project. Nella schermata successiva clicchiamo su OK e attendiamo l’aggiornamento che verrà notificato nella barra in basso a destra di Eclipse.

Passiamo ora al codice Java. Apriamo il file ManageVirtualMachine.java, troviamo l’inizio del main

public static void main(String[] args) {

e inseriamo subito dopo la dichiarazione di 4 variabili, sostituendo alle XXXX i valori che abbiamo recuperato nella fase di configurazione dei permessi sul portale di Azure.

final String client = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
final String tenant = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
final String key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
final String subscriptionId = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

Dopo le 4 variabili aggiungiamo l’istruzione per il funzionamento di Log4j:

BasicConfigurator.configure();

Questa libreria, sviluppata dalla Apache Software Foundation, permette di gestire un ottimo sistema di logging per tenere sotto controllo il comportamento di una applicazione.

Subito dopo individuiamo il blocco:

final File credFile = new File(System.getenv("AZURE_AUTH_LOCATION"));
Azure azure = Azure
.configure()
.withLogLevel(HttpLoggingInterceptor.Level.BASIC)
.authenticate(credFile)
.withDefaultSubscription();

e sostituiamolo con:

ServiceClientCredentials credentials = new ApplicationTokenCredentials(client, tenant, key, AzureEnvironment.AZURE);
Azure azure = Azure.authenticate(credentials).withSubscription(subscriptionId);

Con questo passaggio abbiamo sostituito la funzionalità ancora sperimentale che prevede l’accesso attraverso un file di configurazione delle credenziali. Utilizzeremo invece la classe ApplicationTokenCredentials che richiede semplicemente i parametri di accesso in forma di stringhe. L’ultimo parametro AzureEnvironment.AZURE rappresenta essenzialmente l’accesso al cloud pubblico di Azure.

Analizzando il file ManageVirtualMachine.java possiamo subito notare come le istruzioni per creare una macchina virtuale si riducano esclusivamente all’istanza di una classe VirtualMachine e al settaggio di tutti i parametri di configurazione (che, in modo classico, andremmo a impostare dall’interfaccia del portale di Azure):

VirtualMachine windowsVM = azure.virtualMachines().define(windowsVMName)
.withRegion(Region.US_EAST)
.withNewResourceGroup(rgName)
.withNewPrimaryNetwork("10.0.0.0/28")
.withPrimaryPrivateIpAddressDynamic()
.withoutPrimaryPublicIpAddress()
.withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_R2_DATACENTER)
.withAdminUserName(userName)
.withPassword(password)
.withSize(VirtualMachineSizeTypes.STANDARD_D3_V2)
.create();

Per lanciare l’esecuzione del programma fare click con il tasto destro su ManageVirtualMachine.java e selezionare Run As e poi selezionare Java Application.

L’applicazione inizierà ad eseguire le operazioni e potremo verificarne lo stato attraverso i messaggi della console.

Troveremo riscontro delle operazioni eseguire collegandoci al portale di Azure.

Come già discusso, questa guida ci ha permesso di creare una macchina virtuale con poche istruzioni utilizzando una semplice classe Java. Questo sottolinea, ancora una volta, l’attenzione di Microsoft nei confronti del mondo open source e di come Azure stia diventando il calderone dove miscelare le varie tecnologie con i vari ambienti e i vari linguaggi al fine di ottenere il massimo della produttività con il minimo sforzo di integrazione.