• Artikel

Dieser Artikel wurde maschinell übersetzt.

Microsoft Azure

Plattformübergreifende Cloud-Automatisierung mit JavaScript

Steven Edouard

Nicht Everyoneknows Microsoft Azure hat die Cross-Plattform-Befehlszeilenschnittstelle (Xplat-Cli) zur Verwaltung von Azure Infrastructure-as-a-Service (IaaS) und Platform-as-a-Service (PaaS) Dienste, aber es funktioniert. Jahrelang hat Microsoft dafür ausgesprochen, mit Windows PowerShell als Skriptsprache, die Bereitstellung von Cloud-basierte Ressourcen gut funktionierte. Aber jetzt, mehr Entwickler bereitstellen und Verschieben von Anwendungen in die Cloud beteiligt sind, es macht mehr Sinn, JavaScript zu verwenden. Die Azure Service Management REST-APIs erleichtern diese Cross-Plattform-Implementierung. Die offizielle Azure Xplat-Cli ist auf Node.js, häufig verwendet, um Hochleistungs-Web-Sites und APIs mit JavaScript erstellen derselben Laufzeit aufgesetzt.

Gebäude auf Node.js scripting macht wirklich Cross-Plattform. Es bedeutet, dass Sie Ihre Skripte zur Verwaltung virtueller Maschinen (VMs), SQL-Datenbanken, Websites und virtuelle Netzwerke von jeder Maschine ausführen können. Dies befreit Sie um Automatisierungsskripts in eine größere Vielfalt von Sprachen und bei einer größeren Anzahl von Client-Computern zu tun (siehe Abbildung 1).

unterstützt Skriptumgebungen
Abbildung 1 unterstützt Skriptumgebungen

Es gibt viele Vorteile für die Skripterstellung Wolke Ressourcenbereitstellung. Zum Beispiel das Web-Portal ist nicht wiederholbar und erfordert menschliches Zutun. Ein weiterer Vorteil ist die Möglichkeit zur Quelle steuern die Schritte zur Bestimmung und Bereitstellung von Ihren Dienst mit unterschiedlichen spezifischen Konfigurationswerte. In diesem Artikel werde ich den Prozess des Erstellens von VMs, die mit einer Bezugsgruppe und ein virtuelles Netzwerk mit Node.js als unser Skript-Automatisierungsumgebung scripting durchlaufen.

Die Cross-Plattform-CLI

Wie die Azure PowerShell CLI bietet die Cross-Plattform-Version leistungsfähige Skript-Fähigkeit, IaaS und PaaS-Dienste verwalten. Dadurch können Sie Ihre Infrastruktur mit Code zu beschreiben, teilen Sie es mit Ihrem Team über Quellcodeverwaltung und Automatisierung der Erstellung von Entwicklungs-, Test- und Herstellung-Anwendung-Bereitstellungen.

Informationen zum Einstieg mit dem Xplat-Cli, gehen Sie zu Nodejs.org und das entsprechende Node.js-Paket für Ihr System zu installieren. Sie können das Azure-Cli-Paket auf anzeigen, nach der Installation von Knoten, npmjs.org/package/azure-cli.

Das Paket-Angebot gibt Ihnen die entsprechende Dokumentation auf der CLI sowie der einfachen Befehlszeile um das Paket zu installieren. Dieses Paket ist eine CLI, so es Sinn macht, installieren Sie es im globalen Node.js Paketspeicher durch Angabe – g, Azure Befehlszeilen Anrufe von einem beliebigen Verzeichnis, anstatt explizit die CLI ein bestimmtes Verzeichnis aufrufen vornehmen:

npm install azure-cli -g

Nach ein paar Zeilen der Ausgabe aus dem Knoten Paket-Managerhaben Sie Ihre Azure-Cli installiert, und Sie können beginnen, es sofort zu benutzen.

Komplett selbst erkennbaren CLI

Das Tolle an der CLI ist, dass es komplett selbst sichtbar ist. Sie können einfach loslegen, einfach durch Eingabe von Befehlen, die, denen Sie gerne mehr darüber wissen möchten. Abbildung 2 zeigt, was passiert, wenn Sie den Basis-CLI-Befehl Azure aufrufen.

