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

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

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

扫描二维码登录本站

QQ登录

只需一步,快速开始

搜索
查看: 632|回复: 0

云原生关于DevOps、容器和编排、微服务和安全的一些思考

[复制链接]
发表于 2018-11-14 09:47:46 | 显示全部楼层 |阅读模式
本帖最后由 adminlily 于 2018-11-14 09:55 编辑 # S' b% Q% p7 ^2 H

# x1 G" h5 @9 a/ ^7 S) b/ P3 F4 y6 D6 _' b! j% `" e4 H& F

' ~( h8 u8 A5 H4 {
第一部分:定义
  L5 N6 C& J3 |9 p, `/ L
% ]4 i) Q$ B, J' `& N
在Craig和我开始打造Heptio的时候,我们做了不少关于我们行业发展方向的思考。我们在Google里呆了很久的时间(两个人加起来的日子有16年了),对于Google构建和管理系统的方式有很深入的理解。但是很可能你没有在Google任职的经历。那么对于一个普通的公司、开发或者运维人员,应该如何理解并应用这些不断演变的新概念呢?, n1 {2 P, ?- u- e
& q, ~7 n' n7 b" D+ W8 w' j) q
0 f. d4 Z7 z2 G) s
云原生意味着什么,并没有一个固定或死板的定义。实际上,还有一些与之重叠的概念和思想。但在它云原生的核心,是对团队、文化和技术的精心组织,利用自动化和架构的力量来掌控复杂度,突破速度的束缚。在这种模式下的运作,不但是一种技术的扩张方式,更是一种人力的扩张方式。
& m/ \- x% y1 X: ?8 d6 ^) b- t5 w8 ^* Q) W4 y+ A
  {! t4 _) O. k6 j8 g
很重要的一点是,不一定要在云环境中运行才能叫“云原生”。这其中的技术可以在恰当的时候叠加地采用,并且帮助向云过渡的过程变得顺畅。
, y- b/ w, i  X) e- w5 H( t- n. {  T. L; ]$ h- \

0 |( J: D8 g! g+ q1 ]0 e  w云原生的真正价值所在远不止与之密切相关的一篮子技术。要真正的理解行业的动向,我们需要思考我们能从哪些地方用什么途径让公司、团队和个人更加成功。# k) h4 t* t8 ^7 _5 `: M$ U

# s* r9 P2 V7 x; F6 c
2 k- ]  a5 ]1 T* G0 Q. @+ Y5 q目前,这些技术已经被那些以技术为中心且眼光高远的公司验证,它们为此做出了努力并投入了大量的资源。想想Google、Netflix或者Facebook。同样也有规模更小,灵活性更高的公司实现了价值。然而,除在这些技术的早期采用者之外,这套哲学理念却少见有利用。 当把目光投射到整个IT领域,我们仍然在这条旅程起点不远的地方。3 t; p( e; T5 X+ d- l) J
/ M. `' L3 c/ v' N( N' i
; w  `: z/ `/ i
随着早期的经验不断被验证和分享,如今都有哪些涌现的主题呢?( H+ V. \; {+ H+ w6 f

" T/ G3 I+ L* u9 J: h* E3 x$ b
5 b! [, f6 e" n8 n
  • 更有效率和更开心的团队。云原生的工具让大的问题切分成小的问题,便于分工让更专注和更敏捷的团队来解决。

    + t* o9 y  ]% F/ ?3 C4 O% R
' }: C2 k6 Q' q9 k9 [
, [# u, Y8 V( z( |3 y. t$ u( h% N9 R
  • 减少枯燥重复的劳动,通过将很多人工操作自动化,也避免了因为手工操作引发的运维上痛苦和停机时间。这一般是通过自愈合的自管理基础设施达成。更多的事情被期望用系统来解决。

    ' r+ f. i! {6 ?7 g0 e- x* e

2 W$ v  {; v  f1 n
  • 更可靠的基础设施和应用。构建用来处理一些可预见的故障的自动化流程,通常对不可预见的事件和故障是更好的失效模式。举个例子,如果部署开发的应用只需要一个命令或者点击一下按钮,那在灾难恢复的场景下(通过或手动或自动的方式)进行自动化部署也更加的容易。

    3 g- @1 Y% a- }# P# s8 u
& Z$ t2 r3 F5 o& T  S
6 ]+ r# E$ L+ B& ]) A2 I
  • 可审计,可察视,可调试。复杂的系统会变的非常晦涩难懂。云原生使用的工具,通常能让人对应用内部发生的事情有清楚的了解。

    ! i' ], V+ e  v8 m+ x% i+ l- y
; G* W8 K- r$ i: \( |# t

+ U1 c" r  |* |" V4 _" M( m
  • 深度的安全性。如今很多IT系统的外壳都很坚固,但内在都很脆弱。现代的系统默认情况下应该有安全防护,采取最小信任(least trust)策略。云原生让应用开发者能在应用安全方面扮演重要的角色。

    3 f; G$ j2 u) ^" ^* M! N
& B8 b% R* f% y6 D9 F
  • 资源的更高效的利用。应用和服务的自动化式的、类云环境的部署及管理方式,开启了采用各种算法的自动化的机遇。比如,一个集群调度器/编排器可以自动完成工作负载的安放,而不需要运维团队用类似excel的方式进行管理。
    , O, g* O2 d3 t% }7 L7 a+ X# c7 S
, Y" O* \! P% R  i2 f
在Heptio,我们特别兴奋我们能帮助把云原生的恩惠带到更广阔的IT领域。在接下来的部分,我们将讨论与已有的系统进行整合,DevOps,容器和编排,微服务和安全。9 O6 p& J- l: k9 ~; R9 c# I
2 X: w, d' {3 l

0 s" h8 W4 r- {  j2 w5 n- h# n) s
第二部分:实践
7 g! J$ N5 @; D* d/ _1 `

