Introducing Distributed Application Runtime (Dapr): Simplifying Microservices Applications Development Through Proven and Reusable Patterns and Practi (Paperback)

Chapter 1: Introduction to Microservices (15 pages)

This chapter introduces the idea behind the Microservices architecture. It sets the stage for the benefits and the challenges when designing, developing and deploying such distributed applications. A variety of technologies and concepts are needed in order to accomplish the goals set by such a solution. This chapter highlights some of the most important technological pieces for cross-service communication, container management and orchestration.

1) What is Microservices architecture

2) What are the benefits

3) What are the challenges

4) Technological choice for Microservices

Chapter 2: Introduction to Dapr (8 pages)

While microservices brings a lot of benefits, it still carries a lot of challenges for everyone involved. You need to know so many things! Dapr addresses some of those challenges for enterprise developers by providing building blocks that are comprised of components. Building blocks are the de-facto API of Dapr. Components are the moving parts inside those building blocks. Dapr is language and platform agnostic by design but does that mean that it has to be difficult to utilize it from our language of choice or framework? You can always use the RESTful endpoints of Dapr but to make it feel more natural it has SDKs for a number of languages and integration with various development frameworks.

1) Goals of Dapr

2) How it works

3) Building blocks and components

4) The concept of a Dapr application

5) Dapr SDKs ? crafted and gRPC proto generated

Chapter 3: Getting up to speed with Kubernetes (10 pages)

Since Kubernetes is one of the natively supported hosting modes of Dapr, it is a good idea to cover the basics of Kubernetes.

1) Overview of Kubernetes concepts

2) Understanding Kubernetes objects

3) Deploying an application to Azure Kubernetes Service

Chapter 4: Getting started with Dapr (10 pages)

Let’s get started by installing Dapr and exploring its CLI. Dapr supports two hosting modes ? it can run in self-hosted mode as a process or inside a Kubernetes cluster. 

1) Installing Dapr

2) Exploring Dapr CLI

3) Self-hosted mode

4) Kubernetes mode

Part II: Building blocks overview

Chapter 5: Service invocation (8 pages)

A microservices application consists of a set of smaller services that must work as a whole. In order to do so, they should have a way to communicate with each other. In this chapter, we will go through the service invocation building block and see how it helps us to connect our microservices. It acts as a reverse-proxy between the caller and the callee services and provides some additional concepts like service discovery, resiliency and protocol mappings out of the box.

1) Overview of the service invocation building block

2) Cross-protocol invocation (gRPC & HTTP)

Chapter 6: State management (10 pages)

When it comes to persisting the state of your services you will most likely identify and use a suitable SDK that helps you talk to the state service of choice. However, when you use Dapr state management comes out of the box along with a functionality to manage the concurrency and consistency of the state store. Choosing between Redis or Cosmos DB is a matter of changing a configuration file, as opposed to changing your whole application code!

1) Overview of the state management building block

2) Supported state stores and their differences

3) Querying and controlling state store behaviors

Chapter 7: Publish and subscribe (10 pages)

Chapter 5: Service invocation describes how to communicate directly between microservices. However, in this chapter we will go through the Publish-subscribe building block which lets you achieve decoupling in the communication between your microservices. Apart from calling the Pub Sub API endpoints, you also have to choose the message bus which will serve as a messaging medium.

1) Overview of Publish and subscribe building block

2) CloudEvents for service-to-service communication

3) Supported message buses and their differences

4) Dynamic subscription (Note: This feature is currently in development, so the whole building block could change)

Chapter 8: Resource bindings for input and output (13 pages)

Microservices applications often depend on some external services. For example, you want to monitor a blob storage account and when a new blob is created your application should do some analysis on the uploaded blob and then send the result over email. But in order to implement that case you will need some additional services that come with their specific libraries e.g. Azure Event Grid for receiving the newly created blobs and SendGrid for sending emails. A lot of boilerplate code has to be implemented just for having a way to talk to those two external systems.

Dapr takes a different approach and translates the communication with a diverse array of systems and services into a simple configuration of the binding component in YAML.

1) Overview of the bindings building block

2) Supported bindings

Chapter 9: The Actor pattern (20 pages)

The Actor pattern treats actors as the lowest level of a concurrent computational unit. The self-contained unit of code called actor receives messages, processes them one at a time, sends one or more messages to other actors or creates new actors. This pattern is pretty popular when it comes to building games or IoT solutions. Dapr includes in its runtime an implementation of the Virtual Actors pattern which was initially made famous by Project Orleans and Service Fabric Reliable Actors. 

1) Overview of the Virtual Actor pattern

2) When to use Actors

3) How Actors work in Dapr

4) Exploring the .NET SDK for Actors

Chapter 10: Secrets (7 pages)

1) Overview of the secrets building block

2) Supported secret stores

Chapter 11: Observability: Metrics, Logs, Distributed Tracing (10 pages)

Observability is a term from control theory. Observability means you can answer questions about what's happening on the inside of a system by observing the outside of the system, without having to ship new code to answer new questions. This chapter will describe what can be monitored in Dapr and how to leverage services like Azure Monitor and Application Insights for storing, analyzing and visualizing our observability data.

1) Overview of Dapr observability

2) Monitor metrics and logs using Azure Monitor

3) Setting up Application Insights for distributed tracing

Part III: Using Dapr

Chapter 12: Plugging middleware (12 pages)

Dapr allows custom middleware to be plugged into the request processing pipeline. Middleware can perform additional actions on a request, such as authentication, encryption and message transformation before the request is routed to the user code, or before the request is returned to the client. 

1) Overview of middleware support in Dapr

2) Using the OAuth2 middleware

3) Using the rate limit middleware

4) Implementing a custom middleware

Chapter 13: Using Dapr in ASP.NET Core (10 pages)

Dapr provides support for ASP.NET Core. In this chapter, we are going to see how to register your application to work with Dapr and how to utilize the different attributes along with the DaprClient class that come out of the box from the Dapr .NET SDK.

1) Integrating Dapr into an ASP.NET Core application

2) Using the state building block in ASP.NET Core controllers

3) Using the DaprClient to interact with Dapr endpoints

Chapter 14: Using Dapr as a Workflow Execution Engine (10 pages)

Quite often, certain applications are implemented with the sole purpose of scheduling, automating, and orchestrating business processes. This is often called a business workflow. Workflows also frequently integrate with other apps, data, systems, and services across organizations. Since Logic Apps engine has been decoupled into a set of reusable libraries, it’s easy to combine Dapr capabilities with Logic Apps to support the execution of workflows across hosting platforms. 

1) Overview of Logic Apps support in Dapr

2) Designing a Logic Apps workflow using Visual Studio Code

3) Invoking a Logic Apps workflow

Chapter 15: Using Dapr with Azure Functions (10 pages)

Note: This is not available yet as a functionality in Dapr but it’s coming.

Chapter 16: Configuring development environment for Dapr (8 pages)

In this chapter, we will see how to make our Visual Studio Code more efficient when we develop Dapr applications.

1) Developing inside a Container from VS Code.

2) Using the Dapr VS Code extension for development and debugging

Radoslav Gatev (지은이)    정보 더보기

분야의 베스트셀러 >