Application response time is a critical factor when building high-performance applications. To optimize this time, we can use caching strategies.

Assume we have an inventory management service that connects to the database. for high availability, we have two instances of API servers.

There are main two types of cache strategies that can be followed in microservices.

1. Distributed Cache
2. Local Cache Strategies

In the distributed architecture, there are two types of distributed cache available.

1. Centralized Cache
2. Embedded Cache

For example, we can use Redis as a centralized cache provider, since the cache instance will be available as a single instance it will synchronize the data between microservices.

In the example above, we can integrate any type of cache provider to offer a centralized cache for applications. This approach is suitable for large-scale, enterprise-grade architectures, though maintaining a centralized cache introduces additional costs to the system.

The next approach is to use an application-level cache. However, if there are multiple instances, we cannot guarantee that user requests will be routed to the same instance in future requests. As a result, all cache instances need to be synchronized.

Hazelcast

Hazelcast is a widely used open-source distributed caching provider, particularly popular in microservices architectures. In this guide, I will outline the steps to configure a Spring Boot application with Hazelcast.

1. Add Dependencies

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-cache</artifactId>
  </dependency>
<dependency>
    <groupId>com.hazelcast</groupId>
    <artifactId>hazelcast-spring</artifactId>
    <version>5.3.1</version>
</dependency>

2. Add Hazelcast configs file

@Configuration
public class HazelcastConfig {

  private final Logger logger = LoggerFactory.getLogger(getClass());

  @Bean
  public HazelcastInstance hazelcastInstance() {
    HazelcastInstance instance = Hazelcast.newHazelcastInstance();
    instance.getConfig().addMapConfig(new MapConfig("inventory-api").setTimeToLiveSeconds(5));
    LogListener listener = logEvent -> logger.info(logEvent.getLogRecord().getMessage());
    LoggingService loggingService = instance.getLoggingService();
    loggingService.addLogListener(Level.INFO, listener);
    return instance;
  }

  @Bean
  public ClientConfig clientConfig() {
    ClientConfig cfg = ClientConfig.load();
    cfg.setClusterName("inventory-api-cluster");
    return cfg;
  }
}

3. Enable cache in the spring boot application.

@EnableCaching
public class ApiServiceApplication {

    public static void main(String[] args) {
       SpringApplication.run(ApiServiceShrApplication.class, args);
    }

}

5. Can use spring cache annotations to implement cache features

@Cacheable(value = "products", key = "#category")
@Override
public List<ProductSummaryDto> getProductsByCategory(String category) {
 // your logic
}

Once we start the service, it will launch embedded Hazelcast instances. If multiple instances are running, you can observe that all the Hazelcast instances synchronize properly.

Thank you for taking the time to read this blog! Your feedback and suggestions are invaluable in helping us improve the content and make it more useful for our readers. Please feel free to share your thoughts and comments below. Your input is greatly appreciated!

In the year 2024, I started with good news, I had cleared my CKAD exam and I thought to share my experience to prepare and face the exam.

Background

I have done projects in the last 4 years using the k8 environments. Though I have worked on projects I thought to prepare for certification and prove I know k8. My first choice was to start CKA and decided to start CKAD first and then moved to CKA.

Materials

1. Mumshad Mannambeth this udemy course I have followed.
2. KillerCode this Tutorial link
3. K8 Documentation https://kubernetes.io/docs/home/
4. For Network policies this repository is very useful
5. This GitHub repository is ok but some of the content is outdated.

Prepare for Exam

The main challenge in this exam is time management. you will get 16–22 questions ( for me it is 16 questions ). Time is enough and don’t spend on questions if you don’t remember or have difficulty when identifying the issue. Just flag the question and move to the next one. That way at the end of the exam you can see that time is enough for the exam. Another thing needs to having to remember some of the imperative commands it will reduce your time searching the official documentation. Here at the end, I will add the commands I have noted while preparing for the exam.

The next thing is please make sure to complete the free two mock exams provided by Killercode. It will help to familiarize with the environment. especially how to copy and paste from official documentation to the remote desktop terminal.

