微服务架构：面向容器化的.NET应用

需积分: 10 22 浏览量更新于2024-07-15 收藏 11.19MB PDF 举报

“.NET Microservices: Architecture for Containerized .NET Applications” 本书主要探讨了如何使用.NET框架构建微服务架构的容器化应用，特别是在Docker容器技术的背景下。随着企业对成本效益、部署效率以及DevOps和生产运营改进的需求增加，容器化成为了软件开发的新趋势。微软通过Azure Kubernetes服务（AKS）、Azure Service Fabric等产品，以及与Docker、Mesosphere和Kubernetes等业界领先者的合作，为Windows和Linux提供了强大的容器解决方案。 Docker作为容器行业的标准，得到了Windows和Linux生态系统中关键供应商的广泛支持。本书内容已更新至ASP.NET Core 3.1版本，这是微软推荐的用于构建高性能Web应用的框架，它提供了跨平台的开发能力，并且与容器环境高度兼容。本书由微软开发者事业部、.NET和Visual Studio产品团队出版，旨在帮助开发者理解如何利用.NET框架构建和部署微服务。书中详细阐述了微服务架构的关键概念，包括服务发现、服务间通信、数据管理、持续集成和持续交付（CI/CD）流程，以及监控和日志记录等重要主题。书中涵盖了以下几个核心知识点： 1. **微服务设计原则**：介绍如何将大型单体应用分解为小型、独立的服务，每个服务都拥有自己的数据库和业务逻辑，从而提高可伸缩性和可维护性。 2. **容器化.NET应用**：讨论如何将.NET应用打包成Docker镜像，以及如何使用Docker Compose和Kubernetes进行服务编排，实现跨主机的容器部署。 3. **ASP.NET Core与微服务**：讲解如何利用ASP.NET Core构建API服务，以及它如何与微服务架构相结合，提供高效、轻量级的Web服务。 4. **服务发现与负载均衡**：深入探讨如何实现服务之间的动态发现，以及如何利用Kubernetes的服务网格实现负载均衡。 5. **持久化数据**：讨论微服务中的数据存储策略，包括如何在分布式环境中处理事务和一致性，以及使用如SQL Server和NoSQL数据库的最佳实践。 6. **监控与日志记录**：介绍如何集成Prometheus、Grafana等工具进行性能监控，以及使用ELK（Elasticsearch、Logstash、Kibana）堆栈进行日志收集和分析。 7. **安全性**：讲解如何保护微服务免受攻击，包括认证、授权、加密以及使用OAuth 2.0和OpenID Connect实现身份验证。 8. **DevOps实践**：涵盖自动化测试、持续集成（CI）和持续交付（CD），以及使用Jenkins、GitLab CI/CD等工具实现高效软件开发流程。 9. **云原生策略**：探讨如何利用Azure Kubernetes服务（AKS）和其他云服务，实现微服务在公共云中的运行和扩展。通过阅读本书，开发者能够掌握构建和管理容器化.NET微服务所需的技术和最佳实践，从而在现代云环境中构建可扩展、可靠和高效的软件系统。

4 CHAPTER 2 | Introduction to Containers and Docker

similar to instantiating a process like a service or web app. For reliability, however, when you run

multiple instances of the same image across multiple host servers, you typically want each container

(image instance) to run in a different host server or VM in different fault domains.

In short, containers offer the benefits of isolation, portability, agility, scalability, and control across the

whole application lifecycle workflow. The most important benefit is the environment’s isolation

provided between Dev and Ops.

What is Docker?

Docker is an open-source project for automating the deployment of applications as portable, self-

sufficient containers that can run on the cloud or on-premises. Docker is also a company that

promotes and evolves this technology, working in collaboration with cloud, Linux, and Windows

vendors, including Microsoft.

Figure 2-2. Docker deploys containers at all layers of the hybrid cloud.

Docker containers can run anywhere, on-premises in the customer datacenter, in an external service

provider or in the cloud, on Azure. Docker image containers can run natively on Linux and Windows.

However, Windows images can run only on Windows hosts and Linux images can run on Linux hosts

and Windows hosts (using a Hyper-V Linux VM, so far), where host means a server or a VM.

Developers can use development environments on Windows, Linux, or macOS. On the development

computer, the developer runs a Docker host where Docker images are deployed, including the app

and its dependencies. Developers who work on Linux or on macOS use a Docker host that is Linux

based, and they can create images only for Linux containers. (Developers working on macOS can edit

code or run the Docker CLI from macOS, but as of the time of this writing, containers don’t run

directly on macOS.) Developers who work on Windows can create images for either Linux or Windows

Containers.

To host containers in development environments and provide additional developer tools, Docker

ships Docker Community Edition (CE) for Windows or for macOS. These products install the necessary

VM (the Docker host) to host the containers. Docker also makes available Docker Enterprise Edition

6 CHAPTER 2 | Introduction to Containers and Docker

For VMs, there are three base layers in the host server, from the bottom-up: infrastructure, Host

Operating System and a Hypervisor and on top of all that each VM has its own OS and all necessary

libraries. For Docker, the host server only has the infrastructure and the OS and on top of that, the

container engine, that keeps container isolated but sharing the base OS services.

Because containers require far fewer resources (for example, they don’t need a full OS), they’re easy to

deploy and they start fast. This allows you to have higher density, meaning that it allows you to run

more services on the same hardware unit, thereby reducing costs.

As a side effect of running on the same kernel, you get less isolation than VMs.

