What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

AI Assistant (beta) to help accelerate your learning

Practical Microservices with Dapr and .NET

Chapter 1: Introducing Dapr

This chapter will introduce you to the Distributed Application Runtime (Dapr) project to teach you the core concepts of its architecture and prepare you to develop with Dapr.

Dapr accelerates the development of new cloud-native applications and simplifies the adoption of a microservice architecture.

In this chapter, we are going to cover the following main topics:

An overview of Dapr
The architecture of Dapr
Setting up Dapr
Building our first Dapr sample

At this stage, learning these topics is important with regard to obtaining a solid foundation on Dapr internals and understanding its approach to microservice architectures. These basic concepts will guide our learning throughout the rest of this book.

Our first steps into the project will start with exploring Dapr and understanding how it works.

An overview of Dapr

Dapr is an event-driven, portable runtime created by Microsoft with an open source approach and, at the time of writing this book, is still in active development.

Being event-driven, which is emphasized in the definition of Dapr, plays an important role in microservices as an application can be designed to efficiently react to events from external systems or other parts of the solution, and to produce events as well, in order to inform other services of new facts or to continue processing elsewhere or at a later stage.

Dapr is portable, as it can run locally on your development machine in self-hosted mode; it can also be deployed to the edge, or it can run on Kubernetes.

The following diagram shows the many building blocks of a Dapr architecture:

Figure 1.1 – Dapr architecture

Portability does also extend beyond the hosting environment—while Dapr is an initiative that was started by Microsoft, it can also run on Kubernetes on-premises or in the cloud, with Microsoft Azure, Amazon Web Services (AWS), Google Cloud Platform (GCP), or any other cloud vendor.

Dapr has been built on the experience gained by Microsoft in developing hyperscale cloud-native applications. It has been inspired by the design of Orleans and Service Fabric, which in turn enables many Microsoft Azure cloud services to operate resiliently and at a large scale.

Dapr offers developers an approach to design the tools to build and the runtime to operate applications, based on a microservice architecture style.

Microservices offer a vast array of benefits balanced by increased complexities in team and product management, usually with a significant burden on the developer and the team in order to get started.

What if you could leverage a runtime such as Dapr to help you get through the common patterns you will likely need to adopt, and thus ease your operations?

This diagram shows the two Dapr hosting modes:

Figure 1.2 – Dapr sidecar

As depicted in Figure 1.2, the Dapr runtime operates in sidecar processes, lifting most of the complexity from the application to a separate environment, greatly simplifying development and operations as well. These sidecar processes are run locally in your development environment or as containers in a Pod on Kubernetes.

From an application perspective, Dapr is an application programming interface (API) that can be directly reached via HyperText Transfer Protocol (HTTP) or gRPC Remote Procedure Call (gRPC) calls or, even more simply, via any of the software development kits (SDKs) available. At the time of writing this book, these SDKs are .NET, Java, Go, Python, C++, JavaScript, and Rust.

As we will experience later, it is not necessary to adopt the Dapr SDK in your application: a call to a Dapr service can be as simple as an HTTP call to an endpoint such as http://localhost:3500/v1.0/invoke/<app-id>/method/<method name>. Nevertheless, using the SDK does provide many benefits if you are writing a Dapr service or leveraging the Dapr actor model.

What Dapr is not

While I hope the overview of Dapr has informed and intrigued you enough to spend time on this book, when I have the chance to talk about Dapr, I often find myself in need of clarifying what Dapr is not. This makes it easier to eliminate any misconceptions we may have about what Dapr does, as follows:

