Archive. Posts from 2004 to 2016, kept as they were written. My current blog is at dariuszparys.com.

Nachdem Node.js für Windows zur Verfügung steht, kann man Node.js auch auf der Windows Azure Plattform betreiben. Dazu muss man allerdings erst ein Rahmenwerk schaffen, denn Node.js ist ein eigener Prozess welcher in der Regel über die Kommandozeile gestartet wird. Eine Anmerkung vorweg: es gibt mittlerweile ein IIS Module das sich iisnode nennt. Mit diesem Modul kann man Node.js direkt in den IIS integrieren. Ich beschreibe in diesem Blogpost allerdings den Weg ohne den IIS.

Um einen Prozess in Windows Azure zu hosten nimmt man am besten die Worker Role her. Dort wird die Basis gelegt um die Node.js Umgebung samt Anwendung zu starten und einen Port nach außen durchzureichen.

Die Node.js Anwendung

Zuerst zur Demo App für Node.js. Die Anwendung reagiert auf folgende Routen

  • / (Redirect auf /info )
  • /json (Rückgabe als JSON)
  • /info (Info-Text als HTML Rückgabe)
  • /form (Eine einfache Eingabemaske)
  • /data (Die Ausgabe der /form via POST)

und verwendet hierfür zwei Module. Zum einen node-router um die URL Routen mit Funktionalität zu verknüpfen, zum anderen node-formidable um Postback Daten einer HTML Form einfach auszuwerten.

Normalerweise installiert man Node Module per npm. Allerdings ist das node-router Modul nicht in der npm Registry. Somit habe ich es einfach mittels

git clone [email protected]:creationx/node-router.git node-router

in das Verzeichnis nodemodules_ hineinkopiert. Formidable dagegen ist in der npm Registry und kann mittels

npm install formidable

installiert werden. Damit habe ich folgende Verzeichnisstruktur in meiner Node Anwendung:

- index.js
- node_modules
- formidable
- node-router

In index.js werden zuerst die Module referenziert

var server     = require( "node-router" ).getServer(),
util       = require( "util" ),
formidable = require( "formidable" );

util enthält ein paar praktische Helfer unter anderem um Objekt-Dumps in der Console anzuzeigen

console.log( util.inspect( fields ) );

Das Modul node-router erlaubt es einfach Routen mit den entsprechenden HTTP Verb an Funktionen zu binden. Zum Beispiel

server.get( "/", function( req, res ) {
res.redirect( "/info" );
} );

wird mit der Route “/” und dem HTTP Verb die Funktion verknüfpt in welcher dann ein Redirect auf “/info” erfolgt.

Mit dem Modul formidable kann man einfach Form Daten auswerten und bekommt einen Callback für jedes Formfeld zurück.

var form = new formidable.IncomingForm();
form.on( "field", function( field, value ) {
console.log( field, value );
} );

Das Gesamtlisting von index.js sieht dann folgendermaßen aus:

var server = require( "node-router" ).getServer(),
util = require( "util" ),
formidable = require( "formidable" );
server.get("/", function (req, res, match) {
res.redirect( "/info" );
} );
server.get( "/info", function ( req, res, match ){
res.writeHead( 200, { "Content-Type": "text/html" });
res.write( "<h1>Node.js on Windows Azure</h1>" );
res.write( "<div>A simple demo app using node-router and node-formidable.</div>" );
res.end();
} );
server.get( "/json", function( req, res ) {
res.simpleJson( 200, { name: "Dariusz", email:          "[email removed]" });
} );
server.get( "/form", function( req, res ) {
res.writeHead( 200, { "Content-Type": "text/html" });
res.write( "<form method='post' action='/data'>");
res.write( "<label for='eingabe'>Nachricht</label><br/>");
res.write( "<input type='text' name='eingabe' />");
res.write( "<input type='submit' name='Senden' value='Senden'/>");
res.write( "</form>" );
res.end();
} );
server.post( "/data", function( req, res ) {
var form = new formidable.IncomingForm();
// Writing a 200 header cause I'm
// optimistic. Don't do this in production code!
res.writeHead( 200, { "content-type": "text/html" } );
res.write( "<h1>Data from Post</h1>");
form
.on( "field", function( field, value ) {
res.write( "<h3>" + field + "</h3>" );
res.write( "<div>" + value + "</div>"   );
} )
.on( "end", function() {
res.end();
} );
form.parse( req );
} );
server.listen( 80 );

Die Worker Role für Windows Azure

In einem neuen Windows Azure Projekt legt man eine Worker role an. In diese kopiert man nun folgende Dateien

- node.exe
- index.js
- node_modules
- node-router
- package.json
- lib
- node-router.js
- formidable
- package.json
- lib
- file.js
- incoming_form.js
- index.js
- multipart_parser.js
- querystring_parser.js
- util.js

und stellt bei der Eigenschaft Copy If Newer ein. Damit wird die Node Anwendung ins Output Verzeichnis kopiert. Man kann natürlich auch ein Post Build Event einbauen das einfach die Dateien rüberkopiert, so kann man von xcopy profitieren ohne für jede einzelne Datei die Einstellungen zu tätigen.

Um die node.exe in der Windows Azure Umgebung zu starten benutzt man den Hook OnStart() in der WorkerRole Klasse. Mittels Process() wird ein neuer Prozess gestartet und die entsprechenden Umgebungsparameter gesetzt.

public override bool OnStart()
{
process = new Process()
{
StartInfo = new ProcessStartInfo(
Environment.ExpandEnvironmentVariables(
@"%RoleRoot%\approot\node.exe"),
"index.js" )
{
UseShellExecute = false,
CreateNoWindow = true,
WorkingDirectory =
Environment.ExpandEnvironmentVariables(
@"%RoleRoot%\approot\" )
}
};
process.Start();
return base.OnStart();
}

Zum Schluß muss man noch in der Konfiguration der Worker Role einen TCP Port nach außen einrichten. Der Code hierfür kommt von Nathan Totten.

[Image not archived]

Deployment nach Windows Azure

Der Rest ist reine Formsache. Packages erstellen und nach Windows Azure hochladen,

[Image not archived]

warten bis der Upgrade durch ist

[Image not archived]

und final noch den Browser öffnen und schauen ob die Anwendung läuft.

[Image not archived]

Grundlage gelegt

Damit ist die Grundlage gelegt um Node.js Anwendung auf Windows Azure zu betreiben. Vieles muss man noch von Hand machen. Einen komfortableren Weg kann man mit der Vorgefertigten Windows Azure Rolle SmarxRole nehmen. Steve Marx hat hier neben Node.js zusätzlich Ruby und Python eingebunden und verknüpft das mit einer komfortablen Anwendungsinstallation die direkt aus GitHub oder dem Azure Storage erfolgen kann.

Unter den zahlreichen Modulen die es für Node.js gibt findet man auch eines das den Zugriff auf die Windows Azure Blob Storage und Queue API kapselt. Natürlich sind die großen Service APIs wie Dropbox, Twitter, Facebook, usw. auch vertreten. Einfach mal reinschauen.