- e# Q4 c' C& }8 t# y5 Q" v
与任何正在经历变革的领域一样,云原生世界中有繁杂的概念。上一个部分列举的概念,不是每人个人都清楚应该如何恰当地利用。同时,很多关键的项目,要么太庞大,要么太重要,不适合重头重写。因此,我们觉得最好把这些新的结构用在新的项目或者老项目的新部件中。在系统老的部件得到了改善后,然后再花时间合理地学习并采用其他新技术。寻找把新的特性或者系统分解成微服务的方式。% s: J  F- x6 n) N: L

: g- {) o! H- T1 L9 ], f. c1 m# i$ E# Q7 j$ X$ P; s
没有硬性的规则。每一个机构都是不同的。软件开发的实践必须要根据身边的团队和项目来做出调整。理想不同于现实。有的项目经得起实验折腾,但是很多非常重要的项目应该采取更加谨慎的态度。还有一些场景是介于两者之间的,一些技术即使已经被验证过,但仍需要规范化并且经过大规模的测试,之后才能应用到核心系统上。
% S; M+ V+ Z1 l; `' n6 `. R/ G
5 P) d; `4 X9 l) `8 v4 S3 U
云原生的定义中离不开的更好的工具和系统。没有这些工具链,每一个新部署在生产环境的服务都会有很高的运维成本。监控,跟踪,配置等等都增加了一个处理的负担。这个额外的开销是对微服务大小的切分应该合理的主要原因之一。开发团队的速率和在生产环境中运行更多(服务)的成本,这两者的利弊需要权衡。类似的,新的技术和语言引入,尽管可能新鲜刺激,也必须仔细考虑其风险和代价。关于这个话题,Charity Majors有一个非常好的演讲。9 w) m8 Q0 v% N4 K* S* ~
, g$ ~  _& s2 @7 {) S8 a* |2 S

