Brendan Burns的《分布式系统设计：K8s模式与部署策略》

需积分: 10 172 浏览量更新于2024-07-18 收藏 5.46MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

《设计分布式系统：可扩展、可靠的模式与实践》是一本由Brendan Burns编著的专业书籍，于2017年出版。这本书是针对软件开发人员和架构师的权威指南，特别关注在现代云计算环境，如Kubernetes（K8s）中设计分布式系统的最佳实践。Kubernetes作为容器编排平台，已经成为部署和管理微服务架构的标准工具之一。书中深入探讨了11种关键的Kubernetes部署模式，这些模式涵盖了如何构建可靠且可扩展的服务，其中涵盖了以下几个核心概念： 1. Sidecar模式：这种模式通常用于在容器中嵌入额外的独立进程，如代理、日志处理器或监控工具，以增强主服务的功能或隔离性。 2. 分片服务（Sharded Service）：通过将服务拆分为多个较小的部分，每个部分处理特定的请求范围，从而实现水平扩展和负载均衡。 3. 事件驱动的批处理处理：利用事件驱动架构，将任务分解成可批量处理的事件，确保系统响应实时变化，并且资源使用高效。 4. 高可用性和容错：书中强调了故障转移、冗余备份和数据一致性策略的重要性，以确保在分布式系统中的高可用性。 5. 微服务设计：Kubernetes支持的微服务架构，提倡服务的独立部署和轻量级通信，有助于简化复杂系统的维护和扩展。 6. 负载均衡和自动缩放：K8s的自动伸缩功能，如Horizontal Pod Autoscaler (HPA)，允许根据需求动态调整服务实例数量。 7. 容器化和Docker：作为基础技术，Docker使得服务可以在任何环境中运行，并且易于管理和部署。 8. 服务发现和注册：Kubernetes的Service和Endpoint机制，帮助服务找到其他服务，实现内部通信。 9. 命令行接口（CLI）和API：Kubernetes CLI和RESTful API提供了强大的工具，用于配置、监控和管理分布式系统。 10. 监控和日志管理：书中讨论了如何使用K8s的内置工具（如Prometheus和Grafana）以及第三方解决方案，确保系统的可观测性。 11. 安全性：涉及网络策略、认证、授权和加密，确保在分布式系统中数据的安全传输和存储。《Designing Distributed Systems》不仅提供了理论框架，还包含实战案例和实用技巧，适合那些希望深入了解分布式系统设计原则并应用到Kubernetes实践中的读者。无论你是初入此领域的开发者，还是经验丰富的架构师，这本书都能为你提供宝贵的指导和参考。

资源详情

资源推荐

one program at a time to running multiple programs on a single machine via time-

sharing operating systems, but these machines were still disjoint from each other.

Gradually, machines came to be networked together, and client-server architectures

were born so that a relatively low-powered machine on someone’s desk could be used

to harness the greater power of a mainframe in another room or building. While this

sort of client-server programming was somewhat more complicated than writing a

program for a single machine, it was still fairly straightforward to understand. The

client(s) made requests; the server(s) serviced those requests.

In the early 2000s, the rise of the internet and large-scale datacenters consisting of

thousands of relatively low-cost commodity computers networked together gave rise

to the widespread development of distributed systems. Unlike client-server architec‐

tures, distributed system applications are made up of multiple different applications

running on different machines, or many replicas running across different machines,

all communicating together to implement a system like web-search or a retail sales

platform.

Because of their distributed nature, when structured properly, distributed systems are

inherently more reliable. And when architected correctly, they can lead to much more

scalable organizational models for the teams of software engineers that built these

systems. Unfortunately, these advantages come at a cost. These distributed systems

can be significantly more complicated to design, build, and debug correctly. The engi‐

neering skills needed to build a reliable distributed system are significantly higher

than those needed to build single-machine applications like mobile or web frontends.

Regardless, the need for reliable distributed systems only continues to grow. Thus

there is a corresponding need for the tools, patterns, and practices for building them.

Fortunately, technology has also increased the ease with which you can build dis‐

