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

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

 找回密码
 微信、QQ、手机号一键注册

扫描二维码登录本站

QQ登录

只需一步,快速开始

艾拓先锋
搜索
查看: 414|回复: 0

看DevOps平台中的自动化部署框架设计

[复制链接]
来自- 广东广州

参加活动:0

组织活动:0

发表于 2018-8-31 15:55:13 | 显示全部楼层 |阅读模式 来自- 广东广州
本帖最后由 adminlily 于 2018-8-31 17:20 编辑
& K% |: W. G3 |& c! z: g
+ _! Q" ]$ @' a4 j' @0 B; ~1 Q
1.png
本文目录:

, l2 w. s3 D. k) P' M3 A8 y2 q5 g
一、背景

( ]; W, r  |' Q6 m" H& J5 \
; j7 f; f/ v# p8 q- R" b
二、我们的需求是什么?
- M" D& M; ~& x% M
4 |7 T1 A) L7 F8 E7 i  V* o1 t5 L
三、概念澄清

4 @  E( V' g) L# x$ t; V) @! I
5 X" u+ D; }1 e( R( H" z$ g0 ^+ i
四、概念模型
2 f7 l9 q0 ?4 b

' {" x# S, L. F4 e* t. _6 w# {4 J
五、总体设计
9 [0 V3 M- O1 B' m$ k( l

6 T1 u9 S0 o/ T' k- ?& ^4 K
六、关键点设计

/ w5 e1 S7 f  m# Q: T

$ m" G+ K8 t' b( s* h' u- X
七、总结
" ]' J$ u7 @, R, f& K7 b: V
3 b+ @! j1 ]. I1 _) Z7 A0 {

2 t7 t) @6 `7 m4 ~
一、背景
  ^. S, V# U# j: d. }
说到自动化部署,大家肯定都会想到一些配置管理工具,像ansible,chef,puppet, saltstack等等。虽然这些工具给运维效率和安全性带来了很多好处。但是实际工作中,我们还是会遇到一些问题:

' c0 H! z1 r) [, z
; J% ]* G: U$ l
这些工具无法普及到开发、测试人员,经常找运维帮忙,无法自助;
; U/ V/ u0 U" X# Y* N( P
. O3 n* o' ~. V" Z' ]$ G
项目人员无法直观的参看到系统的部署架构设计,及架构的演进过程;

$ m9 k+ \3 k5 A# I! T0 k
( S4 [, J8 w$ D# k' n
从物理架构设计到最终上线,无法形成闭环;
" a/ z  p; K/ K' P1 B$ J
* K1 ]) e# V6 @: w2 e
受差异性的基础设施影响较大。
  r9 L! I. v4 j& |3 D' n
% f8 V+ Q/ R8 U- B5 p% j0 O

; W6 Y  ]; Y. d0 P. C6 J( ]* u: K1 m) i/ W; }
二、我们的需求是什么?

) `9 f+ z  f4 o
我们DevOps平台的部署模块就克服上面这些问题,为实现DevOps以产品为核心,以项目管理为驱动,将需求、设计、交付、运维整个链路打通这一目标提供有力支持。具体来看其需求涵盖一下几点:
* g( U8 o  S; u1 q$ ]$ F+ H. Q
1 B5 n( [# D" q- K& s
将架构设计纳入DevOps管理过程中,支持架构设计版本化;
; v9 I4 w5 Y2 a! `# I' Y
1 l! i5 n1 [3 Z& _
一次架构设计多次部署;
& p8 e# C( {- p. [. p

9 _* u! ]7 n2 l; |# c
以最佳实践为基础,实现架构设计模版重用;
9 r7 o; K0 M0 Z+ T1 T# k$ r
多环境部署,同时支持应用在虚拟机、容器上的部署
" f) c/ |7 [' i8 Y* ?

/ J0 Y4 e+ m! e# i; k( A
支持多种部署模式(单机、高可用)、部署策略(全新、蓝绿、滚动升级、回滚)
' u6 h. s" ]  t# Y8 f6 q

7 k8 B% a# ?$ A
2 J1 ^( b$ c' G4 W) F+ K! f. @; H9 s
三、概念澄清
9 Y# @& t! U9 Q+ ~, p/ |
在正式讲解我们的设计之前,我们想澄清CI/CD的基本概念,因为本次的主题和持续集成、持续交付和持续部署这些名词总有些渊源。

2 f$ ?# C" {: j  H8 A$ J3 x7 K7 y1 d% _9 M2 h4 X+ v5 R0 S+ O
1、什么是持续集成?

7 b/ ]" i& `. U& Q  L
' T7 u/ v  K1 a
持续集成(Continuous Integration)指的是,频繁地将代码集成到主干,以便快速发现错误、防止分支大幅度偏离主干。
$ T0 h0 M* k' f, D. c$ c
持续集成的目的,就是在产品快速迭代的同时保持代码质量,它的核心措施主要有两点:
+ X+ |+ ]" N& h8 Y1 ]

* u5 u% P! I- u  J4 ]
1)代码集成到主干之前,必须通过自动化测试,只要有一个测试用例失败,就不能集成。