From My Note Book

This is the list of commands I have put in my note.

1. Short Keys

export do=" - dry-run=client -o yaml"
export now=" - force - grace-period 0"

2. Most used commands

// cronjobs 
k create cj cj1 -oyaml --dry-run=client --schedule="* * * * *" --image=busybox

// pods
k run nginx --image=nginx --restart=Never --port=80
k exec my-pod -- ls
k exec -it mynginx  -- pwd
kubectl run busybox --image=busybox --command "sleep" -- "5000"
k set image pod/nginx nginx=nginx:1.7.1
k get po -l app=v6
K get logs -f my-pod -c <init-cotainer>
k run mynginx --image=redis --env=SAMPLE=user
k top po -n rcluster --sort-by memory --no-headers // filter pods

// quota for node
k create quota myquata --hard=copu=1,memory=1G,pods=2

// deployments
k set image deployment.v1.apps/nginx nginx=nginx:1.7.1
k scale rs --replicas=5 frontend
k scale deploy --replicas=4 demo


// service
k expose pod redis --port=6379 --name redis-service $do -o yaml > service.yaml
kubectl expose deployment nginx --port=80 --target-port=8000
kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
k expose pod redis --port=6379 --type=NodePort --name redis-service


// Configs Maps
k create cm my-test —from-literal=key=value —form-literal=key=val

// Secrets
k create secret generic db-secret --from-literal=DB_Host=sql01 --from-literal=DB_User=root --from-literal=DB_Password=password123

// Service Account

k create sa my-test

// Taints for node

kubectl taint nodes node01 spray=mortein:NoSchedule

Remove Taint ( add - end of line)

kubectl taint nodes node01 spray=mortein:NoSchedule-

// deoployment rollout 

kubectl rollout history deployment/nginx-deployment

k rollout undo deployment/nginx-deployment


// Ingress

k create ingress ingress-pay -n critical-space --rule="/pay=pay-service:8282" --dry-run=client -o yaml > ingress2.yaml

k get ingress

// Roles

kubectl create role foo --verb=get,list,watch --resource=pods,pods/status

k auth can-i create nodes — as dev-user


// View Contexts

k config view
k config use-context sajith@production

// cluster roles
k get clusterroles
k get clusterrolebindings

// labels
kubectl label nodes my-node app=backend


// Update deployment specs

k set resources deploy redis --requests=cpu=0.2 --limits=cpu=0.5


// helm commands

healm list

uninstall

helm uninstall <> -n namespace release_name

healm install internal-issue-report-apache bitnami/nginx --version=1.0.0

Update repos's
helm repo update

Set Values in install

helm install q30 bitnami/nginx -n helm-test --set replicaCount=2

// RBAC Commands

k auth can-i get secret/sajith100 --as sajith

Answer : # no

k create role thinkrole --verb=get,create,list --resource=secret --resource-name=sajith100


k create rolebinding sajith100binding --role=thinkrole --user=sajith


k auth can-i get secret/sajith100 --as sajith

answer : # yes

If you are planning to sit CKAD 2024 this post will help to prepare for your exam. will see you in another post regarding CKA in the next couple of months.

Last week I was able to set up Grafana and Prometheus to monitor the k8 cluster using the helm chart.

Before starting this blog I want to say that I am not an expert in Kubernetes and if any false information is in the blog please correct me. This blog is for beginners who are trying to learn Kubernetes.

Here I am not going to discuss the Kubernetes concepts. So My primary goal Is to set up Grafana + Prometheus in the Kubernetes cluster in AWS. For that, I am planning to use helm. The main advantage of using helm is, that it is providing templates that will save our configuration overhead in setup in k8.

AWS K8 Cluster Setup

First Create a Kubernetes cluster in AWS.

For that, I am planning to use eksctl tool to create a cluster. Please use these instructions to install the eksctl tool.

First Create the sample specification for the cluster using a configuration file.

Then, using the following command can create an EKS cluster successfully.