Dapr's goal is not to force the developer to embrace a programming model with strict rules and constraints. On the contrary—while the application developer is freed by Dapr of the many complexities of a microservice architecture, the developer is not mandated on how to write the application. As an example, the management of the connection pooling to the database where the state is stored is a responsibility of Dapr and, as we will see in the following chapters, it is transparent to the microservice application code.
Dapr is not a service mesh. While many similarities can be found in the general objectives of Dapr and service meshes, Dapr does provide these benefits at the application level while a service mesh operates on the infrastructure. For instance, Dapr applies retry logic in its interaction with state stores and services, but it is the developer's responsibility to decide how to handle errors Dapr might return if there is a conflict or an intermittent issue: whether raising an error back to the client, compensating an operation, or adopting a retry policy (maybe leveraging Polly in .NET), these are explicit choices only the developer can make.
Dapr is meant to be integrated with service meshes such as Istio, which is out of the scope of this book.
Dapr is not a Microsoft cloud service: it does help the developer build microservice applications in the cloud, and it surely provides many integrations with Azure cloud services, but it also has as many components for AWS, GCP, and other services.
It is also true that Dapr does not run better on Azure than on any other Kubernetes environment in the cloud. I would hope to convince you that Azure Kubernetes Service (AKS) is the best-managed Kubernetes offering in the cloud space, but this is a different conversation for another time.
Important note
While this book is heavily skewed toward .NET, Dapr does provide the same benefits to Python developers (just as an example) as it provides SDKs for Dapr and Dapr Actor, working on macOS, and with Kubernetes as the deployment target—Dapr welcomes all developers in a vendor-neutral and open approach.

The next section will be dedicated to understanding the architectures that Dapr can enable.

The architecture of Dapr

Dapr has been designed from the ground up as a set of pluggable building blocks: developers can create an application counting on the support of many facilities, while operators can adapt applications to the hosting environment by simply intervening in the configuration.

Here is a complete list of the tools and components of Dapr:

The Dapr command-line interface (CLI): A cross-platform command-line tool to configure, manage, and monitor the Dapr environment. It is also the tool used to locally debug Dapr applications.
The Dapr API: The API that defines how an application can interact with the Dapr runtime in order to leverage its building blocks.
The Dapr runtime: This is the core of Dapr that implements the API. If you are curious, you can take a look at how it is developed in Go at Dapr's repository: https://github.com/dapr/dapr.
The Dapr host: On your development machine, the host runs as a standalone process; in Kubernetes, it is a sidecar container in your application's pod.
The Dapr operator: Specific to Kubernetes mode, the operator manages bindings and configurations.
The Dapr sidecar injector: Once instructed via configuration in Kubernetes mode, this takes care of injecting the Dapr sidecar into your application pod.
The Dapr placement service: This service has the objective of distributing (or placing) Actor instances across the Dapr pods.
Dapr Sentry: A built-in certificate authority (CA) to issue and manage certificates used by Dapr to provide transparent mutual Transport Layer Security (mTLS).

Dapr provides several building blocks that microservice application developers can adopt selectively, based on their needs. These are outlined here:

Service invocation: Service-to-service invocation enables your code to call other services located in the same hosting environment while taking care of the retry policy.
This building block is presented in more detail in Chapter 3, Service-to-Service Invocation.
State management: This is to efficiently manage the application state as a simple key-value pair (KVP), relieving your stateful or stateless services of the need to support different backends. Dapr provides many state stores, which include Redis, Azure Cosmos DB, Azure SQL Server, and PostgreSQL, which can be plugged in via configuration.
You can learn about this building block in Chapter 4, Introducing State Management.
Publish and subscribe (pub/sub) messaging: The pub/sub pattern enables decoupled communication between microservices by exchanging messages, counting on the presence of a service bus, which can route messages between producers and consumers.
A discussion of this building block is presented in Chapter 5, Publish and Subscribe.
Resource bindings: This is where the event-driven nature of Dapr shines: with bindings, your application can be triggered by a Short Message Service (SMS) message sent via Twilio (just one of the popular services in this area).
This building block is presented in more detail in Chapter 6, Resource Bindings.
Actors: The actor pattern aims to simplify highly concurrent scenarios by splitting the overall request load between a large number of computation units (the actors), which take care of the job in their smaller, but independent, scope by processing requests to a single actor one at a time. Dapr provides great benefits in this space.
You can learn about this building block in Chapter 7, Using Actors.
Observability: Dapr enables the developer and operator to observe the behavior of the system services and applications without having to instrument them.
This building block is presented in more detail in Chapter 9, Tracing Dapr Applications.
Secrets: It is a common requirement and a healthy practice to keep secrets at a safe distance from the code, even if only to prevent unintended access in a development environment to the connection string intended for the production environment. Dapr enables you to store secrets and to reference these from other Dapr components, in Kubernetes or Azure Key Vault, among many options.

