Utveckla Node.js-mikrotjänster
Bygg fristående Node.js-tjänster som kommunicerar med varandra med fokus på domändriven design.
Utveckla Node.js-mikrotjänster är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.
Introduktion till Node.js-mikrotjänster
Välkommen till utvecklingen av Node.js-mikrotjänster! Vi ska utforska hur du skapar små, självständiga tjänster som samarbetar.
En mikrotjänst är en arkitekturstil där en applikation byggs som en samling små, autonoma tjänster. Varje tjänst körs i sin egen process och kommunicerar via lättviktiga mekanismer, ofta ett HTTP-API.
Grundläggande principer för mikrotjänster
Mikrotjänster följer några viktiga principer:
- Oberoende driftsättning: Varje tjänst kan driftsättas oberoende av de andra.
- Lös koppling: Tjänsterna är inte tätt beroende av varandra.
- Enkelt ansvar: Varje tjänst fokuserar på en specifik verksamhetsförmåga (en "domän").
- Teknisk mångfald: Olika tjänster kan använda olika tekniker (men här håller vi oss till Node.js).
Grunderna i Domain-Driven Design
Domain-Driven Design (DDD) är centralt för mikrotjänster. Det innebär att du strukturerar tjänsterna kring verksamhetsdomäner (till exempel "användare", "produkter" och "beställningar").
- Bounded Contexts: Varje mikrotjänst definierar sin egen tydliga gräns och äger sina specifika domändata och sin domänlogik.
- Ubiquitous Language: Att använda ett gemensamt språk för domänbegrepp inom tjänsten.
Strukturera en Node.js-tjänst
Ett typiskt Node.js-mikrotjänstprojekt kan ha en struktur som denna:
my-service/-
src/ -
controllers/(logik för förfrågningar) -
models/(datascheman) -
routes/(API-slutpunkter) -
app.js(grundläggande Express-konfiguration) -
package.json -
.env(miljövariabler)
Kommunikation mellan tjänster
Mikrotjänster måste kommunicera för att kunna hantera förfrågningar. Vanliga metoder är:
- HTTP/REST: Synkrona anrop mellan tjänster. En tjänst skickar en HTTP-förfrågan till en annan.
- Meddelandeköer: Asynkron kommunikation via en meddelandeförmedlare (till exempel RabbitMQ eller Kafka). Tjänster publicerar händelser och prenumererar på andra.
I den här lektionen fokuserar vi på HTTP-kommunikation eftersom den är enkel.
Bygga en användarmikrotjänst
Vi skapar en enkel "Users"-mikrotjänst med Express. Tjänsten hanterar användardata och körs på port 3001.
Prova att köra den här koden:
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}`);
});Bygga en produktmikrotjänst
Nu skapar vi en separat "Products"-mikrotjänst. Tjänsten hanterar produktdata och körs på port 3002.
Det här är en helt fristående 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}`);
});Simulera kommunikation mellan tjänster
Hur skulle tjänsten "Products" hämta uppgifter om ägaren till en produkt? Den skickar ett HTTP-anrop till tjänsten "Users"!
I det här exemplet simulerar vi både en liten server (för användare) och en klient (som hämtar användardata) i ett och samma skript för att visa kommunikationsflödet. Klientdelen är det som din produkttjänst skulle göra.
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));Mikrotjänsternas avvägningar
Även om mikrotjänster är kraftfulla medför de vissa avvägningar:
- Ökad komplexitet: Fler tjänster innebär mer att hantera, driftsätta och övervaka.
- Datakonsistens: Det kan vara svårt att upprätthålla datakonsistens mellan flera databaser.
- Distribuerade transaktioner: Åtgärder som omfattar flera tjänster kräver noggrann utformning.
- Operativt merarbete: Kräver robusta verktyg för CI/CD och övervakning.
Snabb kontroll: mikrotjänsternas fördelar
Vilken av följande är, utifrån det du har lärt dig, en huvudsaklig fördel med att använda en mikrotjänstarkitektur?
Sammanfattning och nästa steg
Vi har gått igenom grunderna i att utveckla Node.js-mikrotjänster, förstå deras centrala principer och se hur de kommunicerar. Vi såg hur du strukturerar små, domänfokuserade tjänster och till och med simulerar kommunikation mellan tjänster.
Kom ihåg att mikrotjänster, trots sina fördelar, innebär avvägningar när det gäller komplexitet. Nästa gång får du lära dig hur klientförfrågningar till dessa tjänster hanteras med en API Gateway!
Lär dig JavaScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 22
- Lektioner
- 92
Vanliga frågor
Är lektionen ”Utveckla Node.js-mikrotjänster” gratis?
Ja – hela texten till ”Utveckla Node.js-mikrotjänster” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.
Vad lär jag mig i ”Utveckla Node.js-mikrotjänster”?
Bygg fristående Node.js-tjänster som kommunicerar med varandra med fokus på domändriven design. Ni övar på Bootcamp i backendutveckling med Node.js med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med Node.js?
Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.
Hur lång tid tar lektionen ”Utveckla Node.js-mikrotjänster”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med Node.js-lektionen?
Ja. Varje Bootcamp i backendutveckling med Node.js-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Introduktion till mikrotjänstarkitektur
- Utveckla Node.js-mikrotjänster
- Implementera en API-gateway
- Kommunikation mellan tjänster med meddelandeköer