Microsoft .NET微服务架构实战：eShopOnContainers案例

需积分: 10 116 浏览量更新于2024-07-19 2 收藏 14.2MB PDF 举报

本资源是一份由微软开发者部门和.NET及Visual Studio产品团队发布的名为"容器化.NET应用的.NET微服务架构"的官方指南。版本为EDITION v2.01，可在<https://aka.ms/microservicesebook>下载。该指南着重于如何利用微软的技术栈构建和部署容器化的微服务应用程序，以提高可扩展性、灵活性和部署效率。该指南的核心内容围绕eShopOnContainers这个开源示例项目进行。eShopOnContainers是一个基于.NET的微服务架构实现，它展示了如何将传统的.NET应用程序拆分为一组独立的服务，并使用容器技术（如Docker）进行部署。通过这个实例，读者可以学习到如何设计服务之间的通信、数据共享、服务发现、安全性管理和持续集成/持续部署(CI/CD)的最佳实践。在微服务架构方面，指南涵盖了以下关键知识点： 1. **服务拆分**：理解服务拆分的原则，确保每个服务专注于单一业务逻辑，降低耦合度。 2. **微服务模式**：介绍诸如面向切面编程(AOP)、事件驱动架构和无状态服务等微服务设计模式。 3. **容器化技术**：Docker的应用，包括创建和管理容器、配置环境变量和网络设置，以及使用Docker Compose进行服务编排。 4. **服务注册与发现**：使用如Consul或Eureka这样的工具，确保服务之间的发现和连接。 5. **API Gateway**：作为服务间通信的代理，处理路由、负载均衡和安全控制。 6. **安全性**：讨论如何实现服务的身份验证、授权和加密，以保护微服务架构中的数据。 7. **CI/CD管道**：使用Azure DevOps或其他DevOps工具，确保代码质量、自动化测试和部署流程的标准化。 8. **监控与日志管理**：介绍如何收集和分析微服务的性能指标，以及使用Logstash、ELK Stack等工具进行日志管理。 9. **故障隔离和恢复**：设计容错机制，确保单个服务失败时不会影响整个系统。值得注意的是，所有内容均受到版权保护，未经许可不得复制或传播。书中提供的示例可能不反映真实业务场景，仅用于教学目的。此外，书中引用的Microsoft、Docker等商标信息也强调了各方的知识产权归属。通过阅读这份指南，开发人员能够深入理解和实践微服务架构在.NET环境中的应用，提升软件开发的现代化水平和整体项目的可维护性。

8 Introduction to Containers and Docker

Docker Hub: A public registry to upload images and work with them. Docker Hub provides Docker

image hosting, public or private registries, build triggers and web hooks, and integration with GitHub

and Bitbucket.

Azure Container Registry: A public resource for working with Docker images and its components in

Azure. This provides a registry that is close to your deployments in Azure and that gives you control

over access, making it possible to use your Azure Active Directory groups and permissions.

Docker Trusted Registry (DTR): A Docker registry service (from Docker) that can be installed on-

premises so it lives within the organization’s datacenter and network. It is convenient for private

images that should be managed within the enterprise. Docker Trusted Registry is included as part of

the Docker Datacenter product. For more information, see Docker Trusted Registry (DTR).

Docker Community Edition (CE): Development tools for Windows and macOS for building, running,

and testing containers locally. Docker CE for Windows provides development environments for both

Linux and Windows Containers. The Linux Docker host on Windows is based on a Hyper-V virtual

machine. The host for Windows Containers is directly based on Windows. Docker CE for Mac is based

on the Apple Hypervisor framework and the xhyve hypervisor, which provides a Linux Docker host

virtual machine on Mac OS X. Docker CE for Windows and for Mac replaces Docker Toolbox, which

was based on Oracle VirtualBox.

Docker Enterprise Edition (EE): An enterprise-scale version of Docker tools for Linux and Windows

development.

Compose: A command-line tool and YAML file format with metadata for defining and running multi-

container applications. You define a single application based on multiple images with one or more

.yml files that can override values depending on the environment. After you have created the

definitions, you can deploy the whole multi-container application with a single command (docker-

compose up) that creates a container per image on the Docker host.

Cluster: A collection of Docker hosts exposed as if it were a single virtual Docker host, so that the

application can scale to multiple instances of the services spread across multiple hosts within the

cluster. Docker clusters can be created with Docker Swarm, Mesosphere DC/OS, Kubernetes, and

Azure Service Fabric. (If you use Docker Swarm for managing a cluster, you typically refer to the

cluster as a swarm instead of a cluster.)

Orchestrator: A tool that simplifies management of clusters and Docker hosts. Orchestrators enable

you to manage their images, containers, and hosts through a command line interface (CLI) or a

graphical UI. You can manage container networking, configurations, load balancing, service discovery,

high availability, Docker host configuration, and more. An orchestrator is responsible for running,

distributing, scaling, and healing workloads across a collection of nodes. Typically, orchestrator

products are the same products that provide cluster infrastructure, like Mesosphere DC/OS,

Kubernetes, Docker Swarm, and Azure Service Fabric.

11 Choosing Between .NET Core and .NET Framework for Docker Containers

• You need to use third-party .NET libraries or NuGet packages that are not available for .NET

Core.

Using .NET Framework on Docker can improve your deployment experiences by minimizing

deployment issues. This “lift and shift” scenario is important for containerizing legacy applications that