After learning about Dapr architecture and components, before we can start using them, we need to set up Dapr in our development environment, which will be the topic of the next section.

Building our first Dapr sample

It is time to see Dapr in action: we are going to build a web API that returns a hello world message. I chose to base all my samples in the C:\Repos\dapr-samples\ folder, and I created a C:\Repos\dapr-samples\chapter01 folder for this first sample. We'll take the following steps:

Let's start by creating a Web API .NET project, as follows:

PS C:\Repos\dapr-samples\chapter01> dotnet new webapi -o dapr.microservice.webapi

Then, we add the reference to the Dapr SDK for ASP.NET. The current version is 1.1.0. You can look for the package versions on NuGet at https://www.nuget.org/packages/Dapr.Actors.AspNetCore with the dotnet add package command, as illustrated in the following code snippet:
```
PS C:\Repos\dapr-samples\chapter01> dotnet add package Dapr.AspNetCore --version 1.1.0
```
We need to apply some changes to the template we used to create the project. These are going to be much easier to do via VS Code—with the <directory>\code . command, we open it in the scope of the project folder.

To support Dapr in ASP.NET, I made a few changes to the code. In Startup.cs, I changed the ConfigureServices method to services.AddControllers().AddDapr();.

In Configure, I also added endpoints.MapSubscribeHandler();. This is not necessary for our sample, as we will not use the pub/sub features of Dapr. Nevertheless, it is better to have it in mind as the base set of changes you need to apply to a default ASP.NET project.

Finally, in order to simplify the code, I removed app.UseHttpsRedirection();.

Here is the modified code of the Startup.cs class:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace dapr.microservice.webapi
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        public IConfiguration Configuration { get; }
        // This method gets called by the runtime. Use //this method to add services to the container.
        public void ConfigureServices
         (IServiceCollection services)
        {
            services.AddControllers().AddDapr();
        }
        // This method gets called by the runtime. Use //this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app,
          IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.UseRouting();
            app.UseAuthorization();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapSubscribeHandler();
                endpoints.MapControllers();
            });
        }
    }
}

In the preceding code block, I instructed Dapr to leverage the model-view-controller (MVC) pattern in ASP.NET. Keep in mind there is an alternate approach for Dapr in ASP.NET, which does rely on routing with MapGet(...) and MapPost(...). You can see an example at https://github.com/dapr/dotnet-sdk/tree/master/examples/AspNetCore/RoutingSample.

Finally, I added a controller named HelloWorldController, as illustrated in the following code snippet:

using Dapr;
using Microsoft.AspNetCore.Mvc;
using System;
namespace dapr.microservice.webapi.Controllers
{
    [ApiController]
    public class HelloWorldController : ControllerBase
    {
        [HttpGet("hello")]
        public ActionResult<string> Get()
        {
            Console.WriteLine("Hello, World.");
            return "Hello, World";
        }
    }
}

In the preceding code snippet, you can see [HttpGet("hello")]: this ASP.NET attribute is evaluated by Dapr to identify the method name.