Note: When create eks instance using helm it is first time adding the user permission to config maps. for that follow these steps then it will display the cluster details in console.

Install Helm and Grafana Stack

Let's see why we need helm to install grafana stack in Kubernetes. The main Advantage is helm gives the template-based configurations to install and manage complex Kubernetes applications.

First needs to install helm onto your local machine. After that add Prometheus repository to the helm.

Then Install the Prometheus Stack in K8 Cluster.

It will successfully create the deployment.

Inside the kube-prometheus-stack, Prometheus server, alert manager, and grafana will be available as a bundle.

Deploy Spring Boot Application And Monitor Via Grafana

In the next part, we are going to deploy a spring boot application and monitor using the grafana dashboard.

These things needs to consider when writing the spring boot application.

1. Make sure to use the spring actuator to expose administrative endpoints for access via Prometheus.

2. Create Docker Image Repository in ECR and give the correct permissions to the AWS user.

Then we can easily deploy the Docker image to eks cluster.

And the final step is to expose the grafana dashboard to the public.

Before that, we can verify the grafana instance is up or not by using port forward.

This will helps to test the Grafana locally. These are the default credentials for the admin users.

user: admin
pass: prom-operator

Then you can view the cluster matrix via grafana.

Summarize

In this article, we have discussed how to create k8 cluster and deploy the grafana, Prometheus stack using helm and finally deploy custom created docker image. Then we have to monitor the cluster information and other custom-created matrices using the Grafana dashboard.

And the next article I am planning to deeply discuss more Kubernetes concepts until then happy coding.

If you plan to start your next mobile project or if you are a developer who plans to learn new technologies in 2022, This article is for you. Mobile Development is trending day by day and it is evolving the new technologies. As a software developer, I have familiar with most of the mobile development frameworks.

Due to the pandemic situation, I have seen so many mobile products come to the market in a quick time period. The main reason is for this Flutter and similar cross-platform frameworks.

1. Development Time

The first Reason for choosing Flutter for the next project is development time. Flutter is based on dart language and if you are familiar with java and similar programming language it is really easy to learn Flutter. In Flutter logic and UI will be written in the same code-base. unlikely in native android had to learn XML-based UI and it is really hard to familiar with new layout formats. But in a Flutter, all UI elements are available as widgets.

Due to this reason, it is really efficient and within a minimum time period can do MVP product to the market.

2. Same Code, All Platforms

At the early stage of mobile development around a few years back we had the biggest issue was managing two mobile developers for android and ios. It is really hard to manage two code-base for android and IOS because to do the change in each project takes time and it is an error-prone task.

Then few cross-platform development frameworks came but those were run the UI on a web browser. Due to this reason, we haven't discovered all the core features in cross-platform, until Flutter came in 2017. The best thing is Flutter support web application as well. I hope in the future Flutter will be suitable for any web development like react-js.

3. App Performance

The biggest issue had in the cross-platform mobile frameworks is most of them use browser-based component rendering mechanisms. It leads to problems with application native performance not being able to achieve when building enterprise applications.

Dart compiler converts the Flutter application to native code, this is the reason Flutter gives the native features. Read here for how the Flutter compiler works.

4. Rich UI features

In Native android development biggest challenge was to be familiar with XML layout to build the UI components. Flutter has matured UI library and it can be easily added to the project. The main advantage of the Flutter is It support Hot Reload the UI components.

All the UI libraries come up as a widget, due to this reason within minimal code we can include the library and test.

For example, assume needs to implement a full circle shape image. In a native way had to write so many XML files to do that. But in Flutter, just a few lines of code are enough.

Ex: Circle Image

ClipRRect(
    borderRadius: BorderRadius.circular(8.0),
    child: Image.network(
        subject['images']['large'],
        height: 150.0,
        width: 100.0,
    ),
)

These are the few sample apps UI that is written in Flutter.

5. Powerful support

Flutter during the last couple of years steadily become one of the best cross-platform frameworks for mobile development. As below graph, the popularity of the Flutter becomes high than react native in 2020.