4 l# w& }0 ?" n6 u1 e6 @! o7 Q6 r
2)通过Code Review、代码质量分析工具对代码质量进行把关,以便确定是否能够集成。
/ R3 Y! d: i" A# a- W9 u

1 d3 c  O; z- |9 C3 z
Martin Flower说过, “持续集成并不能消除Bug,而是让他们非常容易发现和改正。”

6 J: z$ s; x+ ?2 x" r
, h! Y8 X: o; \% L/ \2 d  ]
2、什么是持续交付?

( _9 g: z8 z" r: \2 {
" t; u  i4 C1 f( r" s
持续交付(Continuous Delivery)指的是,新版本为了能够快速安全的交付到生产环境中,需要将新版本先交付到类生产(Production-like)环境中(如UAT/Staging/Lab环境),以便进行相应的业务验证、安全验证、性能验证等过程。
一旦类生产环境验证通过,新版本就进入到生产阶段。

; L% U3 N$ K3 r) R5 U# `" ^4 N

$ u4 g) O, a  p% `" e9 g( e
持续交付可以看作是持续集成的进一步。它强调的是,不管怎么更新,软件是随时随地可以交付的。
  Y5 t& i! s9 @2 h( Q8 j

, {, x; A' U& _4 @- [3 S  D
3、什么是持续部署?
: e. F: L7 V3 k4 R
0 ]0 m' E, \* r9 ]" i6 G- E
持续部署(Continuous Deployment)指的是,新版本通过类生产环境的验证后,自动部署到生产环境中。

# ]4 Q) y: W1 e

; L: D* B4 O0 z
持续部署可以看成持续交付的进一步。持续部署的前提是自动化完成测试、构建、验证等步骤。
0 }. Q' m5 m- u9 V

/ Z* T2 D5 _6 `2 C& [6 q
持续部署的目标是,代码在任何时刻都可以进入自动地进入生产阶段,为最终用户提供服务。

) I3 n1 G, V8 t# L3 Y% Y- ?

  o/ G' R3 q  {* a9 l, I7 q6 s
持续交付和持续部署的区别可以参考下图:
1.png
(点击可放大查看)
从上图中,我们可以看出:
0 r- [. M3 z  k! ]6 F( {/ Y
7 x( u/ N! Y% p" O4 n0 ?, z, D; E
持续交付流程将自动的测试新版本应用,但是否将新版本交付到生产环境中是一个手动过程。持续部署则是自动地将新版本交付到生产环境中去。

* {7 _' t$ v2 l7 X' _0 C0 }( Q
- P! `/ R0 u% |5 g$ g% G
关于持续交付/持续部署,我们不能说哪一个是最好的方案。对于不同的组织,适合的就是最好的。

+ q; G1 T, J: t* r( z( ?
( |- x+ A* u, I2 a5 L
4、什么是自动化部署?

% A2 ~+ h& c4 F& ?) t: o8 _* [# r
5 K3 f5 d2 A1 {) K3 Y
自动化部署(Automatic Deployment)指的是,通过自动化工具将应用介质部署到指定环境中去。
9 n# `; N' \4 w. |4 s5 X

% T$ H5 I4 K+ g
自动化部署只是持续交付和持续部署流程中的一个功能单元。

8 R) V5 I2 ~/ E0 V
4 k; [9 p, Z% m8 U& r# w; A% ~# I8 c
自动化部署工具:Ansible、Puppet、SaltStack等等。
0 \6 B) L8 b" O7 P$ P7 `
通过以上概念的澄清,我们了解了什么是持续集成、持续交付、持续部署以及自动化部署。

9 ^. u7 f* h4 I
* n  @) T; Q& }9 S5 L
本文的主题不是介绍持续集成、持续交付、持续部署的Pipeline与实现,而是介绍DevOps平台中,在传统自动化部署工具之上的自动化部署框架的设计与实现。而自动化部署模块也是我们DevOps平台中的CI/CD的底层能力。
# i& M  K. b4 u# q8 u

7 ]7 ~* l0 K5 t) j$ @! _2 Z; \  p5 o  |# ^2 N
下面我们就来聊聊具体的设计。

+ V" |7 i' p4 M1 W. P2 n/ D0 @3 [7 M# V+ l) R3 t0 U# T4 t
1 i6 V. }0 r1 ~0 c

8 Y* j, Z/ ^, m( I3 s4 h, J
四、概念模型

$ s! f+ c# O' ]3 I$ C  r3 L' R" I$ i0 F. {
1.png

1 z- ?7 p) T) l3 ]
(点击可放大查看)

