What are Microservices and How Do They Work?

Last updated on August 3rd, 2023

Introduction What are Microservices

Microservices architecture is a modern approach to building scalable and complex applications. Instead of a monolithic architecture, microservices break down an app into many smaller modular services. Each service runs independently and communicates via APIs.

It offer key benefits like scalability, flexibility, and the ability to adopt new technologies. However, they also come with their own challenges around complexity, governance, and testing.

Understanding microservices is key for modern application development, especially in the cloud.

Characteristics of Microservices

There are a few key traits that characterize a microservices architecture:

• Small and modular – Each microservice handles a specific functionality. For example, one service for orders, another for users, etc. They are independently deployable.
• Loosely coupled – Microservices are connected through APIs but have small overlaps. Changes to one service do not break the entire app.
• Independently scalable – Services can scale up or down to meet demand for specific functions. Popular services can scale without bloating everything.
• Decentralized governance – Teams can choose their own technology stacks for each service based on optimal fit.
• Resilient to failure – If one service fails, the entire app does not go down. This improves availability and fault tolerance.

How Microservices Work Together

In a microservices architecture, requests often flow through services in the following way:

1. The UI layer calls an API exposed by a public-facing API gateway service.
2. The API gateway routes requests to the appropriate backend microservice.
3. The microservice handles the request, often calling databases or other services.
4. The microservice returns the result to the API gateway.
5. The API gateway returns the final response to the UI layer.

So microservices form a pipeline, handling discrete tasks that combine to serve the final output.

Microservices Design Patterns

Here are some common design patterns used when architecting microservices:

• API Gateway – A single entry point that receives all requests and routes them to the appropriate services.
• Service Registry & Discovery – A registry that microservices can use to find each other by name or function.
• Database per Service – Each service manages its own database for encapsulation.
• Messaging Bus – An asynchronous message bus like Kafka helps services communicate in a decoupled manner.

Microservices vs. Monolithic Architecture

Monolithic apps have one codebase and database. As they grow large, even small changes can be cumbersome. Microservices split the app into loosely coupled modules for greater agility.

However, it also add complexity around inter-service communication and deployment orchestration. The optimal approach depends on the app and team scale.

Microservices Example in Node.js

Here is a simple microservices app with two services – Users and Posts – in Node.js:

// Users Service

app.get('/users', (req, res) => {
  // Get users from database
  res.json(users) 
})

app.get('/users/:id', (req, res) => {
  // Get specific user
  res.json(req.params.id)
})

// Posts Service

app.get('/posts', (req, res) => {
  // Get posts from database
  res.json(posts)
}) 

// API Gateway

app.get('/users/:id/posts', (req, res) => {
  // Call Users service to get user
  const user = callUsersService(req.params.id)

  // Call Posts service to get user's posts
  const posts = callPostsService(user)

  // Return combined response
  res.json({user, posts})
})

This shows how the API Gateway orchestrates calls to independent services to serve a request. The services themselves are isolated which allows for flexibility.

Frequently Asked Questioned

Why is Node.js good for microservices?

Node.js is well-suited for microservices because it is lightweight, scalable, and provides high performance for real-time services. The asynchronous, event-driven architecture of Node.js makes it ideal for the complex interactions between services. Node.js is also perfect for IO-bound services.

What is the main advantage of microservices?

The main advantage of microservices is the ability to independently develop, deploy and scale individual services. This makes the overall application more flexible, faster to develop, and able to scale only the required components.

What is the disadvantage of microservices?

Microservices complexity is a major disadvantage. Having many independent services makes the system more complex to develop and debug. There is also increased operational complexity around deployment, monitoring, and inter-service communication.

What is the difference between microservice and REST API?

A REST API is an architectural pattern for building web services that expose endpoints and resources. A microservice is an independently deployable modular service that forms part of a larger microservices application architecture. An individual microservice may expose a REST API, but microservices also use asynchronous messaging.

What is the biggest problem with microservices?

The increased complexity from having many moving parts is the biggest challenge with microservices. Distributed systems make debugging, monitoring, and orchestration more difficult. There is also complexity around organizing teams, maintaining consistency, and coordinating updates across services.

Conclusion

It enable writing complex, scalable apps by decomposing them into smaller modular components. This architecture patterns promotes resilience, flexibility and independent scaling at the cost of added complexity.

Leveraging design patterns like shared APIs, service discovery and message buses are key to building a decentralized yet cohesive microservices ecosystem. Node.js provides a fast and ideal runtime for implementing microservices.