At the initial stage of the Flutter, there were few community-driven projects and libraries available. But once Flutter become an industry-leading framework most of the developers wrote libraries and plugins for Flutter.

The Flutter platform community has also grown in the last couple of years.

Flutter now has a very grown community for the support. These are a few Flutter communities. Official Dev, Youtube

Thanks for reading this article and hope you find this helpful.

Learn More

• How To Implement a Customized Google Map with Flutter
• Authentication for Flutter with AWS Amplify
• Mobile App Development in 2022

What is Message Queue Service?

Before learning the AWS SQS we have to learn what is message queue service first. Message Queue service is “the system that pushes a message into a queue by providing an asynchronous communications protocol”. There are two parties involved in queue service. Those parties are called Sender and Receiver.

Event-Driven Architecture

Before starting, the development has to check what is event-driven architecture in microservices.

As an example assumes in e-commerce platform contains the following microservices. Checkout Service, Inventory Service, Shipping Service, Notification Service. When a customer does some product checkout needs to inform to other three microservices. Normally Checkout Service Send requests to each service.

But sending requests to each module is a very time-consuming task and it is taking more resources. In asynchronous architecture, we can use the following way to resolve the above issue.

AWS Simple queue service provides the following two type of queue creation. Standard queue and FIFO queue.

Case Study

To Explain the AWS SQS I will use this case study. Assume there is a quiz micro-service and once the user published the quiz it needs to send a notification to the user with score and message.

AWS Configurations

First Create an AWS user and give the programmatic access. Once user creation is completed needs to create an SQS instance in AWS.

Create an SQS instance and choose the type as Standard.

After the queue is created please get the queue URL in here.

Event Sending Module [Quiz Service]

First, create a spring boot project and add the following dependencies to the project.

<spring.cloud-version>Hoxton.SR8</spring.cloud-version>

Add the AWS credentials in the application.yml file.

Now all the configurations are done. The next step is to write logic to send events to the queue. For sending all the details to SQS needs to create a custom object which contains all the details.

The next step is to create a spring configuration class to create all the required beans for sending objects to the AWS Queue.

And all the beans configurations are done now we can send objects to the queue.

Now you can view the send object in the AWS SQS console. Go to the Queue -> Send and receive messages -> Poll for Messages then you can view the send messages.

Event Receiving Module [Notification Service]

In here all the AWS configurations need to be done. After that through RestController will be able to receive the Messages sent by Quiz Module.

And final we have to exclude these configurations in the spring boot project to start the module.

And that is it all the events sent by the quiz module are now received by the notification service. Hope you guys understand the concept of the queue service with AWS SQS. Please let me know if you have any clarifications.

Learn More

• My AWS Solutions Architect Professional Exam Experience
• Using AWS SQS With Spring Boot
• Managing Database Connections with Amazon RDS Proxy

This is the continuation of the tech series for micro-service monitoring. Last article we have discussed how to integrate prometheus with grafana. In this thread we are going to discuss the how to integrate the loki with grafana.

What is Loki ?

Grafana Loki is logging aggregation system which allows high available and multi tenancy.

In micro-service paradigm to read the logs from each micro-service is really hard when we do one by one. To identify one issue have to tail logs in multiple modules. But what loki does is support the log aggregation in single dashboard and will allow to query the results form dashboard.

In here Promtail push the logs to loki and it can be view in the grafana dashboard.

Configurations

First in this setup have to setup promtail configurations.

Here We have scrape configs for docker logs scrapping. To Enable the docker logs to promtail needs to install docker plugin for that.

docker plugin install grafana/loki-docker-driver:latest --alias loki --grant-all-permissions

After install the plugin , can verify this way. And needs to restart the docker demon.

Next step is to add loki configs. Normally we don’t have any additional configs needs other than default configs.

Now all the module specific configurations added. Now needs to run the loki,promtail, grafana and other microservices ad docker compose file.

Verify Setup

Open the loki & check the setup.

http://localhost:3100/ready

