Udvikling af Node.js-mikrotjenester
Opbyg uafhængige Node.js-tjenester, der kommunikerer med hinanden, med fokus på domain-driven design.
Udvikling af Node.js-mikrotjenester er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.
Introduktion til Node.js-mikrotjenester
Velkommen til arbejdet med Node.js-mikrotjenester! Vi undersøger, hvordan du opretter små, uafhængige tjenester, der arbejder sammen.
En mikrotjeneste er en arkitektonisk stil, hvor en applikation bygges som en samling af små, selvstændige tjenester, der hver kører i sin egen proces og kommunikerer via letvægtsmekanismer, ofte en HTTP-API.
Grundlæggende principper for mikrotjenester
Mikrotjenester følger nogle centrale principper:
- Uafhængig udrulning: Hver tjeneste kan udrulles uafhængigt.
- Løs kobling: Tjenesterne er ikke tæt afhængige af hinanden.
- Ét ansvar: Hver tjeneste fokuserer på en bestemt forretningsfunktion (et "domæne").
- Teknologisk mangfoldighed: Forskellige tjenester kan bruge forskellige teknologier (selvom vi her holder os til Node.js).
Grundlæggende om Domain-Driven Design
Domain-Driven Design (DDD) er afgørende for mikrotjenester. Det betyder, at du strukturerer dine tjenester omkring forretningsdomæner (f.eks. "brugere", "produkter" og "ordrer").
- Bounded Contexts: Hver mikrotjeneste definerer sin egen tydelige grænse og ejer sine specifikke domænedata og sin domænelogik.
- Ubiquitous Language: Du bruger et fælles sprog for domænebegreber inden for den pågældende tjeneste.
Strukturering af en Node.js-tjeneste
Et typisk Node.js-mikrotjenesteprojekt kan have en struktur som denne:
my-service/-
src/ -
controllers/(logik til forespørgsler) -
models/(dataskemaer) -
routes/(API-slutpunkter) -
app.js(den primære Express-opsætning) -
package.json -
.env(miljøvariabler)
Kommunikation mellem tjenester
Mikrotjenester skal kommunikere for at kunne behandle forespørgsler. Almindelige metoder omfatter:
- HTTP/REST: Synkrone kald mellem tjenester. Én tjeneste sender en HTTP-forespørgsel til en anden.
- Meddelelseskøer: Asynkron kommunikation via en meddelelsesbroker (f.eks. RabbitMQ og Kafka). Tjenester udgiver hændelser og abonnerer på andre.
I denne lektion fokuserer vi på HTTP-kommunikation på grund af dens enkelhed.
Bygning af en brugermikrotjeneste
Lad os oprette en enkel mikrotjeneste til "brugere" ved hjælp af Express. Denne tjeneste administrerer brugerdata og kører på port 3001.
Prøv at køre denne kode:
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}`);
});Bygning af en produktmikrotjeneste
Lad os nu oprette en separat mikrotjeneste til "produkter". Denne tjeneste administrerer produktdata og kører på port 3002.
Dette er en helt uafhængig applikation:
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}`);
});Simulering af kommunikation mellem tjenester
Hvordan får tjenesten "produkter" oplysninger om ejeren af et produkt? Den foretager et HTTP-kald til tjenesten "brugere"!
I dette eksempel simulerer vi både en lille server (til brugere) og en klient (der henter brugerdata) i ét script for at vise kommunikationsforløbet. Denne klientdel er det, din produkttjeneste ville gøre.
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));Kompromiser ved mikrotjenester
Selvom mikrotjenester er effektive, medfører de nogle kompromiser:
- Øget kompleksitet: Flere tjenester betyder mere, der skal administreres, udrulles og overvåges.
- Datakonsistens: Det kan være udfordrende at vedligeholde datakonsistens på tværs af flere databaser.
- Distribuerede transaktioner: Handlinger, der strækker sig over flere tjenester, kræver et gennemtænkt design.
- Driftsmæssige omkostninger: Det kræver robuste CI/CD- og overvågningsværktøjer.
Hurtigt tjek: Fordele ved mikrotjenester
Hvilken af følgende er, baseret på det du har lært, en primær fordel ved at bruge en mikrotjenestearkitektur?
Opsummering og næste trin
Vi har gennemgået det grundlæggende i udvikling af Node.js-mikrotjenester, forstået deres centrale principper og set, hvordan de kommunikerer. Vi har set, hvordan du strukturerer små, domænefokuserede tjenester og endda simulerer kommunikation mellem tjenester.
Selvom mikrotjenester er effektive, skal du huske kompromiserne med hensyn til kompleksitet. Dernæst lærer du, hvordan du administrerer klientforespørgsler til disse tjenester ved hjælp af en API Gateway!
Lær JavaScript med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 22
- Lektioner
- 92
Ofte stillede spørgsmål
Er lektionen “Udvikling af Node.js-mikrotjenester” gratis?
Ja — hele teksten til “Udvikling af Node.js-mikrotjenester” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Udvikling af Node.js-mikrotjenester”?
Opbyg uafhængige Node.js-tjenester, der kommunikerer med hinanden, med fokus på domain-driven design. Du øver dig i Bootcamp i backendudvikling med Node.js med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Bootcamp i backendudvikling med Node.js?
Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Udvikling af Node.js-mikrotjenester”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Bootcamp i backendudvikling med Node.js-lektion?
Ja. Alle Bootcamp i backendudvikling med Node.js-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Introduktion til mikroservicearkitektur
- Udvikling af Node.js-mikrotjenester
- Implementering af en API Gateway
- Kommunikation mellem services med message queues