DEV Community: Aditya simant

Microservices: The Future of Software Development

Aditya simant — Tue, 03 Jan 2023 14:07:04 +0000

Microservice architecture, also known as ‘microservices,’ is a development method that breaks down software into modules with specialized functions and detailed interfaces.

Monilithic Architecture

In a monolithic architecture, all components of an application are combined into a single, cohesive unit. This means that the various components of the application, such as the user interface, business logic, and data access layers, are all combined into a single codebase.

This can make it easier to develop and maintain the application since all of the components are located in a single place. However, it can also make it more difficult to scale the application, since changes to one component can potentially affect the entire system. Monolithic architectures are typically well-suited to smaller applications, but may not be the best choice for larger, more complex applications.

Limitations of Monoliths

There are a few key limitations to monolithic architectures:

Scalability: Since all components of a monolithic application are combined into a single unit, it can be difficult to scale specific components without affecting the entire system. This can make it challenging to add new features or support a large number of users.
Modularity: In a monolithic architecture, it can be difficult to reuse code between different components of the application. This can make it harder to develop and maintain the application over time.
Deployment: Deploying a monolithic application can be more complex, since the entire application must be deployed as a single unit. This can make it harder to roll out updates or make changes to the application.
Testing: Testing a monolithic application can be more challenging, since changes to one component can potentially affect the entire system. This can make it harder to identify and fix bugs.

What are microservices?

Microservices: The Future of Software Development In recent years, microservices have gained popularity as a software architecture approach that allows developers to build and maintain complex applications more easily.

But what exactly are microservices, and why are they becoming the go-to choice for many software development projects?

Simply put, microservices are a way of building software applications as a collection of small, independent services that communicate with each other through APIs. Each microservice is responsible for a specific function within the larger application and can be developed, tested, and deployed independently. This modular approach to software development offers several benefits compared to traditional monolithic architecture.

One of the main advantages of microservices is that they allow for more efficient and agile development processes. Since each microservice is focused on a specific task, developers can work on them independently and make changes or updates without affecting the rest of the application. This makes it easier to fix bugs, add new features, and deploy updates without the risk of introducing new issues.

Microservices also make it easier to scale applications as they grow. Since each microservice can be deployed and scaled separately, developers can easily add more resources to specific parts of the application as needed. This makes it possible to handle increased traffic and workloads without having to completely rewrite the entire application. Another benefit of microservices is that they allow for more flexibility in terms of technology choices. In a monolithic architecture, the entire application is built using the same technologies and frameworks. With microservices, each service can be built using the best tools for the job, which can lead to more efficient and effective development. Overall, microservices are a powerful tool for building and maintaining complex software applications. They allow for more agile and efficient development processes, better scalability, and greater flexibility in terms of technology choices.

Understanding the Architecture of Microservices

Microservices architecture is a design approach in which an application is built as a collection of small, independent services, each of which performs a specific task and communicates with other services through well-defined interfaces.

In a microservices architecture, each service is designed to be highly modular and loosely coupled, making it easier to develop, test, and maintain. This modular design also makes it easier to scale specific components of the application, since each service can be scaled independently.

Microservices architectures are typically built using a combination of technologies, including APIs (Application Programming Interfaces) to facilitate communication between services, and containerization tools like Docker to package and deploy the individual services.

Overall, the goal of a microservices architecture is to create a flexible, scalable, and maintainable application by breaking it down into smaller, independent components.

Characteristics of a microservices architecture

Split into numerous components
Robust and resistant to failure
Simple routing process
Decentralized operations
Built for modern businesses

Leading Tech companies using microservices.

1. Amazon

At the turn of the millennium, Amazon’s retail website was a monolith with tightly knit connections between and within its multi-tiered services. This meant that developers had to work carefully to make sure nothing broke every time an upgrade or upscaling activity had to be undertaken.

Real-time Graph of Amazon.com’s Microservice Dependencies in 2008

This was not an exception, as many tech startups at the time adopted this methodology when building their applications. Even large-scale tech projects undertaken by big companies were created using monolithic architecture.