In order to run a Dapr application, you use the following format:
```
dapr run --app-id <your app id> --app-port <port of the application> --dapr-http-port <port in Dapr> dotnet run
```
I left the ASP.NET default port as 5000 but I changed the Dapr HTTP port to 5010. The following command line launches the Dapr application:
```
PS C:\Repos\dapr-samples\chapter01\dapr.microservice.webapi> dapr run --app-id hello-world --app-port 5000 --dapr-http-port 5010 dotnet run
Starting Dapr with id hello-world. HTTP Port: 5010. gRPC Port: 52443
```
The initial message informs you that Dapr is going to use port 5010 for HTTP as specified, while for gRPC it is going to auto-select an available port.
The log from Dapr is full of information. To confirm your application is running correctly in the context of the Dapr runtime, you can look for this part:
```
Updating metadata for app command: dotnet run
You're up and running! Both Dapr and your app logs will appear here.
```
At this stage, ASP.NET is responding locally on port 5000 and Dapr is responding on port 5010. In order to test Dapr, let's invoke a curl command, as follows. Using the browser is equally fine:
```
PS C:\Repos\dapr-samples\chapter01> curl http://localhost:5010/v1.0/invoke/hello-world/method/hello
Hello, World
```
This exciting response has been returned by Dapr, which passed our (the client's) initial request to the ASP.NET Web API framework. You should also see it logged as Console.WriteLine sends its output to the Dapr window, as follows:
```
== APP == Hello, World.
```
From another window, let's verify our Dapr service details: instead of using the dapr list command, let's open the Dapr dashboard, like this:
```
PS C:\Windows\System32> dapr dashboard
Dapr Dashboard running on http://localhost:8080
```

We can open the dashboard by navigating to http://localhost:8080, to reveal the following screen:

Figure 1.3 – Dapr dashboard application

The Dapr dashboard shown in Figure 1.3 illustrates the details of our hello-world application.

In this case, the Dapr dashboard shows only this sample application we are running on the development machine. In a Kubernetes environment, it would show all the microservices running, along with the other components.

The Dapr dashboard also displays the configured components in the hosting environment, as we can see here:

Figure 1.4 – Dapr dashboard components

In Figure 1.4, the Dapr dashboard shows us that the local installation of Redis is configured as state store and pub/sub components, in addition to the deployment of Zipkin.

This ends our introductory section, where we were able to build our first Dapr sample.

Key benefits

Build resilient, stateless, and stateful microservice applications that run on the cloud and edge

Solve common distributed systems such as low latency and scaling using any language and framework

Use real-time and proactive monitoring tools to support a reliable and highly available system

Description

Over the last decade, there has been a huge shift from heavily coded monolithic applications to finer, self-contained microservices. Dapr is a new, open source project by Microsoft that provides proven techniques and best practices for developing modern applications. It offers platform-agnostic features for running your applications on public cloud, on-premises, and even on edge devices. This book will help you get to grips with microservice architectures and how to manage application complexities with Dapr in no time. You'll understand how Dapr offers ease of implementation while allowing you to work with multiple languages and platforms. You'll also understand how Dapr's runtime, services, building blocks, and software development kits (SDKs) help you to simplify the creation of resilient and portable microservices. Dapr provides an event-driven runtime that supports the essential features you need to build microservices, including service invocation, state management, and publish/subscribe messaging. You'll explore all of those in addition to various other advanced features with this practical guide to learning Dapr. By the end of this book, you'll be able to write microservices easily using your choice of language or framework by implementing industry best practices to solve problems related to distributed systems.

Who is this book for?

This book is for developers looking to explore microservices architectures and implement them in Dapr applications using examples on Microsoft .NET Core. Whether you are new to microservices or have knowledge of this architectural approach and want to get hands-on experience in using Dapr, you’ll find this book useful. Familiarity with .NET Core will help you to understand the C# samples and code snippets used in the book.

What you will learn

Use Dapr to create services, invoking them directly and via pub/sub

Discover best practices for working with microservice architectures

Leverage the actor model to orchestrate data and behavior

Use Azure Kubernetes Service to deploy a sample application

Monitor Dapr applications using Zipkin, Prometheus, and Grafana

Scale and load test Dapr applications on Kubernetes

What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

AI Assistant (beta) to help accelerate your learning

Frequently bought together

Practical Microservices with Dapr and .NET

Mex$1004.99

C# 9 and .NET 5 – Modern Cross-Platform Development

Mex$1702.99

Mex$1066.99

Total Mex$ 3,774.97 Stars icon

Filter reviews by

All

Amazon verified reviews

Amos Long Oct 19, 2021

I picked up this book because I wanted to understand more about Dapr and see how it could be used in moderately complicated, business scenarios. I really liked that the book used the same Order Service example throughout, and offered a code repository so you didn't have to type all the code yourself. My plan was to read each chapter, then get the code up and running, then tinker around with it to get a better idea of how it works. Sounds easy enough, right?Unfortunately, when I picked this book up in July and August of 2021, I found large portions of the code outdated/incorrect. This was really disappointing because almost half of the book is sample code, but the code in the book is incomplete. I suspect the files in the repo have changed since the book was first published. By chapter 3, I came across scenarios that were in the book, but not in the repo. By chapter 5, getting the code to run required doing a bit of research on your own to fill in the steps left out by the book.I ran into an assortment of errors, such as:- Some code comments are wrong- Couldn't get program working (Chapter 6)- PowerShell script has errors (Chapter 6's launch.shipping.ps1)- Supplied POST messages cause errors (Chapter 7's order.test.http)- Names of scripts in the book are not in repoBut most importantly, chapter 8 is where everything comes together with a Kubernetes deployment. I went through that chapter three times, and I could never get the program to work as described. That was really disappointing. There's a chance that most of these could be my fault, but I'd guess otherwise. In my 20-year software development career, I've never had so much trouble with a book. I plan to avoid Packt books in the future.On the plus side, the book's appendix includes several short essays worth reading. I especially appreciated the overview of Microservice architectural principles.If the publisher and author care to hear it, here's my advice: Update the book to match the latest repo. Give step-by-step instructions for how to run the programs for each chapter.

Amazon Verified review

S. Buchanan Oct 10, 2021

I thought the code samples provided were quite good. However, I found the description of the overall concepts in each chapter could use much more explanation. When should each of the tools be used? When should they not? The chapter on actors in particular could have used a more thorough explanation. The chapters had many instructions to set up the code. I felt like steps were left out or not explained well. I found myself skipping most of the instructions and just trying to figure things out on my own from the sample code.

Sarita Nag Jul 28, 2021

Enjoy reading this book

Nee Apr 06, 2021

Excellent book for learning dapr for adapting microservices , 10 chapters are nicely elaborated in easy to understand SOA sections with k8s , pub sub, actors , also including scaling , load testing and tracing

Binit Datta Mar 18, 2021

The Microservices domain benefitted massively from Spring Framework, Spring Boot, and Netflix OSS early on. The Java ecosystem made rich contributions to Microservices. However, Polyglot remains a critical goal of the Microservice movement, and each team should be able to choose their languages and frameworks as long as they talk HTTP/REST. From that standpoint, the Distributed Application Runtime (Dapr) emergence from Microsoft plus its open-source nature is a very welcome change. The .NET Core stack maturity, regular release of versions like 5, and 6 and the emergence of framework support enriches the stack for Microservices development.The author has done an excellent job introducing the Distributed Application Runtime (Dapr) in this book and done so within 275 pages! While it has covered general topics such as API development, invoking APIs as a client, it is great to see an Actor framework (like Akka in the Java Ecosystem) coming up in the .NET ecosystem. While Dapr can be deployed standalone and in Kubernetes, I expect the latter to be a dominant force and chapter 8 on Kubernetes' deployment of Dapr is an asset!Overall excellent buy and can be completed in two weekends book and highly recommended. However, after completing this book, spend serious time covering solid nonfunctional requirements like security, monitoring, scalability and error handling, logging for both standalone and in Kubernetes before you consider Dapr for high traffic production applications. For other applications can use right away for having a feel.

Practical Microservices with Dapr and .NET: A developer's guide to building cloud-native applications using the Dapr event-driven runtime

What do you get with Print?

Practical Microservices with Dapr and .NET

Chapter 1: Introducing Dapr

Technical requirements

An overview of Dapr

What Dapr is not

The architecture of Dapr

Setting up Dapr

Docker

The Dapr CLI

.NET

VS Code

The Dapr extension

Windows Terminal

Installing self-hosted Dapr

Installing Dapr on Kubernetes

Updating the Dapr version

Building our first Dapr sample

Summary

Page 1 of 7

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Product Details

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs

Practical Microservices with Dapr and .NET: A developer's guide to building cloud-native applications using the Dapr event-driven runtime

What do you get with Print?

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs