First Look at Dapr for Microservices Running in Kubernetes – InApps Technology is an article under the topic Software Development Many of you are most interested in today !! Today, let’s learn First Look at Dapr for Microservices Running in Kubernetes – InApps Technology in today’s post !

Read more about First Look at Dapr for Microservices Running in Kubernetes – InApps Technology at Wikipedia

You can find content about First Look at Dapr for Microservices Running in Kubernetes – InApps Technology from the Wikipedia website

In a previous article, I introduced the architecture and building blocks of Dapr, a portable, event-driven runtime for distributed systems originally developed by Microsoft. To appreciate the platform, let’s zoom into the state management building block of Dapr. This hands-on guide will walk you through all the steps involved in dealing with state management in Dapr.


We are going to deploy two microservices written in Node.js and Python in Kubernetes. The services will use Redis as the persistence layer to store the state. Since we use Dapr, we will swap out Redis with etcd while continuing to run the microservices.

To complete this tutorial, you need a Kubernetes cluster running within Minikube or a managed service such as the Azure Kubernetes Service (AKS).

I am running Minikube on my development machine.

Installing Dapr

Download the Dapr CLI for your OS from the releases page of GitHub repository, rename and add the binary to the path.

Run the below command to install Dapr in your Kubernetes environment.

The installer deploys a few Pods in the default Namespace that are a part of Dapr control plane. Like the service mesh, Dapr has a control plane that integrates with Kubernetes and a data plane that runs as a sidecar inside each Pod.

The dapr-operator Pod watches for Pods that have the Dapr Annotations. The dapr-sidecar-injector Pod is responsible for adding the sidecar container to each Pod annotated as “ true”. Finally, the dapr-placement Pod manages the communication across all the sidecar containers injected into the Pods.

Configuring Redis as the Persistence Layer

Since we are dealing with the state store, the next step is to deploy Redis and configuring it as the default state store for the microservices.

Deploy Redis by submitting the below YAML file to Kubernetes. This results in the creation of a Pod and a ClusterIP Service.

With the Redis Pod up and running, let’s configure it as a Dapr state store. Create a YAML file with the below specification and apply it.

This creates a Rudr component for Redis. Rudr is a reference implementation of the Open Application Model (OAM) specification jointly created by Microsoft and Alibaba. For more details on OAM and Rudr, refer to this article and the tutorial.

Deploying Microservices That Use Dapr State Store

Let’s start by creating a Pod and Service spec that runs the first microservice written in Node.js. You can take a look at the code for this microservice at Dapr samples repo.

Note that the Pod has Annotations for Dapr which act as a hint to inject the sidecar container.

If you analyze the code, you realize that the microservice is not directly referring to the persistent store in the microservice. Instead, it makes a call to the REST endpoint exposed by Dapr runtime. The sidecar container is responsible for enabling this communication between the microservice and the Dapr runtime.

Let’s deploy the second microservice written in Python that continuously invokes the API exposed by the first service deployed in the previous step.

Since both the Pods are annotated for Dapr, the control plane has injected the sidecar into the Pods.

Checking the logs of the Node Pod shows that the state is being persisted.

You can also access the same from the NodePort of Minikube.

You can check the key/value pair by accessing the CLI in the Redis Pod.

Replacing Redis State Store with etcd

Dapr also supports etcd as one of the Components for the state store building block service. Let’s now replace the Redis state store with etcd
First, create a etcd cluster. You can use a Helm Chart or the below YAML spec to deploy a 3-node etcd cluster in Kubernetes.

The etcd endpoint is exposed as a ClusterIP Service.

Now, we can delete the existing state store Component and recreate it with a pointer to etcd.

The below spec creates an etcd State Store:

Delete the Node.js Pod to force Kubernetes to launch a new Pod.

Wait for the Node.js Pod to become ready before checking if everything is intact by invoking the NodePort endpoint of the first microservice.

You can also use etcdctl, the client, from one of the etcd Pods to check the key/value pair maintaining the state.

This tutorial demonstrated how to use Dapr state service with Kubernetes. In one of the future tutorials, we will explore the resource binding building block of Dapr.

Janakiram MSV’s Webinar series, “Machine Intelligence and Modern Infrastructure (MI2)” offers informative and insightful sessions covering cutting-edge technologies. Sign up for the upcoming MI2 webinar at

List of Keywords users find our article on Google:

dapr tutorial
managed redis
dapr kubernetes
redis wikipedia
redis managed service
injector python
qa labels
redis on kubernetes
kubernetes which node is my pod running on
kubernetes get pods running on node
redis ui
redis port
node.js redis
dapr oam
dapr github
dapr io
quay high key 126
hands on microservices
wikipedia redis
etcd wikipedia
ats spec
python kubernetes client
microservices hands on
coreos wiki
dapr vs kubernetes
download dapr
etcd logo
etcd wiki
redis persistence kubernetes
jupyterhub kubernetes
dapr ui
redis npm
kubernetes redis deployment
qc labels


Rate this post

Let’s create the next big thing together!

Coming together is a beginning. Keeping together is progress. Working together is success.

Let’s talk

Get a custom Proposal

Please fill in your information and your need to get a suitable solution.

    You need to enter your email to download


      Success. Downloading...