Mengembangkan Layanan Mikro Node.js
Bangun layanan Node.js mandiri yang saling berkomunikasi, dengan fokus pada desain berbasis domain.
Mengembangkan Layanan Mikro Node.js adalah pelajaran Node.js Backend Development Bootcamp gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Node.js Backend Development Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Node.js Backend Development Bootcamp mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
Node.js Microservices Intro
Welcome to building Node.js microservices! We'll explore how to create small, independent services that work together.
A microservice is an architectural style where an application is built as a collection of small, autonomous services, each running in its own process and communicating with lightweight mechanisms, often an HTTP API.
Core Microservice Principles
Microservices follow key principles:
- Independent Deployment: Each service can be deployed independently.
- Loose Coupling: Services are not tightly dependent on each other.
- Single Responsibility: Each service focuses on a specific business capability (a 'domain').
- Technology Diversity: Different services can use different technologies (though we'll stick to Node.js here).
Domain-Driven Design Basics
Domain-Driven Design (DDD) is crucial for microservices. It means structuring your services around business domains (e.g., 'Users', 'Products', 'Orders').
- Bounded Contexts: Each microservice defines its own clear boundary, owning its specific domain data and logic.
- Ubiquitous Language: Using a common language for domain concepts within that service.
Structuring a Node.js Service
A typical Node.js microservice project might have a structure like this:
my-service/-
src/ -
controllers/(logic for requests) -
models/(data schemas) -
routes/(API endpoints) -
app.js(main Express setup) -
package.json -
.env(environment variables)
Inter-Service Communication
Microservices need to communicate to fulfill requests. Common methods include:
- HTTP/REST: Synchronous calls between services. One service makes an HTTP request to another.
- Message Queues: Asynchronous communication via a message broker (e.g., RabbitMQ, Kafka). Services publish events and subscribe to others.
For this lesson, we'll focus on HTTP communication due to its simplicity.
Building a User Microservice
Let's create a simple 'Users' microservice using Express. This service will manage user data and run on port 3001.
Try running this code:
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}`);
});Building a Product Microservice
Now, let's create a separate 'Products' microservice. This service will manage product data and run on port 3002.
This is a completely independent application:
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}`);
});Simulating Service Communication
How would the 'Products' service get user details for a product's owner? It makes an HTTP call to the 'Users' service!
In this example, we simulate both a mini-server (for users) and a client (fetching user data) in one script to show the communication flow. This client part is what your Product service would do.
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));Microservice Trade-offs
While powerful, microservices come with trade-offs:
- Increased Complexity: More services mean more to manage, deploy, and monitor.
- Data Consistency: Maintaining data consistency across multiple databases can be challenging.
- Distributed Transactions: Operations spanning multiple services require careful design.
- Operational Overhead: Requires robust CI/CD and monitoring tools.
Quick Check: Microservice Benefits
Based on what you've learned, which of the following is a primary benefit of using a microservices architecture?
Recap & Next Steps
We've covered the basics of developing Node.js microservices, understanding their core principles, and how they communicate. We saw how to structure small, domain-focused services and even simulated inter-service communication.
While powerful, remember the trade-offs in complexity. Next, you'll learn how to manage client requests to these services using an API Gateway!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Mengembangkan Layanan Mikro Node.js” gratis?
Ya — teks lengkap “Mengembangkan Layanan Mikro Node.js” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Node.js Backend Development Bootcamp, upgrade ke CoddyKit PRO. Kursus Node.js Backend Development Bootcamp mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Mengembangkan Layanan Mikro Node.js”?
Bangun layanan Node.js mandiri yang saling berkomunikasi, dengan fokus pada desain berbasis domain. Kamu berlatih Node.js Backend Development Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Node.js Backend Development Bootcamp?
Tidak diperlukan pengalaman sebelumnya. Node.js Backend Development Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Mengembangkan Layanan Mikro Node.js” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Node.js Backend Development Bootcamp ini?
Ya. Setiap pelajaran Node.js Backend Development Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Pengantar Arsitektur Layanan Mikro
- Mengembangkan Layanan Mikro Node.js
- Menerapkan API Gateway
- Komunikasi Antar-Layanan dengan Antrean Pesan