The Azure Xplat-cli
Abbildung 2 The Azure Xplat-cli

Es gibt eine Vielzahl von möglichen Befehle kannst du aus dem Basis-Azure-Befehl. Sagen Sie bemerken den Vm-Befehl aus der Hilfe-Ausgabe in Abbildung 2. Sie können einen Drilldown in den Befehl aus, um besser zu verstehen, wie man es benutzt, durch einfaches Eintippen des Befehls Azure Vm (siehe Abbildung 3):

CLI-Befehl zum Erstellen einer virtuellen Maschine
Abbildung 3-CLI-Befehl zum Erstellen einer virtuellen Maschine

Das gleiche Muster gilt für alle Befehle in der CLI. Eine intuitive Oberfläche für die Erkundung der Befehlszeile erstellt.

Zugriff auf Ihr Abonnement von CLI

Es überrascht nicht, wird nicht die meisten Azure Befehle tatsächlich funktioniert, bis Sie melden Sie sich für ein himmelblau-Abonnement und dem Befehlszeilentool welche Azure Abonnements sagen verwenden. Ähnlich wie bei der Windows PowerShell -Tools, müssen Sie dem CLI-Zugang zu Ihrem Abonnement zu geben. Es gibt zwei Möglichkeiten, dies zu tun — über eine Active Directory-Konto mit einer Organisationseinheit Microsoft-Konto mit den Befehl Login oder mit einer tragbaren .publishsettings-Datei, die mit dem Konto importieren Befehl. Die letztere Methode ist besser portierbar, da es nicht ist die organisatorische Kontoeinrichtung erforderlich. Es gibt eine einfache Möglichkeit, Ihre .publishsettings durch Ausführen von herunterladen:

azure account download

Tatsächlich wird als Standardbrowser auf einen Link geöffnet, die Sie zu Ihrem Azure Konto anmelden und Ihre .publishsettings-Datei herunterladen. Nachdem die Datei heruntergeladen hat, können Sie den Konto-Import-Befehl, um die Datei zu laden:

azure account import <PATH TO .publishsettings>

Dies wird die Befehlszeile einrichten, Azure Abonnements angegeben in der .publishsettings für jeden Azure Befehl fordert die CLI verwenden. Um festzustellen, ob die CLI funktioniert, rufen Sie den Befehl List Website alle Websites, die auf Ihr aktuelles Abonnement ausgegeben.

Erstellen einer Dev-VM aus dem CLI

VMs eignen sich besonders für DevOps Szenarien. Sie können sie leicht durch die Xplat-Cli bereitstellen.

Ich werde schließlich die CLI verwenden, diese Aufgaben zu automatisieren, indem sie mit JavaScript auf Nodejs scripting. Zum Beispiel erstelle ich eine neue Ubuntu-VM. Dazu brauche ich ein VM-Image zu finden. Ich kann eine Liste der verfügbaren VMs holen, indem Sie den Befehl ausführen:

azure vm image list

Die Ausgabe des Befehls zeigt eine Liste der verfügbaren öffentlichen und privaten Bilder, die Sie verwenden können, um eine VM bereitzustellen. Die öffentlichen Bilder sind kuratiert von Microsoft, aber können Sie auch eigene hochgeladene Bilder.

Um eine VM zu erstellen, benötigen Sie einen Datacenter-Speicherort. Führen Sie diesen Befehl, um eine Liste der gültigen Positionen zu erhalten, Sie Ihre VM platzieren:

azure vm location list

Als Eingabe für die Vm erstellen aus, um eine neue VM erstellen, können Sie diesen Speicherort:

azure vm create <yourdomainname> <imagename> <username> <password> --location '<selected datacenter region>'

Nun, da Sie von der Befehlszeile aus eine VM erfolgreich erstellt haben, werfen Sie einen Blick an, wie leicht Sie tun können diese mithilfe eines Skripts.

Skript entfernt Azure Ressourcen in JavaScript