- V% l0 D2 [4 f- K: U6 g3 x  G
除了系统内置的一些模版概念,我们将自动化部署流程分为三个阶段,即设计、转换、运维。每个阶段都会有相应的基本模型。

" N- [) m: K: U; c

" \9 O% I) e$ G9 u/ U9 N/ ?7 b  ^6 K
下面,我们分阶段的去解释一下这些概念模型。

" T# F" a8 M4 C$ g9 C$ F( P

( H8 l/ P3 S- c; Z  N. C
1、设计阶段

: t5 O' O" O+ J0 t

( m& c: J0 q+ r' j6 B8 v5 L! j
设计(Design),是在装配(Assembly)内对应用/系统的架构的描述;而应用/系统,是由含有多个组件(Component)的系统(Platform)组成的。
: ^! Q3 i; F# j3 I# d8 ]( q; ]
( ]! p  C% l$ \% l0 ^
Design阶段的基本流程:

$ t4 Y: q7 K  f/ P* c- f* B0 X/ _* z# w, Q$ S' {
(1)创建装配(Assembly)

7 Y+ [: f) X2 o
+ {' Z7 c% {# c$ p$ e) c
通过选择可用的系统模版(Platform Template),添加一个新的Platform;

) r" q, \/ F5 Z' A* S7 A6 ^

+ @5 ]% }- v. I; s9 a  H: a
每一个Platform都对应一种应用(如mysql,tomcat,springboot,nginx);
2 n1 U4 [  }6 v2 c4 f0 K' `* _
* l( J; S4 l1 k7 W" {2 K8 w% K" X
在Assembly内,用户可以通过设置Platform Link设置各个Platform之间的关系

4 D9 Z7 d) T) |6 ^( b8 Z
" m# _* I2 Y; Z1 \( P+ O: b9 e
(2)配置系统(Platform)内的组件(Component)的属性值

# I. |& `* A) P# \4 }. q4 n

' S; d- I; c8 k6 s! {3 ^
Component是最底层的部署(或者配置)单元,如springboot中的secgroup, compute, os,jdk, fatjar, lb都是一个组件;

3 g& d$ D/ x' p# {; n

9 R8 E$ {1 g" O3 K
每一个Component都有相应的配置模版

$ J% o: O- z; {) S

" `. D. z. G" e; V+ Q
(3)提交设计
0 P; s8 U5 x3 e% _1 o7 P7 S
% Y& a& `' E3 P+ p
提交的过程是将已经完成的设计做一次Commit,做一次归档。

& Z* N2 }/ k3 Z1 T& \2 T: M) `% H0 }6 P2 H' K" j
& j2 R8 S4 u( K) Z$ ^- C4 @% U" z
2、转换阶段
9 Z6 ?; W, x' {; R- S. a

+ ^+ _( m! z6 W5 f9 G& H
转换(Transition),是在Assembly内对应用/系统在某一Environment内的部署过程。
Transition阶段的基本流程:

# h# y/ z9 I7 B& l5 s; l# L) h9 T  F
& m3 B0 r6 T* i! }7 k
(1)创建部署环境(Deploy Environment)

: n2 l  C9 W* Y+ C% C
3 M% c3 T" m: T" g
根据环境类型(如dev, test, prod等),添加属于某个Assembly的部署环境

, ^4 m) J5 h; e- T, H' }" D' D

9 ^' d$ z- p; e" Y- ?7 k
部署之前,部署环境是应用/系统用于部署的配置的抽象
6 O- A8 ]' C* `) ]8 y' w
+ G( l4 {5 _6 g# H7 ^* _
部署之后,部署环境就是管理和监控应用/系统的具体实例的集合
3 Y% _& V, ^; }8 k; A

& O  s: R3 ^' S5 L: N
(2)配置部署环境

$ q* E- B8 a  b

5 X. G, R# [: d( S( p. I
设置每个Platform关联的资源(vm/container)、部署模式(单点,高可用)

  E: M% q% |7 A
# C1 q% |$ z! i1 V: R# b4 t
(3)选择Assembly内的一个或多个Platform生成并提交执行计划

0 j+ G0 j. \2 i5 S2 A- r

7 T- M. J/ [. r, D: p
根据部署策略不同,一个Platform的执行计划可能包含几个子计划

. [$ \7 u0 o/ c5 |1 }
' K9 W. A, m8 a$ n
(4)执行部署
. ^6 a1 ?  }6 u( \

) _# A' S  j* Q: ^7 y
每个Assembly/Environment/Platform下面的每个Component都有一个instance,这些instance可以进行单独Repair

: L6 @$ R/ K8 [) ~7 ~; j  F
) ?. _" g$ J6 x7 I- c5 Y3 k6 d: X
. V* O1 w" b/ X) P
9 `, W4 a3 k( x! X0 W" X1 c  ]) R* }: W
3、运维阶段
2 s0 v5 F. A* V2 B* m

" M$ C) u) A7 S# U# |
运维(Operation),是在Assembly内对各个部署环境内Instances的管理和监控。
1 L( O1 [$ \5 i
, r; l! V: x" t$ G" D  f$ c0 W6 |
Operation阶段的基本任务:

+ F  X- a2 p! [' Q) s0 U9 _# i- F
, w6 u7 E( f! o# r, B0 n' a3 x* Q
(1)组件实例运维,例如

9 |1 L" V6 l& j7 Y$ P' q. ^
; K$ o. o  X* O5 U$ l3 f, `
Compute: Status, Reboot, upgrade-os-security, powercycel,repair, upgrade-os-all

