万本电子书0元读

万本电子书0元读

顶部广告

Building Microservices with .NET Core 2.0 - Second Edition电子书

售       价:¥

15人正在读 | 0人评论 9.8

作       者:Gaurav Aroraa

出  版  社:Packt Publishing

出版时间:2017-12-22

字       数:36.0万

所属分类: 进口书 > 外文原版书 > 电脑/网络

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
Architect your .NET applications by breaking them into really small pieces - microservices -using this practical, example-based guide. About This Book ? Start your microservices journey and get a broader perspective on microservices development using C# 7.0 with .NET Core 2.0 ? Build, deploy, and test microservices using ASP.Net Core, ASP.NET Core API, and Microsoft Azure Cloud ? Get the basics of reactive microservices Who This Book Is For This book is for .NET Core developers who want to learn and understand the microservices architecture and implement it in their .NET Core applications. It’s ideal for developers who are completely new to microservices or just have a theoretical understanding of this architectural approach and want to gain a practical perspective in order to better manage application complexities. What You Will Learn ? Get acquainted with Microsoft Azure Service Fabric ? Compare microservices with monolithic applications and SOA ? Learn Docker and Azure API management ? Define a service interface and implement APIs using ASP.NET Core 2.0 ? Integrate services using a synchronous approach via RESTful APIs with ASP.NET Core 2.0 ? Implement microservices security using Azure Active Directory, OpenID Connect, and OAuth 2.0 ? Understand the operation and scaling of microservices in .NET Core 2.0 ? Understand the key features of reactive microservices and implement them using reactive extensions In Detail The microservices architectural style promotes the development of complex applications as a suite of small services based on business capabilities. This book will help you identify the appropriate service boundaries within your business. We'll start by looking at what microservices are and their main characteristics. Moving forward, you will be introduced to real-life application scenarios; after assessing the current issues, we will begin the journey of transforming this application by splitting it into a suite of microservices using C# 7.0 with .NET Core 2.0. You will identify service boundaries, split the application into multiple microservices, and define service contracts. You will find out how to configure, deploy, and monitor microservices, and configure scaling to allow the application to quickly adapt to increased demand in the future. With an introduction to reactive microservices, you’ll strategically gain further value to keep your code base simple, focusing on what is more important rather than on messy asynchronous calls. Style and approach This guide serves as a stepping stone that helps .NET Core developers in their microservices architecture. This book provides just enough theory to understand the concepts and apply the examples.
目录展开

Title Page

Second Edition

Copyright

Building Microservices with .NET Core 2.0

Second Edition

Credits

Foreword

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

An Introduction to Microservices

Origin of microservices

Discussing microservices

Monolithic architecture

Service-Oriented architecture

What is a service?

Understanding the microservice architecture

Messaging in microservices

Synchronous messaging

Asynchronous messaging

Message formats

Why should we use microservices?

How does the microservice architecture work?

Advantages of microservices

SOA versus microservices

Prerequisites of the microservice architecture

Understanding the problems with the monolithic architectural style

Challenges in standardizing a .NET stack

Fault tolerance

Scaling

Vertical scaling or scale up

Horizontal scaling or scale out

Deployment challenges

Organizational alignment

Modularity

Big database

Prerequisites for microservices

Functional overview of the application

Solutions for current challenges

Handling deployment problems

Making much better monolithic applications

Introducing dependency injections

Database refactoring

Database sharding and partitioning

DevOps culture

Automation

Testing

Versioning

Deployment

Identifying decomposition candidates within monolithic

Important microservices advantages

Technology independence

Interdependency removal

Alignment with business goals

Cost benefits

Easy scalability

Security

Data management

Integrating monolithic

Overview of Azure Service Fabric

Summary

Implementing Microservices

Introduction

C# 7.0

Entity Framework Core

Visual Studio 2017

Microsoft SQLServer

Size of microservices

What makes a good service?

DDD and its importance for microservices

Domain model design

Importance for microservices

The concept of seam

Module interdependency

Technology

Team structure

Database

Master data

Transaction

Communication between microservices

Benefits of the API gateway for microservices

API gateway versus API management

Revisiting the Flix One case study

Prerequisites

Transitioning to our product service

Migrations

Code migration

Creating our project

Adding the model

Adding a repository

Registering the repositories

Adding a product controller

The ProductService API

Adding EF core support

EF Core DbContext

EF Core migrations

Database migration

Revisiting repositories and the controller

Introducing ViewModel

Revisiting the product controller

Adding Swagger support

Summary

Integration Techniques and Microservices

Communication between services

Styles of collaboration

Integration patterns

The API gateway

The event-driven pattern

Event sourcing

Eventual consistency

