Il presente articolo è stato tradotto automaticamente.
Microsoft Azure
Automazione cloud multipiattaforma con JavaScript
Non everyoneknows Microsoft Azure è l'interfaccia della riga di comando di piattaforme (xplat-cli) per la gestione dei servizi di Platform-as-a-Service (PaaS) e Azure Infrastructure-as-a-Service (IaaS) ma. Per anni, Microsoft ha proposto l'utilizzo di Windows PowerShell come un linguaggio di script funzionava correttamente per il provisioning di risorse basato su cloud. Ma ora che gli sviluppatori più sono coinvolti nella distribuzione e migrazione di applicazioni cloud, rende più vantaggioso utilizzare JavaScript. API del resto di gestione del servizio di Azure rendere più semplice l'implementazione di piattaforme. Ufficiale xplat Azure-cli è implementata su Node. js, il runtime stesso spesso utilizzato per creare siti Web a elevate prestazioni e l'API JavaScript.
Edificio sopra Node. js rende scripting davvero multipiattaforma. Significa che è possibile eseguire gli script per la gestione delle macchine virtuali (VM), database SQL, siti Web e reti virtuali da qualsiasi computer. In tal modo è possibile eseguire script di automazione in una più ampia gamma di lingue e per una vasta gamma di computer client (vedere Figura 1).
.png "supportato ambienti di script")
Figura 1 supportato ambienti di script
Esistono molti vantaggi per gli script di provisioning di risorse cloud. Ad esempio, il portale Web non è ripetibile e richiede l'intervento umano. Un altro vantaggio è la possibilità di origine controllare i passaggi per eseguire il provisioning e distribuire il servizio utilizzando i valori di configurazione specifici diversi. In questo articolo esaminerò il processo di creazione di macchine virtuali associate a un gruppo di affinità e una rete virtuale utilizzando Node. js come il nostro ambiente di script di automazione per la creazione di script.
CLI multipiattaforma
Come CLI PowerShell Azure, la versione multipiattaforma offre la possibilità di script potente per gestire i servizi IaaS e PaaS. Consente di descrivere l'infrastruttura con codice, condividerlo con il team tramite il controllo del codice sorgente e automatizzare la creazione di distribuzioni di applicazioni di sviluppo, test e produzione.
Per iniziare a utilizzare la cli xplat, head rispetto a Nodejs.org e installare il pacchetto di Node. js appropriato per il sistema. Dopo l'installazione di nodo, è possibile visualizzare il pacchetto di azure cli su npmjs.org/package/azure-cli.
L'elenco dei package offre tutta la documentazione pertinente in CLI, nonché la semplice riga di comando per installare il pacchetto. Questo pacchetto è una CLI, pertanto è opportuno installarlo nell'archivio dei pacchetti Node. js globale specificando – g, in modo che è possibile effettuare chiamate della riga di comando Azure da qualsiasi directory, invece di dover richiamare in modo esplicito da una directory specifica CLI:
npm install azure-cli -g
Dopo poche righe di output da nodo Gestione pacchetti, è possibile la cli di azure installato e si può iniziare a utilizzarlo immediatamente.
CLI individuabile completamente autonomo
L'aspetto interessante di CLI è completamente automatica individuabile. È possibile iniziare facilmente digitando i comandi che si desidera ricevere ulteriori informazioni. Figura 2 mostra cosa accade quando si chiama il comando CLI base Azure.
.png "Azure il xplat-cli")
Figura 2 Azure il xplat-cli
Esiste un gran numero di possibili comandi che è possibile eseguire il comando di Azure base. Supponiamo si nota che il comando della macchina virtuale dall'output della Guida in Figura 2. È possibile analizzare il comando per comprendere meglio come utilizzarlo digitando il comando di azure vm (vedere Figura 3):
.png "CLI comando per creare una macchina virtuale")
Figura 3 CLI comando per creare una macchina virtuale
Questo stesso modello viene applicato a tutti i comandi CLI. Consente di creare un'interfaccia intuitiva per l'esplorazione della riga di comando.
Accedere la sottoscrizione da CLI
Ovviamente, la maggior parte dei comandi di Azure effettivamente non funzionerà fino a quando non effettuare una sottoscrizione Azure e indicare a quali sottoscrizione Azure utilizzare lo strumento della riga di comando. Come per gli strumenti di Windows PowerShell , è necessario fornire l'accesso CLI alla sottoscrizione. Per eseguire questa operazione in due modi: tramite un server Active Directory account utilizzando un Account di Microsoft organizzativa con il comando login o con un file. publishsettings portatile utilizzando l'account Importa comando. Quest ' ultimo è più portabile, poiché non richiede l'impostazione del conto organizzativa. Esiste un modo semplice per scaricare il. publishsettings eseguendo:
azure account download
Effettivamente verrà aperto il browser predefinito per un collegamento che sarà necessario accedere al proprio account Azure e scaricare il file. publishsettings. Dopo che il file viene scaricato, è possibile utilizzare il comando di importazione di account per caricare il file:
azure account import <PATH TO .publishsettings>
Utilizzare la sottoscrizione Azure nel. publishsettings per qualsiasi comando Azure chiamato su CLI, questo verrà impostato la riga di comando. Per verificare se funziona CLI, chiamare il comando di elenco del sito per l'output di tutti i siti Web in esecuzione sul tuo abbonamento.
Creare una macchina virtuale Dev da CLI
Le macchine virtuali sono particolarmente utili per gli scenari di reparti di sviluppo. Si può facilmente provisioning attraverso xplat-cli.
Alla fine si utilizzerà la CLI per automatizzare queste attività per la creazione di script con JavaScript su Nodejs. Ad esempio, creare una nuova VM Ubuntu. A tale scopo, è necessario individuare un'immagine di macchina virtuale. È possibile recuperare un elenco di macchine virtuali disponibili eseguendo il comando:
azure vm image list
L'output del comando Mostra un elenco di immagini pubbliche e private disponibili che è possibile utilizzare per eseguire il provisioning di una macchina virtuale. Le immagini pubbliche sono curated da Microsoft, ma è possibile utilizzare anche le proprie immagini caricate.
Per creare una macchina virtuale, è necessario un percorso di datacenter. Per ottenere un elenco di percorsi validi posizione della macchina virtuale, eseguire il comando:
azure vm location list
È possibile utilizzare questo percorso come input per la macchina virtuale è creare un comando per creare una nuova macchina virtuale:
azure vm create <yourdomainname> <imagename> <username> <password> --location '<selected datacenter region>'
Hai creato correttamente una macchina virtuale dalla riga di comando, osservare di quanto sia semplice, è possibile eseguire questa operazione utilizzando uno script.
Risorse Azure stoccaggio di script in JavaScript
Gli sviluppatori più siano tentando di utilizzare JavaScript per ogni tipo di situazione. Provisioning di risorse nel cloud non fa eccezione. Ciò supporta altri linguaggi di script, anche, ad esempio Bash, Batch e persino Windows PowerShell. La scelta della lingua si riduce alle piattaforme su cui verrà eseguita e le preferenze di lingua.
Microsoft rilascerà non appena il gestore delle risorse Azure, che verrà utilizzato un modello più dichiarativo anziché il modello a livello di codice. Fino a quando il gestore delle risorse Azure è pronto, è possibile utilizzare alcune di queste tecniche per automatizzare il provisioning nel cloud.
Se Sfoglia strettamente sulla documentazione cli azure npm (npmjs.org/package/azure-cli), si noterà che è dipendente da azure-cli chiamato azure scripty una libreria. Si scopre un utente nella finestra Apri origine comunitari Node. js ha già deciso di scrivere un adattatore della riga di comando per la cli azure per JavaScript. Poiché questa libreria è un wrapper della riga di comando, è possibile utilizzare gli stessi comandi come nella riga di comando in JavaScript. Ecco un esempio in cui verrà elencate tutte le macchine virtuali:
// Get the list of existing VMs on this subscription
scripty.invoke('vm list', function (err, result) {
if (err) {
return cb(err);
}
for (var i in result) {
console.log(result[i].VMName);
}
});
Per iniziare, osservare come si può fare un po' di macchine virtuali. Innanzitutto, installare i pacchetti necessari:
# a command-line wrapper for the azure-cli
npm install azure-scripty
# a small library that helps manage asynchronous tasks
npm install async
# a library that makes using JSON configuration files easy
npm install nconf
Per evitare hardcoded per le impostazioni di configurazione per la gestione temporanea, test e produzione, è possibile utilizzare un file di configurazione per mantenere gli script sufficientemente flessibili per ambienti diversi, ad esempio sviluppo, test e produzione. Chiamare config.json questo file di configurazione (vedere Figura 4).
Figura 4 Config.json mantiene le impostazioni flessibili
{
"vnet_name":"azuretedvnet2",
"vm_count": "3",
"vm_image_name":
"b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04-LTS-amd64-server-20140416.1-en-us-30GB",
"vm_base_name":"sedouardmachine",
"vm_username":"sedouard",
"vm_password":"p@assW0rd",
"affinity_group":{
"name":"azureteddemoaffinitygroup",
"label":"sedouard",
"location":"West US"
}
}
È possibile utilizzare tale file di configurazione per impostare un ambiente di sviluppo completo con tre macchine virtuali Ubuntu che fanno parte del gruppo di affinità (azureteddemoaffinitygroup) e una rete virtuale corrispondente (azuretedvnet2). Questo approccio è dichiarativo, ovvero che è necessario apportare modifiche a un file di configurazione per modificare il modo in cui che vengono impostati gli ambienti di sviluppo. È inoltre possibile impostare ulteriori versioni per la gestione temporanea, test e produzione e controllare ognuno di origine.
Il codice JavaScript personalizzato analizzerà il file di configurazione in modo che le dipendenze, quali i gruppi di affinità, eseguire il provisioning con i valori e nomi corretti. All'interno del file config.json, lo script è in grado di leggere il nome desiderato per il gruppo di affinità (azureteddemoaffinitygroup). Da questo punto, è possibile eseguire una query controllo per verificare se il gruppo di affinità è stata già creato scorrendo l'elenco dei gruppi di affinità provisioning già esistenti nel centro dati (vedere Figura 5).
Figura 5 creare un gruppo di affinità
//////////////////////////////////////////////////////////////////////////////
//Creates an affinity group if the specified one doesn't exist
//////////////////////////////////////////////////////////////////////////////
function createAffinityGroup(cb) {
console.log('Getting affinity groups...');
scripty.invoke('account affinity-group list', function (err, result) {
// Check for errors.
if (err) {
return cb(err);
}
console.log('Current affinity groups');
// For debugging purposes, list out names of existing affinity groups.
for (var i in result) {
console.log(result[i].name);
}
// Get the name of the desired affinity group from the config.json file.
var affinityGroup = nconf.get('affinity_group').name;
var label = nconf.get('affinity_group').label;
// Verify that affinity group hasn't already been created.
for (var i in result) {
if (result[i].name === affinityGroup && result[i].label === label) {
// The affinty group to use in the config already exists.
return cb();
}
}
// Create affinity group because it doesn't exist.
console.log('Specified affinity group ' + affinityGroup +
' does not exist, creating new one...');
var cmd = {
command: 'account affinity-group create',
positional: [affinityGroup],
location: '\"West US\"',
label: label
};
scripty.invoke(cmd, function (err) {
if (err) {
cb(err);
}
return cb();
});
});
}
Si noti come la libreria scripty di azure consente facilmente output di analisi da cli azure tramite l'argomento risultato della funzione callback. Consente inoltre di creare comandi CLI specificando in modo dichiarativo il comando, i parametri posizionali e denominati.
Il modello in nella figura 6 è lo stesso si utilizza per creare la rete virtuale e si utilizza la libreria di azure scripty nello stesso modo.
Figura 6 creare una rete virtuale
//////////////////////////////////////////////////////////////////////////////
//Creates the config specified vnet, if it doesn't already exist
//////////////////////////////////////////////////////////////////////////////
function createVirtualNetwork(cb) {
console.log('Getting networks...');
scripty.invoke('network vnet list', function (err, result) {
if (err) {
return cb(err);
}
var networkName = nconf.get('vnet_name');
for (var i in result) {
console.log(result[i].name);
}
// Check if VNet name listed in config.json exists.
// If it doesn't, create the VNet.
});
}
Parte del codice in nella figura 6 è stato omesso per brevità, ma esiste lo stesso modello. La risorsa richiesta è specificata nel file di configurazione. È necessario effettuare il provisioning se non esiste.
Dopo avere creato le dipendenze (i gruppi di affinità e le reti), è possibile creare un batch di macchine virtuali. Il numero di macchine virtuali che ti consente di creare è specificato nel campo vm_count nel file di configurazione config.json. In seguito lo stesso modello, elencare le macchine virtuali corrente nella sottoscrizione, controllare se una delle macchine virtuali si creerà già esiste e creare solo quelli che non esistono.
Figura 7 verrà seguire un semplice algoritmo per denominare le macchine virtuali utilizzando il campo vm_base_name la config.json e aggiungere i numeri 0 – (vm_count-1) alla fine del nome della macchina virtuale. Dato il config.json corrente, creare sedouardmachine0, sedouardmachine1 e sedouardmachine2 poiché nessuno dei due computer sono già presenti nella sottoscrizione.
Figura 7 creare un elenco di macchine virtuali per eseguire il provisioning
scripty.invoke('vm list', function (err, result) {
if (err) {
return cb(err);
}
// Read the desired VM name from config.json.
var baseName = nconf.get('vm_base_name');
var vmNames = [];
// Create the array of the computed VM names.
for (var z = 0; z < count; z++) {
vmNames.push(baseName + z.toString());
}
// Go through the list of existing VMs.
for (var i in result) {
for (var k in vmNames) {
if (result[i].VMName === vmNames[k]) {
// A VM we intend on creating already exists on this sub.
// Remove it on the list of VMs to create.
delete vmNames[k];
}
}
}
// vmNames now only contains the name of VMs that do not exist.
// Create them.
Figura 7 conferma l'elenco delle macchine virtuali non esistente nella matrice vmNames. Figura 8 utilizzerà la libreria async per gestire le attività asincrone che verranno inseriti off e creare le macchine virtuali.
Fine della figura 8 Provisioning di macchine virtuali
var domainName = nconf.get('dns_name');
var userName = nconf.get('vm_username');
var password = nconf.get('vm_password');
var imageName = nconf.get('vm_image_name');
var vmCreationTasks = [];
var taskArguments = [];
for (var m in vmNames) {
if (vmNames[m]) {
var cmd = {
command: 'vm create',
positional: [vmNames[m], imageName, userName, password],
'affinity-group': nconf.get('affinity_group').name,
'virtual-network-name': nconf.get('vnet_name')
}
// Define the async task function that will create each VM.
var task = function (args, cb) {
console.log('Creating vm ' + vmNames[args[0]]);
scripty.invoke(args[1], function (err) {
if (err) {
console.log('Vm creation failed: ' + vmNames[args[0]]);
return cb(err);
}
console.log('vm creation of ' + vmNames[args[0]] + ' successful');
cb();
});
}
// Bind this function to this context and pass the index and VM create command.
task = task.bind(this, [m, cmd]);
vmCreationTasks.push(task);
}
}
// Execute each VM creation task using the async libray.
async.series(vmCreationTasks, function (err) {
if (err) {
return cb(err);
}
console.log('All VMs created successfully!');
cb();
})
Figura 8 crea un'attività per ogni macchina virtuale è necessario creare. È quindi necessario aggiungere tali attività in una matrice, vmCreationTasks. Ogni funzione di attività è associato agli argomenti necessari per chiamare Azure cli azure con il nome della macchina virtuale corretto. Successivamente, utilizzare la libreria async esegue ogni attività in serie ed eseguire il callback con un valore null o un parametro di errore che indica se le macchine virtuali sono state create. Figura 9 conferma l'output dello script ed elenca tutte le VM sono state create.
.png "l'elenco finale delle macchine virtuali")
Figura 9, l'elenco finale delle macchine virtuali
Ciascuna delle macchine virtuali è stato creato correttamente. È possibile persino per verificare il portale per confermare che le macchine siano state create e fanno parte della rete virtuale specificata. Utilizzare il repository di GitHub a cli bit.ly/azure-xplat per avviare il programma di installazione di Azure utilizzando Node. js per la creazione di script.
Conclusioni
Xplat-cli Azure consente di automatizzare completamente il processo di configurazione e distribuzione delle risorse Azure in script portatile, che è possibile utilizzare su qualsiasi sistema operativo. Consente inoltre di utilizzare file di configurazione e controllo del codice sorgente per semplificare la condivisione. È possibile avere più versioni di config.json, che rappresenta un modello di distribuzione per test, prova e produzione di ciascuno di essi.
È inoltre possibile ricreare il processo di distribuzione rapida ed efficiente. Microsoft Azure prossima Gestione risorse di rilascio nel 2015 verrà andrà ben oltre ciò che è illustrato qui, ma questo approccio è praticamente identico al gestore delle risorse di Azure eseguirà, che è specificare in modo dichiarativo come il provisioning delle risorse nel centro dati di Azure.
Steven Edouard è un developer evangelist presso Microsoft. Prima che, ha lavorato nel team di runtime .NET come un test di software engineer distribuire i prodotti Microsoft .NET Framework 4.5 e compilazione nativa di .NET. La sua passione si trova in persone interessanti sull'infinito potenziali del cloud computing services tramite coinvolgere dimostrazioni tecniche, contenuto in linea e presentazioni.
Grazie al seguente esperto tecnico di Microsoft per la revisione di questo articolo: Bruno Terkaly