Microservices Architecture Design and Best Practices 

What is Microservices Architecture?

A microservices architecture style is an approach for developing small services each running in its process. It enables the continuous delivery/deployment of large, complex applications. It also allows an organization to evolve its technology stack.

Why Microservices Architecture?

Microservices came in a picture of building systems that were too big. The idea behind microservices is that there are some applications that can easily build and maintain when they are broken down into smaller applications that work together. Each component is continuously developed and separately managed, and the application is then merely the sum of its constituent elements. Whereas in traditional “monolithic” application which is all developed all in one piece.

Microservices Architecture Design

Distributed architecture

All the services communicate with the API gateway through REST or RPC. These services can be deployed as multiple instances, and the requests can be distributed to these instances.for

Separately deployed components

Each component is deployed separately. If one component needs changes, others don’t have to deploy again.

Service components

Services components communicate with each other via service discovery

Bounded by contexts

It encapsulates the details of a single domain, and define the integration with other domains. It is about implementing a business capability.

Benefits of Adopting Microservices Architecture Design

• Asynchronicity.
• Integration & Disintegration.
• Complected Deployments.
• Evolutionary Architecture.
• Components are deployed.
• Features are released.
• Applications consist of routing.
• Easier to understand the code — It is easy to distinguish one small service and flow of the whole service rather than one big codebase.
• Fast Software delivery — Each service can be developed by different developers and in many different languages.
• Efficient debugging — Don’t have to jump through multiple layers of an application and in essence better fault isolation.
• Reusable — Since it is an independent service it can be used in other projects also.
• Scalability
• Horizontal scaling
• Workload partitioning
• Don’t have to scale the whole project. We only need to scale up that component that needs to scale up.
• Deployment — Need only to deploy that service which has been changed not the whole project again.

Characteristics of Microservices Architecture Design

• Small in size
• Messaging enabled
• Bounded by contexts
• Autonomously developed
• Independently deployable
• Decentralized
• Built and released with automated processes

Continue Reading: XenonStack/Insights

Serverless Computing is Exploding

Serverless Computing

Serverless Computing Advances the way Applications are Developed

Monolith => Microservice => FaaS

• Creating a Deployment Package

• Uploading a Deployment Package

Database Integration For Your Application

• Install MongoDB and configure it to get started.

• Create Database EmployeeDB

• Create table Employee

• Insert some records into the table for the demo.

• Write a file “config.py” to setup configuration on the serverless architecture as shown below.

Continue Reading the full Article at: XenonStack.com/Blog

Serverless Architecture

What it means to have servers?

• Managing how the primitives (functions in the case of applications, or objects when it comes to storage) map to server primitives (CPU, memory, disk etc.).

• Own provisioning (and therefore paying) for the capacity to handle your application’s projected traffic, independent of whether there’s actual traffic or not.

• Own managing reliability and availability constructs like redundancy, failover, retries etc.

Advantages of going Serverless

• PaaS and Serverless - A user of traditional PaaS have to specify the amount of resources—such as dynos for Heroku or gears for OpenShift—for the application. The Serverless platform will take care of finding a server where the code is to run and to scale up when necessary.

• Lower operational and development costs - The containers used to run these functions are decommissioned as soon as the execution ends. And the execution is metered in units of 100 ms, You don't pay anything when your code isn't running.

• Fits with microservices, which can be implemented as functions.

How to migrate to a Microservices Architecture?

• One code per app/service: There is always a one-to-one correlation between the codebase and the service.

• Explicitly declare and isolate dependencies: This can be done by using packaging systems.

• Use environment variables to store configurations.

• Strictly separate build, release and run stages.

• Treat logs as event streams. Route log event stream to analysis system such as Splunk for log analysis.

• Keep development, staging, and production as similar as possible.

Microservices Architecture: Benefits

Microservices Architectures have lots of very real and significant benefits:

• Systems built in this way are inherently loosely coupled

• The services themselves are very simple, focusing on doing one thing well

• Multiple developers and teams can deliver independently under this model

• They are a great enabler for continuous delivery, allowing frequent releases whilst keeping the rest of the system available and stable

In this post, we will implement a Nexastack function which integrates with a database(MongoDB used here).

We are going to implement this new function in Java using Spring Framework. So, Let’s get started -

Employee Service

We are going to build an Employee Service consisting of a function to show Employees information from the database.

For Demo purpose we are here implementing one function “GetEmployee”.

1. Setting up MongoDB Instance 

• Install MongoDB and configure it to get started.

• Create Database EmployeeDB

• Create table Employee

• Insert some records into the table for demo.

• Write a file “config.properties” to setup configuration on the serverless architecture

 Continue Reading the full article at: XenonStack.com/Blog