It is a great and humble feeling to release my very first book “Designing Microservices Platforms with NATS” on 19th November 2021 (first edition). You can read it through Amazon, Barnes and Nobel, Packt, and other distributors worldwide.
Cover of the book Designing Microservices Platforms with NATS
Why Another Microservices Book?
I hear you! Why there are so many books about microservices? Is that so complicated? Why do people use it? Those were some of the questions I had when reading about microservices in the wild (internet). The more I read through, the more I realized that there is something missing. That missing piece was the first principle and the simplicity when building microservices.
Automation of business processes enables organizations to better meet critical factors for success across industries today — from increased team agility and faster time-to-market to lower costs and improved customer service. However, many are hindered by the existing dependencies between their software, systems, and teams, making process automation and business efficiency all the more challenging to achieve and maintain.
This Refcard introduces a way to address such challenges using a microservice architectural style and a workflow engine for orchestration. You will learn key techniques in areas such as microservice design, communication, and state management, as well as first steps to take when getting started with business process automation.
Distributed tracing for Microservices architecture is an emerging concept that is gaining momentum across internet-based business organizations.
We know that microservices architecture introduced an all-new way to scale an application (cloud) with several independent services. It does facilitate high resiliency, scalability, productivity, and efficiency when compared to monolithic architectures.
While microservices offer tremendous benefits and help you stay agile, it’s important to get them right.
In this post, we are going to see how the nature of microservices makes choosing the right API layer even more important and how GraphQL perfectly fits in it.
The software industry has come a long journey and throughout this journey, Software Architecture has evolved a lot. Starting with 1-tier (Single-node), 2-tier (Client/ Server), 3-tier, and Distributed are some of the Software Architectural patterns we saw in this journey.
The Problem
The majority of software companies are moving from Monolithic architecture to Microservices architecture, and Microservices architecture is taking over the software industry day-by-day. While monolithic architecture has many benefits, it also has so many shortcomings when catering to modern software development needs. With those shortcomings of monolithic architecture, it is very difficult to meet the demand of the modern-world software requirements and as a result, microservices architecture is taking control of the software development aggressively. The Microservices architecture enables us to deploy our applications more frequently, independently, and reliably meeting modern-day software application development requirements.
I’m sure you want to build scalable apps, right? Who doesn’t? If so, you must have come across the words “Cloud Native.” This approach is like an angel which can resolve most of your scaling challenges. So, what exactly is cloud native?
Cloud native is an approach used to build apps which can harness all the capabilities of the cloud.
Hi folks! In this blog, we will understand why one should use gRPC for inter-service communication over other RESTful services.
What is gRPC?
It is a high performance, open-source, universal RPC framework. In simple words, it enables the server and client applications to communicate transparently and build connected systems. Google developed gRPC and made it available open-source. With it, a customer can directly call methods on a server application on a different machine as if it were a local object. gRPC is based on the foundations of conventional Remote Procedure Call (RPC) technology but implemented on top of the modern technology stacks such as HTTP2, protocol buffers, etc., to ensure maximum interoperability.
Learn how to develop a custom Spring Cloud Stream binder from scratch.
Spring Cloud Stream is a framework built on top of Spring Boot and Spring Integration that is designed to build event-driven microservices communicating via one or more shared messaging systems.
The core Spring Cloud Stream component is called “Binder,” a crucial abstraction that’s already been implemented for the most common messaging systems (e.g. Apache Kafka, Kafka Streams, Google PubSub, RabbitMQ, Azure EventHub, and Azure ServiceBus).
Spring Cloud Data Flow is a cloud-native toolkit for building real-time data pipelines and batch processes. Spring Cloud Data Flow is ready to be used for a range of data processing use cases like simple import/export, ETL processing, event streaming, and predictive analytics.
We can categorize SCDF applications as Streams and Tasks. Generally, Streams are long-running applications and continue processing data as long as desired; on the other hand, Tasks are short-lived applications which are created, executed and terminated within a relatively short span of time. Our focus in this article is the former.
RSocket is a binary, asynchronous, one-to-one, stateless, symmetrical protocol that relies on one between TCP, WebSocket, Aeron, and HTTP/2 streams to be used as a transport protocol behind the curtains.
Why service discovery is important in a microservices architecture.
How to implement service discovery.
What Eureka is.
What Is Service Discovery?
When we talk about a microservices architecture, we refer to a system with a large number of small services, working with each other:
Basic Mircoservices Architecture
An important feature of such architectures is auto-scaling. The number of instances of a microservice varies based on the system load. Initially, you could have 5 instances of Microservice5, which go up later to 20, 100, or 1000!
In this piece, which originally appeared here, we’ll look at the challenges of refactoring SOAs to MSAs, in light of different communication types between microservices, and see how pub-sub message transmission — as a managed Apache Kafka Service — can mitigate or even eliminate these challenges.
If you’ve developed or updated any kind of cloud-based application in the last few years, chances are you’ve done so using a Microservices Architecture (MSA), rather than the slightly more dated Service-Oriented Architecture (SOA). So, what’s the difference?