However, as the demand for the project or product increased, Amazon added more developers to work on it, and the codebase became bigger. This made the architecture more complex to modify, adding overheads to the process and slowing down the software development lifecycle.

2. Netflix

Just like Amazon, Netflix is a pioneer in the microservices space. Its migration began in 2008 when the streaming platform faced numerous scaling issues and service outages.

Dave Hahn Shows off the Entire Architecture of Netflix in One Flow Diagram

When a primary database of the company was corrupted, causing a three-day blockage on DVD shipping to members, Netflix realized it was time to migrate to microservices. It began migrating away from vertically-scaled single points of failure, such as relational databases in its data centers. Instead, the platform adopted highly reliable cloud-based distributed systems that were horizontally scalable. Netflix chose Amazon Web Services as its cloud provider to achieve its migration goals.

3. Uber

Like Amazon and Netflix, Uber, too, decided to shift away from its monolithic structure due to growth hurdles. The challenges faced by the ride-sharing platform included inefficiency in the development and launch of new features, the inability to fix bugs quickly, and problems with integrating its fast-growing global operations. It reached a point where the complex application architecture needed extensively experienced developers to make minor changes and updates to the system.

To conquer the challenges presented by its monolithic application, Uber broke it down into cloud-powered microservices. Soon, individual microservices were developed for business functions such as trip management and passenger management. These services communicate with each other through an API gateway.

The adoption of this microservices architecture helped Uber overcome its technological challenges. Here’s how:

Development teams took ownership of specific services, boosting development initiative quality, speed, and manageability.
Teams focused on the services that needed to be scaled up, thus facilitating swift scaling up of the entire application as demand increased over time.
Fault tolerance was improved, and Uber could update individual services without disrupting the rest of the application.

Microservices Best Practices

Keep services small and focused: Each service should have a specific, well-defined purpose and should be small enough to be developed and maintained by a single team.
Use APIs to facilitate communication between services: Use APIs to define the interfaces between services, allowing them to communicate and exchange data in a standardized way.
Use containerization tools like Docker*: Containerization tools like Docker make it easier to package and deploy microservices, allowing you to scale and manage them more efficiently.
Use a cloud-based platform: A cloud-based platform like Amazon Web Services (AWS), Microsoft Azure, or Google Cloud Platform (GCP) can make it easier to deploy and scale microservices.
Monitor and log everything: Monitor the health and performance of your microservices to ensure they are functioning correctly, and use logging to track errors and debug issues.
Practice continuous integration and delivery: Use continuous integration and delivery (CI/CD) practices to automate the build, test, and deployment of your microservices, allowing you to roll out updates and fixes more quickly.
Use a microservices-friendly framework : Consider using a framework like Spring Cloud or MicroProfile that is designed specifically for building and deploying microservices.
Use a service mesh : A service mesh like Istio can help you manage the complexity of a microservices architecture by providing features like load balancing, service discovery, and monitoring.

If you're considering using microservices in your next software project, the benefits are worth considering. I hope this blog helped explain the concept of microservices and their benefits in software development.

Let me know if you have any questions!

Android : Mock Response with Retrofit & OkHttp

Aditya simant — Sat, 22 Oct 2022 04:49:20 +0000

What is Mock Server?

A mock API server or mock server API imitates a real API server by providing realistic mock API responses to requests. They can be on your local machine or the public Internet. Responses can be static or dynamic, and simulate the data the real API would return, matching the schema with data types, objects, and arrays.

Why API Mocking?

A mock API server is useful during development and testing when live data is either unavailable or unreliable. While designing an API, you can use mock APIs to work concurrently on the front and back-end, as well as to gather feedback from developers.

You can also use mock APIs to emulate APIs you don’t control. For example, you can use a local mock server to fake results from a public API when you aren’t connected to the Internet. Or, use mock data responses if live calls to an API would incur a charge from the provider.

How to Mock API Response with OkHttp and consume with Retrofit?

We can simply acheive mocking API response with the help of OkHttp and how? By using Interceptor from OkHttp. OkHttp provides a way to intercept during every network operation requested by Client (Android Application).

Practical Example?

Let's say, we want to call an api endpoint called fake-login. This API endpoint should return an response (Error or Success). But at this moment, we just received an JSON as response from the Backend Engineering Team and APIs still under development.

In this scenario, we can be benefited by OkHttp. We can intercept during the network operation and ask OkHttp to return a Mock Response for an/some API endpoints.

Let's get into the coding part


object APIProvider {
    //Return a lazy instance of OkHttp client
    private val myHttpClient: OkHttpClient by lazy {
        val ins = OkHttpClient().newBuilder()
            .connectTimeout(1, TimeUnit.MINUTES)
            .readTimeout(1, TimeUnit.MINUTES)
            .writeTimeout(1, TimeUnit.MINUTES)
            .retryOnConnectionFailure(true)
        ins.build()
    }

    //Public access point for Mock API Service
    fun getMockAPI(): MockAPIEndpoint = retrofitInstance.create(MockAPIEndpoint::class.java)

    //Return a lazy Retrofit instance
    private val retrofitInstance: Retrofit by lazy {
        Retrofit.Builder()
            .baseUrl("https://rommansabbir/api/v2/")
            .client(myHttpClient)
            .build()
    }
}

We have an Singleton Object calledAPIProvider, which expose an public function to get access of MockAPIEndpoint. Lets take a look at the MockAPIEndpoint.


interface MockAPIEndpoint {
    @GET("fake-login")
    fun login(): Call<ResponseBody>
}

MockAPIEndpoint has only one API at this moment and we want to return a mocked JSON object as Response.

Now, lets work on our LoginInterceptor class.


class LoginInterceptor: Interceptor{
    override fun intercept(chain: Interceptor.Chain): Response {
        //If requested endpoint matched to targeted endpoint, we will return an mocked response.
        if (chain.request().url.toUri().toString().endsWith("fake-login")) {
            val responseString = "OUR_JSON_RESPONSE_FROM_ASSET_OR_OTHER_SOURCE"
            return chain.proceed(chain.request())
                .newBuilder()
                .code(200)
                .protocol(Protocol.HTTP_2)
                .message(responseString)
                .body(
                    responseString
                        .toByteArray()
                        .toResponseBody(
                            "application/json".toMediaTypeOrNull()
                        )
                )
                .addHeader("content-type", "application/json")
                .build()
        } else {
            //Skip the interception.
            return chain.proceed(chain.request())
        }
    }
}

Here, we are intercepting during the API request. If requested endpoint matches to our targeted endpoint, we will return a mocked JSON object as response. We can get this JSON from Asset or other source (eg. String).

We are almost done with our API Mocking. Let's add our LoginInterceptor to OkHttpClient. Update APIProvider::myHttpClient as shown down.


    //Return a lazy instance of OkHttp client
    private val myHttpClient: OkHttpClient by lazy {
        val ins = OkHttpClient().newBuilder()
            .connectTimeout(1, TimeUnit.MINUTES)
            .readTimeout(1, TimeUnit.MINUTES)
            .writeTimeout(1, TimeUnit.MINUTES)
            .retryOnConnectionFailure(true)
        //Adding our LoginInterceptor only on Debug mode only
        if (BuildConfig.DEBUG){
            ins.addInterceptor(LoginInterceptor())
        }
        ins.build()
    }

That's it. Now, when we want to execute an API request to the targeted endpoint with Retrofit, OkHttp will return Mock API Response.

Testkube: The Kubernetes-native testing framework

Aditya simant — Thu, 29 Sep 2022 16:01:39 +0000

What is TestKube?

Testkube is a Kubernetes-native testing framework. It enables running tests directly in your Kubernetes cluster and then saves the results to a centralized space. It abstracts away all the troubles of containerizing different test types. Testkube makes testing in Kubernetes a smooth cloud-native experience.

TestKube gives us a centralized test result and is simple to integrate with GitOps and CI/CD procedures.

So, in this blog, we will go to cover:

Why Testkube?
Is it for you?
Installation of Testkube
Demo.

Prerequisties:

Basic knowledge of K8s

Why TestKube?

TestKube Decouples the testing activities performed at CI/CD pipeline and defines them in Testkube so that we can run our tests anytime without having to run the entire CI/CD pipeline for running an individual test, So moving across CI/CD platforms becomes more accessible as we don't need to redefine all the tests as we can reuse the way tests has been defined and orchestrated in TestKube.

CI/CD Workflow With TestKube

CI/CD Workflow Without TestKube

Because TestKube retrieves the test files from the project repository and executes them as you want, you don't need to perform any complicated settings to run your tests.

The complexities involved with CI/CD testing are simplified as TestKube Manages all the testing activities themselves.

TestKube provides the entire infrastructure for taking care of all testing workloads from inside the Kubernetes cluster.

Is TestKube for you?

If you are doing Integration testing for your application under Kubernetes, Testkube is for you.
If you wish to surpass K8's limitations, such as network limits or lack of access to testing environments
If your CI/CD and testing processes are too closely related

Installation

Now, open your terminal and write this command.👇
$ kubectl testkube install
Now, run this👇 command to view all the TestKube components.
$ kubectl get pods -n testkube

Now, your screen will look like this👇

Now, we will be able to see both client and server versions.

To see the version of the TestKube, run this command.👇 $ kubectl testkube version

To run your test, run this command.👇
kubectl testkube run test our-first-test-name

The screen will look like this.👇

Running a K6 Test

K6 is integral part of Testkube. During the Testkube installation, the Testkube k6 executor installs by default. You must first build a Test in Testkube to perform a K6 test.

Create a new JS file.

// bash

$ touch k6-test.js

// You can give any name

Now we will create a k6 load test and run it. Write this code 👇 inside the k6-test.js file.

import http from 'k6/http';
import { check, sleep } from 'k6';
export const options = {
stages: [
 { duration: '5s', target: 20 },
 { duration: '5s', target: 10 },
],
};
export default function () {
const res = http.get('https://httpbin.test.k6.io/');
check(res, { 'status was 200': (r) => r.status == 200 });
sleep(2);
}

Save the file as k6-test.js or anything you like.

Now execute the test script. First, we need to define it as k6/script 👇


$ kubectl testkube create test --file path/to/your/k6-test.js --type "k6/script" --name k6-test

Now, run this command.

$ kubectl testkube run test k6-test -f

Now, we can view our logs and test results in the Testkube dashboard. Run this command.👇

$ kubectl testkube dashboard

Thank You

I hope you learn something from this blog.

How I won my first hackathon.

Aditya simant — Wed, 28 Sep 2022 17:35:38 +0000

What is a Hackathon and Why should you care?

A Hackathon is the best place to learn and collaborate with a lot of diverse people just like you. In simple words, Hackathon is about bringing your crazy ideas to reality through technology. It’s an event where anyone, regardless of their individual field can come & participate to learn, build & share their creations.

The first-ever Civo Hackathon was an initiative to bring together developers, architects, experts, and students from across the globe to develop innovative Kubernetes projects on Civo. It provides a learning experience towards hosting applications on Kubernetes while exploiting the blazing fast speed and the simplicity of Civo’s Kubernetes platform.

MY JOURNEY

It all started out when I first heard about the Hackathon in my community space, as I was in my freshmen year and was exploring various fields, I decided to give it a shot and registered for the hackathon without any prior experience. All I knew was that we were expected to make some projects on a given theme, which in this hackathon was deploying application using kubernetes. As of today I am a open-source enthusiast and I work/contribute mostly in DevOps, Kubernetes and containers, but during that time I barely knew what kubernetes, servers, containers or deployment was. As the date for the hackathon approached, we were asked to make teams and start planning.

I didn't knew anyone in the hackathon to form team with nor did any of my friends participated with me, so I decided to make team with random people in hackathon. I started emailing random participant in a hope of getting a reply and getting to know each other to make a team. Approximately I emailed around 12-15 people, to which I got 2 replies.

None of us knew each other before the hackathon. We randomly connected with each other through emails and Discord groups. It was a wonderful experience meeting and collaborating with new people. Our main goal was to learn and explore new technologies.

Members of my team :

Aditya simant (me)
Bala yokesh mani.
Prajwal jaiswal.