Compensating transactions

Competing consumers

Azure Service Bus

Azure queues

Implementing an Azure Service Bus queue

Prerequisites

Sending messages to the queue

Adding configuration settings

Receiving messages from the queue

Summary

Testing Microservices

How to test microservices

Handling challenges

Testing strategies (testing approach)

Testing pyramid

Types of microservice tests

Unit testing

Component (service) testing

Integration testing

Contract testing

Consumer-driven contracts

How to implement a consumer-driven test

How Pact-net-core helps us achieve our goal

Performance testing

End-to-end (UI/functional) testing

Sociable versus isolated unit tests

Stubs and mocks

Tests in action

Getting ready for the test project

Unit tests

Integration tests

Consumer-driven contract tests

Summary

Deploying Microservices

Monolithic application deployment challenges

Understanding the deployment terminology

Prerequisites for successful microservice deployments

Isolation requirements for microservice deployment

Need for a new deployment paradigm

Containers

What are containers?

Suitability of containers over virtual machines

Transformation of the operation team's mindset

Containers are new binaries

Does it work on your machine? Let's ship your machine!

Introducing Docker

Microservice deployment with Docker overview

Microservice deployment example using Docker

Setting up Docker on your machine

Prerequisites

Creating an ASP.NET Core web application

Summary

Securing Microservices

Security in monolithic applications

Security in microservices

Why won't a traditional .NET auth mechanism work?

JSON Web Tokens

What is OAuth 2.0?

What is OpenID Connect?

Azure Active Directory

Microservice Auth example with OpenID Connect, OAuth 2.0, and Azure AD

Registration of TodoListService and TodoListWebApp with Azure AD tenant

Generation of AppKey for TodoListWebApp

Configuring Visual Studio solution projects

Generate client certificates on IIS Express

Running both the applications

Azure API management as an API gateway

Rate limit and quota policy example

Container security

Other security best practices

Summary

Monitoring Microservices

Instrumentation and telemetry

Instrumentation

Telemetry

The need for monitoring

Health monitoring

Availability monitoring

Performance monitoring

Security monitoring

SLA monitoring

Auditing sensitive data and critical business transactions

End user monitoring

Troubleshooting system failures

Monitoring challenges

Scale

DevOps mindset

Data flow visualization

Testing of monitoring tools

Monitoring strategies

Application/system monitoring

Real user monitoring

Semantic monitoring and synthetic transactions

Profiling

Endpoint monitoring

Logging

Logging challenges

Logging strategies

Centralized logging

Using a correlation ID in logging

Semantic logging

Monitoring in Azure Cloud

Microsoft Azure Diagnostics

Storing diagnostic data using Azure storage

Using Azure portal

Specifying a storage account

Azure storage schema for diagnostic data

Introduction of Application Insights

Other microservice monitoring solutions

A brief overview of the ELK stack

Elasticsearch

Logstash

Kibana

Splunk

Alerting

Reporting

Summary

Scaling Microservices

Scalability overview

Scaling infrastructure

Vertical scaling (scaling up)

Horizontal scaling (scaling out)

Microservice scalability

Scale Cube model of scalability

Scaling of x axis

Scaling of z axis

Scaling of y axis

Characteristics of a scalable microservice

Scaling the infrastructure

Scaling virtual machines using scale sets

Auto Scaling

Container scaling using Docker Swarm

Scaling service design

Data persistence model design

Caching mechanism

CacheCow

Azure Redis Cache

Redundancy and fault tolerance

Circuit breakers

Closed state

Open state

Half-Open state

Service discovery

Summary

Introduction to Reactive Microservices

Understanding reactive microservices

Responsiveness

Resilience

Autonomous

Message-driven: a core of reactive microservices

Let's make code reactive

Event communication

Security

Message-level security

Scalability

Communication resilience

Managing data

The microservice ecosystem

Coding reactive microservices

Creating the project

Communication between the application and the database

Client – coding it down

Summary

Creating a Complete Microservice Solution

Architectures before microservices

The monolithic architecture

Challenges in standardizing the .NET stack

Scaling

Service-oriented architecture

Microservice-styled architecture

Messaging in microservices

Monolith transitioning

Integration techniques

Deployment

Testing microservices

Security

Monitoring

Monitoring challenges

Scale

Component lifespan

Information visualization

Monitoring strategies

Scalability

Infrastructure scaling

Service design

Reactive microservices

Greenfield application

Scoping our services

The book-listing microservice

The book-searching microservice

The shopping-cart microservice

The order microservice

User-authentication

Synchronous versus asynchronous

The book-catalog microservice

The shopping-cart microservice

The order microservice

The user-authentication microservice

Summary

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部