When your server is slow, call Fastify to the rescue

Transcript

1. When Your Node.js Server Is Slow, Call Fastify To The Rescue Tamar Twena-Stern
2. Tamar Twena-Stern twitter @tamarstern linkedin /tamarstern tamar.twena@gmail.com
3. I am going to develop a shiny and new micro service , which Node.js Framework should I choose ?
4. Crowd Wisdom
5. Do You Know When Express Released Major Version 4.0 ? Express Current Version
7. Large Community Very stable Tones of examples online A lot of support
8. Don’t you think it is time we will all try something new, which might be more updated for today’s standards ?
9. A web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture. It is inspired by Hapi and Express and as far as we know, it is one of the fastest web frameworks in town.
10. The Focus Of Fastify Development Experience Performance Flexibility
11. The Focus Of Fastify Development Experience Performance Flexibility
12. Let’s Start With A Benchmark !
14. Comparing Apples To Apples
16. Benchmark Execution With Autocannon autocannon -c 10 http://localhost:3000/
17. Setup - Express Server import express from 'express'; const app = express(); const port = 3000; app.get('/', (req, res) => { res.send('Hello World!'); }) app.listen(port, () => { console.log(`Example app listening on port ${port}`); })
18. Setup - Fastify Server import Fastify from 'fastify' const fastify = Fastify({ logger: false }); fastify.get('/', async (request, reply) => { return { hello: 'world' } });
19. const start = async () => { try { await fastify.listen({ port: 3000 }); } catch (err) { fastify.log.error(err); process.exit(1); } } start(); Setup - Fastify Server
20. Results - Express
21. Results - Fastify
22. Comparing Hello World Results
23. Comparing Express Fastify Req/Sec, 97.5% 20,431 48,831 Latency, 99% 1 mili 0 mili Bytes Read/Sec 4.85MB 9.1MB
24. Double Speed
25. Maybe This Is A One Time Occasion ?
26. Let’s Do Another Benchmark !
29. Benchmark Execution With Autocannon autocannon -c 10 -m 'POST' -b '{ "animal" : "cat"}' -H 'Content-Type=application/json' http://localhost:3000/animals
30. Setup - Express Server import express from 'express'; import mongoose from 'mongoose'; import bodyParser from 'body-parser'; import animalController from './animals.js'; const port = process.env.PORT || 3000; mongoose.connect('mongodb://localhost:27017/test_db); const app = express(); app.use(bodyParser.urlencoded({ extended: true }));
31. Setup - Express Server - Continue const router = express.Router(); router.post('/animals', async (req, res) => { await animalController(); return res.json({ "msg" : "OK" }); }); app.use('/', router); app.listen(port); console.log('server is up ' + port);
32. Setup - Express Controller import Animal from'./animalModel.js'; const createAnimal = async () => { const animal = new Animal(); animal.animal = 'cat'; await animal.save(); }; export default createAnimal;
33. Setup - Fastify Server const fastify = Fastify({ logger: false }); fastify.register(dbConnector) fastify.register(routes) fastify.listen({ port: 3000 }, function (err, address) { if (err) { fastify.log.error(err) process.exit(1) } });
34. Setup - Fastify Routes async function routes (fastify, options, done) { const collection=fastify.mongo.db.collection('test_collection'); const animalBodyJsonSchema = { type: 'object', required: ['animal'], properties: { animal: { type: 'string' }, }, }
35. Setup - Fastify Routes - Continue const schema = { body: animalBodyJsonSchema, } fastify.post('/animals', { schema }, async (request, reply) => { const result = await collection.insertOne({ animal: request.body.animal }); return result }); //Function end export default routes
36. Results - Express
37. Results - Fastify
38. Comparing Express Fastify Req/Sec, 97.5% 6691 9079 Total number of requests 70,000 86,000 Bytes Read/Sec 1.6MB 2.068MB
39. 30% Faster
40. Impressive
41. Last Note • Mongoose also creates performance overhead • Observing a server with express and native Mongo driver
42. Results - Express + Native Mongo Driver
43. Results - Fastify Microservice With Mongo
44. Comparing Express Fastify Req/Sec, 97.5% 7047 9079 Total number of requests 74,000 86,000 Bytes Read/Sec 1.73MB 2.068MB
45. Rocket Faster
46. So What Makes This Framework Much Faster?
47. Super Fast JSON Parsing With Npm Library fast-json-stringify Embrace This To Your Micro Services !
48. The Architecture
49. The Focus Of Fastify Development Experience Performance Flexibility
50. What You Usually Do When Processing A Web Request?
51. Performance Is Not Enough
52. Explore Fastify Functionality
53. Hello World With Fastify import Fastify from 'fastify' const fastify = Fastify({ logger: true }); fastify.get('/', async () => { return { hello: 'world' } });
54. Hello World With Fastify import Fastify from 'fastify' const fastify = Fastify({ logger: true }); fastify.get('/', async () => { return { hello: 'world' } });
55. Everything Is A Plugin Routes Controllers DB Connectors Utilities
56. The Pugin API async function routes (fastify, options, done) { const collection = fastify.mongo.db.collection('test_collection'); const animalBodyJsonSchema = { type: 'object', required: ['animal'], properties: { animal: { type: 'string' }, }, } const schema = { body: animalBodyJsonSchema, }
57. The Pugin API fastify.post('/animals', { schema }, async (request, reply) => { const result = await collection.insertOne({ animal: request.body.animal }) return result }); done(); } export default routes;
58. The Pugin API fastify.get('/animals/:animal', async (request, reply) => { const result = await collection.findOne({ animal: request.params.animal }); if (!result) { throw new Error('Invalid value'); } return result }); done(); } export default routes
59. Registering A Plugin const fastify = Fastify({ logger: true }); fastify.register(dbConnector) fastify.register(routes)
60. Encapsulation With Fastify
61. Adding Functionality To A Fastify Scope With Decorators fastify.register((instance, opts, done) => { instance.decorate('util', (a, b) => a + b) console.log(instance.util('hello ', 'world')) done(); }); fastify.register((instance, opts, done) => { console.log(instance.util(‘hello ', 'world')) // This will throw an error done(); })
62. Fastify Hooks fastify.decorate('util', (request, key, value) => { request[key] = value }) fastify.addHook('preHandler', (request, reply, done) => { fastify.util(request, 'timestamp', new Date()) done(); }); fastify.get('/plugin1', (request, reply) => { reply.send(request); }); fastify.get('/plugin2', (request, reply) => { reply.send(request); });
64. Given Common Functionalities When Developing A Micro Service - What Will be The Best Fastify Approach For Each ?
65. Logging Each Request
66. Answer : Fastify Hooks fastify.addHook('preHandler', (request, reply, done) => { if (request.body) { request.log.info({ body: request.body }, 'parsed body') } done(); });
67. Role Based Access Control
68. Can Be Done With A Hook On The Global Scope + Register A Plugin For Each Route
69. Input Sanitizing
70. Can Be Done With Hook Or Plugin Of An Instance Scope
71. async function routes (fastify, options, done) { const collection=fastify.mongo.db.collection('test_collection'); const animalBodyJsonSchema = { type: 'object', required: ['animal'], properties: { animal: { type: 'string' }, }, } Fastify Input Sanitizing Using Options
72. const schema = { body: animalBodyJsonSchema, } fastify.post('/animals', { schema }, async (request, reply) => { const result = await collection.insertOne({ animal: request.body.animal }); return result }); //Function end export default routes Fastify Built In Input Sanitizing Using Options
73. CORS Validation
74. Answer : Fastify Plugin On Global Scope import cors from '@fastify/cors' const fastify = Fastify() await fastify.register(cors, { // put your options here });
75. Block Access To APIs In The API Gateway
76. Answer 1 - 2 Different Micro Services
77. Answer 2 - Register 2 Different Plugins For Fastify Instance fastify.register(firstRouteGroup); fastify.register(SecondRouteGroup);
78. The Focus Of Fastify Development Experience Performance Flexibility
79. • AWS Lambda: ◦ Write a fastify server ◦ Expose it in the lambda with @fastify/aws-lambda • Google cloud functions : ◦ Native support except content type parsing Serverless
80. TypeScript And GrpaphQL Support • Native Typescript support • GraphQL Plugin
81. Summary When you choose a technology in an organization, you usually avoid 2 technologies. You are concerned of the overhead. Web server layer is usually infrastructure that will have less changes and maintenance . To my opinion you can have 2 technologies in that layer. Fastify is a good choice to consider.
82. Tamar Twena-Stern twitter @tamarstern linkedin /tamarstern tamar.twena@gmail.com