Testing

Now login to grafana dashboard and add loki as data source.

And final step is query the logs from microservices.

when you go to explore tab you can filter the logs based on containers.

Note: If container search option not showing please follow this configuration guide and restart the docker demon again.

I hope now you familiar with setup loki with grafana to aggregate docker container logs. Put your comments and feedback’s bellow here.

Thanks

Monitoring Spring Boot Application using Prometheus and Grafana

When Dealing with multiple micro-services it is always better to monitor the systems using a monitoring tool. Here I am going to explain how we can monitor spring boot applications using Prometheus and Grafana.

What is Prometheus?

Prometheus is an open-source monitoring system that helps to periodically monitor the JVM Based systems.

What is Grafana?

Grafana is a tool that can inject various data sources and display them in a comprehensive graphical experience. It supports various data sources like ELK, Prometheus, Graphite. And It also supports sending alerts base on different conditions.

First Create the Spring microservice and add enable the actuator endpoints for the module.

In Spring web flux have to explicitly enable actuator endpoint. To do that have to add the following configuration application.yml

After that, once the spring boot application started it will show the exposed Prometheus endpoint.

As the Next step create a docker image from the spring boot microservice.

The next step is to start Prometheus API Server. To-Do that needs to create a separate config for the Prometheus server. create a file called “prometheus.yml‘’.

The next step is to start to spring boot Microservice, Prometheus and grafana instances. for that here using the docker-compose to start all the modules.

Once all the modules are started can verify the instance is available in Prometheus dashboard.

url : http://localhost:9090/graph

search by “process_cpu_usage”

After all, module startup go to grafana dashboard and setup data source.

add the correct Prometheus URL in config.

verify the Prometheus setup.

The final step is to create a dashboard panel and view the analytics.

Conclusion

To view the JVM statistics in grafana needs to first enable the actuator and enable the Prometheus endpoint for the Prometheus server. The next step is to set up Prometheus and open Prometheus as the data source in grafana.

I really hope you will understand the concepts of setup monitor tools integration in JVM-related frameworks.

Learn More

• Using AWS SQS With Spring Boot
• Getting Started with SpringBoot and MongoDB

Spring cloud Discovery Server with web flux

As we lest in our last article we are continue the micro-services case study. In this thread we are discussing about the service discovery in micro services.

Why Need Service Discovery

First why we need service discovery? In the real world when we dealing with communicate with micro services needs to check whether service is up and ruining ? If the service is not reachable we can communicate to other instance.

In above example first instance of service B will be not available to access. So when request originated from service A It will be failed to connect to service B if it access the first instance. So there came up design pattern to keeps the registry of instances in separate server. So that one will give the instance details when connecting to service B.

Here when start the Service B instance It will be register in Service Registry. Then there are no hard coded instance details in Service A. It will helps to dynamically connects to the Service B. Assume if the one of the Service B instance got failed, So service registry prevent to connect with that one with Service A.

Spring Boot With Netflix Eureka

Lets implement the discovery pattern using netflix eureka library.

First Our web bff module act as discovery server. These are the main configs changes needs to add to pom.xml & Annotations.

Web Bff Module

Dependencies

Config Changes

Shop Service Module

Here This module needs to register as eureka client modules. So They will automatically register with the eureka server.

Here we have to set Application Name & Instance ID for the micro service.

And add following annotation for the spring boot application.

Those registered micro-services will be display in discovery server admin portal.

Load Balancing with Webclient

Here is the tricky part. Most of the times we are using RestTemplate to connect micro-services. But In this scenario we have to use WebClient.

Make sure to add spring-cloud-loadbalancer to the Project.

And We can’t use @LoadBalanced Annotation as we used in RestTemplate.In Order to use Load Balancing behavior in WebClient needs to use ReactorLoadBalancerExchangeFilterFunction class as filter config in WebClient.

This will demonstrate how to use spring webflux with Spring Cloud Discovery Service.

Here you can access the code base.

Pet-Web-Bff

Pet-Shop-Service