5 }# m0 }3 y: j要降低构建和运行新服务中的运维成本,自动化是关键。像Kubernetes、容器、CI/CD、监控等等这样的系统,都有一个相同的重要目标 - 让应用开发和运维团队的效率更高行动更快,让打造的产品更可靠。
" O7 y$ P8 ^. ^! x& d7 M7 C1 r* a+ I6 c6 o0 E  D
9 y5 [) Q1 ^" _5 o/ b4 G2 z
要达到云原生的愿景,最好使用新一代的工具和系统,而不是传统的配置管理工具,因为它们有助于分解问题然后分工给不同的团队处理。通常来讲,新的工具通常能让独立的开发和运维团队拥有自主权,然后通过自服务(self service IT)提高生产力。
) [" C" C) i: n" C& i. S, b
/ b5 \$ P6 Y6 g. }# \
, _- I6 g3 Z, P7 P8 B8 F# o3 w) g5 P
第三部分:DevOps
9 j  l2 J; N, J! v6 {

; s8 ]( H+ n( B$ ~; p7 Z' F
不妨将DevOps看成一种文化的转型,开发者现在需要关心他们的应用是怎样在生产环境中运行的。而运维也对应用的运作机制有了认识并且授予了知情权,从而可以在帮助打造可靠应用方面发挥重要作用。增进这些团队之间的理解和建立同理心是关键。. Q) i% ^) R. k. x% I4 _
6 H1 ]3 l2 x1 s) [
% P7 X* b7 M9 x1 N  T
但是可以更进一步。如果我们重新思考我们的应用的构建过程和运维团队的结构组成,我们能进一步加深这种关系。
" G/ B6 [* V* \" _% I5 w! s
" Z" N) N/ A1 U2 f
# F- T$ u; `, X" m$ }Google没有传统意义的运维团队。相反,Google定义了一种新的叫做SRE(Site Reliability Engineer,网站可靠性工程师)的工程师。他们是技能扎实的工程师(报酬同其他的工程师处同一个水平)他们不但随时保持在线,同时得到授权并被赋予通过自动化来在推动应用变得更加稳固方面扮演至关重要角色的重望。
8 C0 |& R4 ]+ F4 e1 L" F3 D' b; X% |9 h1 |9 i3 f$ {, O
" q& l7 `- Y: m
当在凌晨两点报警触发的时候,任何响应该报警的人都会做同一件事情 - 努力弄清出了什么问题,好早点回去继续睡觉。真正定义一个SRE的地方是第二天早上10点钟发生的事情。运维组的人是否只会抱怨,还是会和开发团队一起协作保证同样的报警不会再次出现?在让应用变得尽可能稳定可靠方面,SRE和开发团队有一样追求。结合不追责的的事后剖析,可以保持项目的健康,不让技术债务堆积。2 ^( K' N; |5 D% f+ U/ Z
0 o4 `5 p: H5 }2 f* B$ f
$ y4 _# J4 _: y& D6 H. o
SRE在Google是最被看重的人群之一。在实际中,很多项目在没有SRE参与启动的时候,开发团队肩负了让他们的产品在生产环境中运行起来的期望。引入SRE团队的流程,通常需要开发团队向SRE团队证明他们的产品已经准备到位。开发团队需要已经做好了所有的准备工作,包括设置好监控和报警,报警的应对策略和发布流程。开发团队要能显示出报警的情况已经达到了最少的程度,并且绝大多数的问题已经被自动化了。
/ h9 @% v* k' _
/ ~5 T* a  ]' q4 x& [3 r5 v* ~  Z8 }1 Y/ E/ s# u; ]0 _
随着运维的角色参与程度更深,与特定的应用相关度更高,让一个运维团队掌控整个运维栈变得不合理。这引出运维规范

) b0 H* l4 o: _: N: ^3 f
(Operations Specialization)的问题。从某种意义来说这是一种“反DevOps(anti-devops)”的做法。让我们来自下而上的看:
, L7 |% n4 ~: Y6 Z7 U8 p
1 a& p' t0 ~5 F

1 F3 _* n: r6 H4 N) K' L- u
  • 硬件运维。这一层很显然可以分离出来。实际上,很容易把云IaaS看成是“硬件运营即服务(Hardware Ops as a Service)”。
    : v* }& r3 L9 X

- r; f; u2 m3 k/ b3 ^$ w' }5 |# J
4 O$ F( g' v; x/ Z5 {
  • 操作系统运维。必须有人保证机器能够顺利启动,并且有一个好的内核。将这一部分从应用的依赖管理中分离出来也反映出了用来托管容器的操作系统发行版(CoreOS, Red Hat Project Atomic, Ubuntu Snappy, Rancher OS, VMWare Photon, Google Container Optimized OS)的最小化趋势。

    & Y0 `, T0 r/ t5 c' K  ?2 n
$ Q6 N. Q& _# O* b  k. W
  • 集群运维。在容器化的世界中,一个计算的集群变成了一个逻辑上的基础设施平台。集群系统(Kubernetes)提供了一组原语能让很多传统的运维任务自服务化。
    8 ?* w+ p/ d( ]# K' f

0 p6 n4 s% b4 x
  • 应用运维。每一个应用现在可以根据需要拥有一个专门的应用团队。若有必要,开发团队有能力并且应该担任起这个角色。这种运维团队应该更深入应用,因为他们不需要在其他的层次上专研太深。比如,在Google,AdWords的前端SRE团队会和AdWords Frontend的开发团队交流很多,超过他们与集群团队之间的交流。这能带来更好的成果。

    . J0 d/ ~/ J9 m' Y: z
4 B4 m& v: g* I  a$ ~
很可能还有其他专业性的SRE团队的空间。例如,存储服务可能会划分成单独的服务,或者根据某种政策,可能有团队来负责验证所有团队使用的基础容器镜像。
1 D( ~+ }) ?7 c6 n$ h+ K  Z9 x: k# K) Z
; k) A, M6 _  b# }
第四部分:容器和集群
) c0 V: q9 d9 x) B
7 i5 G2 Q4 R, `  P; I7 ?1 K
有很多人对于容器相关技术兴奋不已。了解为什么大家如此兴奋的的根本原因是有益处的。在我看来,有三个原因:
7 R! i5 i% |8 m# l

9 ^% l: k4 `1 ~3 {- v
3 e* f8 D( \8 x! f& h
1.打包和移植性& b) F3 }+ k; I" o' B+ t$ L5 B* B