# s3 n- j& Z2 m) h, M0 n
Tomcat/Jboss: Status, Stop, Start, Restart, Repair, Debug

" x- M) x2 ~8 ^, E/ q
Artifact:Repair, Redeploy, Custom User Attachment
) P* w# h8 r, H# o

# O4 j& J9 c$ }0 r
(2)展现正在部署的操作,有可能还会Replace或Cancel其中一项组件部署或整个部署

% i9 j3 {" Q+ R- X

( T2 O' h/ m7 ]% s
(3)展示Assembly某一Environment下的组件实例图谱

" a" n" N5 o0 ~& H$ o
' X! F% O, @* W/ B' y
(4)日志查询
2 _, N* B) a. d- F& o

/ ^7 B/ ]- P$ v% f5 A
7 z7 [' I7 B: P+ a, H
对基本的概念模型有了基本认识后,我们来看一下自动化部署框架的总体思路。
* ]  f% b  D6 D/ o2 h2 v+ V( g
5 E( n# `- w9 o9 ]1 B  c
3 N; a  s7 d; D0 [$ Y  m& |$ Z, ~
- p; _# m" K( J& q0 c2 f
五、总体思路

  U  J' f' [4 q; J- F
( B) y. W6 h" ~2 g, \4 y9 w/ M
DevOps自动化部署框架采用DevOps平台(设计)+Jenkins(执行)的方式完成。
% V( U$ Y3 m9 _/ ^
8 L, x; Q) G) z8 n, h! J
DevOps的职责

5 _8 G' \# c  W! \$ {( [

7 ?5 _0 @: J/ d* |
完成部署架构设计;

3 D7 B. _. d2 e; T

  i5 O  r- C" T' I8 p* S/ E
根据部署架构设计和部署环境的配置创建生成相应的执行计划及子执行计划,每一个子计划对应一个Jenkins pipeline job配置文件(config.xml);

5 R. v/ c  U& _& F9 b+ v: w

' H) Y# C, g/ B& E# S, e" n
/ t. S2 q4 N6 d
查询Jenkins执行job的实时进度与结果。
& b, J( }' t* G! Z* `
6 C) E3 w3 \$ A: R! _" f
Jenkins的职责

% l  O% @$ E) Y" h

' b. m) l: C- E& n* m. z3 D
根据config.xml创建Jenkins Pipeline Job;
9 p1 O8 I8 Y* ^) J1 E2 w
2 _5 y6 r3 [  w- R3 [/ m" B- t
执行pipeline job;

4 |) M; M* }) `/ z3 @

) \! Z3 X  t4 M* _
& Z7 l4 F' p0 i, X) l/ s
Jenkinsjob 通过pipeline script中ansible/openshift命令进行相应的部署等执行操作;

; ]+ i; j6 E  W2 h+ p
+ p2 \/ H5 v; [' l
提供查询job执行情况的Rest API。
0 \4 r0 h7 s( F/ x
% i% Z+ {9 I+ S9 h4 Y- i

+ Q* a& _! R+ m6 M
结合上面提到的三个阶段,具体的流程如下所示:
1.png
(点击可放大查看)
# D0 v% O% s- P: |+ |, k

+ {% F( ?- R8 q) \2 c
下面是具体的部署视图:
1.png

' s1 {8 I, p% i* b5 b0 J3 a+ S8 ~" U* G
看完整体思路和部署视图,大家肯定会问为什么选择jenkins作为具体的执行引擎?

: w4 ^& Y- m0 R$ a( e& M7 e
- K9 m7 A8 g1 ~# D! |6 \: S: H, \
首先,jenkins支持master/slave架构,能根据性能需求水平扩张,slave又可以支持多种环境,可以将不同的job分配到不同的slave节点。
3 n4 Q+ `  f( P, N, c
& y& S: E: _: V1 m: l& j" {
还有非常重要的一点,就是Jenkins Pipeline的能力。
1 |2 V3 ~- H9 v- D4 |3 \
" _, z1 C1 ^4 p7 Q
Jenkins中pipeline的设计理念是实现基于groovy脚本,灵活,可扩展的工作流。
! U% N" v- I( O; g0 y! q
9 Q+ w9 E, W" f. D) t5 Q, ?. a
durable持久性:在jenkins的master按计划和非计划的重启后,pipeline的job仍然能够工作,不受影响。

1 Z/ F4 v- y( A) w' H- Z
' ?0 Q7 @) ~+ y/ A, z. B* @
可暂停性:pipeline基于groovy可以实现job的暂停和等待用户的输入或批准然后继续执行。

# b6 Z2 W* B  L
0 O1 K% i- Q- ?/ c. K; p
更灵活的并行执行,更强的依赖控制,通过groovy脚本可以实现step,stage间的并行执行,和更复杂的相互依赖关系。

: e- }5 E  b' F- C* t* [" }9 ^
4 n, q! G8 ]/ ?; I, l& i