The main goal of an image is that it makes the environment (dependencies) the same across different

deployments. This means that you can debug it on your machine and then deploy it to another

machine with the same environment guaranteed.

A container image is a way to package an app or service and deploy it in a reliable and reproducible

way. You could say that Docker isn’t only a technology but also a philosophy and a process.

When using Docker, you won’t hear developers say, “It works on my machine, why not in production?”

They can simply say, “It runs on Docker”, because the packaged Docker application can be executed

on any supported Docker environment, and it runs the way it was intended to on all deployment

targets (such as Dev, QA, staging, and production).

A simple analogy

Perhaps a simple analogy can help getting the grasp of the core concept of Docker.

Let’s go back in time to the 1950s for a moment. There were no word processors, and the

photocopiers were used everywhere (kind of).

Imagine you’re responsible for quickly issuing batches of letters as required, to mail them to

customers, using real paper and envelopes, to be delivered physically to each customer’s address

(there was no email back then).

At some point, you realize the letters are just a composition of a large set of paragraphs, which are

picked and arranged as needed, according to the purpose of the letter, so you devise a system to

issue letters quickly, expecting to get a hefty raise.

The system is simple:

1. You begin with a deck of transparent sheets containing one paragraph each.

2. To issue a set of letters, you pick the sheets with the paragraphs you need, then you stack and

align them so they look and read fine.

3. Finally, you place the set in the photocopier and press start to produce as many letters as

required.

So, simplifying, that’s the core idea of Docker.

In Docker, each layer is the resulting set of changes that happen to the filesystem after executing a

command, such as, installing a program.

7 CHAPTER 2 | Introduction to Containers and Docker

So, when you “look” at the filesystem after the layer has been copied, you see all the files, included the

layer when the program was installed.

You can think of an image as an auxiliary read-only hard disk ready to be installed in a “computer”

where the operating system is already installed.

Similarly, you can think of a container as the “computer” with the image hard disk installed. The

container, just like a computer, can be powered on or off.

Docker terminology

This section lists terms and definitions you should be familiar with before getting deeper into Docker.

For further definitions, see the extensive glossary provided by Docker.

Container image: A package with all the dependencies and information needed to create a container.

An image includes all the dependencies (such as frameworks) plus deployment and execution

configuration to be used by a container runtime. Usually, an image derives from multiple base images

that are layers stacked on top of each other to form the container’s filesystem. An image is immutable

once it has been created.

Dockerfile: A text file that contains instructions for how to build a Docker image. It’s like a batch

script, the first line states the base image to begin with and then follow the instructions to install

required programs, copy files and so on, until you get the working environment you need.

Build: The action of building a container image based on the information and context provided by its

Dockerfile, plus additional files in the folder where the image is built. You can build images with the

Docker docker build command.

Container: An instance of a Docker image. A container represents the execution of a single

application, process, or service. It consists of the contents of a Docker image, an execution

environment, and a standard set of instructions. When scaling a service, you create multiple instances

of a container from the same image. Or a batch job can create multiple containers from the same

image, passing different parameters to each instance.

Volumes: Offer a writable filesystem that the container can use. Since images are read-only but most

programs need to write to the filesystem, volumes add a writable layer, on top of the container image,

so the programs have access to a writable filesystem. The program doesn’t know it is accessing a

layered filesystem, it is just the filesystem as usual. Volumes live in the host system and are managed

by Docker.

Tag: A mark or label you can apply to images so that different images or versions of the same image

(depending on the version number or the target environment) can be identified.

Multi-stage Build: Is a feature, since Docker 17.05 or higher, that helps to reduce the size of the final

images. In a few sentences, with multi-stage build you can use, for example, a large base image,

containing the SDK, for compiling and publishing the application and then using the publishing folder

with a small runtime-only base image, to produce a much smaller final image

Repository (repo): A collection of related Docker images, labeled with a tag that indicates the image

version. Some repos contain multiple variants of a specific image, such as an image containing SDKs

8 CHAPTER 2 | Introduction to Containers and Docker

(heavier), an image containing only runtimes (lighter), etc. Those variants can be marked with tags. A

single repo can contain platform variants, such as a Linux image and a Windows image.

Registry: A service that provides access to repositories. The default registry for most public images is

Docker Hub (owned by Docker as an organization). A registry usually contains repositories from

multiple teams. Companies often have private registries to store and manage images they’ve created.

Azure Container Registry is another example.

Multi-arch image: For multi-architecture, it’s a feature that simplifies the selection of the appropriate

image, according to the platform where Docker is running. For example, when a Dockerfile requests a

base image FROM mcr.microsoft.com/dotnet/core/sdk:3.1 from the registry, it actually gets 3.1-

sdk-nanoserver-1909, 3.1-sdk-nanoserver-1809 or 3.1-sdk-buster-slim, depending on the

operating system and version where Docker is running.

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 Kubernetes, Azure Service Fabric, Docker Swarm and

Mesosphere DC/OS.

剩余349页未读，继续阅读

卓清风

粉丝: 0
资源: 1

微服务架构：面向容器化的.NET应用

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

NET-Microservices-Architecture-for-Containerized-NET-Applications

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

.NET微服务：Docker容器化的应用架构指南

.net Core微服务开发官方源码。

NET微服务架构：Docker容器化应用中文指南

IncompatibleClassChangeError(解决方案).md

中国智慧工地行业市场研究（2023）Word(63页).docx

java大题啊实打实的

asdjhfjsnlkdmv

最新资源