' S# x7 d9 r$ x' P9 f/ R0 c( Q: k% s! f8 F! g
2.效率  b" ^* m  n* z  N9 {
3 E/ y. {% e8 N2 R& `' j+ r' C

# N9 y+ M+ o6 O" f$ ^( M. J5 W7 ]2 @3.安全性
: K/ Z3 E9 L4 `

: y! y: c$ y# t7 K6 X

% T. c7 X4 V0 i, A2 H0 O+ B# P- J7 o* T+ b让我们依次地来看。
3 f; x. ^7 s5 G8 d  F  S5 T
8 s, x* i  k, s' S; y# b$ z! g/ s9 {. H0 l% l
首先,容器提供了一种打包机制。这能让系统的构建从这部署流程中分离开来。另外,构建的成品和镜像比传统的方式如虚拟机移植性更好。最后,部署变得更加的原子化。传统的配置管理系统(Puppet,Chef,Salt,Ansible)很容易让系统处于一种配置不完整的、很难调试的状态。也很容易有版本不可知的、不易被发现,存在机器中,而。7 U1 Q! T9 ^/ C+ K) d$ q& H& d

8 E( |8 I; B8 L* @( D. T, d! L2 X& Z. d5 O' n7 D; G
第二,容器更轻量化,使得资源利用率增加。这是当Google引入cgroups(容器底层的主要核心技术之一)时的一个主要原因。通过共享一个内核,并且允许更流体化的过量使用(fluid overcommit),容器更容易让系统资源每一部分都不浪费(“use every part of the cow”)。随着时间的推移,有望看到更加复杂的用来均衡单个主机上共存容器需求的方式,杜绝吵闹邻居问题。
4 N9 x! ~# ?0 A* k6 F+ b6 h( k& m& S1 E5 q  R/ U
, S, E0 \/ M% a  ~* s1 f. f
最后,很多用户把容器看做是一个安全性界限。尽管容器可以比一个简单的Unix进程更安全,当把它们看做是一个硬的安全性边界的时候还是要注意。Linux命名空间提供的安全保证对于那些运行半信任工作量的“软”多租户环境来说合适,但对于那些运行充满敌意的工作量的硬多租户环境却不适用。: K/ k( Z1 x  H, m2 A' U0 f

( ]# p6 ^' ~0 n* O* s' K# [% y% L! y1 G0 ?
有从很多方面的努力来在模糊容器和虚拟机的界限。一些早期研究如unikernel很有意思,但是很多年内尚不能应用于生产。
  F3 }5 ^0 |- p! z& e, Y( E; z( x5 I' |: g- s% s5 m

/ u! j: z7 g) k/ \3 U, y% B要达到上述目标,容器尽管是一条简单的途径,但却不是必要的途径。例如,Netflix,传统以来一直运行一个非常现代化的技术栈,它们以类似使用容器的方式,来打包并使用虚拟机镜像。
. Y) F1 `* V+ J% o2 i6 }5 M& l  G6 ]! x% P! c- \/ @: z

# J* p3 ]9 r! W% T7 q2 X0 R尽管绝大多数围绕着容器的努力集中于在单个节点上管理软件,使之更加可靠和可预测,这个改革的下一步集中于集群(通常也被称作编排器)。给定一批节点然后把他们和自动化系统绑定起来,为开发和运维团队提供了一组逻辑基础设施的自服务。
, f: {. b* L7 f0 L  D0 F8 K) [* g: o1 h  R
1 g8 q! e5 l) S! W* o! ]. g) B* M
集群能帮助消除运维中枯燥乏味。有了容器集群我们让计算机来接管工作,决定负载应该由哪台机器来处理。集群也会默默的在硬件失效的时候修复问题,而不是需要去通知某人。+ Z! d# B- X5 t; Y
* m* B8 k$ G$ K8 c' w
( U& U+ E( s% X
集群的第一个好处就是它启用了运维的规范(见第三部分)可以让应用运维作为一个单独的学科来努力。通过定义个以良好的集群接口,应用开发者们能集中于解决应用自身的一些问题。* d, o# s( v0 k3 a: D
! ]4 P6 c5 Q! C% B! G; h4 M
! s: v: u/ J* M) s
集群的第二个好处是它让启动并管理更多的服务成为可能。从而允许使用能为开发团队高速率的架构(通过下一部分介绍的微服务)。
; A7 A; z  ^1 B) o- z! e# j& |' Y
( _. E# o/ `6 Q

" r6 D: g/ B/ v2 P, T0 `1 }! V8 z
第五部分:微服务
: r5 H+ Y( o9 ]1 Z" c
  I% }, ~' f, z& T
微服务是一个已经存在很久的概念的一个新名称。基本上,它是一种将一个大的应用进行切分的方法,使得他们能独立地进行开发和管理。让我们看看此处相关的关键概念:
! q/ K6 n' a: a5 e' M- c6 P

8 l1 Z$ f1 x+ o( ]. h* X/ z

& q- x2 u) W7 I/ m8 J
  • 强大和清晰的接口。服务之间的紧耦合必须避免。配套了清晰文档和有版本管理的接口有助于强化这种协定,对于这些服务的消费者和生产者同时又都能保有一定的自由度。

    0 w! t$ J' c) b1 _
- J/ N" X# a- O' d/ c/ _0 B

, F5 t0 _2 v3 |* ^* X% z  n
  • 独立的部署和管理。微服务应该能够单个更新,无需和其他的服务一起同步进行。同时,大家也都很希望能够轻松地回滚一个微服务的版本。这意味着部署的二进制文件必须在API上和任何数据格式方面保持向前和向后兼容。这可以作为检验运维和开发团队之间的合作和沟通程度的试金石。

    % x: N: p+ ]) e: T6 W5 b+ p
