Einstieg in Node.js

2. WER BIN ICH?
• Sebastian Springer
• https://github.com/sspringer82
• @basti_springer
• Consultant,Trainer,Autor

3. Was erzähle ich euch
heute?

4. Applikationen in
Node.js

5. Aufbau
Bernd Kasper / pixelio.de

6. Standard Library
Node Bindings
V8 libuv
Eventloop async I/O
...insert

7. your

8. source

9. code

10. here...

11. Repo
npmjs.org
CouchDB
75k Pakete
npm Kommandozeilen
Tool
Bestandteil von
Node.js seit 0.6.3
Open Source
https://github.com/
npm/npm
installation
node_modules
Einfaches Publizieren

12. C:WINDOWS_
C:WINDOWS npm search express
C:WINDOWS npm install express
C:WINDOWS npm list
C:WINDOWS npm update express
C:WINDOWS npm remove express

13. package.json

14. {!
name: express,!
description: ,!
version: 4.2.0,!
author: {},!
dependencies: {},!
devDependencies: {},!
keywords: [],!
repository: {},!
scripts: {},!
engines: {},!
license: MIT,!
readme: ,!
}
C:WINDOWS npm init

15. C:WINDOWS npm install --save express!
npm http GET https://registry.npmjs.org/express
.!
! node_modules!
! express
dependencies: {!
express: ~4.3.1!
},
package.json
current folder

16. Modulsystem
Initiative Echte Soziale Marktwirtschaft IESM / pixelio.de

17. Das Modulsystem
eigene Module
NPM
interne Module

18. require

19. Interne Module
var fs = require(‘fs’);!
!
fs.readFile(‘/tmp/input.txt’, ‘utf-8’,
function(err, data) {!
console.log(‘data’);!
});

20. NPM Module
var express = require(‘express’);!
!
var app = express();!
!
app.get(‘/‘, function(req, res) {!
res.send(‘Hello World’);!
});!
!
app.listen(8080);
C:WINDOWS npm install express

21. Eigene Module
var fs = require(‘fs’);!
!
module.exports = {!
readFile: function() {!
return fs.readFileSync(‘/tmp/
input.txt’, ‘utf-8’);!
}!
}
myModule.js

22. Eigene Module
var myModule = require(‘./myModule’);!
!
var data = myModule.readFile();!
!
console.log(data);
index.js

23. Beispiel express
Applikation
Tim Reckmann / pixelio.de

24. express.js
Web Application Framework. Baut auf dem http-
Modul von Node.js auf. Bietet Middleware-
Komponenten, mit denen auf Requests reagiert
werden kann. Zusätzlich verfügt express.js über
einen Router.

25. Initiierung
var express = require(‘express’);!
!
var app = express();!
!
app.listen(8080);

26. Routing
Navigation in der Applikation per URL.
Variablen in URLs für dynamische Inhalte.
Eine Route besteht aus zwei Teilen: HTTP-
Methode und Pfad.
Routendefinition in eine separate Datei
auslagern.

27. Routing
module.exports = function(app) {!
app.get(‘/‘, function(req, res) {!
res.end(‘Hello World’);!
});!
app.get(‘/user/:id’, function(req, res) {!
res.end(‘Requested User: ‘ +
req.params.id);!
});!
};
var router = require(‘./router’);!
router(app);
router.js
index.js

28. Statischer Inhalt
Es ist kein zusätzlicher Webserver
erforderlich. Node.js liefert HTML, CSS, clientseitiges
JavaScript und Mediendateien selbst aus.