: |+ l: ^& w! L/ f
可扩展性:通过groovy的编程更容易的扩展插件。
2 w7 D& i' m" s, h0 H1 S/ H  n9 b; C

( t- i& i0 @; S3 t! o
丰富插件:Jenkins已经支持通过groovy命令调it、maven、npm、gradle、shell、junit、sonarqube、ansible、docker、openshift、kubernetes等插件,不需要我们再单独实现集成。
/ b9 p" S: g. E" G, K2 ~9 B7 w+ G+ P

$ A! Q  d/ b  h4 ~5 N+ B
RestAPI:Jenkins提供通过Rest API的方式获取每一个stage的执行情况。

1 r$ q) L, k. p
$ Y; e, K" X4 K7 |0 s7 P# x3 L
由于我们最终会将应用部署到虚拟机和容器云中,虚拟机部署主要通过jenkins中提供的ansible插件+jenkins pipeline script来实现;容器云部署则根据具体的容器云,通过openshift插件(会有一定扩展)或者http request插件+jenkins pipeline script来实现。
5 y) c% `" m2 x

2 K5 R- ]0 g$ _6 ]& @
下面我们来看一下Jenkins2的主要概念。

" l! |# t$ B9 U- J3 y4 U& B  L& O) l/ `
step, 其实跟jenkins1中的概念一样, 是jenkins里job中的最小单位,可以认为是一个脚本的调用和一个插件的调用。比如通过git拉取代码就是一个step,mvn clean package也是一个step,一个http远程调用等等。  
: p5 F- V5 C$ S3 [1 n! l7 }
# g( N6 B5 c( S
node, 是pipleline里groovy的一个概念,node可以给定参数用来选择agent,node里的steps将会运行在node选择的agent上。这里与jenkins1的区别是,一个 job里可以有多个node,将job的steps按照需求运行在不同的机器上。例如一个job里有好几个测试集合需要同时运行在不同的机器上。  
6 F2 X- H7 I4 H+ F( c% K! K8 t' a
) u* R# \8 Q% p" _5 M

# l# s" r0 e7 r7 S7 z' Z. g
stage, 是pipeline里groovy里引入的一个虚拟的概念,是一些step的集合,通过stage我们可以将job的所有steps划分为不同的stage,使得整个job像管道一样更容易维护。pipleline还有针对stage改进过的view,使得监控更清楚。这里补充一句,多个stage可以在一个node里定义及执行,一个stage内的多个step可以分到不同的node上执行。
* |/ U0 T  ]# B9 N) P- M/ @
% `7 X, ^" O7 E+ Z% O" @

  m( Z1 v; c1 \6 q  V# T9 ^) j; p: B' K& S* w9 O( t# V
; k9 A6 O2 \8 \2 f
六、关键点设计

0 c2 S$ f' a! E6 D) z9 ~/ s

: y3 ?- `0 {( w# Z5 O3 B0 m
前面我们说的都是概念和流程上的东西,那么用户该如何进行部署架构设计?部署架构设计完成后,如何提交呢? 如何将提交的设计在具体的部署环境中转换成执行计划与子执行计划呢?子计划又如何与jenkins pipeline job映射呢?这就是我们下面要介绍的一些关键点设计。

+ K8 N; ]- z: x& [8 X6 @9 r7 n6 r3 V
, z4 E) r; b9 b' `
1、模块化
1.png

* G& C# Q2 ~4 H2 P* R& ]
前面提到,当用户创建Platform时,我们的DevOps平台提供可选的Platform Template,Platform Template定义了其中可以包含的组件类型(Component Template)等信息。也就是说,我们的平台提供了一种基于最佳实践的方式,帮助用户完成系统的架构设计。不仅如此,通过对Platform Template/Component Template等相关数据准备的介绍,也对以后用户扩展添加新的组件类型,提供了充足依据。基本思路如下:

  ?; |+ B& r% a- `% z8 N0 L3 {4 U
  n7 K# T+ C: Y$ R( j6 }

& \5 n( [9 a( n0 o# e, a% F8 l8 @
1)定义不同的系统模版Platform Template(见表DPS_DLV_PLATFORM_TEMPLATE)。系统模版就是我们通过最佳实践的方式提供了一套应用/中间件系统的模版。如tomcat,nginx、springboot、mysql等。
4 E5 M+ n2 [. M. \5 ?5 @7 z, T
- O: I3 y5 v, O9 t  H" T5 W
一个Platform Template定义了这个模版中包含的组件模版,定义了组件模版之间的依赖关系(见
+ [- h, h- J/ ?2 B; U

. p# h3 B. I* |  Z, f/ e* G) r
表DPS_DLV_COM_RELATION_DEFINITION),以及每一种组件类型所在的层以及每一种组件类型允许添加的组件的个数(见

; k: D* t+ c" z$ S

  {3 V' A+ W' A+ }! c' Z7 `
表DPS_DLV_COMP_CONTAINER_DEFINITION)。当用户添加一个Platform时,必须要选择一种Platform Template。
; m! f6 Z+ F8 |. j: ~2 Y