tributed systems. Containers, container images, and container orchestrators have all

become popular in recent years because they are the foundation and building blocks

for reliable distributed systems. Using containers and container orchestration as a

foundation, we can establish a collection of patterns and reusable components. These

patterns and components are a toolkit that we can use to build our systems more reli‐

ably and efficiently.

A Brief History of Patterns in Software Development

This is not the first time such a transformation has occurred in the software industry.

For a better context on how patterns, practices, and reusable components have previ‐

ously reshaped systems development, it is helpful to look at past moments when simi‐

lar transformations have taken place.

2 | Chapter 1: Introduction

Formalization of Algorithmic Programming

Though people had been programming for more than a decade before its publication

in 1962, Donald Knuth’s collection, e Art of Computer Programming (Addison-

Wesley Professional), marks an important chapter in the development of computer

science. In particular, the books contain algorithms not designed for any specific

computer, but rather to educate the reader on the algorithms themselves. These algo‐

rithms then could be adapted to the specific architecture of the machine being used

or the specific problem that the reader was solving. This formalization was important

because it provided users with a shared toolkit for building their programs, but also

because it showed that there was a general-purpose concept that programmers should

learn and then subsequently apply in a variety of different contexts. The algorithms

themselves, independent of any specific problem to solve, were worth understanding

for their own sake.

Patterns for Object-Oriented Programming

Knuth’s books represent an important landmark in the thinking about computer pro‐

gramming, and algorithms represent an important component in the development of

computer programming. However, as the complexity of programs grew, and the

number of people writing a single program grew from the single digits to the double

digits and eventually to the thousands, it became clear that procedural programming

languages and algorithms were insufficient for the tasks of modern-day program‐

ming. These changes in computer programming led to the development of object-

oriented programming languages, which elevated data, reusability, and extensibility

to peers of the algorithm in the development of computer programs.

In response to these changes to computer programming, there were changes to the

patterns and practices for programming as well. Throughout the early to mid-1990s,

there was an explosion of books on patterns for object-oriented programming. The

most famous of these is the “gang of four” book, Design Patterns: Elements of Reusable

Object-Oriented Programming by Erich Gamma et al. (Addison-Wesley Professional).

Design Patterns gave a common language and framework to the task of program‐

ming. It described a series of interface-based patterns that could be reused in a variety

of contexts. Because of advances in object-oriented programming and specifically

interfaces, these patterns could also be implemented as generic reusable libraries.

These libraries could be written once by a community of developers and reused

repeatedly, saving time and improving reliability.

The Rise of Open Source Software

Though the concept of developers sharing source code has been around nearly since

the beginning of computing, and formal free software organizations have been in

existence since the mid-1980s, the very late 1990s and the 2000s saw a dramatic

A Brief History of Patterns in Software Development | 3

increase in the development and distribution of open source software. Though open

source is only tangentially related to the development of patterns for distributed sys‐

tems, it is important in the sense that it was through the open source communities

that it became increasingly clear that software development in general and distributed

systems development in particular are community endeavors. It is important to note

that all of the container technology that forms the foundation of the patterns

described in this book has been developed and released as open source software. The

value of patterns for both describing and improving the practice of distributed devel‐

opment is especially clear when you look at it from this community perspective.

What is a pattern for a distributed system? There are plenty of

instructions out there that will tell you how to install specific dis‐

tributed systems (such as a NoSQL database). Likewise, there are

recipes for a specific collection of systems (like a MEAN stack). But

when I speak of patterns, I’m referring to general blueprints for

organizing distributed systems, without mandating any specific

technology or application choices. The purpose of a pattern is to

provide general advice or structure to guide your design. The hope

is that such patterns will guide your thinking and also be generally

applicable to a wide variety of applications and environments.

The Value of Patterns, Practices, and Components

Before spending any of your valuable time reading about a series of patterns that I

claim will improve your development practices, teach you new skills, and—let’s face it

—change your life, it’s reasonable to ask: “Why?” What is it about the design patterns

