Node.js-microservices ontwikkelen
Bouw onafhankelijke Node.js-services die met elkaar communiceren, met de nadruk op domeingestuurd ontwerp.
Node.js-microservices ontwikkelen is een gratis Bootcamp backendontwikkeling met Node.js-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met Node.js. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.
Introductie tot Node.js-microservices
Welkom bij het bouwen van Node.js-microservices! We onderzoeken hoe je kleine, onafhankelijke services maakt die samenwerken.
Een microservice is een architectuurstijl waarbij een applicatie wordt opgebouwd als een verzameling kleine, autonome services. Elke service draait in een eigen proces en communiceert via lichte mechanismen, vaak een HTTP API.
Basisprincipes van microservices
Microservices volgen belangrijke principes:
- Onafhankelijke implementatie: Elke service kan onafhankelijk worden geïmplementeerd.
- Losse koppeling: Services zijn niet sterk afhankelijk van elkaar.
- Één verantwoordelijkheid: Elke service richt zich op een specifieke zakelijke mogelijkheid (een 'domein').
- Technologiediversiteit: Verschillende services kunnen verschillende technologieën gebruiken (hoewel we ons hier op Node.js richten).
Basisprincipes van Domain-Driven Design
Domain-Driven Design (DDD) is cruciaal voor microservices. Het betekent dat je services structureert rond zakelijke domeinen (bijvoorbeeld 'Users', 'Products' en 'Orders').
- Bounded Contexts: Elke microservice definieert een eigen duidelijke grens en beheert de gegevens en logica van zijn specifieke domein.
- Ubiquitous Language: Binnen die service gebruik je een gemeenschappelijke taal voor domeinconcepten.
Een Node.js-service structureren
Een typisch Node.js-microserviceproject kan er als volgt uitzien:
my-service/-
src/ -
controllers/(logica voor aanvragen) -
models/(gegevensschema's) -
routes/(API-eindpunten) -
app.js(belangrijkste Express-configuratie) -
package.json -
.env(omgevingsvariabelen)
Communicatie tussen services
Microservices moeten communiceren om aanvragen af te handelen. Veelgebruikte methoden zijn:
- HTTP/REST: Synchrone aanroepen tussen services. Eén service doet een HTTP-aanvraag aan een andere service.
- Berichtenwachtrijen: Asynchrone communicatie via een berichtenbroker (bijvoorbeeld RabbitMQ of Kafka). Services publiceren gebeurtenissen en abonneren zich op gebeurtenissen van andere services.
In deze les richten we ons vanwege de eenvoud op HTTP-communicatie.
Een gebruikersmicroservice bouwen
Laten we een eenvoudige microservice voor 'Users' maken met Express. Deze service beheert gebruikersgegevens en draait op poort 3001.
Probeer deze code uit te voeren:
const express = require('express');
const app = express();
const PORT = 3001;
app.use(express.json());
const users = [
{ id: 'u1', name: 'Alice', email: 'alice@example.com' },
{ id: 'u2', name: 'Bob', email: 'bob@example.com' }
];
app.get('/users/:id', (req, res) => {
const user = users.find(u => u.id === req.params.id);
if (user) {
res.json(user);
} else {
res.status(404).send('User not found');
}
});
app.get('/users', (req, res) => {
res.json(users);
});
app.listen(PORT, () => {
console.log(`Users Service running on port ${PORT}`);
});Een productmicroservice bouwen
Laten we nu een afzonderlijke microservice voor 'Products' maken. Deze service beheert productgegevens en draait op poort 3002.
Dit is een volledig onafhankelijke applicatie:
const express = require('express');
const app = express();
const PORT = 3002;
app.use(express.json());
const products = [
{ id: 'p1', name: 'Laptop', price: 1200, ownerId: 'u1' },
{ id: 'p2', name: 'Mouse', price: 25, ownerId: 'u2' }
];
app.get('/products', (req, res) => {
res.json(products);
});
app.listen(PORT, () => {
console.log(`Products Service running on port ${PORT}`);
});Communicatie tussen services simuleren
Hoe krijgt de service 'Products' de gegevens van de eigenaar van een product? De service doet een HTTP-aanroep naar de service 'Users'!
In dit voorbeeld simuleren we zowel een miniserver (voor gebruikers) als een client (die gebruikersgegevens ophaalt) in één script om de communicatiestroom te laten zien. Dit clientgedeelte zou je Product-service uitvoeren.
const http = require('http');
// --- SIMULATED USER SERVICE (SERVER PART) ---
const users = {
'u1': { id: 'u1', name: 'Alice', email: 'alice@example.com' },
'u2': { id: 'u2', name: 'Bob', email: 'bob@example.com' }
};
const simulatedUserServer = http.createServer((req, res) => {
if (req.url.startsWith('/users/') && req.method === 'GET') {
const userId = req.url.split('/')[2];
if (users[userId]) {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify(users[userId]));
} else {
res.writeHead(404, { 'Content-Type': 'text/plain' });
res.end('User not found');
}
} else {
res.writeHead(404, { 'Content-Type': 'text/plain' });
res.end('Not Found');
}
});
const SIMULATED_PORT = 3001;
simulatedUserServer.listen(SIMULATED_PORT, () => {
console.log(`Simulated User Service running on port ${SIMULATED_PORT}`);
});
// --- CLIENT PART (e.g., a Product Service trying to get user data) ---
async function fetchUserFromSimulatedService(userId) {
return new Promise((resolve, reject) => {
const options = {
hostname: 'localhost',
port: SIMULATED_PORT,
path: `/users/${userId}`,
method: 'GET'
};
const req = http.request(options, (res) => {
let data = '';
res.on('data', (chunk) => data += chunk);
res.on('end', () => {
if (res.statusCode === 200) {
resolve(JSON.parse(data));
} else {
reject(new Error(`Failed to fetch user: ${res.statusCode}`));
}
});
});
req.on('error', (e) => reject(e));
req.end();
});
}
console.log('\n--- Product Service fetching user data simulation ---');
fetchUserFromSimulatedService('u1')
.then(user => console.log('Fetched User:', user))
.catch(error => console.error('Error fetching user:', error.message))
.finally(() => {
// Important: close the simulated server after demonstration
simulatedUserServer.close(() => console.log('Simulated User Service stopped.'));
});
fetchUserFromSimulatedService('u3') // Try fetching a non-existent user
.then(user => console.log('Fetched User:', user))
.catch(error => console.error('Error fetching user:', error.message));Afwegingen bij microservices
Hoewel microservices krachtig zijn, brengen ze afwegingen met zich mee:
- Meer complexiteit: Meer services betekenen meer zaken om te beheren, implementeren en bewaken.
- Gegevensconsistentie: Gegevens consistent houden in meerdere databases kan een uitdaging zijn.
- Gedistribueerde transacties: Bewerkingen die meerdere services omvatten, vereisen zorgvuldig ontwerp.
- Operationele overhead: Dit vereist robuuste CI/CD- en bewakingstools.
Snelle controle: voordelen van microservices
Welke van de volgende opties is, op basis van wat je hebt geleerd, een belangrijk voordeel van een microservicesarchitectuur?
Samenvatting en volgende stappen
We hebben de basisprincipes van het ontwikkelen van Node.js-microservices behandeld, hun kernprincipes besproken en bekeken hoe ze communiceren. We hebben gezien hoe je kleine, domeingerichte services structureert en zelfs communicatie tussen services simuleert.
Hoewel microservices krachtig zijn, moet je de afwegingen rond complexiteit onthouden. Vervolgens leer je hoe je clientaanvragen naar deze services beheert met een API Gateway!
Leer JavaScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 22
- Lessen
- 92
Veelgestelde vragen
Is de les “Node.js-microservices ontwikkelen” gratis?
Ja — de volledige tekst van “Node.js-microservices ontwikkelen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Bootcamp backendontwikkeling met Node.js wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.
Wat leer ik in “Node.js-microservices ontwikkelen”?
Bouw onafhankelijke Node.js-services die met elkaar communiceren, met de nadruk op domeingestuurd ontwerp. Je oefent met Bootcamp backendontwikkeling met Node.js door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Bootcamp backendontwikkeling met Node.js te beginnen?
Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met Node.js op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Node.js-microservices ontwikkelen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met Node.js?
Ja. Elke les over Bootcamp backendontwikkeling met Node.js bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Inleiding tot microservicesarchitectuur
- Node.js-microservices ontwikkelen
- Een API Gateway implementeren
- Communicatie tussen services met message queues