were originally developed with the traditional .NET Framework, like ASP.NET WebForms, MVC web

apps or WCF (Windows Communication Foundation) services.

Additional resources

• eBook: Modernize existing .NET Framework applications with Azure and Windows Containers

https://aka.ms/liftandshiftwithcontainersebook

• Sample apps: Modernization of legacy ASP.NET web apps by using Windows Containers

https://aka.ms/eshopmodernizing

When to choose .NET Core for Docker containers

The modularity and lightweight nature of .NET Core makes it perfect for containers. When you deploy

and start a container, its image is far smaller with .NET Core than with .NET Framework. In contrast, to

use .NET Framework for a container, you must base your image on the Windows Server Core image,

which is a lot heavier than the Windows Nano Server or Linux images that you use for .NET Core.

Additionally, .NET Core is cross-platform, so you can deploy server apps with Linux or Windows

container images. However, if you are using the traditional .NET Framework, you can only deploy

images based on Windows Server Core.

The following is a more detailed explanation of why to choose .NET Core.

Developing and deploying cross platform

Clearly, if your goal is to have an application (web app or service) that can run on multiple platforms

supported by Docker (Linux and Windows), the right choice is .NET Core, because .NET Framework

only supports Windows.

.NET Core also supports macOS as a development platform. However, when you deploy containers to

a Docker host, that host must (currently) be based on Linux or Windows. For example, in a

development environment, you could use a Linux VM running on a Mac.

Visual Studio provides an integrated development environment (IDE) for Windows, and supports

Docker development.

Visual Studio for Mac is an IDE, evolution of Xamarin Studio, that runs on macOS and supports

Docker-based application development. This should be the preferred choice for developers working in

Mac machines who also want to use a powerful IDE.

You can also use Visual Studio Code (VS Code) on macOS, Linux, and Windows. VS Code fully

supports .NET Core, including IntelliSense and debugging. Because VS Code is a lightweight editor,

you can use it to develop containerized apps on the Mac in conjunction with the Docker CLI and the

.NET Core command-line interface (CLI). You can also target .NET Core with most third-party editors

12 Choosing Between .NET Core and .NET Framework for Docker Containers

like Sublime, Emacs, vi, and the open-source OmniSharp project, which also provides IntelliSense

support.

In addition to the IDEs and editors, you can use the .NET Core CLI tools for all supported platforms.

Using containers for new (“green-field”) projects

Containers are commonly used in conjunction with a microservices architecture, although they can

also be used to containerize web apps or services that follow any architectural pattern. You can use

.NET Framework on Windows Containers, but the modularity and lightweight nature of .NET Core

makes it perfect for containers and microservices architectures. When you create and deploy a

container, its image is far smaller with .NET Core than with .NET Framework.

Creating and deploying microservices on containers

You could use the traditional .NET Framework for building microservices-based applications (without

containers) by using plain processes. That way, because the .NET Framework is already installed and

shared across processes, processes are light and fast to start. However, if you are using containers, the

image for the traditional .NET Framework is also based on Windows Server Core and that makes it too

heavy for a microservices-on-containers approach.

In contrast, .NET Core is the best candidate if you are embracing a microservices-oriented system that

is based on containers, because .NET Core is lightweight. In addition, its related container images,

either the Linux image or the Windows Nano image, are lean and small making containers light and

fast to start.

A microservice is meant to be as small as possible: to be light when spinning up, to have a small

footprint, to have a small Bounded Context, to represent a small area of concerns, and to be able to

start and stop fast. For those requirements, you will want to use small and fast-to-instantiate container

images like the .NET Core container image.

A microservices architecture also allows you to mix technologies across a service boundary. This

enables a gradual migration to .NET Core for new microservices that work in conjunction with other

microservices or with services developed with Node.js, Python, Java, GoLang, or other technologies.

Deploying high density in scalable systems

When your container-based system needs the best possible density, granularity, and performance,

.NET Core and ASP.NET Core are your best options. ASP.NET Core is up to ten times faster than

ASP.NET in the traditional .NET Framework, and it leads other popular industry technologies for

microservices, such as Java servlets, Go, and Node.js.

This is especially relevant for microservices architectures, where you could have hundreds of

microservices (containers) running. With ASP.NET Core images (based on the .NET Core runtime) on

Linux or Windows Nano, you can run your system with a much lower number of servers or VMs,

ultimately saving costs in infrastructure and hosting.

剩余318页未读，继续阅读

eureka2000

粉丝: 0
资源: 7

Microsoft .NET微服务架构实战：eShopOnContainers案例

NET-Microservices-Architecture-for-Containerized-NET-Applications.pdf

surging 是一个分布式微服务框架,提供高性能RPC远程服务调用，采用Zookeeper

Manning Microservices in .Net Core with examples in Nancy

容器化.NET.NET微服务 应用架构指南.rar

.Net微服务：容器化.Net应用架构指南.pdf

NET微服务容器化.NET应用架构指南（中英）.rar

.NET 微服务：适用于容器化 .NET 应用程.pdf

微软文库：.NET 微服务：适用于容器化 .NET 应用程 序的体系结构-428

WebAdvert.WebApp:.NET Core和AWS微服务课程-客户端Web应用

【容器与微服务】5.马洪喜-传统 .net应用向微服务架构迁移的实践经验.pdf

最新资源

容器化.NET.NET微服务应用架构指南.rar

微软文库：.NET 微服务：适用于容器化 .NET 应用程序的体系结构-428