and practices that can change the way that we design and build software? In this sec‐

tion, I’ll lay out the reasons I think this is an important topic, and hopefully convince

you to stick with me for the rest of the book.

Standing on the Shoulders of Giants

As a starting point, the value that patterns for distributed systems offer is the oppor‐

tunity to figuratively stand on the shoulders of giants. It’s rarely the case that the

problems we solve or the systems we build are truly unique. Ultimately, the combina‐

tion of pieces that we put together and the overall business model that the software

enables may be something that the world has never seen before. But the way the sys‐

tem is built and the problems it encounters as it aspires to be reliable, agile, and scala‐

ble are not new.

This, then, is the first value of patterns: they allow us to learn from the mistakes of

others. Perhaps you have never built a distributed system before, or perhaps you have

never built this type of distributed system. Rather than hoping that a colleague has

some experience in this area or learning by making the same mistakes that others

4 | Chapter 1: Introduction

have already made, you can turn to patterns as your guide. Learning about patterns

for distributed system development is the same as learning about any other best prac‐

tice in computer programming. It accelerates your ability to build software without

requiring that you have direct experience with the systems, mistakes, and firsthand

learning that led to the codification of the pattern in the first place.

A Shared Language for Discussing Our Practice

Learning about and accelerating our understanding of distributed systems is only the

first value of having a shared set of patterns. Patterns have value even for experienced

distributed system developers who already understand them well. Patterns provide a

shared vocabulary that enables us to understand each other quickly. This understand‐

ing forms the basis for knowledge sharing and further learning.

To better understand this, imagine that we both are using the same object to build

our house. I call that object a “Foo” while you call that object a “Bar.” How long will

we spend arguing about the value of a Foo versus that of a Bar, or trying to explain

the differing properties of Foo and Bar until we figure out that we’re speaking about

the same object? Only once we determine that Foo and Bar are the same can we truly

start learning from each other’s experience.

Without a common vocabulary, we waste time in arguments of “violent agreement”

or in explaining concepts that others understand but know by another name. Conse‐

quently, another significant value of patterns is to provide a common set of names

and definitions so that we don’t waste time worrying about naming, and instead get

right down to discussing the details and implementation of the core concepts.

I have seen this happen in my short time working on containers. Along the way, the

notion of a sidecar container (described in Chapter 2 of this book) took hold within

the container community. Because of this, we no longer have to spend time defining

what it means to be a sidecar and can instead jump immediately to how the concept

can be used to solve a particular problem. “If we just use a sidecar” … “Yeah, and I

know just the container we can use for that.” This example leads to the third value of

patterns: the construction of reusable components.

Shared Components for Easy Reuse

Beyond enabling people to learn from others and providing a shared vocabulary for

discussing the art of building systems, patterns provide another important tool for

computer programming: the ability to identify common components that can be

implemented once.

If we had to create all of the code that our programs use ourselves, we would never

get done. Indeed, we would barely get started. Today, every system ever written

stands on the shoulders of thousands if not hundreds of thousands of years of human

The Value of Patterns, Practices, and Components | 5

剩余163页未读，继续阅读

whossa

粉丝: 2
资源: 20

Brendan Burns的《分布式系统设计：K8s模式与部署策略》

Designing Distributed Systems（设计分布式系统）.epub

Designing Distributed Systems Patterns and Paradigms for Scalable, Reliable epub

Designing Distributed Systems(Early Release) 无水印pdf

Designing Distributed Tree-based Index Structures for Fast RDMA-capable Networks

List at least three challenges when designing programming for multicore systems.

SE-workbench

推荐几本分布式数据库的书籍

integer verilog

memory attribute

labview-robtics

请用英语介绍一下计算机科学与技术专业

designing data-intensive applications pdf

头歌深入理解计算机系统系列实验

verilog signed

校园交互式导识系统用户体验设计研究英文参考文献

system verilog

designing and lmplementing aserverinfrastructure

designing data-intensive applications awz3 mobi

an87216_designing_a_gpif_ii_master_interface_chinese pdf

vhdl process

最新资源