" B# H( `" n5 p( x. Y: X" K: ^
  • 由内打造的耐受性。微服务应该构建成为并经测试验证有独立的耐受性的。在消费的服务不可用或者异常的时候,那些消费一个服务的代码应该要努力保持正常工作并且做出合理响应。同样的,那些提供的服务应该对于未曾预料的负载和异常输入做好防护。
    + M3 ]% w# G! e( S3 k' i* U

/ N' j  C0 D* `2 ]9 o确定微服务的大小是一个很难做对的事情。我的意见是要避免选择小的过分的服务(pico-services),反之将服务按照自然的边界(编程语言,异步队列,伸缩的要求)进行切分,同时保持团队大小合理(例如:两个披萨团队)。
4 K; B/ Z# w3 ]8 X( h( n
2 l1 i; j2 F" n7 @9 Z( O. |' i$ Z
4 ~4 J2 @7 f+ N' i, T) }应用的架构应该能允许以一种切合实际并且自然的方式增长。与其以20个微服务开始,不如从2到3个开始,然后随着该领域复杂度再对服务进行拆分。经常对一个应用的架构的认识直到应用在处于开发阶段才会变得透彻。这也说明了很少有已经竣工完成的应用,他们都总是一个正在施工的工程。. T$ C2 Q; k: A- L+ f& A