As the Hackathon started, I was scared that I might mess up and because of me my teammates would be defeat as well. After recollecting myself I just took up a challenge to myself that I have to do it anyhow without thinking about the results, even if I lose at least I will take some learning back with me which will help me in the future.

THE PROJECT

For the hackathon we created the Speech Companion. It was a simple application but a complete project. We tried to focus on how we can solve a small daily life problem using our project.
We as students always struggle with assignments and projects. Most of this work requires reading a big amount of text. We always wished there was a technology that can read the given text for us and also write the given text. So we built a project named Speech Companion.

Speech Companion can convert your given speech into text for convenience. It can also read the given text for you making your work a lot easier.

Speech Companion Github.

How we built it?

How we built the application: We made use of ReactSpeechRecognition npm library for implementing the voice to text functionality. We also used JavaScript's inbuilt speechSynthesis module for text to voice conversions. We chose to usereactJS as our frontend library since it offers quick state refreshes and component based approach. We used fontawesomeicons for implementing icons on the user interface. We also wrote our custom CSS for designing the home page with the best possible User Interface for users.

Then comes the deployment. This was done in just a few simple steps. We first containerized our app using Docker. Then we created a kubernetes cluster on the Civo Website and added three simple .yaml files in our application.

deployment.yaml file -


apiVersion: apps/v1
kind: Deployment
metadata:
  name: speech-companion
spec:
  replicas: 2
  selector:
    matchLabels:
      app: speech-companion
  template:
    metadata:
      labels:
        app: speech-companion
    spec:
      containers:
        - image: prajwalj27/speech-companion
          name: speech-companion

service.yaml file -


apiVersion: v1
kind: Service
metadata:
  name: speech-companion
  labels:
    app: speech-companion
spec:
  ports:
    - name: "speech-companion"
      port: 3000
  selector:
    app: speech-companion

ingress.yamlfile -


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations:
    kubernetes.io/ingress.class: traefik
  labels:
    app: speech-companion
  name: speech-companion-ingress
spec:
  rules:
    - host: speech-companion.ae150322-a780-4657-a1e0-604a842c2fc0.k8s.civo.com
      http:
        paths:
          -
            backend:
              service:
                name: speech-companion
                port:
                  number: 3000
            path: /
            pathType: "Prefix"

What's next for the project?

Speech Companion has a lot of improvements to make yet. We can design it such that it can also be used in different languages, also we can give users the best experiences by changing the accent and speed for the better.

Use of Civo Kubernetes

Before the hackathon, all the members of our group had experience in making web applications using React or other frameworks, but none of us had ever worked with cloud platforms. To participate in this hackathon it was mandatory to make use of the services provided by Civo in our project.

So one week before the hackathon we started exploring some of the core concepts related to DevOps. We got to learn about containers, containerized applications, Docker, Kubernetes, etc. And the best place to get started with learning and using Kubernetes is the Civo Academy. Most people find it difficult to start learning Kubernetes right away, as a result, the videos in the Civo Academy are structured in such a way that is easy to understand for most of the beginners.

Talking more about Civo, I would say the simplicity and the ease with which we can work on our applications is really impressive. With just few clicks here and there, selecting some options and within a few minutes we can have our fully running clusters. The people in the slack community are also very helpful. Even if there is a small problem or a thing that we are unable to understand, people in the community are always willing to solve our problems at any time of the day.

Overall I would like to say it was a wonderful experience participating in this hackathon.

We won it by 3rd overall position

While randomly checking my emails I saw their email,
I was so happy at that moment that finally, I have done something, You know "The best thing in life is unexpected".

Things I learned

Never Underestimate yourself.
Don't think too much start taking action.
Ask a lot of questions.
Build for fun, make sure you learn something new.
Don't just run to winning.
Learn while building.
Collaboration and team building help a lot.
Time Management
No one wants you to be an expert

Conclusion

Enjoy every single small achievement that you earned and be proud of it always. Share the learnings, write a blog on it, and help and guide others.

"It's never too late to start something, Dont think just start experimenting with things that's how you will learn, Hackathons are all about learning and experimenting things".