Understanding the Messaging queue in Microservices

Akhilesh Kumar — Tue, 27 Apr 2021 19:44:09 +0000

Microservices is an architectural style that structures an application as a collection of services that are loosely coupled, highly maintainable, pluggable, and owned by small teams based on services.

Microservice architecture helps you in scaling your complex application, deploy services independently, rapid delivery of new features, and fully testable. Around microservice-based architecture, we are also able to utilize diverse tech stacks. So before starting out with your next Microservice application, you need to keep one important term in mind, i.e. Messaging Queue.
A message queue is a form of asynchronous inter-service communication. Messages are stored on the queue until they are processed and deleted. Each message is processed only once, by a single consumer. Message queues can be used to decouple heavyweight processing, to buffer or batch work, and to smooth spiky workloads. Common messaging tools are Kafka, RabbitMQ, AWS SQS.
Let dive into Messaging queue and learn why do we need them in a Microservice architecture.

Message Queue

A message queue is a queue of messages sent between services/applications. A message is some information that is produced by a producer application in byte form, stored in a queue and is consumed by a consumer application.
The best thing about a message queue is even when some service is offline, the message queue preserves the message in the queue and can be retrieved by the consumer.

Let’s say we have a Digital Signing service SignMe. With SignMe we enable organizations to send documents to people for electronic signatures. Once someone creates a document and has to send it for signature, they need to add recipients. Now to inform recipients, we need to send them an email. We also need to send recipients a reminder to sign the documents if they forget to sign after x days. Let’s think of some approach where we can send emails to the recipients.

There is one service where a sender goes and creates a template, adds recipients, and sends the envelope for signature. There is another notification service that sends the recipient notifications as email or push notifications. We want to send emails to end recipients with the help of messaging queue.

We can either have a rest synchronous architecture, where we have an external call to notification service and wait for the response, or an asynchronous messaging queue.
Synchronous call to notification service will block the current thread until the request is resolved and for any failure in the service, it will give an exception and we will lose the current process. If the goal is to support a few hundreds or thousands of users, then a simple rest synchronous architecture will be a good choice to go with.
However, when we talk of large-scale applications where tens of thousands of requests are created, we need to use the Messaging queue.

To send emails, how can we do it?

Our Envelope Sending service will be a publisher which pushes these notification actions to some topic of messaging queue and, respond back to the users. So once we write the message to the queue, the notification service which acts as a consumer can read messages from the queue and, process them asynchronously.
So this is how we can achieve high reliability, scalability, and true decoupling. In certain scenarios when our dependency services are down, we still have the messages stored safely with us in the queue which we can retrieve later. Wonderful, right? Let me know your thoughts in the comments.

Deploying React App to Github Pages

Akhilesh Kumar — Fri, 10 Apr 2020 04:21:29 +0000

I have been hosting my static webpages on Github and use the CNAME to point the hosted project on gh-pages on my own domain name.

I am new to modern web development and have been actively exploring the Full-stack web Development recently. Earlier just pushing my static HTML, CSS and JS files to github used to deploy the static contents directly. But when I pushed the react app for the first time to my Github repository, it simply didn't publish my page. It took me no longer to understand that some other way must exist to publish the static generation from React App.

Well, it’s simpler than I considered it to be. I am showing how to deploy a react app to gh-pages in no time.

Getting Started:

I had created a Notes taking app using Firebase and React. Nothing fancy but a very good starter project to do.

You must have a Github account and Git and Node installed to your system. I assume, since you are looking forward to host an existing React Application, so you must be having these installed.

Moving forward, I will quickly jump to installing Github Pages Package gh-pages. There are two kinds of Development Environment when working on some App.

Development Environment
Production Environment

To practice good coding habits we take care of the Production and Development Environment and therefore we will be installing gh-pages to the Development Environment.

Let's quickly jump to the current working directory of our React Application and then install gh-pages with the NPM package manager.

npm install gh-pages --save-dev or yarn add gh-pages --save-dev

This package basically creates a gh-pages branch on Github and also serve our bundled react files on the branch.

In any Node application, package.json is used to manage the properties and dependencies of the project. Let's find the package.json file in the root directory, add this line of code to your script: "homepage": "link-to-your-repository", and save. In my case it looks like this:
{ "name": "Notes App", "version": "1.0.0", "private": true, "homepage": "https://akhilesh-k.github.io/notes", ... }
As I wrote earlier, I used to use my custom domain until it expired, so in case you too have a custom domain, you can add the domain the homepage property.

You have also noticed that inside your package.json file there is script object, it basically contains the scripts our React App uses to run.

Again in the package.json file, let's find “scripts” and add these lines there:
{ ... "predeploy": "npm run build", "deploy": "gh-pages -d build", ... }
It depends on you, what package manager you use, you can write yarn run build too if you use yarn. In my case it was npm.

Now our script looks like this:

"scripts": { "start": "react-scripts start", "predeploy": "npm run build", "deploy": "gh-pages -d build", "build": "react-scripts build", "test": "react-scripts test", eject": "react-scripts eject" },

The predeploy command basically works behind the scenes in bundling up the React App while deploy command starts using the bundled app.

Assuming that you have git repository initialized and Github remote added to the directory, We will now run the deploy command to deploy it on Github Pages!

So let's do it!

In the terminal, run
npm run deploy

Alternatively you could also use yarn run deploy if you are Yarn guy. deploy basically pushes the after build file to the gh-pagesbranch on our remote Github repository.

In the meanwhile we have successfully published our React App to the Github pages, don't forget to commit the code!

Godspeed

Forem: Akhilesh Kumar

Understanding the Messaging queue in Microservices

Message Queue

Deploying React App to Github Pages