Immer mehr Entwickler versuchen, JavaScript für fast alles zu verwenden. Bereitstellung von Ressourcen in der Cloud ist keine Ausnahme. Dies unterstützt auch andere Scriptsprachen wie Bash, Batch und sogar Windows PowerShell. Die Wahl der Sprache läuft auf den Plattformen auf denen Sie laufen und Ihre Spracheinstellungen.

Microsoft wird bald der Azure-Ressourcen-Manager, freistellen, die ein mehr deklaratives Modell anstatt das programmgesteuerte Modell verwendet wird. Bis Azure Ressourcen-Manager bereit ist, können einige dieser Techniken Sie um Ihre Bereitstellung in der Cloud zu automatisieren.

Wenn Sie eng auf der Azure-Cli Npm-Dokumentation durchsuchen (npmjs.org/package/azure-cli), Sie werden feststellen, dass es eine Bibliothek Azure-Cli genannt Azurblau-Antiphonar abhängig. Herausstellt, jemand im freien Quellcode Node.js Gemeinschaft hat bereits beschlossen, einen Command-Line-Adapter für die Azure-Cli für JavaScript zu schreiben. Da diese Bibliothek einem Wrapper ist, können Sie die gleichen Befehle wie in der Befehlszeile in JavaScript. Hier ist ein Beispiel, in denen alle unsere VMs aufgeführt wird:

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

Um loszulegen, schauen Sie wie Sie einen Stapel von VMs machen können. Installieren Sie zuerst die notwendigen Pakete:

# 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

Um die Konfigurationseinstellungen für Inszenierung, Test und Produktion von hartzucodieren zu vermeiden, verwenden Sie eine Konfigurationsdatei, um die Skripte, die flexibel für unterschiedliche Umgebungen wie z. B. Entwicklung, Test und Produktion zu halten. Rufen Sie diese Konfiguration Datei config.json (siehe Abbildung 4).

Abbildung 4 Config.json unterhält Flexible Einstellungen

{
  "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"
  }
}

Sie können die Konfigurationsdatei verwenden, eine Entwicklerumgebung, komplett mit drei Ubuntu VMs einrichten, die Teil der Bezugsgruppe (Azureteddemoaffinitygroup) und einem entsprechenden virtuellen Netzwerk (azuretedvnet2) sind. Dieser Ansatz ist deklarative, was bedeutet, dass Sie nur müssen Änderungen in eine Konfigurationsdatei ändern, die Ihren Entwicklungsumgebungen eingerichtet sind. Sie können auch zusätzliche Versionen für Inszenierung, Test und Produktion haben — und jede steuern.

Der benutzerdefinierte JavaScript-Code wird die Konfigurationsdatei analysiert, damit die Abhängigkeiten, z. B. Bezugsgruppen, mit den richtigen Namen und Werten bereitgestellt werden. Innerhalb der config.json-Datei kann das Skript den gewünschten Namen für die Bezugsgruppe (Azureteddemoaffinitygroup) lesen. Von dort können sie Abfragen, überprüfen, um festzustellen, ob die Bezugsgruppe durch Durchlaufen der Liste der bereitgestellten Bezugsgruppen, die bereits im Datencenter existieren bereits erstellt wurde (siehe Abbildung 5).

Abbildung 5 Erstellen einer Bezugsgruppe

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

Beachten Sie, wie die Azure-Antiphonar Bibliothek lässt Sie ganz einfach analysieren Ausgabe aus dem Azure-Cli per Rückruf Funktionsargument Ergebnis. Zudem können Sie die CLI-Befehle erstellen, indem Sie den Befehl und positionelle und benannte Parameter deklarativ angegeben.

Das Muster in Abbildung 6 ist die gleiche Sie verwenden, um Ihr virtuelles Netzwerk erstellen und benutzt die Azure-Antiphonar Bibliothek auf die gleiche Weise.

Abbildung 6 erstellen ein virtuelles Netzwerks

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

Teil des Codes in Abbildung 6 hat der Kürze halber weggelassen, aber das gleiche Muster vorhanden ist. Die benötigte Ressource ist in der Konfigurationsdatei angegeben. Sie müssen es bereitstellen, falls es nicht existiert.

