Page 132 - 《软件学报》2021年第5期
P. 132

1356                                     Journal of Software  软件学报 Vol.32, No.5,  May 2021

                 系的部署工具.
                    实验 6~实验 13 中均在实验集合 1 和集合 2 中选取相同的具有依赖的服务组作为实验对象,其中,在实验 1
                 中,从实验集合里选取一个具有 4 个服务依赖的服务 A;在实验 2 中,选取服务 A、具有 7 个依赖的服务 B 以及
                 具有 5 个依赖的服务 C,A,B,C 的依赖均不相同.实验 6、实验 7 分别对这两组服务进行服务实例的部署操作;实
                 验 8、实验 9 进行对系统中以满足依赖关系的实例删除操作.
                    实验 10、实验 11 进行对该实例的升级操作.其中,实验 10 将系统中的服务 A 升级到新版本,依赖关系变更
                 为 5 个,其中两个依赖关系和升级前兼容,另外 3 个依赖均与之前不同且没有子依赖;实验 11 除了升级服务 A 之
                 外,还将服务 B 升级,新增 2 个依赖,服务 C 升级,减少 2 个依赖.
                    实验 12、实验 13 对该实例进行依赖变更操作:实验 12 将服务 A 的 1 个依赖关系替换为新依赖;实验 13
                 除此之外,还将服务 B 的 2 个依赖关系以及服务 C 的 3 个依赖关系均替换为新依赖.其中,所有的新依赖均不包
                 含子依赖.实验结果见表 2.
                                    Table 2    Experimental results of Experiment 6~Experiment 13
                                               表 2   实验 6~实验 13 的实验结果
                                            DevOps   实例部署  实例删除    是否人工    是否支持     是否能     是否修改源码,
                         实验          方法
                                           指令数量      数量      数量     参与     依赖关系    多版本共存  停止服务实例
                                   Kubernetes  5      5       0      是       否        是         否
                     实验 6(部署 A)      JRO      1       5       0      是       是        否         否
                                    MF4MS     1       5       0      否       是        是         否
                                   Kubernetes  19     19      0      是       否        是         否
                     实验 7(部署 B)      JRO      3       19      0      是       是        否         否
                                    MF4MS     3       19      0      否       是        是         否
                                   Kubernetes  5      0       5      是       否        是         是
                     实验 8(删除 A)      JRO      5       0       5      是       是        否         是
                                    MF4MS     1       0       5      否       是        是         是
                                   Kubernetes  19     0      19      是       否        是         是
                     实验 9(删除 B)      JRO      19      0      19      是       是        否         是
                                    MF4MS     3       0      19      否       是        是         是
                                   Kubernetes  6      4       3      是       否        是         是
                     实验 10(升级 A)     JRO      4       4       3      是       是        否         是
                                    MF4MS     1       4       3      否       是        是         是
                                   Kubernetes  12     8       7      是       否        是         是
                     实验 11(升级 B)     JRO      10      8       7      是       是        否         是
                                    MF4MS     3       8       7      否       是        是         是
                                   Kubernetes  6      3       3      是       否        是         是
                   实验 12(依赖变更 A)     JRO      4       3       3      是       是        否         是
                                    MF4MS     1       2       2      否       是        是         否
                                   Kubernetes  20     10     10      是       否        是         是
                   实验 13(依赖变更 B)     JRO      13      10     10      是       是        否         是
                                    MF4MS     3       7       7      否       是        是         否
                    从实验 6、实验 7 可以看出:Kubernetes 由于不支持服务之间的依赖关系,导致在部署带依赖的服务时,需要
                 人工参与来判断服务的依赖是否满足以及需要额外部署哪些服务.第 1 组服务 A 有两个依赖,因此一共需要部
                 署 3 个实例;第 2 组服务一共有 16 个不同依赖,一共需要部署 19 个实例.每次部署操作均需要一个 DevOps 指
                 令(Kubernetes 可以通过配置文件的方式将所有操作配置到一个文件中,这里我们依然计算指令数量,而不是配
                 置文件数量).而 JRO 以及本文的方法 MI4MS+MF4MS 则能够根据服务依赖描述自动进行依赖部署,仅需要进
                 行 3 次指令部署 3 个服务 A,B,C.
                    实验 8、实验 9 中,由于 JRO 仅仅支持带依赖关系的实例部署操作,因此 JRO 与 Kubernetes 相同,均需要多
                 次操作指令才能够将指定服务实例以及对应的依赖实例删除.
                    实验 10、实验 11 中,由于 Kubernetes 支持容器的升级操作,因此在升级服务实例 A 时,需要删除一个失效
                 依赖,部署一个新的依赖实例,并对服务 A 的实例执行升级操作,一共 6 个操作指令,部署 4 个新实例(新的依赖实
   127   128   129   130   131   132   133   134   135   136   137