29. Statischer Inhalt
app.use(express.static(__dirname + '/
public'));

30. Middleware
Request
Response
func(req,res, next)
func(req,res, next)
func(req,res, next)

31. Template Engine
Generiertes HTML mit dynamischen Inhalten.
Es sind mehrere Template Engines verfügbar
z.B. Jade, Twig oder Handlebars.

32. Template Engine
var hbs = require(‘express-hbs');!
app.engine('hbs', hbs.express3());!
var view = path.join(__dirname, 'views');!
app.set('views', view);!
app.set('view engine', ‘hbs');
app.get(‘/‘, function(req, res) {!
res.render(‘index’);!
});

33. Datenbanken
Tim Reckmann / pixelio.de

34. Datenbanken
Speichern und Auslesen dynamischer Inhalte.
Es werden nahezu alle Datenbanken unterstützt
z.B. mySQL, SQLite, Redis, MongoDB.
Zugriffe auf Datenbanken sind in der Regel
asynchron.

35. Datenbanken
var sqlite = require(‘sqlite3’);!
!
var db = new sqlite.Database(‘/tmp/db’);!
!
db.get(‘SELECT * FROM users’, function(err,
data) {!
res.send(‘Hello ‘ + data.name);!
});
C:WINDOWS npm install sqlite3

36. Asynchronität
Rainer Sturm / pixelio.de

37. Asynchronität
Nahezu alle Operationen in Node.js sind
asynchron. Das gilt vom Webserver über den
Zugriff auf das Dateisystem bis hin zu
Datenströmen. Es wird viel mit Callback-
Funktionen gearbeitet. Diese können mit Promises
besser verwaltet werden.

38. Promises
Versprechen auf die Erfüllung einer
asynchronen Operation.

39. var myAsyncFunc = function() {!
var deferred = Q.defer();!
fs.readFile('input.txt', 'utf-8',
function(err, data) {!
if (err) {!
deferred.reject(err);!
} else {!
deferred.resolve(data);!
}!
});!
return deferred.promise;!
}!
!
myAsyncFunc().then(function(data) {!
console.log(data);!
});

40. Skalierung
Uwe Schlick / pixelio.de

41. Skalierung
Node.js ist im Normalfall Single Threaded und
kann deswegen nur mit einer bestimmten Anzahl
von Anfragen umgehen. Ressourcen eines
Servers können nicht vollständig ausgeschöpft
werden.
Es existieren mehrere Lösungszenarien.

42. Webserver

43. Webserver
$ curl localhost:8080
curl localhost:8080
$ node server.js
incoming request!
request answered in: 4636ms!
incoming request!
request answered in: 4622ms

44. Child_Process

45. Child_Process
$ curl localhost:8080
curl localhost:8080
$ node server2.js
incoming request!
incoming request!
request answered in: 4959ms!
request answered in: 4963ms

46. Cluster

47. Cluster
Es werden Kindprozesse über die fork-Methode
erzeugt. Die Kindprozesse teilen sich einen
TCP-Port.
Das Betriebssystem übernimmt das
Loadbalancing.

48. Child_Process
$ curl localhost:8080
curl localhost:8080
$ node cluster.js
incoming request!
incoming request!
request answered in: 4878ms!
request answered in: 4885ms

49. Loadbalancer

50. Loadbalancer
Mit einer Shared Nothing-Architektur kann
Node.js problemlos hinter einem Loadbalancer
betrieben werden.
Gemeinsamer Applikationsstatus wird über
eine Datenbank wie Memcache oder Redis
verwaltet.
Gut eignen sich z.B. HAProxy oder Nginx.

51. Cloud

52. Cloud
Cloud Support in Heroku und Microsoft
Azure. Applikationen werden deployed und
Knoten können nach Bedarf hochgefahren
werden.

53. Tests
uygar sanli / pixelio.de

54. Tests
Node.js ist selbst recht ordentlich getestet (tests/
simple/*.js). Es verfügt über ein eigenes
Testframework (assert-Modul).
Es gibt verschiedene Unittest-
Frameworks für Node.js.

55. $ wget http://nodejs.org/dist/v0.10.26/
node-v0.10.26.tar.gz
$ tar xvzf node-v0.10.26.tar.gz
$ cd node-v0.10.26/test/simple
$ node test-http.js
{ accept: '*/*',
foo: 'bar',
host: 'localhost:12346',
connection: 'keep-alive' }
DEBUG: Got /hello response
DEBUG: Got /world response
DEBUG: responses_recvd: 2
DEBUG: responses_sent: 2

56. nodeunit

57. nodeunit
$ nodeunit test.js !
!
test.js!
setUp!
firstExample!
tearDown!
✔ firstExample!
setUp!
tearDown!
✔ exampleGroup - secondExample!
!
OK: 2 assertions (8ms)

58. nodeunit
Installation über npm install -g nodeunit.
nodeunit ist ein eigenständiges Testframework.
Bietet übersichtlichere Ausgabe als das Assert-
Modul.
Die verfügbaren Assertions sind ähnlich wie die
des Assert-Moduls.

59. Mocha

60. $ mocha test!
!
․․․․․․․․․․․․․․․․!
!
16 passing (48ms)
Mocha

61. Mocha
Installation über npm install -g mocha!
Eigenständiges Testframework, das
zusätzliche Assertion Libraries wie expect.js
und should.js einbindet.
Nicht nur für Node.js exklusiv.

62. describe(Subject, function () {!
it(should do something, function () {!
expect(true).to.eql(true);!
});!
it.only(should do something, function () {!
expect(true).to.eql(true);!
});!
it.skip(should do something, function () {!
expect(true).to.eql(true);!
});!
});

63. Fragen
Angela Parszyk / pixelio.de

64. KONTAKT
Sebastian Springer
sebastian.springer@mayflower.de
!
Mayflower GmbH
Mannhardtstr. 6
80538 München
Deutschland
!
@basti_springer
!
https://github.com/sspringer82