4 c2 }" M4 {1 N, s
2)根据不同的部署模式(单节点、高可用)、不同的目标资源(虚拟机、容器)、不同的部署策略(全新、蓝绿、滚动升级、回滚),一个系统模版会对应到多个执行计划模版 (见表DPS_DLV_PLATFORM_ACTION_PLAN_TEMPLATE)。
! a: {; [; Q& g

" V  c0 v+ w! Y
3)一个系统由多个组件组成,因此系统模版和组件模版之间也是多对多的关系。例如springboot模版对应的组件模版有:secgroup模版、os模版、jdk模版、java application模版等等。
+ G0 t+ l; N' \- y0 ^; y! I$ P
" F, {. K$ |. X9 A  X, _3 Y3 |
组件模版Component Template(见表DPS_DLV_COMP_TEMPLATE)以及组件的所有属性(见表DPS_DLV_COMP_ATTRIBUTE_DEFINITION)。组件模版就是组件的元数据,为Platform添加的Component都是源于Component Template。
% P' [+ X1 g; |3 j: v% p
% G2 |( |' j3 S; b4 @1 O8 O$ s* l
4)为每个Component Template定义Operation模版(见表DPS_DLV_COMP_OPERATION),以便对单个组件实例进行操作,如restart, repair, stop等。  
& a/ k9 Z# a# z# ^- n, `* ?3 {

6 Z/ S( }% E1 N3 Z/ o& m
通过以上4步系统预置的Platform Template和Component Template以及相应的数据,就可以提供给用户添加一个Platform了。这些预置数据也为后面生成部署计划Deploy Plan做好的准备。

8 I( N; J8 J+ d" e( @& q
! f* E- B7 l9 D( c9 E1 a
2、变量管理
# n5 V' P: P  F  b8 H$ b

3 }1 O# J; a; S% `& I0 D0 \3 k
在需求分析中,我们就提出希望一次设计多次部署。但是在设计阶段设置各个组件属性时,并不能确定在不同的部署环境中其值是一致的,并且一个系统的不同组件的属性也可能是共用一个值。这时候我们就需要引入变量管理。变量管理的主要思路如下:
0 u+ I0 D9 d9 ~0 w) N& d# i8 {1 I& z
& F, g% j6 ?7 C" |
1)设计阶段,为系统定义一些变量(ConfigMeta)并设置一个默认值,如install_dir。然后在设置某个组件属性值时可以用@P{install_dir}来表示。

+ t* D4 _' f* }1 @, A4 |) X- x0 O# h# W9 l2 _3 o; W9 ?
2)提交设计时,也一同将变量定义作为设计的一部分进行提交。
) Q: f5 `' s1 K# C. G
+ V% w9 D; Z) L3 \& }2 s- m
7 g# j% i) H/ i  c$ C5 k
3)转换阶段,在部署环境中,为每一个变量设置当前环境下的值(ConfigValue)。当创建执行计划时,会将属性@P{install_dir}替换为当前环境的值。

* O2 i9 H# h& s4 }+ b

; I' K7 B' R; E4 @- x9 f. v& W) m9 Q9 j. L5 j4 ?$ ]; O
不仅Platform内可以定义变量供该Platform下的Component使用,我们也可以给Assembly定义变量供所有Platform及其组件使用, 形如@A{assembly_var}。
3 `& D1 B% u& P3 {+ L
6 e3 D4 K0 f' n$ i+ f
3、设计提交
& n/ L9 @/ }8 a2 E
1.png

