3 Things About Emerging Software That You May Not Know

1. It’s easy to learn.

You can build more than one application, which is a key feature in Microservices. That means that you don’t have to worry about how to use different technologies and libraries in your application for each service. As an example, let’s say you want to create two web applications using Express.js (Node.js), and then make the other one on Laravel.io. At first glance, it should be harder to figure out what’s causing you so much trouble because both of these applications will run on the same server setup. So, for instance, by typing “node app.js” in a search bar, you’ll see this page with all the dependencies that went into building both applications: http://localhost:8000/app

On the other hand, the node app.js uses express 5.8.0. When you type node app.js, only one server will start and serve all the services. In contrast to node app.js, there’s no information on where the data is going and how everything works (at least, not from the outside world). On the other hand, the Laravel app.js use Laravel 4 and PHP 7.6. For instance, if we go to https://laravel-app.com/, only we can find something like this: https://laravel-app.com/app.php

2. No dependency management issues:

One of the most common problems that could arise comes from the way of how the code in Microservices is written. They mostly rely on one technology, which makes them hard to patch. Since they’re only using one module, the changes are carried automatically and there’s no need to have a CI/CD pipeline to automate their updates. The module manager can also make errors and even crashes while developing new modules. One of the ways to manage this problem is to set up separate development environments, but I like to avoid that since it increases efforts in maintaining new modules, which is usually not worth it in most cases. If we have a production environment, then setting development environments separately increases our maintenance costs by adding more layers between us and the rest of the infrastructure. Plus, having multiple developers has its perks. With less time between team members, they can add features and bug fixes without breaking existing projects. In addition to being able to develop faster, since everyone works together in a larger team, each developer gets to work independently in another project. However, in order to achieve such an advantage, it doesn’t mean you have to split your resources across multiple teams. There are still tools that help us develop features without losing the efficiency of those features on legacy systems. In today’s fast-paced business world of ours, no wonder every company wants to integrate their products and services using containers (or virtual machines) as well as platforms like Amazon Web Services or Google Cloud Platform. And one of the reasons why we choose microservices to build an entire platform is that we can take advantage of Docker while being able to focus on specific tasks.

3. Control all layers of the system using APIs:

There are several ways to connect software layers with API layers in Microservices. For instance, we can use Kafka and publish messages to Pub/Sub. We could use Spring Boot to enable the CRUD functionality in our end-user apps. Also, we can use ActiveMQ as the message broker, a very popular tool that has millions of users running it in a production environment. Other options are similar. But if you want to know more about the best practices, check this blog post that I wrote in 2015. In addition to making the API layer accessible, you can also use third-party open source libraries to create client-side applications. Let’s take an interesting example. A user wants to log in to his account with Facebook. So he starts writing a request to the backend of the social network and sends a request to my API to get more details.

Here’s the result:

As soon as he posts his password, I receive that.

If you want to understand more in detail how I build this application, read my previous articles on microservices and APIs. So far for me, just for logging a login, you only see the login page with Facebook’s logo; however, with a successful login, there’s a page that gives you access to your accounts: https://facebook.com/YourName

This was just an illustration of how simple this can also become. But this isn’t the complete story, since there’s an extra stage that we can play. Every endpoint can be used to generate a token for authentication. Even with authorization, we can give permission to perform certain actions like grant access to certain pages or perform specific operations. Each endpoint can be configured with certain conditions, for instance, to only show the logged in information when the person was logged in before. But this is optional. There are some other things that are included, such as: who is performing the operation and if there’s no error returned, if the operation is still required, and whether it needs authorization. By storing an object of authentication, we can tell this logic in future when dealing with this endpoint. So that basically, each endpoint allows only authorized people to authenticate themselves.

3. Use one single point of failure:

When I think about this solution, I can see other companies who use this technique. However, I think that this strategy was invented in response to security threats. This seems obvious enough, but it’s important to remember this in terms of businesses. Your customers can have unlimited amounts of access to any part of the application, without worrying about the system failure, or lack of availability in case something goes wrong. So if it does happen, they can easily identify what caused the problem and fix it. Then, after fixing whatever is broken, the customer will need only to deploy the new change and everything will be good again. This way, we reduce the chances to break down new apps. To this day, I still haven’t seen a scenario where a company has had a huge number of failed products due to one single point of failure. It would make sense at the moment, but I’m not sure if this strategy is viable anymore.

In conclusion, now we’ve seen some common trends in Microservices, and we’ve seen three important factors for choosing the right approach to implement a scalable system. If you still don’t know about them, I’d recommend reading the latest books that I write about the subject.