请选择 进入手机版 | 继续访问电脑版

ITIL,DevOps,ITSS,ITSM,IT运维管理-ITIL先锋论坛

 找回密码
 立即注册

扫描二维码登录本站

QQ登录

只需一步,快速开始

查看: 791|回复: 0

微服务与 DevOps实践:技术架构与组织架构

[复制链接]
发表于 2021-4-7 14:47:18 | 显示全部楼层 |阅读模式
一、概述

% J) p. }( n. d7 x# R5 B9 y+ h
5 m& t1 Y4 m+ f7 l9 P
首先,我们来看看微服务的定义:微服务是一个界限明确、高度封装、松耦合、可以独立部署和独立扩展的服务应用组件。如图所示。微服务架构基于 SOA 和领域驱动设计(DDD)构建,其主要目的包含以下三个方面:开发的敏捷性、部署的便利性及明确的可扩展性。
% ~$ @7 A) t8 _" n9 K
. |% ~8 L# b; w, N5 D: P
粘贴上传202104071416541806..png

- N7 u6 Y- ]4 n8 `
5 C/ _! a* R0 w7 Y. M) R* f& o+ z
; U' j! g0 O3 K7 R8 P6 t, ~

( u* G; [" m- X; c; F- [# i
! ^9 [* [+ H1 C8 q8 o1 V& u( f
其次,微服务和传统的 SOA 有什么异同:
9 l& j! @* J. ?8 A  E; ^4 u6 R' I# Q
  • 从设计原则上来讲,微服务架构遵循 SOA 的设计原则。
  • 小的、可重用的服务并不一定是微服务,微服务架构强调敏捷、独立开发、独立部署、独立扩展,重用在某种程度上会影响敏捷性。
    7 X. V# C& K- X6 {4 R( W  N/ U2 x6 D
- l" y( c% U6 E5 K  e0 K3 j

6 b) f) e) J, p. u2 P2 _
7 D; t8 l! c0 v) V8 b
2 }) j3 Y4 l3 O

3 R# m! {6 K; q) B: L3 u" H7 W. W
( H4 v+ N! p( i
微服务架构为了实现其敏捷特性,在 SOA 架构约束的基础之上又添加了新的约束,微服务之间不能互相依赖,因此要求微服务能够独立部署、独立扩展,微服务之间的依赖越少越好。微服务中的一个服务只实现一个独立的特性。对于微服务而言,尽量不要为外部应用发布代码级 API,可以通过服务调用或者事件解决依赖问题。微服务中的服务之间最好通过异步事件交互。微服务中的每个服务都拥有自己独立的数据。另外,微服务架构的优点有很多:
  • 敏捷性:微服务不仅可以提高开发的敏捷性,还可以加速持续部署(CD),从而使开发团队能够尽快部署新的功能。
  • 减少风险:由于每个微服务都是比较小巧并且独立部署的,因此可以减少每次部署的风险。
  • 适合分布式开发:微服务之间依赖程度低,因此可以更加灵活地独立开发。
  • 技术灵活性:微服务之间的耦合程度低,因此技术团队可以根据不同的特点选择最合适的技术栈,例如利用不同的编程语言解决不同的领域问题。
  • 可扩展性:一个应用有许多微服务组成,每个微服务可以根据需要独立扩展,而无须对整个应用做整体扩展。
    4 h& P) X" g/ H1 j+ Y4 v
" ]& y" y: M; F$ |3 x" W
. L, M' w' Z# e

6 _0 @4 u1 Z+ X6 n  K0 q) L2 V" A
/ t$ L9 e. x0 t( ]1 D' Y4 q
鉴于以上优点,我们来看一下微服务的本质。微服务在本质上是一种服务实现模式,微服务可以实现一个应用中独立的业务功能,而不是整个应用或者模块,因此,微服务其实是将单体应用的复杂性从程序内部转移到了服务组件之间,这就对微服务抽象的粒度有一个比较高的权衡要求。对于微服务的粒度,大家讨论的最多,这也是实践过程中经常遇到的令人纠结的问题。实际上,如果抽象粒度太细,就需要大量的服务编排来满足业务场景,而大量使用服务编排就可能会导致微服务退回到 SOA 模式(服务编排是类似 BPM 或者 ESB 的系统);而如果服务粒度太粗,则不利于开发的敏捷性和部署的便利性。微服务的主要目的是实现敏捷,微服务架构的主要构建方式是采用领域驱动设计,而领域驱动设计主要包括如下五个概念:
' e; n% m- q& }6 y
* @6 p3 o+ g9 J& w9 `/ Z
& v% g* G, C; T& P0 P- {5 P! A; T& l4 Y
9 s: ~, t8 Q7 v1 j: }+ f
  • Bounded Context
  • Context Map
  • Event Sourcing
  • CQRS
  • BASE. [7 Z9 G8 B8 `4 A

3 Q% p3 D" c7 s3 i5 O# ]
0 `$ O* f4 v! I1 A! `, m

, c! O( j1 m2 D; Q4 \9 D

- X3 I. X& K; |4 K微服务的粒度并没有一个明确的界限,也就是说“尺寸”是相对的。通常,微服务的粒度和对敏捷性的要求密切相关,往往粒度越细其敏捷度也越高,但是并不是所有的应用对敏捷的要求都那么高,也就是说在微服务的设计和实现过程中,对于粒度的大小可以做适当的调整。对于想要采用微服务架构的团队,首先要考虑如下几个前提条件:# q2 f5 ~# @. ^
0 d, t* v5 j* R6 k1 [
$ H2 I) ~: o/ |/ q

0 _$ I. u4 @* Q+ }2 o$ G
  • 现有软件架构是否已经服务化或者按照系统功能做了模块化切分。
  • 团队的敏捷成熟度如何,是否有足够的 DevOps 经验。
  • 开发团队是否有足够的架构设计能力来适应采用微服务所带来的设计方法、模式以及技术架构上的巨大差异。
  • DBA 团队是否有能力和意愿制定新的数据管理模式——将数据管理的方式由原来的集中管理转变为去中心化管理。
  • 运维团队是否有足够的能力为微服务提供全新的环境管理工具、部署工具和监控工具。
  • 综上所述,我们建议微服务的演进线路如图所示。
    - b# o5 a& L( u# _6 Y
( y: P! E5 X% s7 J

8 m2 }4 n4 {% s- f% `! f4 Z7 i/ N3 q$ ~0 b/ I7 D

7 C- i/ v7 O# r
粘贴上传202104071419363870..png

3 }2 I* o$ T. P2 X& R2 J: s) w4 r& `4 C1 U0 A

" h+ u+ @8 B3 W8 V% x- x+ A
; ?. g9 R  c7 f, O( w/ r% b+ u7 P% N0 m, P3 j, Q1 V0 \* a0 @6 ~
  • 从单体应用或者传统分层架构的应用向服务化过渡,通过封装和组合等方式提供对外发布接口的能力,从而提升应用的可访问性。
  • 通过重构将 Domain-Level(领域层面)的功能模块转变为可以独立部署的服务,从而提升整个应用的敏捷性。我们将这种可独立部署的服务称为 MiniService,其粒度比微服务粗,因而抽象难度比较低,但是也能在一定程度上获得微服务所带来的敏捷性提升的好处,但是对 DevOps 的基础设施等要求没有微服务高,因此建议没有微服务经验的团队可以从 MiniService 开始尝试。
  • 通过 Feature-Level(特性层面)的抽象,根据单一职责原则将 MiniService 拆分成微服务,从而获得更高的扩展性和敏捷性。) J! Q; B( ~2 N5 }' |

1 h/ \  k, v2 s3 @
二、融数数据微服务的架构选型

" J# d5 w% m4 v1 I1 \5 U

8 K: J/ r6 ]. m* p" Z
, L9 C5 ?5 J9 D6 a7 ^
我们在构建微服务体系的过程中,经历了技术选型、技术验证、引入开源实现及完全自研等一系列的过程,其中也走过不少弯路,现在回想起来,感触良多,在这里跟大家分享一下,希望能够有所帮助。对于技术选型,我们不希望重复发明轮子,也不希望完全受制于开源的实现,所以在技术选型时遵循如下原则:
- r- b! \3 r3 ~3 T8 P
$ [5 _% t* Q3 `- z/ a& w& N( |. I

. V- I" C' q, s2 Q
" [% V: F( G" P4 k$ [7 ^

; u+ l( U2 X( J8 m
( g7 Z, p$ i0 d5 A6 f1 P: i/ K
粘贴上传202104071421184673..png

$ ^5 w6 H' @3 |* r. H# R8 O$ P
$ P, e$ v) O9 H* c9 }2 l- Z

1 U8 y( _4 B: ?$ G2 F. K$ @; d4 [5 u3 C

3 X5 H$ ?0 M5 d' Q( ~3 _+ D+ E4 G% Y4 m" m4 D! w' C1 w9 ?$ X2 I
4 i5 N. {6 O% p0 c
考察社区热度、架构成熟度、学习曲线、可维护性,如图所示。尽量照顾现有服务的开发方式和框架的使用习惯,不对目前的研发团队造成太大的冲击。能够给程序员提供何种能力?我们的期望是:
$ {  s0 M6 N9 `) x4 U3 f2 {5 Q
9 p4 ^* p' v) a% c; c

3 S; {; B- b& c4 A8 Z. n6 ^- L0 b* ]2 u+ q
  • 方便开发
  • 方便迁移
  • 多协议支持
  • 多语言支持
  • 方便监控
  • 方便运维  s: p' B! ^1 t# |6 ?
我们比较了可能用到的一些开源服务框架,并对它们的功能点进行了评估,如图所示。; i# X( Y* N* B
# p+ x; L  }0 N& \; Z* |

" ^: {: O, ^8 }1 q3 Z8 B; @' q0 _2 g/ Q% E) t
; A5 R( ]/ A) F6 D5 K0 l1 u
- ?) F3 `+ a4 }/ O. c9 D( f7 T

# x2 M! v* J2 P# y7 q7 O, a% A4 \
+ N1 K5 D4 O& I4 j% ]/ C. C- k
粘贴上传202104071422211492..png

) {5 Q: r* N. |& W, K% L% ~
3 w* n- @( p8 E, I! {
/ T* e8 c; `  ~0 h; x  ^

6 s8 D& x4 n* e& z6 s8 S+ e
% c5 K6 u+ ]9 e& b) \2 A5 V5 ^4 f
/ M  T/ G+ ^7 p4 `4 H
" M" [) ^3 g* s* n
由于之前团队采用 RESTEasy + Spring Boot 的方式实现服务,不希望对现有的系统和产品产生太大的影响,因此决定服务框架首先需要支持 REST 服务,又由于 Netflix 提供了比较全面的解决方案,并且 Spring Cloud 在遵循 cloud-native 原则的基础上对 Netflix 进行了比较友好的封装,因此初步的结论是可以基于 Spring Cloud 进行二次开发,封装我们自己的微服务框架。经过半年的实践,我们发现 Netflix 技术栈的思想不错,但是很多实现并不是特别完美,例如:
5 e! m( H2 j  x; s% n2 K, A+ r% E9 F* u( n; q
  • Zuul 提供的 Edge Service 及 API 网关是完全基于 HTTP 协议的过滤器实现的,基于 HTTP 协议的同步调用方式会带来性能的损失,并且缺乏长连接的推送及多路复用的能力。
  • Zuul 不能满足 RPC 调用的需求,而在大规模团队协作的过程中,契约优先的开发方式优于代码优先的开发方式,因此对于应用内部交互来讲,RPC 框架从管理和协作的角度要优于 REST 服务。
    ! a  o- a- x# `# n5 e
基于 Eureka 的服务注册依然是中心化治理的方式,与传统基于 ZooKeeper 或者 etctd/consul 的治理方式一样,中心化的治理会给服务的部署带来非常大的阻碍,需要对不同的环境配置不同的中心注册服务器,服务的版本管理及服务注册信息的同步也会带来问题,更加糟糕的是,在某些服务不正常的情况下,客户端需要进行大量的判断,防止出现治理风暴等问题。因此,我们后来果断转换思路,对之前的微服务框架进行了彻底的改造:
! G: `+ h3 F  z3 ^6 `" n
; l+ ], O; C6 O2 K9 f3 Q  s3 \

+ A5 e* ?) k8 }5 X* j
( \& _2 X* ?" {# E( j9 G" @( }/ `
  • 基于对 gRPC 的封装,构建 Service Provider 的全新实现,替代 REST 服务。
  • 通过 Proxy 方式,实现 gRPC 与 REST 服务的相互转换,保持系统兼容性。
  • 进行去中心化治理,通过 Proxy 来实现端点治理,将客户端治理变为服务端治理。
  • 通过扩展并集成 Zipkin 实现服务链路监控和运行时拓扑收集。
  • 构建 Endpoint inventory 服务,以 semantic versioning 的方式管理服务版本。
  • 将 Proxy 作为服务部署的执行端点,通过 VIP 绑定,透明化客户端寻址工作。利用 Proxy 提供轻量级的负载均衡、流量控制及灰度发布的功能。
    4 n5 s1 D2 @4 z# D

/ Q8 h$ I0 D1 n, Y. i) a' h5 P
三、设计思想
8 m9 P* y& L; s6 j
/ T4 u' o* h% ?
% F; Z7 Q0 ^4 Q3 H+ p& i
融数数据微服务架构的整体设计思想如图所示。
; m7 h5 G3 R  F0 a2 |8 C
, _% Z% Z/ N" }( [

' O* }* y$ d1 \2 B' W; g# ]0 f/ T( G- L: T
, n6 E/ u' {7 r! D9 s
粘贴上传202104071423378656..png
! G5 r' N9 X. L2 G

# V" @8 @' g# R3 G& }! W
$ X; @6 G3 O$ Z. Z
  j. G. a5 t2 I( N
0 Q  b7 V& m0 B# [+ s# d

! @$ P- q) ~# @' G

  h2 H! Z6 f8 c( c4 j% ]9 a$ |) F$ w. G4 n- i

/ k' [+ s- `3 ~. y该设计思想的具体说明如下。
( b% h1 {  i/ h2 \
6 E% }3 ]7 Y3 [+ v
2 G$ ^/ _5 [, T! Q# k5 `
8 M7 ^+ V- X+ g! {& z! z
  • 面向运维的设计,配合 DevOps 平台,提供服务生命周期管理及易于被监控的能力。
  • 面向开发者,合理封装。开发者无须了解 gRPC 的具体实现。
  • 基于 IDL 的契约优先的开发方式。
  • 提供完善的测试框架和 Mock 工具。
  • 提供完善的易于监控的能力。
    7 N  B/ W5 d; F2 L5 f9 R

7 ~, ?! c( H: g: \0 A( U
四、总体架构

  m  R& c  _3 D: d, U, n
8 m1 v% O0 b5 ?
8 ]- e9 q! t7 x3 ]6 Q4 Z融数数据微服务总体架构(Graeae)如图所示。
# B( @& x$ i: O+ ?3 q& |4 o' l+ c  s# Q% v- v
; e# w9 J( M# Z. A. _- S) p

: q# _7 A- v' R: C1 n

5 p7 j) \) y! j7 |' r$ H: H3 K1 q. z
- f% u9 s7 n6 A% q/ Y3 L* L: p1 G
7 p& B- O3 ^+ A6 o4 ?
粘贴上传202104071424585336..png

% c5 W, q! {. Z* x& U+ ?: Z' a6 Y' W4 q: D) b  y
9 a  r8 A) d* ]2 t7 g. Z% V1 ^
1 \% j4 J% J& h" |

& C  {4 T# P& J, k; r; x- Q, C( ?" e  J( d7 T
% `3 l0 M; H4 X

2 e- }# M" a4 m
4.1 总体架构的特性融数数据微服务总体架构有如下特性。5 J5 e% _0 P( i
1 A8 U  ~2 l1 o: g

. R' {! J& C, L& I* I- C0 N+ W* j# u3 F! a: ~% s
  • Graeae 架构与协议无关。该架构可以基于 Netty4、线程模型及 buffer pool 进行调整,以减少 GC 压力并通过线程切换提升性能协议。
  • 遵循 protocol buffer 协议,可以做到通用性强、序列化性能好、压缩效率高。
  • 语言中立,目前整个架构支持 Java、Python 和 Go 三种语言的开发。
  • 引入了熔断器机制、流量控制、服务治理。
  • 基于 Proxy 和 PaaS 平台进行分布式治理监控。
  • 使用集成 Zipkin 的调用链监控,以及基于 Pinpoint 的 APM 监控。
  • 对于该架构而言,直接调用的性能好于反射调用,且使用 Netty4 线程模型优化。
    - a# {+ X. O. W
; ?+ n* d8 R+ H' {
, `0 a( Z1 X# s4 v; Q/ d3 K% h
4 O, G! t& Z/ ?# h4 x+ F  F
% J  v' N  B5 {4 c8 L: |  n
4.2 具体实现服务提供者 Endpoint 基于责任链模式(如图所示)对 gRPC 进行封装,对屏蔽了 gRPC 框架的事件驱动采用同步调用方式,方便业务迁移。
5 W4 W( J1 V3 I' T9 K& Y5 N$ W3 G7 f- y) G% f

% Z8 S; S4 d" k: M! p9 z
粘贴上传202104071426033769..png
* Y* s0 i/ ]. [8 }3 L9 ]- D

8 o2 |* |; e0 h7 {0 H

1 e# [0 q* `( T0 a4 `& e. N, x1 t0 s. [5 Y/ H) g7 s: c( E8 W
3 y4 N: t1 o  n3 W2 D' _) ?

1 T% [; ?/ o) B/ J
0 u% v8 d( O& N# V6 w9 E8 ^
5 B9 r# n* ]# H" \4 d

. m2 |8 }' }  u0 S  J' }9 p$ F( A# e  k! d- X7 P: d1 Z! T' k

0 Z2 X% G2 }7 s6 UEndpoint 封装了脚手架工具,提供基于 ProtoBuf 的 IDL 接口定义语言,使用契约优先的方式定义服务,并可以自动生产服务端和客户端的代码框架。代码优先意味着实现简单,能够快速执行。问题也很明显,可能和某个具体语言绑定,面对多语言环境,其打通成本较高。契约优先的中立性提供了一个中间桥梁,让面向多语言成为了可能,基于契约的元信息为后续治理和演进提供了入口点。缺点是需要引入契约语言的学习,并与多语言进行适配。Endpoint 采用生命周期自管理的方式,提供容器化的生命周期管理 API 和相应的 SPI,方便扩展及与 DevOps 工具结合。外部管理(如 Tomcat)让用户不用关注自身的起始、消亡,但带来的不足是对生命周期的管理相对减弱、部署的依赖管理扩散。进程自治可以加强其对自身生命周期的管理,高内聚,不将依赖扩散。在一定程度上能够带来部署的便利及不同部署环境的适应性(如云环境)。为优雅关闭提供切入点,进一步增强对系统的可控性。从对环境适应性和对生命周期的管理能力考虑,进程自治有着不可忽略的优势。Endpoint 将配置与代码分离,提供多种方式的配置覆盖能力,使得改变配置无须重新部署。配置和代码一起进行的优点是使开发变得简单,但不足也很明显,即面对不同的环境需要部署多套代码,复杂度增加。配置和代码分离后的优点是真正做到了只部署一套代码。配置信息按环境独立配置,不受环境制约,可随时调整。集成 Spring Boot,提供自定义注解方式,能够快速启动服务,方便开发。
. L- @* H: a3 v2 T4 E* R7 a2 R$ S; \" R

5 ^! t: ~( f9 `- {8 K
# ]' s+ r6 q9 j
  J5 I0 W* G. l( }6 G
粘贴上传202104071428102303..png

0 G' t/ T' C4 U+ w7 d
+ l3 S$ I* q9 Z2 |' H! b9 _! o/ b. R; I, }
利用 Proxy 部署和设置服务治理端点,进行分层治理,如图所示。 ( t+ B! A. {" n% c, m

- Z4 }+ a( Y8 m

' {8 F- R* E# Q& u: o& J
7 l1 b+ U% L. ]

9 w; g% y1 k) l. b* z7 I2 U$ k; Q5 U8 u( X# L
4 P* W% R# D2 i
粘贴上传202104071429336995..png
/ t6 U# A; T8 X9 ?
: X0 v# Q, s. U1 _! w

* B1 `' R. z8 z' n) z# B  k
7 |* E& f( F' b- ^$ |! H+ D

# M7 v& Y, Y2 F8 `6 g

% ^" V' |- }& J# M9 k( d
7 |6 G' U- b8 V  b' C

2 H) u6 V; h7 e1 U0 A' n8 B
2 Q  G' L' }* o: D% c

* H. Z& n' K# c' H3 u" w0 B

" i8 S: {! k: B: A
粘贴上传202104071430373306..png
( A3 x' P$ d  I/ _. ?8 K

$ `( X9 M) Y& f

+ ~5 U& N  l3 o: \7 p
" B+ ^8 I  z9 z2 Q: z' \' U
7 m: @: G* T  R3 V, r, Z
用 Proxy 配合部署方式来兼容 semantic versioning 的版本管理,版本格式有主版本号、次版本号、修订号、版本号递增同时需要备注,规则如下:5 T$ F1 M0 @9 Q/ r
. ]. g8 Y  c3 M' {' j, Y
  • 主版本号:当做了不兼容的 API 修改时,需要递增主版本号。
  • 次版本号:当做了向下兼容的功能性新增时,需要递增次版本号。修订号:当做了向下兼容的问题修正时,需要递增修订号。
    ! A8 h+ c) j  ]' v
先行版本号及版本编译信息可以加到“主版本号.次版本号.修订号”的后面,作为延伸。+ \) R; c5 v1 B( `$ I
- [& ?/ \/ O& c7 Q4 L5 c5 e& Z: s

# X: f, {) {/ q/ X/ o, F) Y# c8 p! y8 `7 Q8 G  S# N& _/ m. X

, i, O, q+ A6 c+ \) b, r" v) j6 ~3 a9 w4 p' Y0 W0 M
五、对微服务的支撑
" A3 U% M2 D6 t' g' ~+ N

9 I$ x/ }6 V/ t: N! a
9 G1 U' n: S5 q
融数数据 DevOps 体系主要解决的问题是有效地识别和管理元数据,以便高效、自动化、高质量地将系统动态组装并运行起来,该体系架构如图所示。2 T3 ]" Y2 w) t7 X
下面结合图对 DevOps 体系做几点说明。
* s& Z0 T7 T- ]0 m- c+ e! G  K
% S" r$ @! Q: `
2 I) b6 J0 P2 Z1 }
. H) x5 q& `+ z; j
  • 抽象了部署的最小单元——包。
  • 每个微服务都是由包及其配置组成的,前面提到,服务框架做了代码和配置分离,因此这里可以将包和包的配置分离,提供运维便利性。
  • 逻辑环境包括了微服务、微服务配置及运行微服务所依赖的 Host 或者 Host Group。
  • 版本化逻辑环境,方便回滚。
    0 J6 S& Z/ J% @
该体系中的服务组件=(可运行代码 + 配置)&(依赖 + 配置)&(基础设施 + 配置),如图所示。

& ~/ e/ G; q) `' {
' M) U. h0 D( X- O! }* M9 o% A) O
粘贴上传202104071432015743..png
* m- a$ C, O5 H. k. S) w

- X: Y' @! {9 |8 ]
8 g9 K$ Z! N- B8 o
" N. C- Y3 p0 O
粘贴上传202104071433279636..png
* p5 c0 S3 i- L! [, |5 X
8 a1 |" I4 f, t4 y- q- s0 y

; p8 Z% d. y' |" C
$ o$ _3 T# S! Z+ H: P4 g5 C4 z- R7 h* w/ m. C. v

% X, F$ m+ p) F# x! v- }+ a* {  P) D  U; D7 H2 `
从部署的角度讲,无论包还是包的集合(往往是组成一个独立业务域的独立功能)都需要依靠版本才能进行整体部署,可以部署在不同的逻辑环境上,也可以部署在同一个逻辑环境上,如图所示。

. ?( U. J$ v  ~) z. O) r, J4 O3 p, l0 m& b. `

6 G: R' Q- Q7 ~2 u% s
粘贴上传202104071435126766..png

, K$ p. n1 F% Y- Z, {5 D/ ^* }
- N9 z; E& m5 r! i
' l& N4 |' o2 ?# n+ \
粘贴上传202104071436268796..png
2 V! t( q9 _5 x9 @
+ ?0 Q5 ?' Y1 V$ W0 U7 U
5 {$ `* Z. M+ Q+ s8 J2 ~
$ j2 I( {4 Q/ C# _: t& J3 ]

6 K$ v) s$ R9 c8 B0 L
六、DevOps 平台总体架构
0 A! I0 u: Q. j4 R5 D
# L$ G3 ^" i. _# |4 l1 e- }

2 e$ O! {( I! A  A+ g3 \* W) {DevOps 平台通过构建平台将代码编译成物理二进制包,再使用元数据对这个二进制物理包进行描述,形成逻辑包,且将部署、依赖和二进制包本身的元数据统一存储到元数据服务中,最终通过统一环境管理平台读取元数据,按需拉取相应的逻辑包对应的物理包,放置到目标环境的相应目录下。之后通过进程管理调用相应的服务启动相关微服务,在部署的过程中,由逻辑环境管理绑定 VIP 到微服务的 Proxy 上,将信息注册到 service inventory 服务上,这样 Proxy 和服务 Endpoint 等的运行时信息(例如 IP、端口、版本等)就可以被收集到 service inventory 服务上。5 I+ W% ?2 T4 e7 s! x
在真正调用服务时通过内建的 Zipkin 可以收集服务调用链的情况,并同 inventory 服务的元数据信息进行匹配,便可以准确地知道服务调用的关系,从而达到真正的分布式治理;而客户端调用只需要知道服务所在的逻辑环境信息就可以自动完成服务寻址,这个服务地址就是 Proxy 绑定的 VIP 地址,从而简化客户端调用。DevOps平台要做的就是保证 Proxy 的健壮性,由于 Proxy 只是简单的反向代理,不存储服务状态,因此只需要做故障漂移就可以了,如图所示。9 z' X0 ~2 u  J  c" @4 S

$ O4 `- g5 Y0 }* n. g! q8 X5 D+ [- ]
3 v9 @* R% u& j: c; V  K/ K) R4 u

+ I( t, X8 q" T; c  T/ v9 {! b
& J4 C& b+ B$ s# y: h) n
粘贴上传202104071437416166..png

& G" @( {1 d! `  T( ^3 V# G
1 P  o* H& V* n6 X/ }
  ^4 j. w/ h9 h$ r, z" v$ Y" V

  j. N- b0 X  H0 B
# }# i2 m' z% S. U
- M7 ~" F; x" x! l% L% e: a5 v+ ]. T

+ I9 V* m# P! x7 e, a. a
5 C1 Q1 x% e9 E1 B' ~+ Y9 c5 ?
3 `, l# q$ N" t0 w0 N8 V. j2 y0 H
# n1 N9 V" ?1 K: S- c! O2 |3 X8 b

. g4 x" `# B5 C6 D. V. M4 a4 u6 B( l6 l+ _4 g7 ~- _) v/ ^: Z
( J' E6 M9 Q  L) R* n

. y, b& {9 v7 T  D
' f8 b% L" g. r2 k! a4 L: V; w. C
七、融数数据面向微服务的研发团队介绍

( }* v$ `" f/ D$ C# w
- O2 h( x: F; c3 ^  E/ K0 @) |2 X: F

4 ]$ Z6 M- }0 m5 a  {想成功地实施微服务架构,仅仅有服务框架、开发平台及 DevOps 平台是不够的,组织和文化也需要适应微服务的需求。根据康威定律,架构由组织决定,因此需要对团队的文化及组织划分结构进行调整。$ a! ~, S( I# P" ]/ M& G
融数根据 two-pizza team 的原则,按照业务来划分研发团队,建立全栈小团队,从而提高沟通效率、降低沟通成本,具体的团队策略如图所示。* J. g* W3 V9 w+ Y4 l  ~! M
6 O$ ?$ Z# ]7 }$ i1 z7 Z
, i7 ]+ M: y3 y# V# y7 W- x. [

. D  s7 A$ C. h, |
2 m" @- T& ^2 J2 Z
粘贴上传202104071438366280..png

. W% [3 Y1 W# y0 D4 R. G5 M5 @" n' `6 j4 W* y

9 I" b* O7 T5 w# B9 r9 W  e* [3 P* R% g7 [# J% `& {8 j

5 N, c( Y$ w3 g; @* {0 Q( |% v7 O- N3 W+ [9 ^: V9 I5 _! C
* q! T$ P3 D9 f
将团队切分后,我们按照业务线对组织进行架构规划,以便技术团队能够专注于解决对应业务问题(业务驱动,或者说业务优先)。这时,团队内部的设计决策将在团队内部消化,因为团队的规模已经是 7+/-2 人的量级,因此一般情况下不会对于团队内成员来说过于复杂的工作。但团队增多后,团队的协调将是一个问题,因此微服务从技术上帮助团队将负责的系统解耦,而计划流程会帮助团队在工作安排上找到合理的步骤。那么,虽然当一个大的业务被分解到各个小团队时,还是会有跨团队的设计工作,但是以上两点是要严格执行的。技术团队和业务团队的合作并非经由上层协调,双方的主要沟通都是团队之间直接进行水平沟通,也就是说,在底层的团队之间,需求、问题和日常交流都直接由业务团队反馈给技术团队的经理,而解决问题时容许业务团队直接接触开发人员,如图所示。我们在团队中强调以结果为导向的工作方式,如图所示。
% ]9 o$ e/ \6 e$ M& W, k% {% {) c; P: W) U& ]. K# e
9 C9 q0 w- h7 T, T% s- ]
5 E( ?" ]! V9 g7 z) y/ u
粘贴上传202104071439469198..png
4 y8 J' W  {" S/ n' F, `! f
$ A  l- {# G+ J* L% Y9 j

6 d7 j& \8 w! R* R' W7 o' ]
# J; ^+ k$ a5 J. i团队成员要有主人翁意识。团队的利益就是个人的利益,团队的成功才是个人的成功,团队成员之间要相互帮助和补位,不允许存在“事不关己,高高挂起”的情况出现。- {" [8 h$ y3 d- w* g7 r' p

! w, }- ?# K6 I6 P: @* p1 a& r/ S

9 y% u& p% ]( Q. P7 M# A) m
5 U/ ^! c' ^8 Y% e

5 l( G0 J7 U' e- m- `! h- p
粘贴上传202104071440515141..png
: I, |, ?) }7 I) \5 j

+ v9 ^2 q5 v4 O9 h/ Y, Z2 J7 }% s( F$ \% F, K
: Z$ @8 i! P1 X+ |. T
! Z; Q) A! F/ p
在团队中,成员可以发表意见,也可以抱怨,但是不能只停留在语言层面,大家需要行动起来,找到解决问题的方法;我们希望每个开发人员都参与架构设计,而不是仅由架构师决定;我们还强调不要过度设计,鼓励通过抽象和简化解决问题,当然也鼓励引入新技术,但前提是能够有足够的掌控力而且不影响系统稳定。软件工程师负责需求调研、设计、开发、测试、部署、维护、监控、功能升级等一系列的工作,也就是说软件工程师负责应用或者服务的全生命周期的所有工作。运维是团队成员的第一要务。在强大的自动化运维工具的支撑下,软件工程师必须负责服务或者应用的 SLA。在团队中引入 oncall 机制,强调保障处理及时性,并引入卓越运维的思想,用数据统计每个团队的线上故障、解决及时性,并逐步要求故障数量递减,通过强大的数据支持保证团队解决问题的 SLA,并逐步改善软件质量。" m3 w  p5 F! `  o
" r2 h" r3 E' F' J" b1 ]) {* \8 J
6 S, w3 K. X1 K! j6 `! R) \1 s
  _, ?: z- v' K" N0 }3 d* a
9 k1 v, v8 J  g. z

2 s) R+ e3 Z6 M3 S8 w; I
八、总结

3 ^* X" g7 H- _9 t) l% ^
+ X1 U. q# b5 H3 U' }3 A* p5 l* u

& T) |" O5 M7 Z0 ?; \( J0 H! m9 o6 }" u- P8 d" G
DevOps 的推行是按业务来组织团队,团队包含设计、开发、测试、运维等人员,这样一方面可以有效减少服务内部修改所产生的内耗;另一方面,团队边界可以变得更为清晰。DevOps 实际是一种文化上的变迁,打破了传统开发与运维之间的壁垒,帮助组织形成从开发、测试到部署、运维这样一个全功能化的高效能团队。(IDCF)- w7 g6 R. z: {) y

" c7 [: d  Y2 O: G6 t+ L. P: r8 g) l




上一篇:如何进行有效的TDD实践
下一篇:通过组织转型打造高效研发团队的五个维度
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

参加 ITIL 4 基础和专家认证、长河ITIL实战沙盘、DevOps基础级认证、ITSS服务经理认证报名

QQ|ITIL ( 粤ICP备11099876号 )|appname

GMT+8, 2022-9-26 19:46 , Processed in 0.104886 second(s), 32 queries .

Powered by Discuz! X3.4 Licensed

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表