Sobald Sie die Abhängigkeiten (Bezugsgruppen und Netzwerke) erstellt haben, können Sie einen Stapel von VMs erstellen. Die Anzahl der VMs, die Sie erstellen, werden ist im Feld Vm_count in der config.json-Konfigurationsdatei angegeben. Nach dem gleichen Muster zuerst Listen Sie der aktuellen VMs auf das Abonnement auf, überprüfen Sie, ob die VMs bereits erstellen werde existieren und erstellen nur diejenigen, die nicht vorhanden sind.

Abbildung 7 folgen einen einfachen Algorithmus, um die VMs mit dem Vm_base_name-Feld in der config.json zu nennen und fügen Sie die Zahlen 0 – (Vm_count-1) bis zum Ende der VM-Name. Angesichts der aktuellen config.json, erstellen Sie sedouardmachine0, sedouardmachine1 und sedouardmachine2, da keiner von diesen Maschinen auf das Abonnement bereits vorhanden sind.

Abbildung 7 Erstellen Sie eine Liste von virtuellen Maschinen auf Bereitstellung

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.

Abbildung 7 bestätigt die Liste der nicht vorhandenen VMs im VmNames-Array. Abbildung 8 wird die Async-Bibliothek verwenden, um die asynchronen Aufgaben zu verwalten, die gehen wird und die VMs zu erstellen.

Abbildung 8-Finish, die Bereitstellung von virtuellen Maschinen

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

Abbildung 8 erstellt eine Aufgabe für jede VM, die Sie erstellen müssen. Dann müssen Sie diese Aufgaben in ein Array, VmCreationTasks hinzufügen. Jede Aufgabe-Funktion ist auf die erforderlichen Argumente gebunden, um die Azure Azure-Cli mit dem richtigen VM-Namen aufrufen. Danach verwenden Sie die Async-Bibliothek, um führen Sie jede Aufgabe in Serie und des Rückrufs mit Null oder einen Fehlerparameter, der angibt, ob die VMs erfolgreich erstellt wurden. Abbildung 9 bestätigt die Ausgabe des Skripts und listet Sie den virtuellen Computer, die erstellt wurden.

die endgültige Liste der virtuellen Maschinen
Abbildung 9 die endgültige Liste der virtuellen Maschinen

Jede Ihrer virtuellen Computer wurde erfolgreich erstellt. Sie können auch zurück zu Ihrem Portal zu bestätigen, dass die Maschinen erstellt wurden und sind Teil des angegebenen virtuellen Netzwerks. Verwenden Sie das GitHub Repository auf bit.ly/Azure-Xplat-Cli um loszulegen scripting das Azure-Setup mit Node.js.

Zusammenfassung

Die Azure Xplat-Cli können Sie vollständig automatisieren den Prozess der Konfiguration und Bereitstellung von Azure Ressourcen in portable Skripte können, die Sie auf nahezu jedem Betriebssystem verwenden. Zudem können Sie die Quelldateien Steuerung und Konfiguration verwenden, um gemeinsame Nutzung vereinfachen. Hätten Sie mehrere Versionen von config.json, jeweils ein Bereitstellungsmodell für Test, Test- und Produktionsumgebungen darstellt.

Sie können den Bereitstellungsprozess auch neu, schnell und effizient gestalten. Bevorstehenden Azure Ressourcen-Manager für Microsoft Release im Jahr 2015 wird gehen über das hinaus was hier dargestellt wird, aber dieser Ansatz ist praktisch identisch, was die Azure-Ressourcenverwaltung wird — das ist deklarativ angegeben, wie die Ressourcen im Azure Datencenter bereitgestellt werden.

Steven Edouard ist ein Developer Evangelist bei Microsoft. Davor arbeitete er im .NET Runtime-Team als Software Test Engineer liefert Produkte wie die Microsoft .NET Framework 4.5 und .NET Native Kompilierung. Heute lebt seine Leidenschaft in spannende Menschen auf die grenzenlosen Möglichkeiten des Cloud computing-Services durch Einbeziehung von technischen Demonstrationen, online-Inhalte und Präsentationen.

Unser Dank gilt dem folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Bruno Terkaly