6 E6 c" n8 L+ ]
(点击可放大查看)
当用户设计完部署架构、设置每个组件属性及变量后,需要将当前的设计指定好版本进行提交,即归档。只有提交的设计,才能在部署环境中获取的到指定的版本。通过版本化,我们可以设计的不同版本做相关的对比。

  X! {" x. W3 }: _2 t% E
; i0 F9 l$ C1 P
. {  n( s  t) s, L) R# ~
上面的表结构是比较清晰的表述。
' B% n1 R8 O4 ~/ [
' ^4 U7 o$ s8 _
$ Y% c! c3 f- [  h) k/ M
4、执行计划
, ^* y( M+ R3 @/ H! B
$ {8 m1 ~6 b6 Q+ i
a.                  根据不同的部署模式(单节点、高可用)、不同的目标资源(虚拟机、容器)、不同的部署策略(全新、蓝绿、滚动升级、回滚),一个系统模版会对应到多个执行计划模版,并且计划模版之间有父子关系。
3 r- ]: a7 H* Q3 t6 U# D
: \- L5 Z1 W6 B
b.                  每一个子执行模版就是一个jenkins pipeline script模版。

+ H* I  U  ~& L/ Q% O; Q* V5 a, H3 y
+ B3 }6 U0 B4 J7 N
c.                  当用户在部署环境中选择某个具体系统及部署策略生成相应的执行计划(含子计划)时,每一个子计划的jenkins pipeline script就是将具体的组件属性注入到执行模版中生成的。
8 C* w% l" [4 ?- b; k5 v
" p, _' ^* T+ o1 D
另外,为什么需要显示的创建出子计划呢?例如,对于一个高可用的应用,除了要部署具体的应用,还需要更新load balance配置,而这两者之间可能需要加入一些人工活动。所以我们通过显示的创建处子计划,支持用户按子计划一步步的来做。
% e1 B" \8 M* g4 o: Q1 T( r$ u! r' i
- Z# V1 j& U. o: _) F) O+ S' l0 v; s% @
而jenkins pipeline script的stage几乎都对应到一个具体的组件,具体可以看下图。

4 `3 V# s0 i! c
1.png
(点击可放大查看)

5 u3 Y. S2 S" m% I
5、部署策略

9 v5 {9 p& \+ T
- ~. k3 [8 E/ r
前面我们提到了“部署策略”这个词,除了全新部署,我们常见的部署策略有蓝绿发布、滚动升级、灰度发布/金丝雀发布、回滚。下面来看看我们的相应解决方案。每一种部署策略都会有相应的执行计划模版(含子计划)。
+ J0 X! N( L) D0 a) h& a9 q

5 J; l; j' ~8 x( P* `3 T6 K6 [
蓝绿发布
& k  l7 m. ]: d4 ^. \4 Z
& \( C6 Q* Y8 O: R4 w! x8 j
* _* _0 y: x. f. Q
什么是蓝绿发布?

3 O7 x, R4 ^8 z% H7 r$ D" s+ r

0 R6 o1 ^- ~. K
在发布的过程中用户无感知服务的重启,通常情况下是通过新旧版本并存的方式实现,也就是说在发布的流程中,新的版本和旧的版本是相互热备的,通过切换路由权重的方式(非0即100)实现不同的应用的上线或者下线。
8 Y9 r0 I: c7 Q6 b" t/ Z

7 j/ Y0 Y0 x& V$ y
前提条件

0 {$ \+ E$ p$ z; Z' B8 h- r4 S
$ `% H0 F4 \: w" @" {
双份资源 or 支持双端口模式

. \1 O% _- h& |5 [$ C! X; `) R

( a- I5 ]3 y& z  g
负载均衡服务 + 操作API接口

# c9 Z% L. H/ D" w
, G% q% `3 q! z) ^  G! B
实施方案
2 t0 o: a$ ?- J. D4 d

- M! S; z( x% j5 S, r
第一步,设置系统将要部署的资源列表。

0 |% F1 ]" f, t

* x8 y/ P* M# L
第二步,将新版本部署容器部署到资源列表中。

! I* d" c( u' B" H
: r' @& y5 s( W6 }9 O4 _/ E7 m
第三步,调用负载均衡服务的API接口更新负责均衡配置。
! U7 ]- [  i6 }; g% j& z
第四步,更新资源的标签。
# s5 o$ B' V, E1 Z+ ^2 q( I( Y

; a3 ^1 X8 [- n  i& ~
考虑到用户可能会手工介入确定是否需要更新负载配置,我们会将第二步、第三步分为两个子执行计划。
1 d0 a- W  _% l6 M8 `
9 O1 n$ p+ J8 N
滚动升级

8 e' z% D3 l( J8 _, d

' r1 T/ R! R6 k* _4 k1 W( h
/ ?% S% @# h9 M! g" S3 \
什么是滚动升级?
. O: W' `% J. L
  t9 _$ O1 N3 q7 k2 p7 m% |
: A( w2 x' [0 @1 T' D
滚动发布,一般是取出一个或者多个服务器停止服务,执行更新,并重新将其投入使用。周而复始,直到集群中所有的实例都更新成新版本。
9 i" s2 O" W$ O& t4 v+ r4 W$ l5 Y
这种部署方式相对于蓝绿部署,更加节约资源——它不需要运行两个集群、两倍的实例数。我们可以部分部署,例如每次只取出集群的20%进行升级。
$ r4 Y1 l: S9 R+ `
! A% o+ z! V( |6 d1 L9 ~
- W' K; j7 w. K6 y8 g3 }
前提条件

1 o$ @7 ^9 R; T0 @" ]3 `8 l4 ?

) O, D/ N+ q0 K
负载均衡服务 + 操作API 接口

) T! |5 M2 R( F0 H
# X! q- \  X7 P9 k2 ^3 Q7 J; g4 V
实施方案
5 J) }3 S% F2 k1 V9 d& N2 s
: G% v) X4 V' I& R1 e
7 X8 O5 ^0 N8 i7 {! N
第一步,设置滚动升级系数(步进),如20%/n个。

0 [/ m' ?( H2 W6 {
8 e6 R% `: Z8 F2 F% g

/ @. @# h6 L1 i
第二步,依次将20%的部署容器移除负载,然后在原资源处部署新版本,然后加入负载。
! U! K* g. b; q* o* Q9 h* @
  S& u0 S# Z5 F( E- Q' u( Q
灰度发布/金丝雀发布
* A# Q8 {+ a5 S2 d0 z. |1 |: A

% ]* [, I) |2 q2 a) y9 k- g
什么是灰度发布/金丝雀发布?
5 l" ^; a4 t' l! d' q- {3 s  a

9 [8 a+ e' Y7 @9 A4 b& g' `
6 g6 A, {1 F$ x
灰度发布是增量发布的一种类型,它的执行方式是在原有软件生产版本可用的情况下,同时部署一个新的版本。同时运行同一个软件产品的多个版本。

' B* ]3 C% w" _+ D: T

& X- C3 y" \$ p( s
% j9 B8 \' x1 Z7 K( k( ~7 {' ?% g- d
其实,灰度发布是滚动升级的一种变体,其实灰度发布是先划分出新版本的路由权重,新版本在真实数据验证通过后,在进行剩余老版本的升级。
& l( d9 K% P6 B- d

3 c, U+ I% c3 A" q) [9 F* C2 `. D7 s
前提条件
4 l! Q3 l% e" M

% \1 c7 I2 A0 M, A2 A( }
- o! Y2 _" I1 L
负载均衡服务 + 操作API 接口
$ F1 d2 c3 m0 D6 `7 w0 C
: B- j. j0 V/ ^( @* m! @" |

6 ^$ W( ]+ V; x& Y
实施方案
* t: p2 M9 K* g4 V9 \0 e( Q$ |
. ?1 `4 y( l1 h7 W+ w1 R

, b% a# J+ f+ o5 u. ^" R0 r# m# z  Z
第一步,设置新老版本的路由权重,如90%的用户维持使用老版本,10%的用户使用新版本。
  j" s( k( M5 Y1 A: ?& C

! {$ K) ^# ?! R0 _5 }! d3 x) A0 f& B7 C. ^( d! g0 a
第二步,将10%的部署容器移除负载,然后在原资源处部署新版本,然后加入负载。

+ b4 }: Z7 p3 o$ n, S

7 J8 W2 X; {( R6 t9 r* \7 t/ y2 a+ {$ o) N7 }
第三步,待真实数据验证通过后,再进行剩余老版本的滚动升级。
: C) `# T9 J) \( M7 ~( l

/ T2 J2 R% h2 `  e* Z# K1 n$ Z/ G
+ n' S/ k) m. d! G' i
回滚
) t: y3 w6 G. ]

" Z. S+ \5 `6 ?  p" C8 Y7 J$ i( [/ Z
什么是回滚?
& k. E! J* b$ y  t3 j+ {- B
8 \( a5 \: r, @& b# F

5 ]" f, G' A7 B) Y' g; ~  C
回滚是指将应用/服务回退到上一可用版本,并使之可用。

* H7 e" W0 j# I/ |3 ^$ U; \

, p: o' u/ q& V6 k* u" G( g' @
& W% C; Q  k: _0 c% U
我们暂时只支持针对蓝绿发布的回滚。

6 g. c8 s$ Q5 q
5 P/ g) T& ?4 X# \" V0 i  x
前提条件
3 k9 m4 I+ H0 p. T1 h" U3 M  S

; c$ z) z5 o/ y8 B) ?
新版本是基于蓝绿发布策略完成的部署。
8 E0 H5 e) n$ t. u
2 G2 t: |7 f) I+ `# I# w+ J

% B* E! U3 n6 z
负载均衡服务+操作API接口。

+ e: V. g: I9 W6 [

* p+ [2 g4 o" {1 F3 R6 S6 c& b8 O( Y2 o( p: M
实施方案

" h& r$ q8 L/ x' O% j4 F% }1 H, w; O% T! f9 Y# x' w
更新负载配置
, ~2 h, k, \" d; k: V+ y
9 W: `! p2 a* I3 P6 Z* o
+ [( L+ T8 b8 `' A/ _, Y8 @

$ [! @2 ~( y8 d  R
七、总结

: R5 S; i3 K4 j
( H* N: T+ G& w% L" ]
本文大致向大家介绍了我们的DevOps平台中自动化部署框架的相关设计,主要简单介绍了实现思路和几个关键点。 其中还有很多细节,比如如何与CMDB集成,如何与各种容器云集成,以及我们实践过程中遇到的各种坑等等,这里不再一一赘述。

# Y( |# y! G5 W  I& H- H3 `( R( C" i. R
5 L; V( Q' m+ b3 F8 E5 @
关于作者:许二虎 EAII-企业架构创新研究院 专家委员

8 }. I' P/ f: \. _% S& @

0 |. ]# t$ G8 Y5 a% a+ N

本版积分规则

选择云运维时代的王牌讲师-长河老师,助你轻松入门ITIL Foundation培训课程

QQ|小黑屋|手机版|Archiver|艾拓先锋网 ( 粤ICP备11099876号-1|网站地图

Baidu

GMT+8, 2019-1-23 22:15 , Processed in 0.270750 second(s), 31 queries .

Powered by Discuz! X3.2

© 2001-2013 Comsenz Inc.

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