( r! n  {: ?/ l4 n$ ~6 F  G6 k7 k& _, O# _( q
微服务是一个新概念吗? 非也。这其实是另外一种类型的软件组件化(software componentization)。我们过去把代码切分成库。这只是把“链接器”从一个构建阶段的概念转变成了一个运行时的概念(实际上,Buoyant有一个有意思的项目叫做linkerd,其基于Twitter Finagle系统。)。这与多年前的SOA潮很相似,只是不见了各种样式的XML。数据库从另外一个角度看,一直以来几乎是一个微服务,因为它实现和部署的方式都满足上面列的点。( n2 z& E7 x+ V  d4 n

% Z8 e: t9 p' s: \& s  y# v' _6 D' x$ C/ M& k1 H. V
约束可以转变成生产力。 尽管,很容易让每一个团队各自决定在每一个微服务上使用什么语言或框架,但不妨考虑下规范化,定下几种语言或者框架。这么做有助于机构内部的知识技术交流积累,更好应对人员流动。但是,在必要时也要有打破政策的开放心态。这是比起PaaS的垂直式集成结构,这个世界中的一个关键优势,换句话说,约束应该是来自政策层面的,而不是来自技术能力层面(constraints should be a matter of policy rather than capability)。( F% M# A5 X- S) E6 p
1 C$ d% S) |& U9 @% Y5 J

3 z4 D$ Z9 t+ b1 Q4 p* g: ^; e1 i尽管绝大多数人把微服务看做是实现一个大型应用的技术,服务光谱(services spectrum)中还有很多其他类型的服务:
4 ~6 J) O' l" x" C; ~
; P1 |6 U- D6 T% H/ Q8 B: U
# {8 M5 b2 t+ h/ L! x# H1 _
1.服务作为实现细节。正如上面描述过的一样,这对于把一个大的应用团队切分成小的开发和运维团队很有用。
% [) l9 y: r1 ]. k5 X( W
0 \$ e+ s( D6 O- u+ X. ]6 q+ s. [' p3 Z
2.成果共享,实例私用(Shared Artifact, Private Instance)。在这种场景中,开发过程通过服务的很多实例间共享。有可能有一个开发团队和很多运维团队,或者很可能一个联合的运维团队,在共享专门的实例间工作。很多数据库属于这种类型,很多团队都在使用同一个MySQL安装的私有实例。

) \; D1 u3 O4 O+ g2 w- r
: {- C- s1 G, o! ^( @- {

% Q  C8 ~& h2 h3 d3.实例公用。这种场景下,机构中的一个团队为很多应用或者团队提供一个共享的服务。服务可能会将数据或者操作按照用户(多租户)进行分区,或者提供一个用途广泛的简单服务(如展示一个通用的品牌条HTML,提供机器学习模型等)。+ A$ R4 H7 l- ~6 z3 \1 [( c0 x9 i
: Q" E; D' H9 {: g

2 f- G5 l0 l# H( g4.大型服务(Big-S Service)。绝大多数的企业不会打造这种的服务,但是可能会使用他们。这是一个典型的“硬性”的多租户服务,用来构建来为大量的分散的客户提供服务。这种服务需要某种层次的记账和加固,通常在企业内是不必要的。SendGrid和Twilio属于这一类

0 m. h2 [& N' [: c- d
8 D0 t+ Z+ r7 {' R. }/ j

& c5 |  |6 |8 v6 f随着服务从一种实现细节变成一种企业内常见提供的基础实施,服务网络从一个每应用的概念变成了能跨越整个公司的概念。允许这种依赖是一个既有机遇也有忧患。) I$ P, N  ?& n3 n+ d# C

3 G( K$ J; l& i  ^5 }
/ o' g! i- A+ G4 l5 h
第六部分:安全
' q2 R# L) a: _0 V6 r, g) t% j* b
* k, X: V* s0 m
注:本文中没有覆盖到新出现的“云原生”中与安全相关方方面面。但同时,尽管我不是一个安全专家,安全却是我整个职业生涯都有在关注的事情。请把它当做是值得考虑的事项清单的一部分。+ v. v5 A/ Y' \
1 O0 l+ Q9 K: V# X$ T9 y) Q

- ]3 \+ c: ?9 B' k- }安全仍然是云原生领域中的一个大问题。以往的技术无法完美的应用,在起初云原生可能看起来在开倒车。但在这片无畏的领域,同时也充满了各种机遇。
1 K$ N5 B! {0 p" m2 Z+ }8 e9 y, g( ^8 F
+ D$ l4 s* p9 F" M. O/ g2 g
容器镜像安全

7 [- Z5 Y, k' v) G, \) r1 V" K

3 m5 Z) Z/ o8 d+ P* ^- O+ a: v) }. b
有很多的工具可以帮助对容器镜像进行审计,以确保它们完整地包含了各种补丁。众多选择中,我没有什么很强个人偏好的。" B9 R1 B. K3 G
8 L/ Z$ g8 ^/ z- @$ e" W! [/ ^

/ w! I3 ~$ ?4 b* X* ?3 H真正的问题在于,在发现了一个有漏洞的镜像之后该怎么做呢?这一块市场尚未提供很好的解决方案。一旦有漏洞的镜像被检出,事情就从一个技术问题变成了一个程序/流程问题。你会想着去找出机构中哪些组件受到了影响,问题应该在容器镜像层级树的什么地方进行修补,以及用什么好办法来进行测试并且发布新的打好补丁的版本。
# n) L0 W! \5 M9 A% W4 Q/ u4 ]. U6 H7 N/ i% C( D  p

8 `* z0 l. @' {CD/CD(持续集成/持续部署)是应对良策中的重要内容,因为它可以快速自动地发布新镜像。其与编排系统的集成能让你找出哪些用户正在使用有漏洞的镜像。同时它也能让你验证生产环境上是否采用了已经修复好的版本。最后,部署系统的策略能帮助阻止那些使用有漏洞镜像的容器启动(在Kubernetes的中,这被称作准入(admission))。4 f/ v: u. c7 Z) s1 h( Q

8 _3 c7 d/ a1 |3 X$ _9 c

7 @+ J' N& h" h. q' o; `" ?
微服务和网络安全

6 u: O6 c3 H5 w. e: [

' V" ?$ Y. B/ q4 \+ C  v
但即使集群上所有运行的软件都已经是修复过的,也并不能保证网络中有没有不受信任的活动。
* N( x0 P( f; y: I$ P+ O( U+ v. r. E  b6 w8 k
, l7 l& Z; H! Y
在以动态调度、存时短暂为特征的容器世界中,传统的基于网络的安全工具无法发挥理想的效果。存时短暂的容器可能存活时间过短,以至于传统的扫描工具无法及时扫描到。又或者被扫描到了且扫描报告已经生成,奈何相关容器却已经不存在了。0 ^  O( G4 R" e! ^  j, p4 M
6 i8 r7 L2 C9 B7 Y6 `

" h# ~6 B7 }- T* k+ K& h在动态的编排器中,IP地址不再拥有长久的意味,且它们是可以被自动复用的。解决方案是将网络分析工具和编排器集成,让逻辑名称(结合其他元数据)可以和IP地址一并使用。这可能可以让报警更加容易处理一点。
$ H8 D( X* M: N! j& t( {& s2 u7 M) S; W" J/ C7 U8 k

* c7 H$ c, V5 `4 M很多网络技术都利用了封装技术来实现“一容器一IP”。这可能会给网络追踪和诊断工具带来问题。如果生产环境上部署了这样的网络系统,那这些工具必须要做出相应改进。幸运的是,VXLAN、VLAN中的很大一部分都都已经被标准化了,或者不采用封装或者虚拟化,以便这些系统都能利用这些支持工具。
) @# t' @/ X) Q# h4 Z7 a( {! K" Y* @9 y: \( M8 C! j' G
$ G# s7 r3 U$ N8 f) N4 x& f
然而,个人看法,最大的问题还是跟微服务相关的问题。当在生产环境中运行了很多服务的时候,很有必要确保某特定的服务只能被授权的客户端调用。另外,因为有了IP的重复使用,客户端需要能知道调用的服务是正确的服务。大体上说来,目前这还是一个没有解决的问题。要处理这个问题,有两个(并不互斥的)方案。
( a4 U+ u7 s. i9 u* b! I! V1 ^
/ N# H# y+ P2 F' l2 N& E+ m
; z5 o: m% J0 L; W首先,让实现主机级别的防火墙规则(在任何的容器之外)的网络系统和选项更灵活,以便能细粒度控制访问策略,来控制某些容器能被其他哪些容器调用。我把这个称之为网络的微隔离(network micro-segmentation)。这里的挑战之一在于在动态调度下如何进行策略的配置。尽管尚处于起步阶段,有很多的公司正在努力简化这一点,通过在网络中添加支持,或者同编排器协作,又或者过在处于高层次的应用中进行定义。一个很大的问题是,服务的使用范围越广,微隔离的效果就越小。如果一个服务有成百的调用者,“拥有访问权即意味着得到授权(access implies authorization)”的简单模型不再适用。
3 u$ s- r5 P" h# J2 f& y- B  F8 H* d0 ^. j, n$ X
( N5 M/ f6 D, x" O9 T7 ]2 H
第二个方案是让应用在实现数据中心内的认证和加密中扮演更加重要的作用。这对于那些客户端众多、并且在大的机构中已经形成“软多租户”状态的服务适用。这需要有一个生产环境服务的身份系统。我已经开始一个叫做SPIFFE(Secure Production Identity Framework For Everyone,给大家使用的生产环境安全身份系统框架)的业余项目。这些理念已经在Google这样的公司得到了验证,但是还没有在其他地方施行。
  h: e! M. A' p' i5 g9 L) k" i4 H4 n. ]1 O1 w* Q  U
5 l5 a! l+ C# Y# Y7 Y8 B* A
安全是一个很深入的话题,这里肯定有很多威胁和注意事项没有涉及到,还需要持续的探讨。$ N/ J+ g3 E. m7 D3 N  n4 j# U

. I& |$ z. \8 x1 M
- ]% i" M) \2 a! ?3 B到这里,我们的云原生系列文章就结束了。欢迎大家在Medium留下自己的想法,或者在Twitter上联系jbeda,cmcluck或者heptio。

+ x6 A) F) \* j, w; k% `2 _
原创:博云  翻译:钟最龙
1 `5 w, L4 i+ Y, V4 `* ]

; ~6 @: L2 V9 Z

本版积分规则

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

Baidu

GMT+8, 2019-11-18 06:39 , Processed in 0.149997 second(s), 22 queries .

Powered by Discuz! X3.4 Licensed

© 2001-2017 Comsenz Inc.

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