Node.js Backend Development Bootcamp · Lekcja

Tworzenie mikrousług Node.js

Twórz niezależne usługi Node.js komunikujące się ze sobą, koncentrując się na projektowaniu sterowanym dziedziną.

Tworzenie mikrousług Node.js to bezpłatna lekcja Node.js Backend Development Bootcamp na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Node.js Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Node.js Backend Development Bootcamp zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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.

Tworzenie mikrousług Node.js — ilustracja 1

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!

Często zadawane pytania

Czy lekcja „Tworzenie mikrousług Node.js” jest bezpłatna?

Tak — pełny tekst „Tworzenie mikrousług Node.js” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Node.js Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs Node.js Backend Development Bootcamp zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie mikrousług Node.js”?

Twórz niezależne usługi Node.js komunikujące się ze sobą, koncentrując się na projektowaniu sterowanym dziedziną. Ćwiczysz Node.js Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Node.js Backend Development Bootcamp?

Nie wymagamy żadnego doświadczenia. Node.js Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Tworzenie mikrousług Node.js”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Node.js Backend Development Bootcamp?

Tak. Każda lekcja Node.js Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Wprowadzenie do architektury mikrousług
Tworzenie mikrousług Node.js
Implementowanie API Gateway
Komunikacja między usługami za pomocą kolejek komunikatów

← Powrót do Node.js Backend Development Bootcamp