Utvikle Node.js-mikrotjenester
Bygg uavhengige Node.js-tjenester som kommuniserer med hverandre, med vekt på domenedrevet design.
Utvikle Node.js-mikrotjenester er en gratis leksjon i Bootcamp i backendutvikling med Node.js på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med Node.js, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.
Introduksjon til Node.js-mikrotjenester
Velkommen til bygging av Node.js-mikrotjenester! Vi skal utforske hvordan du oppretter små, uavhengige tjenester som samarbeider.
En mikrotjeneste er en arkitekturstil der en applikasjon bygges som en samling små, autonome tjenester. Hver tjeneste kjører i sin egen prosess og kommuniserer ved hjelp av lette mekanismer, ofte et HTTP-API.
Grunnleggende prinsipper for mikrotjenester
Mikrotjenester følger noen viktige prinsipper:
- Uavhengig utrulling: Hver tjeneste kan distribueres uavhengig.
- Løs kobling: Tjenestene er ikke tett avhengige av hverandre.
- Ett ansvar: Hver tjeneste fokuserer på en bestemt forretningsfunksjon (et «domene»).
- Teknologisk mangfold: Ulike tjenester kan bruke ulike teknologier (selv om vi holder oss til Node.js her).
Grunnleggende om Domain-Driven Design
Domain-Driven Design (DDD) er avgjørende for mikrotjenester. Det innebærer å strukturere tjenestene rundt forretningsdomener (f.eks. «brukere», «produkter» og «ordrer»).
- Avgrensede kontekster: Hver mikrotjeneste definerer sin egen tydelige grense og eier dataene og logikken for sitt spesifikke domene.
- Et felles språk: Det brukes et felles språk for domenebegreper innenfor tjenesten.
Strukturering av en Node.js-tjeneste
Et typisk Node.js-mikrotjenesteprosjekt kan ha en struktur som denne:
my-service/-
src/ -
controllers/(logikk for forespørsler) -
models/(dataskjemaer) -
routes/(API-endepunkter) -
app.js(hovedoppsett for Express) -
package.json -
.env(miljøvariabler)
Kommunikasjon mellom tjenester
Mikrotjenester må kommunisere for å kunne behandle forespørsler. Vanlige metoder er:
- HTTP/REST: Synkrone kall mellom tjenester. Én tjeneste sender en HTTP-forespørsel til en annen.
- Meldingskøer: Asynkron kommunikasjon via en meldingsmegler (f.eks. RabbitMQ eller Kafka). Tjenestene publiserer hendelser og abonnerer på andres hendelser.
I denne leksjonen fokuserer vi på HTTP-kommunikasjon fordi det er enkelt.
Bygging av en brukermikrotjeneste
La oss opprette en enkel «Users»-mikrotjeneste med Express. Denne tjenesten administrerer brukerdata og kjører på port 3001.
Prøv å kjøre denne 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}`);
});Bygging av en produktmikrotjeneste
La oss nå opprette en separat «Products»-mikrotjeneste. Denne tjenesten administrerer produktdata og kjører på port 3002.
Dette er en helt uavhengig applikasjon:
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 av kommunikasjon mellom tjenester
Hvordan kan «Products»-tjenesten hente brukeropplysninger for eieren av et produkt? Den sender et HTTP-kall til «Users»-tjenesten!
I dette eksempelet simulerer vi både en miniserver (for brukere) og en klient (som henter brukerdata) i ett skript for å vise kommunikasjonsflyten. Det er denne klientdelen Product-tjenesten din skulle ha utført.
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));Avveininger ved mikrotjenester
Mikrotjenester er kraftige, men medfører noen avveininger:
- Økt kompleksitet: Flere tjenester betyr mer å administrere, distribuere og overvåke.
- Datakonsistens: Det kan være utfordrende å opprettholde datakonsistens på tvers av flere databaser.
- Distribuerte transaksjoner: Operasjoner som går på tvers av flere tjenester, krever nøye utforming.
- Operasjonell belastning: Dette krever robuste CI/CD- og overvåkingsverktøy.
Rask sjekk: Fordeler med mikrotjenester
Basert på det du har lært, hva er en viktig fordel ved å bruke en mikrotjenestearkitektur?
Oppsummering og neste steg
Vi har gått gjennom det grunnleggende i utvikling av Node.js-mikrotjenester, forstått de viktigste prinsippene og sett på hvordan tjenestene kommuniserer. Vi har sett hvordan man strukturerer små, domenefokuserte tjenester, og til og med simulert kommunikasjon mellom tjenester.
Mikrotjenester er kraftige, men husk avveiningene knyttet til kompleksitet. Deretter skal du lære hvordan du håndterer klientforespørsler til disse tjenestene ved hjelp av en API Gateway!
Lær deg JavaScript med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 22
- Leksjoner
- 92
Ofte stilte spørsmål
Er leksjonen «Utvikle Node.js-mikrotjenester» gratis?
Ja – hele teksten i «Utvikle Node.js-mikrotjenester» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Bootcamp i backendutvikling med Node.js-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.
Hva lærer jeg i «Utvikle Node.js-mikrotjenester»?
Bygg uavhengige Node.js-tjenester som kommuniserer med hverandre, med vekt på domenedrevet design. Du øver på Bootcamp i backendutvikling med Node.js med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med Node.js?
Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med Node.js på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Utvikle Node.js-mikrotjenester»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med Node.js-leksjonen?
Ja. Alle Bootcamp i backendutvikling med Node.js-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Introduksjon til mikrotjenestearkitektur
- Utvikle Node.js-mikrotjenester
- Implementere en API Gateway
- Kommunikasjon mellom tjenester med meldingskøer