自打自己开始弄手游之后，确实遇到了各种各样的问题。各种坑居多，不过也都算顺利，借助搜索引擎以及各大论坛，差不多都算解决了，还有很多bug，倒也不是短时间内能修复的，而且也无关痛痒，也就懒得再深究了。
  在遇到问题通往解决问题的过程里，真的是痛并快乐着，被问题卡住，真的是寝食难安啊，弄明白原理，自己独立解决之后，感觉也真的很好，可很快就会遇到新的问题，这种感觉。。。真的一言难尽。
  其实网上关于游戏搭建的资料和解决方案很多，不过论坛上大多都收费，而加各种群请教了很多大佬，要么左顾言他，要么有偿价格不菲，这简直触碰我这白嫖党的底线了~知识不应该是人类共享的么！！！
  好了，不扯淡了，凭记忆分享些部分我遇到的问题以及解决方案吧，欢迎讨论补充。

幽冥传奇

  手游幽冥传奇目前也是比较火热的，不过里面坑也不算少，需要修复的已知问题有如下问题：

1. 一键双区版的2区没法启动
2. 通天塔每5层闪退
3. 一直提示飘屏广告
4. 英雄技能显示不正确（如战士英雄半月弯刀技能）
5. 很多药水不能使用
6. 最低阶装备也全屏通报
7. 英雄战力只显示为物攻、魔攻或者道术
8. 装备合成只能到宙级
9. 装备一键回收只能到18阶
10. （未完待续）

   其中修复了前 6 个，还有些问题在陆续更改。先说下这些吧

一键双区版的2区没法启动

  造成这个问题的原因是原文件里的配置文件格式有问题，将1区的LogicServer目录复制过去，修改一下端口及区号就可以完美修复了。

通天塔每5层闪退

  这个问题应该是之前人修改的时候，在每层加入了元宝奖励，虽然是好心修改，可这也导致每五层的奖励项由原来的3个变为了4个，于是数据库接收到的数据长度就与程序设定的字段数不一致，导致报错退出。
修复方案就是，将每5层的元宝奖励去掉，或者去掉经验或者洗练符什么其他的，保持奖励项仍为3个，即可不再报错。文件修改路径为build_pub\Server\LogicServer\data\config\fuben\SkyTower目录

飘屏广告

  如果还没开区，则可以在数据库里修改，连接数据库，找到cq_gstatic库就可以看到了。进服公告也可以在这里修改。
如果已经运行一阵子了，那修改数据库就没有用了，也可以修改生成的本地文件来实现修改。文件路径为build_pub\Server\LogicServer\data\notice.txt

英雄技能显示错误

  技能或者物品的显示错误，其实都是在客户端上修改的，不过我们直接去修改客户的客户端还是比较麻烦的，而这个幽冥传奇恰好也支持热更，我们可以用热更的方式，将正确的命名文件放进去，就可以显示正确了。
方案：将www\dev\data\scripts\config\server\language\Zh-CN\Skill.lua中的错误改正，然后用CRC工具算出新更改文件CRC-32的校验值，在list中写入正确的校验值以及字节大小，在打包为list.zip文件，并将新的list.zip文件大小写入version文件中，然后把版本号调高一些就可以自动更新了。

药品使用不了

  这是因为服务端配置出了问题。在服务端中定义了物品的各种属性，一般比较常见的是将物品的type定义错了，例如如果type=102，即为材料，是无法使用的，改为type=103就是药品了，就可以正常吃掉了。有些吃掉没有正确效果的。是因为scriptitem没有定义正确。关于物品的一系列设置都在目录build_pub\Server\LogicServer\data\config\item，详细单个物品设置在子目录ItemClass。物品设置比较复杂，欢迎私下交流，这里不占用篇幅过多介绍了。

低阶物品掉落通告

  也是在build_pub\Server\LogicServer\data\config\item\ItemClass中具体单个文件设置，将其中一个参数dropBroadcast = -1修改为dropBroadcast = 0即可，不要忘记结尾,，否则会报错，启动不了区服。

战神引擎

  复古传奇手游，差不多战神引擎算是目前做的做好得了，真的是完全的复古，复古到我觉得玩起来有点累。。。不过也正是因为对端游的还原度高，导致比较受追捧，所以端和教程虽然满天飞，但大多收费，流出的一些分享的端，也很多是残端，放出来寻求帮助修复的。所以战神引擎搭建的失败几率真的太高了，问题也五花八门，不尽相同。我这里在服务端是完整版本的前提下，来一一解决一下，为后来人提供一些思路与方案。

mongodb服务

  一般教程中，第一步就是安装mongodb数据库（配必备的.NET环境其实可有可无），一般都是三步：

• 双击安装包mongodb-win32-x86_64-2008plus-ssl-3.4.9，安装，在双击robomongo-0.9.0-rc10-windows-x86_64安装包，第二个其实是连接工具，不装也不影响我们搭建，安装这个是为了方便小白测试和排错的。
• 进入mongodb的安装目录下的bin目录找到mongodb的执行文件，创建mongodb服务。也就是按住shift，右键打开命令行工具，输入命令mongod --config "D:\MongoDB\config\mongo.cfg" --serviceName "MongoDB" --install
• 第三步就是启动mongodb服务了，net start mongodb

   这个的前两步一般都没什么问题，不会出现任何报错，不过第三步的时候我就遇到了问题，提示说服务没有响应控制功能。
   我检查了下win下的服务项，路径看下图


   mongodb程序路径和配置文件路径都是对的，如果不对的话，确实会报这个错误，导致服务起不来。可是我这不是啊，实在没有办法，最后我尝试之际使用命令行通过指定配置文件的方式来启动mongodb服务，尝试了下，果然可以以前台进程的方式来启动服务，命令为mongod --config "D:\MongoDB\config\mongo.cfg",检查了下默认端口27017，也用robomongo测试了下，是可以连接的。于是这一步算是解决了（可这也为之后，一直进不去游戏留下了隐患，之后再提）。

m2

   所谓m2，其实就是mysql服务。不同的版本启动mysql的方式也不太一样，有的直接用的phpstudy 将apache和mysql一起启动的，这也省去之后做nginx的虚拟主机开多个端口了。有的版本是通过脚本命令行方式启动，如果没有可以尝试自己进到mysqld.exe所在目录，用命令行命令，``mysqld.exe –defaults-file=”D:\m2\mysql\my.ini”前台启动就可以了。如果实在起不来，检查下端口占用情况是否3306端口被占用，或者配置文件my.ini指定的数据库程序路径或者数据库路径不正确。一般来说都不会有太大问题。如果端口被占用，或者启动了其他的数据库，可以将其他数据库的端口改为3307，战神引擎这个端口改成3307之后，DBserver改不了端口，也就链接不了数据库了，所以还是改别的应用的端口吧。密码就是默认密码，我试了那么多版本的端，倒是没有人该多密码，密码都是相同。

m2.0

   这个算是引擎的主程序了之前都是配套数据库罢了，mongodb用来储存账号相关信息，用来验证登录，而游戏人物数据都在mysql中。所以这一步的环节，就是各项服务读取数据库信息后并相互连结,里面东西说复杂也复杂，说简单也很简单。对于初学者来说，真是一步一坑，对于老手来说就没什么难度了。每个目录做什么的，我这里就不再废话了，直接就大家关心的各种问题来做解释吧。

显示获取版本信息失败，请检查网络连接，是否重试

  这个错误其实很简单，不过这也说明第一步也没弄对啊。一般来说出现这个问题是因为没有获取到project.manifest文件和version.manifest，原因有很多，检查的话可以用浏览器输入你的IP或者域名后跟上面两个文件名，例如http://127.0.0.1/version.manifest（在服务器上的要填公网的ip或者域名）。

• 如果能正常访问，说明是客户端修改IP没有修改对，去看下客户端\assets\res\project.manifest文件的ip是否修改正确。
• 如果浏览器也不能访问，则大概率是assets目录位置不对或apache配置文件路径设置有问题，当然也有可能是客户端的project.manifest修改的IP不正确，如果能实现用浏览器访问此文件的得到的内容也为访问路径IP，说明应该配置没问题了。
• 如果浏览器能访问，手机客户端还有服务器都配置没问题了，还是显示这个报错，那就检查下手机能否联网，或者此APP是否有权限联网，或者用域名的的检测下DNS解析，再或者局域网搭建的看看是不是一个网段（例如忘连接wifi了或者虚拟机设置的NAT模式网卡）

   这个报错很容易解决，以上方案应该囊括了所有情况。

战神引擎更新进度100%后卡住

  这个问题也很常见，不过原因倒是比较简单。因为战神引擎的设置，更新用的端口是88，而更新之后获取列表及访问登录是用的8088端口，方便我们更新服务器和游戏服务器分离开来。前者大概率是phpstudy一键的，所以不会出什么问题就可以开始更新。而从客户端的project.manifest获取更新服务器信息更新完之后，会从客户端的mir2.zip及mir264.zip中读取游戏服务器（这三个文件是不是很眼熟~）。而在这里出问题要么就是服务端的8088端口无法访问到，要么就是客户端修改mir2.zip及mir264.zip文件时IP没有填对。测试方法还是通过浏览器访问IP:8088端口（英文输入法的冒号），测试是否正常访问，战胜引擎的默认主页是有一个hello world来测试访问的

  如果可以正常访问，大概率是客户端那两个压缩包里的IP不正确了。教程里一般都写明了，要修改为16位IP，位数不够用0来凑。但是到底怎么算16位IP，而且到底凑在哪，却都没有提到，造成很多误解和困扰。我这里大概说一下，需要注意的有两个地方:

1. IP中的.也算一位的，所以实际上数字要有13个。
2. 如果IP为111.222.123.123，可能大家都知道，在最后一个123前补0，即可凑齐6位，为111.222.123.0123。不过如果IP为111.22.123.123这种的呢，0补在哪。大家都说法是都可以，问题是我将两个0补在22的位置变为0022后还是连不上，改为111.22.0123.0123之后就可以连上了。所以我推测这个原则是先从后面补齐，每个数字也不要超过4位。也就是说1.1.1.1补齐的话，应该是1.0001.0001.0001。上面俩肯定正确，不过最后的结论个人推测，没遇到过这么短的ip，没有实践过。欢迎大家批评指正。

  如果端口能访问，客户端也修改正确ip，那就很有很能会遇到下面这个报错——获取开发者区服信息失败

提示获取开发者区服信息失败

  这个算是战神引擎新手搭建很容易遇到的问题。究其原因，是你没办法访问到D:\mud2.0\logincenter\logincenter_win\config\serverlist.json或者访问到之后无法通过PHP传奇登陆参数去登录。但是造成此问题最大的问题是因为你的服务端是残端或者被人动过手脚。。。
  真的，我遇到几个版本的战神引擎绝对是有人故意改了配置，改法不尽相同，但都会报这个错误。下面列举我遇到的恶意改动。

配置文件被做了手脚

  因为是提示获取开发者区服信息失败，所以我第一个想到的就是文件路径不对，用户客户端定义获取区服信息是通过访问服务器的/serverlist路径。一般来说想访问此路径获取到到此文件有两种方式，一个是在lua程序中定义。另一个是在nginx里面设置alias。
  这两种修改的我都看到过，先说第一种。第一种方式访问区服列表的，nginx只起到一个代理的作用，不指定路径，因为在logincerter_win目录中已经定义好了访问规则,如下图所示，定义了访问/serverlist路径则去访问下application/controllers/serverlist.lua,而文件又定义了serverlist.json的位置，所以就可以正常获取区服表了。

  不过我遇到有的版本，估计把这个serverlist.lua文件中的路径设置错误，或者把下面开服表内容删掉。因为不同版本开服表信息并不通用，而且名字要相互间匹配，所以如果没有开服表信息或者是错误的，那就比较难解决了。建议换个端试试吧。
  第二种修改nginx的改动就比较好修复了。这种版本的在nginx的配置文件中定义了alias，来实现访问/serverlist路径可以获取到区服表，但是如果这一条alias如果被删掉了，或者故意改错，那就无法访问到正确的文件了。我遇到过一个版本，也是72的，正常来说应该访问/serverlist路径，直接定义到serverlist.json文件本身，可他这个配置文件却是定义到config目录本身，难怪我看nginx日志一直报403，权限拒绝。

  所以需要将后面路径补齐，正确的为alias D:\mud2.0\logincenter\logincenter_win\config\serverlist.json;,记得nginx配置文件每行分号结尾。
  不过也有版本修复了上面的问题后还是不能正常登录，我倒也没发现到底是哪里被做了手脚。不过这个logincenter_win目录倒是通用的，找一个没被做手脚的，将里面的serverlist.json、serverlist.lua换成自己的，就可以用了，非要修复反而很麻烦，毕竟搞破坏比修好容易太多了。

战神引擎区服列表为空或不显示

  最开始显示了测试服务器登录，也输入了要进入的区服，还提示了是否进入”XXXX”，点了确定进去之后，区服列表竟然是空的。这个问题大概率是因为serverlist配置的不对，检查下serverlist.json吧，版本名字都要匹配。

  客户端如果用的版本不一致到也有可能出现这种情况。

战神引擎获取该区补丁失败

  这个问题就是上面的截图中的那个ConfigName条目里填写的文件获取不到了。如果能到这一步，说明端口连通应该是没问题的，应该有两方面原因

1. 检查nginx配置文件，有没有如下代码

         location /downloadconfig {        alias D:\mud2.0\logincenter\ClientConfig;        allow all;        autoindex on;        autoindex_localtime on;    }

2. 查看D:\mud2.0\logincenter\ClientConfig目录下有没有ConfigName条目后面跟着的对应文件，如果有其他名字的文件，改上面的截图中的那个ConfigName条目就可以了。

战神引擎选择完区服之后不开门

  好不容易连接上了服务器，区服信息也显示了，历尽千辛万苦到最后，竟然半天没人开门。这真是气到吐血啊。
  出现此问题，肯定是因为mongodb出了问题，连接不上。

mongodb自身问题

  上面提到，当时启动mongodb是一直报错，后来用命令方式启动起的端口和服务。这样虽然以前台进程方式启动了mongodb服务，也可以通过测试，甚至连接进去查看数据，可以好像战神引擎不认。。。
  其实我mongodb一直无法启动的时候就应该想到，为什么无法用服务方式启动。那是因为云主机默认只有一个C盘，我当时不是纯净系统，上面还跑着其他端，没法直接从C盘压缩卷再创建一个D盘，于是我是通过共享目录在映射网络磁盘的方式，生成了一个D盘（其实还是C盘下的一个目录而已），而这样虽然mongodb通过命令行可以启动，但是等到系统服务方式启动的时候，他就不认这个映射关系了（我用subst命令生成本地磁盘也试了，还是不能访问）。就相当于找不到数据库或者配置文件了。类似linux中很多配置文件中不能存在软链接一个原理吧。
  所以解决方案就是通过原路径C盘目录下来指定配置文件（毕竟文件本来就在C盘），而不是D盘目录下的那个路径了。或者直接把mongodb整个数据库和配置文件目录都拷贝到C盘任一目录下，毕竟这个服务只是需要一个端口来连接就可以了，具体数据库在哪无所谓的。
  修改之后，以服务的方式启动，战神引擎就可以正确连接mongodb数据库，也就可以往里面写入账号信息了。不开门就是因为连接不上mongodb数据库，无法写入信息。

mongodb连接端口被人改掉了。

  如果mongodb本身没有问题，还有就是这一种情况，连接mongodb的端口被人换了。 大家都是用的都是别人设置好的脚本来启动，也不需要检查各种配置文件，而有人把其中配置文件的端口换掉，你自己验证还是很难发现的。

  请检查此文件中的端口是否是默认端口27017，我遇到了个还是72家族的1.85版本这个端口竟然写的27099，通过27099端口怎么也不可能连接到mongodb去验证的！卖端就算了，还要逼你掏钱修复买教程，真的太损了。

其他原因

  毕竟搞破坏太容易，一人作恶，百人都挡不住啊。还很有可能是其他地方也被改掉了，我目前没遇到而已。欢迎大家修改补充。

  如果有用，请帮我点赞~

  本次就说这么多吧，之后有想起来的再令行补充，不过实在修复不了也不必太执着。。。

准备工作

准备游戏服务架构

  这些天，我下载了很多游戏的服务架构，页游、手游、端游都有。看到里面的配置和架构也都五花八门。总的来说，一般页游大多是AMP+JAVA，手游遇到很多， JAVA+MongoDB，页游AMP+Erlang+RabbitMQ的组合。端游就更加五花八门了，很多引擎或者自制脚本，使用的数据库种类也很多，MongoDB、mysql、SQL Server等等，不同游戏的架构选择都不同。
  因为我们自己肯定没法写出来一个完整的游戏服务包，所以最理想的也是最简便的方法就是使用别人已经写好的现成的服务包，安装配置即可（里面坑巨多，免费分享出来的，完整性和质量就没法苛求了），大部分修复下或者调整下也是能够凑活跑起来的。
  不过倒也遇到很多问题，游戏中有很多bug，例如这个任务流程过不去，那个点了没反应，只能边玩边吐槽；还有个手游架设好后，一直没有报错，就一直没管他，运行3天后，有小伙伴说登录不上，才发现服务器数据库崩掉连接不上了，由于搭建好后就没有关注监控这个服务器，甚至不知道是啥时候崩掉的，也就不知道为什么会崩，重新搭建连接完数据库，之前玩的游戏数据也就清空没有（没有设置实时备份数据库），小伙伴们很是扫兴，还好不是实际生产中，这我也很无奈啊。
  但总体下来，大家反应都是很不错的，毕竟道具无限，人人都是大佬，也算无聊的假期大家一起有共同消遣了。

网络环境

  因为要自己开服务器，如果只是在本地电脑上配置，那其他小伙伴们就没法连接进来，自己游戏里再NP也没人分享可太悲哀了。所以，我们一定要连上外网，需要公网IP，才可以供他人访问。
  博主有一个aws的海外云主机，还有一个腾讯云的国内云主机，虽然直接在云主机上搭建可以直接解决公网IP的问题，不过这俩云主机配置都不高，都是1C1G，担心无法完美支撑服务跑起来（花钱升级配置是不可能的~）。于是初步决定在本地先将服务跑起来，用 vpn 打通本地电脑和云主机的网络，配置云主机的反向代理，实现游戏服务器公网搭建。做出规划步骤如下

• 本地搭建游戏服务端
• 用 vpn 打通本地主机和云主机的网络
• 配置云主机的代理转发
• 修改本地主机的游戏服务监听端口
• 配置客户端

正式搭建

本地搭建游戏服务端

  因为我搭建了很多不同类型的游戏，且每一种其实方法步骤都不一样，需要的配置和环境也都不同，遇到的问题也不尽相同，在这里就没法一一细说了，会在文末将我搭建成功的那些服务包都贴出来，有需要的小伙伴可以自行研究。

打通网络

  可以参考我之前博客https://hewanyue.com/blog/2c6b894f.html架设 vpn 。协议可以使用UDP，之前我用TCP总是被封掉。搭建好，建立连接后，其实就已经算是打通网络了。
  在window cmd命令行或者linux的终端里ping 10.8.0.1 就可以ping通云主机了的。然后也可以尝试用云主机验证 访问本地10.8.0.6上面的http服务之类的。

配置云主机反向代理

  虽然这两台机子间是联通了，但是别人访问你的云主机的IP，并不能连接到你本地的服务器主机，所以我们需要在防火墙上配置转发。
  例如本地服务器开启的端口为 12345，而我们想让别人访问云主机的 54321端口就可以登录我们的游戏服务，需要填写dnat 还有地址伪装。代码如下：

iptables -t nat -D PREROUTING -d 0.0.0.0 -p tcp --dport 54321 -j DNAT --to-destination 10.8.0.6:12345

  如果客户端设置的链接协议是UDP，那就将tcp改为UDP，若是不知道客户端程序写的链接方式到底是什么，可以写两条将这俩都转发了。不过如果不写协议会报错的。

[root@ip-172-31-39-115 ~]# iptables -t nat -D PREROUTING -d 0.0.0.0 --dport 54321 -j DNAT --to-destination 10.8.0.6:12345iptables v1.8.2 (nf_tables): unknown option "--dport"Try `iptables -h' or 'iptables --help' for more information.

  如果不想改不同的端口，倒也可以简单粗暴的，将访问云主机的所有数据统统转发到本地，但这样的话，云主机的其他功能就都会受到影响，不建议这样（云主机上没有其他服务倒也可以这样）。
  还有记得防火墙开启转发功能，否则可能服务器的内网网卡收不到数据报文。

echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.confsysctl -p

  有的游戏，本地服务器还配有网站等等例如gm简易工具，需要我们在外网也能访问。可以设置nginx或者apache的反向代理转发，比较简单，这里就不细说了。

修改本地主机的游戏服务监听IP端口

  出于安全考虑，很多游戏服务配置的时候，相互之间都是，配置了访问权限的，我下载的大部分游戏都是监听在本地127.0.0.1回环网卡的，如果我们不修改监听地址，从我们构建来的专线的访问数据是没有权限访问我们的服务的，所以我们需要将监听地址修改为10.8.0.6专线网卡的ip上。或者改为0.0.0.0（不建议，有可能端口冲突，造成服务起不来或者报错）。
  一般php或者数据库那些地址就不用改了，因为还是从本地读取的。到时候捋一捋就可以确保正确连接了。

配置客户端

  因为一般需要连接的服务器IP端口，都是写死在客户端中的，我们修改了服务器的地址，所以还要在客户端中修改为正确的ip地址端口，才可以链接（页游不用，页游没有客户端）。
  不同游戏修改方式和路径都不相同，安卓端可以用APKIDE，苹果ipa的可以直接将后缀改为rar，解压后修改对应ip，这里就不细说了。欢迎就具体游戏来讨论。

附本人搭建测试成功的游戏及网盘分享

• 手游剑侠情缘
  游戏预览：（随便拍的，手边没有安卓机，用的电脑模拟器）

安装vmware的centos虚拟机，里面是java程序。
  下载地址
  剑侠情缘VM一键端
链接：https://pan.baidu.com/s/1D0qOO7XcK2K93BLXCsw-fA
提取码：4371

• 手游蓝月传奇
  游戏预览：
  
  
  
    这个是在windows环境下运行的，用到PHP、nodejs、mysql、Erlang+rabbitMQ
    下载地址
    【蓝月传奇】一键端+修改教程+全功能GM网页后台+外网教程
  链接：https://pan.baidu.com/s/1wjfmMWaTf2YxZ0rxjCtknw
  提取码：6c8m

• 手游七雄争霸
    JAVA游戏，windows环境搭建，用到了memcached、nodejs、PHP
    下载地址
  链接：https://pan.baidu.com/s/1o-pZb4TWKZWf3vmGk70bfQ
  提取码：78ws

• 手游 幽冥传奇
    Windows环境运行，用的战神引擎。
  
  
  
  
  
  
  
    下载地址
  链接：https://pan.baidu.com/s/1mLgic84xPkBhkrOiJqx4ZQ
  提取码：ja6l

• 页游 传奇世界
    H5游戏，也还不错。
    下载地址
  链接：https://pan.baidu.com/s/1Zv1vMoD9l1cegh3FRghaXA
  提取码：7057

• 页游 赤月传说
    下载地址
  链接：https://pan.baidu.com/s/1S1RW6JAmR1Xx063XzoJTOA
  提取码：i168

• 端游 无极联盟传奇
    Windows环境运行，用的GOM引擎。
    这个虽然特效还有模式都还不错，不过是个残端，里面没有提供pak密码，不建议安装。
    下载地址
  链接：https://pan.baidu.com/s/13OOZxWbESveJLXmeS-w1Bw
  提取码：7nom

• 端游 三国战纪OL（第二季）
    Windows环境运行，用的GOM引擎。这个可以完美开服，还算不错。
    下载地址
  链接：https://pan.baidu.com/s/12x4Kvb-_Pipn6Qs73JkBPw
  提取码：xb6r

  很多游戏搭好之后，玩了也还不错，不过忘记保留截图了。还有一些还没上传，等日后再分享。欢迎交流讨论。

  平常也有罢了，不玩也就算了。不过这一阵子，恰逢春节，却又赶上疫情不能出门，几乎排行榜所有的电影都扫遍了，无可奈何又想起了早就删除了的英雄联盟。
  但是现在系统已经是Deepin系统了。用起来很简洁，也比较方便，桌面也很漂亮，给大家看看桌面哈～

vmware

  言归正传，我们需要安装一个window的虚拟机。因为本地已有vmware，所以直接用vmware创建。
  没有安装vmware的去官网下载一个linux版本的，网上找一个个激化码就可以正常使用了。链接为https://download3.vmware.com/software/wkst/file/VMware-Workstation-Full-15.5.1-15018445.x86_64.bundle。可以用迅雷或者谷歌自带下载工具下载，也可以用命令行wget命令下载。
  这是一个可执行程序文件，在命令行中对此文件，加执行权限，执行

./VMware-Workstation-Full-15.5.1-15018445.x86_64.bundle

  安装完毕VMware后，找到window的iso镜像包（要是没有，提前去下载一个）正常安装window系统即可。至少分配4个G内存，开启3D选项（一般是默认开启的）。

可能遇到的问题

3D支持

  开机之后很有可能会vmware的又下角会报错，提示3D不可用

  需要我们进入虚拟机的安装目录，找到vmx文件，vim打开编辑，在最后加一行mks.gl.allowBlacklistedDrivers = "TRUE"来强制开启3D加速。再开启虚拟机，就不会报No 3D support is available from host了。如果报mks.gl.allowBlacklistedDrivers之类的错误，可能是引号格式不正确，重新检查修改一下引号就可以了。

game_error_directx

  当我下载好wegame，安装好英雄联盟客户端，也能正常组队及开始游戏时，载入进度条到100%后，意外给我弹一个这个报错。

  然后游戏也无法重连了，一直报错game_error_directx。

  这上来就坑队友了啊，我也很无奈。赶紧用directx修复工具修复一下directx，果然可以进入游戏了。（首先确保第一步的3D支持已开启，否则单独用修复工具修复是无效的）

卡顿

  进入游戏后，我发现虽然可以流畅游戏，也没有延迟，问题是每隔几分钟就会有个10秒钟左右的画面卡顿，甚至掉线，然后屏幕就黑了。。。这谁顶得住啊。只能停下，赶紧排查原因。
  开始以为是网络卡顿，不过检查了下，发现虚拟机的网络一直没有掉，于是猜测是虚拟机的CPU不响应，于是检测了下CPU的使用率，发现果然在卡顿的几秒钟内，宿主机的CPU使用率很高，难道是有进程占用了CPU，导致虚拟机的程序无法得到响应？
  于是查找CPU优化，初步拟定方向是，将CPU核心绑定至虚拟机进程，修改虚拟机优先级等等。不过linux版的VMware没法设置优先级，并不像window版本的可以设置优先级。

  于是，可优化选项，只有设置预留内存，以及不使用交换分区了。这时我注意到，默认是使用交换分区的，可能导致我不时卡顿的元凶就是这里了。不过无法直接修改内存选项，提示You must be running Workstation as root to change these preferences.。
  于是，只能从命令行切换root用户权限执行vmware，修改后（将默认的Allow some virtual machine memory to be swapped改为第一个），在用普通用户启动vmware，发现果然是继续生效的。
  再次启动虚拟机，进入游戏之后，果然再也没有出现卡顿了。

关闭工具条

  在虚拟机中全屏之后，上面还隐藏一个白色的工具条，打游戏偶尔会点到就会切出去，很影响游戏体验。于是我们要想办法将他去掉。
  在Edit，Preferences选项下的Display标签中，将全屏显示选项栏这个选项勾选取消。


  现在就可以愉快的进行游戏了，你们能看出来我是在虚拟机中游戏吗

实验环境

  本次演示使用主机系统均为ubuntu1804。

  如果机器不够，可以选择复用，例如将etcd的三台主机与master主机和harbor主机复用，可以省下来3台主机。推荐node节点的性能高一些，因为一般之后的pod都将运行在node节点上，如果node节点的资源不足，则很有可能无法创建pod，导致服务启动或者扩容失败。
  具体K8s集群的搭建，可以参考我之前文章使用kubeasz自动化部署K8s。harbor服务器的搭建和部署配置，也可以参考我之前文章Docker（五）——Docker镜像仓库。
  因为是均为内网环境，建议将网络组件calico的IPIP模式（ip-in-ip叠加模式）关掉，使用calico的BGP模式，以节约大量主机内部访问时封装的性能损耗。具体操作可以参考之前博客使用kubeasz自动化部署K8s。

设计架构

  我们设计一个简单架构为例，如下图所示。

  一般负载层是使用物理机上的haproxy服务来实现4层负载，而不是在K8s集群内部pod 实现。我们这里也就将他省略不再细说。
所以我们需要创建一个nginx集群，以及一个tomcat集群。将动态资源，转发给后端的tomcat服务，前端的静态页面由nginx来处理。为了方便我们对后端服务的修改以及部署，我们还需要一个NFS服务器，来共享静态资源以及动态资源，以实现后端服务数据的实时同步。

搭建业务镜像架构

  镜像一般是按层次一级一级实现的，可实现多个业务复用。所以，例如我们将要实现的业务为app1，则我们需要的的镜像，就有对应的app1-nginx及app1-tomcat的业务镜像，以及nginx及tomcat的基础镜像，以及基础系统镜像，我们要一层层的来制作镜像。详细可以参考之前文章Docker（三）——镜像制作。

cd /optmkdir -p k8s/{app1,dockerfile,yaml}cd k8s/dockerfilemkdir {app1,pub-image,system}

  最终结构如下图所示。

root@DockerUbuntu18:/opt/k8s/dockerfile# tree -d.├── app1│   ├── app1-nginx│   └── app1-tomcat├── pub-images│   ├── jdk│   │   └── 8│   ├── nginx-base│   └── tomcat-base└── system    └── centos

  打好的镜像如下所示。

root@DockerUbuntu18:/opt/k8s/dockerfile# docker imagesREPOSITORY                                          TAG                 IMAGE ID            CREATED             SIZEharbor.micepro.net/base/app1-tomcat                  v1                  c7d87d05f8a4        3 days ago          1.19GBharbor.micepro.net/base/tomcat-base                  v8.5.47             12cf3e12f2d0        3 days ago          1.19GBharbor.micepro.net/base/jdk-base                     v8.212              1582b1e9cfe4        3 days ago          1.16GBharbor.micepro.net/base/app1-nginx                   v1                  4836f9aed79b        3 days ago          940MBharbor.micepro.net/base/nginx-base                   v1.16.1             bfc05a5c23ed        5 days ago          940MBharbor.micepro.net/base/centos-base                  v7.6                bc7e922a8352        5 days ago          753MBharbor.micepro.net/base/centos                       base                f1cb7c7d58b7        10 months ago       202MB

配置NFS服务器

  我们计划将动态资源和静态资源都放置至我们的NFS共享存储上，也就是我们的harbor上（任意主机，端口不冲突就可以~）
  可以通过包管理工具快速安装一个NFS服务，毕竟这只是一个辅助工具，无需过多关注。

apt install -y nfs-servermkdir /data/app1/{images,static,ROOT} -pecho "/data/app1 *(rw,no_root_squash)" >> /etc/exportssystemctl enable --now nfs-server

  将/data/app1目录整个共享出去即可，之后我们可以直接将NFS挂载至pod中，也可以通过PV/PVC的方式挂载到pod中。
  我们需要修改权限，通过指定uid的方式，使某个UID在多个主机之间都具有权限。这就要求我们之前在创建基础镜像时，也使用的是相同的UID启动程序。例如我们统一都使用www用户，指定UID为2020。（之前创建的容器以及基础镜像中都要修改服务以UID为2020的www用户启动）

编写yaml文件

  此时我们就可以开始着手准备yaml文件，来规划我们的服务pod了。

namespace

  首先我们需要新创建一个namespace，来实现与其他服务隔离。

cd /opt/k8s/mkdir -p yaml/namespace

vim yaml/namespace/app1.yamlapiVersion: v1 #API版本kind: Namespace #类型为namespacmetadata: #定义元数据  name: app1 #namespace名称

  然后将这个namespace创建出来，使用命令

kubectl apply -f /opt/k8s/yaml/namespace/app1.yaml

  此时使用命令kubectl get ns可以看到我们新创建的namespace

root@DockerUbuntu18:/opt/k8s# kubectl get nsNAME              STATUS   AGEapp1              Active   20sdefault           Active   3dkube-node-lease   Active   3dkube-public       Active   3dkube-system       Active   3d

pod

  先创建好对应的目录，方便后期管理维护。

cd /opt/k8smkdir -p app1/{nginx,tomcat}

  然后我们就可以编写pod的yaml文件了。

cd /opt/k8s/app1/nginx

  可以将Deployment和server写在一起，也可以分开写。我们这直接都写在一起。

vim nginx.yamlkind: DeploymentapiVersion: extensions/v1beta1metadata:  labels:    app: app1-nginx-deployment-label  name: app1-nginx-deployment  namespace: app1spec:  replicas: 2  #设置nginx集群数量  selector:    matchLabels:      app: app1-nginx-selector  template:    metadata:      labels:        app: app1-nginx-selector    spec:      containers:      - name: app1-nginx-container        image: harbor.micepro.net/base/app1-nginx:v1        #command: ["/apps/tomcat/bin/run_tomcat.sh"]        imagePullPolicy: IfNotPresent        #imagePullPolicy: Always        ports:        - containerPort: 80          protocol: TCP          name: http        - containerPort: 443          protocol: TCP          name: https        env:        - name: "password"          value: "123456"        - name: "age"          value: "18"        resources:          limits:            cpu: 2            memory: 2Gi          requests:            cpu: 500m#            memory: 1Gi            memory: 200m        volumeMounts:        - name: app1-images          mountPath: /usr/local/nginx/html/webapp/images          readOnly: false        - name: app1-static          mountPath: /usr/local/nginx/html/webapp/static          readOnly: false      volumes:      - name: app1-images        nfs:          server: 192.168.32.20          path: /data/app1/images      - name: app1-static        nfs:          server: 192.168.32.20          path: /data/app1/static---kind: ServiceapiVersion: v1metadata:  labels:    app: app1-nginx-service-label  name: app1-nginx-service  namespace: app1spec:  type: NodePort  ports:  - name: http    port: 80    protocol: TCP    targetPort: 80    nodePort: 30080  - name: https    port: 443    protocol: TCP    targetPort: 443    nodePort: 30443  selector:    app: app1-nginx-selector

cd /opt/k8s/app1/tomcat

  编写tomcat的pod的yaml文件

kind: DeploymentapiVersion: extensions/v1beta1metadata:  labels:    app: app1-tomcat-app1-deployment-label  name: app1-tomcat-app1-deployment  namespace: app1spec:  replicas: 1  selector:    matchLabels:      app: app1-tomcat-app1-selector  template:    metadata:      labels:        app: app1-tomcat-app1-selector    spec:      containers:      - name: app1-tomcat-app1-container        image: harbor.micepro.net/base/tomcat-app1:v1        command: ["/usr/local/tomcat/bin/run_tomcat.sh"]        #imagePullPolicy: IfNotPresent        imagePullPolicy: Always        ports:        - containerPort: 8080          protocol: TCP          name: http        env:        - name: "password"          value: "123456"        - name: "age"          value: "18"        resources:          limits:            cpu: 2            memory: "1000Mi"          requests:            cpu: 500m            memory: "200Mi"        volumeMounts:        - name: app1-myapp          mountPath: /data/tomcat/webapps/ROOT          readOnly: false      volumes:      - name: app1-myapp        nfs:          server: 192.168.32.19          path: /data/app1/ROOT      - name: app1-static        nfs:          server: 192.168.32.19          path: /data/app1/static---kind: ServiceapiVersion: v1metadata:  labels:    app: app1-tomcat-app1-service-label  name: app1-tomcat-app1-service  namespace: app1spec:  type: NodePort  ports:  - name: http    port: 80    protocol: TCP    targetPort: 8080    nodePort: 38080  selector:    app: app1-tomcat-app1-selector

修改配置文件

  因为要实现一个通用的nginx+tomcat动静分离web架构，即用户访问的静态页面和图片在由nginx直接响应，而动态请求则基于tomcat的service name转发用户请求到tomcat业务app。
  所以我们需要修改当时创建镜像的nginx的配置文件，配置upstream服务器为tomcat的pod，配置如下

upstream tomcat_webserver {    server app1-tomcat-app1-service.app1.svc.app1.local:8080;}server {    location /myapp {        proxy_pass http://tomcat_webserver;        proxy_set_header Host $host;        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;        proxy_set_header X-Real-IP $remote_addr;    }}

  其中pod间通信是基于K8s内部DNS实现的，一般是coreDNS或者kubeDNS，如果没有安装是无法解析的，可以使用kubeasz的第七个playbook安装，可参考之前文章使用kubeasz自动化部署K8s。
  主机名默认组成结构为release-name-rancher.default.svc.cluster.local，也就是ServerName.NameSpace.svc.CLUSTER_DNS_DOMAIN。ServerName是我们在yaml文件中定义的，NameSpace是我们创建pod时选择的namespace，CLUSTER_DNS_DOMAIN是我们在创建K8s集群时设置的集群名，如果是用kubeasz工具创建的K8s集群，可以去/etc/ansible/hosts文件中查看。
  我们可以在pod间测试通信，确保相互之间可以通过主机名通信。

[root@blog-tomcat-app1-deployment-5b4845ddd8-rr5dq /]# ping app1-nginx-service.app1.svc.cluster.localPING app1-nginx-service.app1.svc.cluster.local (10.68.101.60) 56(84) bytes of data.64 bytes from app1-nginx-service.app1.svc.cluster.local (10.68.101.60): icmp_seq=1 ttl=64 time=0.103 ms64 bytes from app1-nginx-service.app1.svc.cluster.local (10.68.101.60): icmp_seq=2 ttl=64 time=0.314 ms64 bytes from app1-nginx-service.app1.svc.cluster.local (10.68.101.60): icmp_seq=3 ttl=64 time=0.077 ms

  而且nginx及tomcat中最好将日志格式改为json格式，方便我们收集日志。
  tomcat的配置文件/usr/local/tomcat/conf/server.xml，设置appBase="/data/tomcat/webapps/,日志格式修改如下

        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"               prefix="localhost_access_log" suffix=".txt"               pattern="{&quot;clientip&quot;:&quot;%h&quot;,&quot;ClientUser&quot;:&quot;%l&quot;,&quot;authenticated&quot;:&quot;%u&quot;,&quot;AccessTime&quot;:&quot;%t&quot;,&quot;method&quot;:&quot;%r&quot;,&quot;status&quot;:&quot;%s&quot;,&quot;SendBytes&quot;:&quot;%b&quot;,&quot;Query?string&quot;:&quot;%q&quot;,&quot;partner&quot;:&quot;%{Referer}i&quot;,&quot;AgentVersion&quot;:&quot;%{User-Agent}i&quot;}" />

PV/PVC

  我们还可以通过创建一个创建PV/PVC的方式的方式来代替直接NFS挂载Volume。
  PersistentVolume（PV）是集群中由管理员配置的一段网络存储。 它是集群中的资源，就像节点是集群资源一样。 PV是容量插件，如Volumes，但其生命周期独立于使用PV的任何单个pod。 此API对象捕获存储实现的详细信息，包括NFS，iSCSI或特定于云提供程序的存储系统。
  PersistentVolumeClaim（PVC）是由用户进行存储的请求。 它类似于pod。 Pod消耗节点资源，PVC消耗PV资源。Pod可以请求特定级别的资源（CPU和内存）。声明可以请求特定的大小和访问模式（例如，可以一次读/写或多次只读）。
  PVC和PV是一一对应的。Persistent Volume相对独立于Pods,单独创建。
  Persistent Volume对具体的存储进行配置和分配，而Pods等则可以使用Persistent Volume抽象出来的存储资源，不需要知道集群的存储细节。
  Persistent Volume和Persistent Volume Claim类似Pods和Nodes的关系，创建Pods需要消耗一定的Nodes的资源。而Persistent Volume则是提供了各种存储资源，而Persistent Volume Claim提出需要的存储标准，然后从现有存储资源中匹配或者动态建立新的资源，最后将两者进行绑定。
  以我们这次的演示为例，PV和PVC如下所示。
  PV的yaml文件示例

apiVersion: v1kind: PersistentVolumemetadata:  name: nfsspec:  storageClassName: manual  capacity:    storage: 10Gi  accessModes:    - ReadWriteMany  nfs:    server: 192.168.32.19    path: "/data/app1/static"

  PVC的yaml文件示例

apiVersion: v1kind: PersistentVolumeClaimmetadata:  name: nfsspec:  accessModes:    - ReadWriteMany  storageClassName: manual  resources:    requests:      storage: 10Gi

  pod中引用PVC

apiVersion: v1kind: Podmetadata:  name: testpv  labels:    role: web-frontendspec:  containers:  - name: web    image: nginx    ports:      - name: web        containerPort: 80    volumeMounts:        - name: nfs          mountPath: "/usr/local/nginx/html/webapp/static"  volumes:  - name: nfs    persistentVolumeClaim:      claimName: nfs

HPA

  虽然我们可以使用命令kubectl scale对运行在k8s 环境中的pod 数量进行扩容(增加)或缩容(减小)。

root@DockerUbuntu18:~# kubectl --help | grep -w scale  scale          Set a new size for a Deployment, ReplicaSet, Replication Controller, or Jobroot@DockerUbuntu18:~# kubectl get deployments -n app1NAME                     READY   UP-TO-DATE   AVAILABLE   AGEapp1-nginx-deployment    1/1     1            1           9dapp1-tomcat-deployment   1/1     1            1           3d4hroot@DockerUbuntu18:~# kubectl scale deployment/app1-tomcat-deployment --replicas=2 -n app1deployment.extensions/app1-tomcat-deployment scaledroot@DockerUbuntu18:~# kubectl get deployments -n app1NAME                     READY   UP-TO-DATE   AVAILABLE   AGEapp1-nginx-deployment    1/1     1            1           9dapp1-tomcat-deployment   2/2     2            2           74s

  不过在实际生产中，我们肯定没法随时根据负载或者服务需要，手动动态伸缩我们的后端服务器数量，但是我们可以通过命令kubectl autoscale自动控制在k8s集群中运行的pod数量(水平自动伸缩)，想要实现自动上伸缩，需要我们提前设置pod范围及触发条件。
  k8s从1.1版本开始增加了名称为HPA(Horizontal Pod Autoscaler)的控制器，用于实现基于pod中资源(CPU/Memory)利用率进行对pod的自动扩缩容功能的实现，早期的版本只能基于Heapster组件实现对CPU利用率做为触发条件，但是在k8s 1.11版本开始使用Metrices Server完成数据采集，然后将采集到的数据通过API（Aggregated API，汇总API），例如metrics.k8s.io、custom.metrics.k8s.io、external.metrics.k8s.io，然后再把数据提供给HPA控制器进行查询，以实现基于某个资源利用率对pod进行扩缩容的目的。
  控制管理器默认每隔15s（可以通过–horizontal-pod-autoscaler-sync-period修改）查询metrics的资源使用情况
支持以下三种metrics指标类型：
  ->预定义metrics（比如Pod的CPU）以利用率的方式计算
  ->自定义的Pod metrics，以原始值（raw value）的方式计算
  ->自定义的object metrics
支持两种metrics查询方式：
  ->Heapster
  ->自定义的REST API
支持多metrics

（未完待续）

  还是去官网下载https://www.elastic.co/cn/downloads/beats/filebeat。本次演示还是以最新版的filebeat7.5.1为例（以前版本的filebeat配置文件格式参数上可能有一些改变，不过大同小异）。

cd /usr/local/src/wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.5.1-amd64.debdpkg -i filebeat-7.5.1-amd64.deb

基础配置

  配置文件也很简单，如果想要写入文件，则配置如下

grep -v "#" /etc/filebeat/filebeat.yml | grep -v "^$"filebeat.inputs:- type: log  paths:    - /var/log/syslog  exclude_lines: ["^DBG"]  exclude_files: [".gz$"]  tags: "syslog-filebeat"output.file:   path: "/tmp"  filename: "filebeat.txt"

  paths路径支持正则通配符写法，exclude是设置不匹配的文件格式。而且filebeat也支持同时从多个路径收集写成如下配置

filebeat.inputs:- type: log  paths:    - /var/log/syslog  exclude_lines: ["^DBG"]  exclude_files: [".gz$"]  tags: "syslog-filebeat"- type: log  paths:    - /var/log/nginx/access.log  exclude_lines: ["^DBG"]  exclude_files: [".gz$"]  document_type: "nginx-accesslog-filebeatoutput.file:   path: "/tmp"  filename: "filebeat.txt"

  同样，filebeat支持写入redis和kafka

filebeat.inputs:- type: log  paths:    - /var/log/syslog  exclude_lines: ["^DBG"]  exclude_files: [".gz$"]    tags: "filebeat-redis-syslog"output.redis:  hosts: ["192.168.32.31:6379"]  key: "filebeat-system-log" #为了后期日志处理，建议自定义 key 名称  db: 1 #使用第几个库  timeout: 5 #超时时间  password: 123456 #redis 密码

  想要写入kafka则添加output插件，配置如下

filebeat.inputs:- type: log  paths:    - /var/log/syslog  exclude_lines: ["^DBG"]  exclude_files: [".gz$"]  tags: "filebeat-kafka-syslog"output.kafka: #写入 kafka  hosts: ["192.168.15.11:9092","192.168.15.12:9092","192.168.15.13:9092"]  topic: "systemlog-1512-filebeat"  partition.round_robin:    reachable_only: true  required_acks: 1 #本地写入完成  compression: gzip #开启压缩  max_message_bytes: 1000000 #消息最大值

配置详解

input

  也就是设置日志收集的来源，需要的属性有type,path，根据官方文档，现在版本常用写法为，

filebeat.inputs:- type: log  paths:    - /var/log/system.log    - /var/log/wifi.log- type: log  paths:    - "/var/log/apache2/*"  fields:    apache: true  fields_under_root: true

  其中type的类型很多

• Log 日志文件，必须有PATH,官方示例如下：

filebeat.inputs:- type: log   paths:    - /var/log/system.log    - /var/log/wifi.log    - /var/log/*.log- type: log   paths:    - "/var/log/apache2/*"  fields:    apache: true  fields_under_root: true

• Stdin 标准输入，没有PATH，官方示例如下：

filebeat.inputs:- type: stdin

• Container 容器中日志，必须有PATH，官方示例如下：

filebeat.inputs:- type: container  paths:     - '/var/lib/docker/containers/*/*.log'

• Kafka 从kafka中读取数据，官方示例如下：

filebeat.inputs:- type: kafka  hosts: ["<your event hub namespace>.servicebus.windows.net:9093"]  topics: ["<your event hub instance>"]  group_id: "<your consumer group>"  username: "$ConnectionString"  password: "<your connection string>"  ssl.enabled: true

• Redis 从redis中读取数据，官方示例如下：

filebeat.inputs:- type: redis  hosts: ["localhost:6379"]  password: "${redis_pwd}"

• UDP 开放UDP端口来接受数据，可设置单条最大数据上限，不定义默认为20MiB。

filebeat.inputs:- type: udp  max_message_size: 10KiB  host: "localhost:8080"

• Docker 也支持直接从容器中读取数据， containers.ids是必须定义说明，可以用*代表所有容器。

filebeat.inputs:- type: docker  containers.ids:     - '8b6fe7dc9e067b58476dc57d6986dd96d7100430c5de3b109a99cd56ac655347'

• TCP 用法与UDP相同，设置监听的主机和端口。

filebeat.inputs:- type: tcp  max_message_size: 10MiB  host: "localhost:9000"

• Syslog 监听系统日志，指定传输协议即可。类似TCP和UDP。

filebeat.inputs:- type: syslog  protocol.udp:    host: "localhost:9000"

filebeat.inputs:- type: syslog  protocol.tcp:    host: "localhost:9000"

• s3 AWS的对象存储日志，不过多介绍
• NetFlow Cisco设备网络设备的日志，不过多介绍
• Google Pub/Sub google云的订阅发布模式协议数据，不过多介绍。

  一般来说，我们都写log，就可以满足我们绝大多数场景的使用了。除了type、path这俩常用的input属性外，还有两个设置属性，我们也经常会用到，就是include_lines、exclude_lines，顾名思义，就是包括和排除，配合path中的通配符，可以帮助我们更灵活的指定要收集的日志文件。
  还有一个很常用的属性就是tags,可以写多个，用[]括起来就可以。因为在filebeat中因为有自带type关键字，所以我们在之后筛选日志的时候，无法通过type字段来区分不同的日志源了，所以我们可以通过自定义tags字段，来实现之前在logstash上type的功能，这样在我们收集到的日志中，会自动加入tags 标签属性，然后通过logstash的筛选时，就可以对tags关键字做判断了。

output

  输出选项有Elasticsearch、Logstash、Kafka、Redis、File、Console、Elastic Cloud。

• File
  输出到文件中是最简单的设置了，一般用于测试。

  output.file:path: "/tmp/filebeat"     #输出文件路径filename: filebeat        #输出日志名称，超过大小限制后会自动添加数字后缀#rotate_every_kb: 10000   #每个日志文件大小限制#number_of_files: 7   #路径下最大的储存日志文件数量，超过此值后自动删除最早的日志文件，默认为7。#permissions: 0600    #创建的日志文件的权限

• Logstash
  filebeat支持直接将数据输出值logstash主机。

  output.logstash:hosts: ["127.0.0.1:5044"]

    而logstash主机需要设置输入为beats，才可以顺利接收filebeat的数据。

  input {beats {  port => 5044}}

output {
elasticsearch {
hosts => [“http://localhost:9200"]
index => “%{[@metadata][beat]}-%{[@metadata][version]}”
}
}

- redis输出值redis，上面有说明，这里就不详细介绍了。

output.redis:
hosts: [“localhost”]
password: “my_password”
key: “filebeat”
db: 0
timeout: 5

- kafka输出至kafka。

output.kafka:

initial brokers for reading cluster metadata

hosts: [“kafka1:9092”, “kafka2:9092”, “kafka3:9092”]

message topic selection + partitioning

topic: ‘%{[fields.log_topic]}’
partition.round_robin:
reachable_only: false

required_acks: 1
compression: gzip
max_message_bytes: 1000000

  也可以输出至kafka的不同的topic中>Rule settings:> topic>    The topic format string to use. If this string contains field references, such as %{[fields.name]}, the fields must exist, or the rule fails. >mappings>    A dictionary that takes the value returned by topic and maps it to a new >name. >default>    The default string value to use if mappings does not find a match. >when>    A condition that must succeed in order to execute the current rule. All the conditions supported by processors are also supported here.   官方示例如下：

output.kafka:
hosts: [“localhost:9092”]
topic: “logs-%{[beat.version]}”
topics:
- topic: “critical-%{[beat.version]}”
when.contains:
message: “CRITICAL”
- topic: “error-%{[beat.version]}”
when.contains:
message: “ERR”

- Elaticsearch可以直接将数据输出给elaticsearch服务器，不过一般来说我们不会这样做，一般是会经过logstash来筛选之后再传入elaticsearch。官方示例如下：

output.elasticsearch:
hosts: [“https://localhost:9200"]
username: “filebeat_internal”
password: “YOUR_PASSWORD”

- Console输出至屏幕终端显示。pretty官方的介绍为``If pretty is set to true, events written to stdout will be nicely formatted. The default is false``，示例如下：

output.console:
pretty: true

收集tomcat日志

  收集tomcat中的日志比较简单，跟nginx一样，将日志序列化为json格式即可。
  修改tomcat配置文件,将日志格式修改为如下格式。

vim /usr/local/tomcat/conf/server.xml

        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"               prefix="localhost_access_log" suffix=".txt"               pattern="{&quot;clientip&quot;:&quot;%h&quot;,&quot;ClientUser&quot;:&quot;%l&quot;,&quot;authenticated&quot;:&quot;%u&quot;,&quot;AccessTime&quot;:&quot;%t&quot;,&quot;method&quot;:&quot;%r&quot;,&quot;status&quot;:&quot;%s&quot;,&quot;SendBytes&quot;:&quot;%b&quot;,&quot;Query?string&quot;:&quot;%q&quot;,&quot;partner&quot;:&quot;%{Referer}i&quot;,&quot;AgentVersion&quot;:&quot;%{User-Agent}i&quot;}" />

  此时查看新生成的访问日志，即可看到新生成的日志已经成json格式了。

tail -f /usr/local/tomcat/logs/localhost_access_log.2020-01-03.txt

{"clientip":"192.168.32.1","ClientUser":"-","authenticated":"-","AccessTime":"[03/Jan/2020:19:34:29 +0800]","method":"GET /bg-button.png HTTP/1.1","status":"304","SendBytes":"-","Query?string":"","partner":"http://192.168.32.51:8080/tomcat.css","AgentVersion":"Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0"}

  不过为了以防万一，可以去网上使用在线json格式校验工具，检查一下格式是否正确。

  此时就可以使用logstash工具来收集我们的tomcat日志了。

vim /etc/logstash/conf.d/tomcat-el.conf

  不过，想必你们一定也发现了，tomcat访问日志中是带有日期格式的，每天的访问日志文件名是不同的，这要怎么写到path中呢？
  哈，别慌，logstash的input-file插件也支持通配符的写法，我们可以写path => "/usr/local/tomcat/logs/localhost_access_log.*.txt"，如下所示。

input {  file {    path => "/usr/local/tomcat/logs/localhost_access_log.*.txt"    stat_interval => 3    start_position => "beginning"    codec => "json"    type => "tomcat_accesslog"  }}output {#  stdout {#    codec => rubydebug#  }  if [type] == "tomcat_accesslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "tomcat_accesslog-%{+YYYY.MM.dd}"  }}}

  PS：可以分开至不同的配置文件，也可以合并至一个文件中，不过我们习惯不同服务用单独的配置文件来抓取，方便修改。
  重启logstash服务，然后去kibana中创建tomcat_accesslog-*的索引，就可以看到tomcat的访问日志了。

收集JAVA服务的日志

  JAVA服务中的日志如果不报错还好，还可以是一行一条，但是一旦出现报错信息，一般都是小半屏幕N多行的报错信息，而我们收集日志的很重要的目的就是为了查看这些报错信息，而如果不对这些日志进行处理，还按照一行一条来收集的话，当我们查看这个日志的时候就会很崩溃了——这乱的几乎完全没法看。所以我们要想办法将JAVA服务的日志处理成一行。
  刚好强大的logstash也支持换行匹配，我们刚好就以logstash服务本身日志为例

vim /etc/logstash/conf.d/java-el.conf

input {  file {    path => "/logstash/logs/logstash-plain.log"    stat_interval => 3    start_position => "beginning"    type => "java_accesslog"        codec => multiline {    pattern => "^\[" #当遇到[开头的行时候将多行进行合并    negate => true #true 为匹配成功进行操作， false 为不成功进行操作    what => "previous" #与以前的行合并，如果是下面的行合并就是 next  }}}filter { #日志过滤，如果所有的日志都过滤就写这里，如果只针对某一个过滤就写在 input 里面的日志输入里面}output {  if [type] == "java_accesslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "java_accesslog-%{+YYYY.MM.dd}"  }}}

  重启logstash服务，然后去kibana中创建java_accesslog-*的索引，就可以看到java的访问日志了。

redis

  从redis读取日志和将收集到的日志储存至redis缓存中，其实使用了input的redis插件和output的redis插件来实现。官方文档地址为： https://www.elastic.co/guide/en/logstash/current/plugins-outputsredis.html

写入redis

  我们还以tomcat日志及java日志logstash日志本身为例，写入redis缓存中。
  先配置好redis服务器如下：

IP：192.168.32.31PORT：6379auth：123456

input {  file {    path => "/usr/local/tomcat/logs/localhost_access_log.*.txt"    stat_interval => 3    start_position => "beginning"    codec => "json"    type => "tomcat_redis_accesslog"  }  file {    path => "/logstash/logs/logstash-plain.log"    stat_interval => 3    start_position => "beginning"    type => "java_redis_accesslog"        codec => multiline {    pattern => "^\[" #当遇到[开头的行时候将多行进行合并    negate => true #true 为匹配成功进行操作， false 为不成功进行操作    what => "previous" #与以前的行合并，如果是下面的行合并就是 next  }}}output {  if [type] == "tomcat_redis_accesslog" {    redis {      data_type => "list"      key => "tomcat_redis_accesslog"      host => "192.168.32.31"      port => "6379"      db => "0"      password => "123456"    }}    if [type] == "java_redis_accesslog" {    redis {      data_type => "list"      key => "java_redis_accesslog"      host => "192.168.32.31"      port => "6379"      db => "1"      password => "123456"    }}}

  将日志数据以列表的形式储存在redis中，多个不同的日志，储存在不同数据库中。

读取redis

  与写入用法大致相同，可以说是怎么写进去的就怎么读出来。形式如下

input {  redis {    data_type => "list"    key => "tomcat_redis_accesslog"    host => "192.168.32.31"    port => "6379"    db => "0"    password => "123456"    codec => "json"  }}  redis {    data_type => "list"    key => "java_redis_accesslog"    host => "192.168.32.31"    port => "6379"    db => "1"    password => "123456"    codec => "json"  }}}output {  if [type] == "tomat_redis_accesslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "tomcat_redis_accesslog-%{+YYYY.MM.dd}"  }}  if [type] == "java_redis_accesslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "java_redis_accesslog-%{+YYYY.MM.dd}"  }}}

  不过需要注意的是input中记得加codec => "json"，否则无法解析正确各项属性，不方便我们查看和统计日志。而且不知道大家有没有发现，当我们从redis中取出数据的时候，我们的input选项中没有像往常那样写上type => "tomcat_redis_accesslog"，而是直接在output中做了type的判断。这是因为，redis中的数据是在写入的时候，已经附加了type属性，它在redis中储存时还是会保留type属性的，所以取出来的时候，还是按照之前写入时的type类型取出即可。

kafka

  在很多大型互联网公司，都喜欢使用kafka来作为缓存层，因为redis虽然效率很高，但数据不如kafka可靠，kafka更适合大数据量场景使用。这就要视业务实际情况而定了。不过使用kafa来作为中间缓冲区的企业还是大有人在的。
  我们可以新开启一个kafka主机，IP为192.168.32.36，使用默认端口9092。kafak的使用方法与redis大致相同。配置文件示例如下

input {  file {    path => "/apps/nginx/logs/access_json.log"    stat_interval => 3    start_position => "beginning"    codec => "json"    type => "nginx_kafka_accesslog"  }}output {  if [type] == "nginx_kafka_accesslog" {  kafka {    bootstrap_servers => "192.168.32.36:9092" #kafka 服务器地址    topic_id => "nginx_kafka_accesslog"    codec => "json"  } }}

  与写入redis有些区别的就是，kafka中不是key了，而是topic_id。所以读取时也有一些区别，填写的关键字为topics，而且同样做判断时，type是当初写进去的那个属性。

input {  kafka {    bootstrap_servers => "192.168.32.36:9092"    topics => "nginx_kafka_accesslog"    codec => "json"    consumer_threads => 1  #线程数，默认值为1，一般设置与分区数量相同    #decorate_events => true #不写默认是关闭的，开启此属性可以将当前topic、offset、group、partition等信息也带到message中  }}output {  if [type] == "nginx_kafka_accesslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "nginx_kafka_accesslog-%{+YYYY.MM.dd}"  }}}

  kafka也支持多文件同时写入，设置不同的topic_id就可以了。

ELK架构

  通常来说，只使用这三个组件就可以进行日志收集了，不过在企业实际生产中，需要用到ELK做集中日志收集的话，日志的产生量都是惊人的，所以通常情况下会需要缓存层来防止elasticsearch被压垮。架构如下图所示。（也可以通过filebeat来收集日志。）

ELK的部署

  需要注意的是，ELK的这三个组件版本要一致，否则可能会出现一些不必要的问题。我们这里选用最新版本7.5.1为例，演示主机均为ubuntu1804。

Elasticsearch

  我们这里用两台主机来搭建一个elasticsearch集群，一般来说因为他的选举机制，elasticsearch集群都是3、5、7奇数个，不过2台主机也可以使用，我们这里节约主机使用两台主机做演示，IP分别为192.168.32.41、192.168.32.42。

  官网下载链接为https://www.elastic.co/cn/downloads/elasticsearch。
  我们这里选择deb安装包安装，也可以选用源码tar包自己解压安装。

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.5.1-amd64.deb

  这个版本的deb包是自带java环境（openjdk11）的，如果主机已经预制java环境，可以去官网下载no-java的版本，使用jdk8的时候有warning，说未来版本将不支持jdk8，建议使用jdk11及以上。

dpkg -i elasticsearch-7.5.1-amd64.deb

  elasticsearch的配置文件路径为/etc/elasticsearch/elasticsearch.yml，需要修改的不多,将集群主机IP设置好就可以了，如下所示

root@elasticsearch1:~# grep "^[a-Z]" /etc/elasticsearch/elasticsearch.ymlcluster.name: ELK-CLuster      #集群名称，名称相同即属于是同一个集群node.name: node-1                 #本机在集群内的节点名称path.data: /elasticsearch/datapath.logs: /elasticsearch/logsbootstrap.memory_lock: true   #服务启动的时候锁定足够的内存， 防止数据写入swapnetwork.host: 0.0.0.0http.port: 9200discovery.seed_hosts: ["192.168.32.41","192.168.32.42"]cluster.initial_master_nodes: ["node-1","node-2"]

  我这里是单独创建了一个日志路径和数据路径，方便管理，并修改属主赋予权限。

mkdir -p /elasticsearch/{data,logs}chown -R elasticsearch:elasticsearch /elasticsearch

  除了在配置文件中设置bootstrap.memory_lock: true以外，还需要在启动配置文件中设置允许无限制使用内存，否则启动检查就会报错，导致服务起不来。

vim /usr/lib/systemd/system/elasticsearch.serviceLimitMEMLOCK=infinity

  而且根据官方文档https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html，最大30G 以内的内存。
  在一般使用中，使用最大内存和最小内存都设置为2G就可以了。

vim /etc/elasticsearch/jvm.options-Xms2g-Xmx2g

  另一台主机也同样配置，记得修改node.name，之后就可以启动elasticsearch了。

systemctl enable --now elasticsearch

  在任意主机使用curl命令可以检查集群的健康状态。

curl -sXGET http://192.168.32.41:9200/_cluster/health?pretty=true

  获取到的是一个 json 格式的返回值，那就可以通过 python 对其中的信息进行分析，例如对 status 进行分析，如果等于 green(绿色)就是运行在正常，等于yellow(黄色)表示副本分片丢失， red(红色)表示主分片丢失。
  至此，elasticsearch服务的部署就算是完成了。

Logstash

  logstash也是一个基于java的插件式服务，很多功能都是依靠于插件来实现的，我们安装官方的安装包，大部分常用插件都是已经预置了，如果还有其他的功能需求，就需要去官网或者github下载插件了。这些之后再说，我们先去官网上将Logstash7.5.1安装包下载下来并部署上。

wget https://artifacts.elastic.co/downloads/logstash/logstash-7.5.1.deb

  logstash也同样需要java环境

apt updateapt install openjdk-8-jdk

  或者安装oracle的jdk，生产环境还是推荐使用oracle公司的jdk，更加稳定。然后安装logstash

dpkg -i logstash-7.5.1.deb

  对于logstash的配置也很少,不做修改也可以使用，不过我们这里同样还是修改一下数据目录和日志目录

root@logstash1:~# grep "^[a-Z]" /etc/logstash/logstash.ymlpath.data: /logstash/datapath.logs: /logstash/logs

  修改属主

mkdir -p /logstash/{data,logs}chown -R /logstash

  logstash的默认执行程序路径为/usr/share/logstash/bin/logstash，这其实也是一个shell脚本文件，脚本中调用java的类库。

root@logstash1:~# /usr/share/logstash/bin/logstash --helpThread.exclusive is deprecated, use Thread::MutexWARNING: Could not find logstash.yml which is typically located in $LS_HOME/config or /etc/logstash. You can specify the path using --path.settings. Continuing using the defaultsUsage:    bin/logstash [OPTIONS]Options:    -n, --node.name NAME          Specify the name of this logstash instance,                                   if no value is given                                  it will default to the current hostname.                                   (default: "logstash1")    -f, --path.config CONFIG_PATH Load the logstash config from a specific file                                  or directory.  If a directory is given, all                                  files in that directory will be concatenated                                  in lexicographical order and then parsed as a                                  single config file. You can also specify                                  wildcards (globs) and any matched files will                                  be loaded in the order described above.    -e, --config.string CONFIG_STRING Use the given string as the configuration                                  data. Same syntax as the config file. If no                                  input is specified, then the following is                                  used as the default input:                                  "input { stdin { type => stdin } }"                                  and if no output is specified, then the                                  following is used as the default output:                                  "output { stdout { codec => rubydebug } }"                                  If you wish to use both defaults, please use                                  the empty string for the '-e' flag.                                   (default: nil)

  不过常用的选项也就-e和-f，分别是通过命令行指定参数或者通过文件来指定配置参数。我们可以使用命令来测试

/usr/share/logstash/bin/logstash -e 'input { stdin{} } output { stdout{ codec => rubydebug }}' 

  通过标准输入输入信息，并通过标准输出返回日志信息。同样，我们也可以调用input的file插件和output的file插件实现从文件中读取数据，或者写入文件。这样就可以实现对日志文件的抓取了。我们可以先尝试抓取系统日志如syslog。

/usr/share/logstash/bin/logstash -e 'input { file { path => "/var/log/syslog"} } output { stdout{ codec => rubydebug }}' 

  哈，系统日志如果太多，估计会刷屏的。
  不过刚才那些都只是一些基本用法而已，而实际生产中，我们肯定不能使用命令行来手动获取数据，我们需要的是一个可靠的服务，来帮我们自动抓取日志并筛选过滤，这就需要我们使用配置文件来设置了。
  例如我们要做的抓取本机的nginx的访问日志、错误日志还有系统日志，并传递至之前配好的elasticsearch中。
  那就在路径/etc/logstash/conf.d/目录下，创建一个新的配置文件，使用systemd启动时会自动读取conf.d下的配置文件。

vim /etc/logstash/conf.d/nginx.confinput {  file {     path => "/var/log/syslog"    stat_interval => 3    start_position => "beginning"    type => "syslog"  }  file {     path => "/apps/nginx/logs/access_json.log"    stat_interval => 3    start_position => "beginning"    codec => "json"    type => "nginx_accesslog"  }  file {     path => "/apps/nginx/logs/error.log"    stat_interval => 3    start_position => "beginning"    type => "nginx_errorlog"  }}output {  if [type] == "syslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "syslog-%{+YYYY.MM.dd}"  }}  if [type] == "nginx_accesslog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "nginx_accesslog-%{+YYYY.MM.dd}  }}  if [type] == "nginx_errorlog" {  elasticsearch {    hosts => ["192.168.32.41:9200"]    index => "nginx_accesslog-%{+YYYY.MM.dd}  }}}

  logstash支持条件判断，多输入以及多输出，设定type规则，来将每一类日志分类在不同的索引，且支持java的时间变量，可以实现根据日期归档每一天的日志，方便查看和统计。
  我们可以使用命令来测试脚本的语法是否正确，如果不加-t可以直接以前台进程的方式启动logstash，不过会占据终端，但测试的时候还是蛮方便的。

/usr/share/logstash/bin/logstash -f /etc/log/logstash/conf,d/nginx.conf -t

  不过仅仅是这样，是无法统计具体访问时间、访问ip及访问路径的详细信息的，我们需要将nginx的日志序列化，或者说是储存为json格式。
  所以修改nginx的配置文件,将日志格式修改一下。

http {    include       mime.types;    default_type  application/octet-stream;    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '    #                  '$status $body_bytes_sent "$http_referer" '    #                  '"$http_user_agent" "$http_x_forwarded_for"';    log_format access_json '{"@timestamp":"$time_iso8601",'        '"host":"$server_addr",'        '"clientip":"$remote_addr",'        '"size":$body_bytes_sent,'        '"responsetime":$request_time,'        '"upstreamtime":"$upstream_response_time",'        '"upstreamhost":"$upstream_addr",'        '"http_host":"$host",'        '"uri":"$uri",'        '"domain":"$host",'        '"xff":"$http_x_forwarded_for",'        '"referer":"$http_referer",'        '"tcp_xff":"$proxy_protocol_addr",'        '"http_user_agent":"$http_user_agent",'        '"status":"$status"}';    access_log  /apps/nginx/logs/access_json.log  access_json;

  PS:加入的属性名称不要有type，否则会影响到logstash做type判断。然后记得在配置文件中注明输入信息为json格式。看到如下信息，则说明日志被成功拆解。

{    "http_user_agent" => "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0",               "path" => "/apps/nginx/logs/access_json.log",         "@timestamp" => 2020-01-03T08:17:47.000Z,       "upstreamhost" => "-",                "xff" => "-",       "responsetime" => 0.0,               "size" => 0,             "status" => "304",          "http_host" => "192.168.32.51",           "clientip" => "192.168.32.1",             "domain" => "192.168.32.51",            "tcp_xff" => "",               "host" => "192.168.32.51",           "@version" => "1",                "uri" => "/index.html",            "referer" => "-",       "upstreamtime" => "-"}

  使用systemctl enable --now logstash启动logstash服务，过一会，日志就写入elasticsearch服务器中了，最好将/etc/systemd/system/logstash.service文件的中启动用户组都改为root，避免因为权限问题，导致无法读取数据。
  我记得之前遇到过一次，命令行可以正常使用logstash，不过使用systemd启动就一直报错，logstash: could not find java; set JAVA_HOME or ensure java is in PATH,明明环境变量都是正常的，后来在/usr/share/logstash/bin/logstash脚本文件中加了一个JAVA_HOME=/usr/local/jdk环境变量就好了，而之后配的时候就没有遇到这个问题了，这就很奇怪了。

Kibana

  日志信息都已经写到elasticsearch服务器中了，不过我们怎么才可以看到具体的日志信息呢？这就需要借助日志展示工具Kibana了。
  虽然elasticsearch可视化工具也有不少，例如head、kopf、cerebro等等，不过他们都是监控elasticsearch集群状态的，对日志做展示分析的还是首推开源的官方组件Kibana。
  同样下载kibana7.5.1版本

https://artifacts.elastic.co/downloads/kibana/kibana-7.5.1-amd64.deb

  配置上也很简单，设置监听IP及端口，设置elasticsearch主机地址，最后再将语言环境改为中文就可以启动kibana服务了。

root@kibana1:~# grep "^[a-Z]" /etc/kibana/kibana.ymlserver.port: 5601server.host: "0.0.0.0"elasticsearch.hosts: ["http://192.168.32.41:9200"]i18n.locale: "zh-CN"

  浏览器访问kibana主机的5601端口。
  创建索引模式，依次添加索引。

  然后点左边第一个（最上面）的那个discover图标，就可以看到数据了。点击更改，选择对应的索引，还可以创建各种视图等一系列功能这里就不再详细讲解了。都比较简单。
  至此ELK的初步部署就算完成了。

  持续集成是指多名开发者在开发不同功能代码的过程当中，可以频繁的将代码行合并到一起并切相互不影响工作。
  持续部署是指是基于某种工具或平台实现代码自动化的构建、测试和部署到线上环境以实现交付高质量的产品。持续部署在某种程度上代表了一个开发团队的更新迭代速率。
  持续交付是在持续部署的基础之上， 将产品交付到线上环境， 因此持续交付是产品价值的一种交付， 是产品价值的一种盈利的实现。
  可以用一个类似戴明环的图来比较形象展示这种生产模式结构。

  比较常用到的开源软件有gitlab、Maven、jenkins、saltstack、slastic以及zabbix。其中gitlab和jenkins是最常用的一个组合，也是目前最为火热的结局方案。本文将详细介绍gitlab的部署及使用。

Gitlib—分布式版本控制系统

持续集成开源工具

  我们需要在公司的服务器安装某种程序，该程序用于按照特定格式和方式记录和保存公司多名开发人员不定期提交的源代码，且后期可以按照某种标记及方式对用户提交的数据进行还原，这是我们就需要用到版本控制系统，也就是所谓的持续集成工具。
  早期的集中式版本控制系统如CVS(Concurrent Version System)，现已基本淘汰，可能有些公司还在使用SVN(Subversion)作为版本控制系统，不过他的缺点相当明显，集中式管理，太依赖于网络带宽，当大家一起从管理服务器拉代码或提交代码时，遇到网速慢的话，可能提交一个10M的文件就需要5分钟，效率很差。
  而gitlab是分布式的版本控制系统，不存在“中央服务器”，每个人的电脑上都是一个完整的版本库，这样，你工作需要提交或者回滚时，就不需要联网了，因为版本库就在你自己的电脑上。需要汇总时，我们将代码提交至gitlab服务器，将每个人的劳动成果也就是分支仓库的代码合并即可。

部署gitlab

  具体安装要求及配置可以参考官方文档
  https://about.gitlab.com/install/ # Gitlab 服务的安装文档
  https://docs.gitlab.com/ce/install/requirements.html #安装环境要求

  最好先配置好依赖仓库源，可以配置阿里的镜像仓库源。
  官方下载deb安装包比较慢，可以使用清华大学的镜像源下载。

  我们这里使用gitlab-ce_11.11.8来演示。也可以去下载其他版本，ubuntu 国内下载地址： https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/ubuntu/pool/。

wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/ubuntu/pool/bionic/main/g/gitlab-ce/gitlab-ce_11.11.8-ce.0_amd64.debdpkg -i gitlab-ce_11.11.8-ce.0_amd64.deb

  安装可能需要一段时间，耐心等待。
  然后修改gitlab的配置文件

root@gitlabUbuntu24:~# grep "^[a-Z ]" /etc/gitlab/gitlab.rbexternal_url 'http://192.168.32.24' gitlab_rails['gitlab_email_from'] = 'example@qq.com' gitlab_rails['smtp_enable'] = true gitlab_rails['smtp_address'] = "smtp.qq.com" gitlab_rails['smtp_port'] = 465 gitlab_rails['smtp_user_name'] = "example@qq.com" gitlab_rails['smtp_password'] = "keyword" gitlab_rails['smtp_domain'] = "qq.com" gitlab_rails['smtp_authentication'] = "login" gitlab_rails['smtp_enable_starttls_auto'] = true gitlab_rails['smtp_tls'] = true user['git_user_email'] = "example@#qq.com" alertmanager['admin_email'] = 'example@qq.com'

  将上面这些选项都设置好。例如使用的是QQ邮箱，则需要去邮箱设置里获取授权码，填在password处。因为gitlab是一般是通过邮件来注册和获取密码的，所以这些配置都要有，邮箱最好填企业邮箱或者公司领导邮箱，以避免员工离职等其他风险。
然后使用命令让配置文件生效。

    gitlab-ctl reconfigure 

  这时就可以通过命令gitlab-ctl start启动gitlab了。
  可以通过gitlab-ctl status命令查看gitlab运行状态，或者后跟组件名称查看具体组件的运行状态。

gitlab 相关的目录：

    /etc/gitlab #配置文件目录    /run/gitlab #运行 pid 目录    /opt/gitlab #安装目录    /var/opt/gitlab #数据目录

gitlab常用命令

  gitlab用法与github几乎相同，这里就不再详细介绍。

git config --global user.name “name“ #设置全局用户名git config --global user.email xxx@xx.com #设置全局邮箱git config --global --list #列出用户全局设置git add index.html / . #添加指定文件、 目录或当前目录下所有数据到暂存区git commit -m “11“ #提交文件到工作区git status #查看工作区的状态git push #提交代码到服务器git pull #获取代码到本地git log #查看操作日志vim .gitignore #定义忽略文件git reset --hard HEAD^^ #git 版本回滚， HEAD 为当前版本，加一个^为上一个， ^^为上上一个版本git reflog # #获取每次提交的 ID，可以使用--hard 根据提交的 ID 进行版本回退git reset --hard 5ae4b06 #回退到指定 id 的版本git branch #查看当前所处的分支git checkout -b develop #创建并切换到一个新分支git checkout develop #切换分支

gitlab数据备份

  gitlab可以通过命令gitlab-rake来备份数据。数据备份前，需要停止unicorn、sidekiq组件服务。

gitlab-ctl stop unicorngitlab-ctl stop sidekiqgitlab-rake gitlab:backup:create #在任意目录即可备份当前 gitlab 数据gitlab-ctl start #备份完成后启动 gitlab

  备份完成的数据储存在/var/opt/gitlab/backups/路径下,生成与时间相关的tar包。

root@gitlabUbuntu24:~# ll /var/opt/gitlab/backups/total 4600drwx------  2 git  root    4096 Dec 25 14:41 ./drwxr-xr-x 20 root root    4096 Dec 25 11:02 ../-rw-------  1 git  git  4700160 Dec 25 14:41 1577256108_2019_12_25_11.11.8_gitlab_backup.tar

  需要注意的是，命令备份仅仅是备份了gitlab中的数据，通常我们我们的备份脚本中还需要备份以下文件。

/var/opt/gitlab/nginx/conf #nginx 配置文件/etc/gitlab/gitlab.rb #gitlab 配置文件/etc/gitlab/gitlab-secrets.json #key 文件

  使用命令gitlab-rake gitlab:backup:restore BACKUP=备份文件名可以恢复之前的备份数据（文件名到时间戳即可）。同样，执行恢复命令之前也要先关闭unicorn、sidekiq组件服务。恢复时，需要输入yes确认。

gitlab-ctl stop unicorngitlab-ctl stop sidekiqgitlab-rake gitlab:backup:restore BACKUP=1577256108_2019_12_25_11.11.8

gitlab的关闭注册

  服务正常启动之后，就可以访问主机的IP或者域名，登陆gitlab系统了。gitlab和github极为相似，也支持邮箱注册。，第一次访问，会放我们设置管理员账户密码，我们使用管理员账户登录，用户名为root。
  gitlab默认是开放注册的，而我们作为企业内部使用的版本管理系统，肯定不希望大家随便创建用户来访问，这样很不便于管理。
  我们可以在点击中间的小扳手图标，选择setting设置，将sign-up功能取消，这样登录界面就无法注册了。

  注意，小心别关错了，要是把sign-in功能取消就没法登陆了，哪怕使用root权限账号退出去也就没法登陆了。如果真的不幸将gitlab的sign-in功能取消掉，那只能使用命令行的方式修改数据库中设置了。
  因为gitlab目前版本默认使用的psql，所以修改数据库的方式，跟mysql不同，具体如下
先切换至gitlab-psql用户。

su - gitlab-psql

  使用 -h指定数据库路径 -d指定数据库，连接psql数据库。

psql -h /var/opt/gitlab/postgresql -d gitlabhq_productionUPDATE application_settings SET password_authentication_enabled_for_web=true;\q

  修改完数据后，重启gitlab服务。

exitgitlab-ctl restart

  此时，web界面就又可以登陆了。

gitlab的中文汉化

  gitlab默认语音为英语，有时有些专业数据或者不太常用的选项配置我们可能无法准确理解它的含义，所以将gitlab汉化成中文还是有一定必要的。
  gitlab的每个用户，可以点击用户头像，设置，设置偏好，选择语音。
  选择中文之后刷新，就可看到一部分菜单变为了中文。但是也仅仅是菜单变成了中文而已，很多选项和图标都还是英文显示，如果想彻底汉化为中文，则需要我们去下载中文汉化补丁了。
  汉化补丁是第三方爱好者提供，github地址是https://gitlab.com/xhang/gitlab，找到对应版本的gitlab汉化包。
  gitlabv11.11.8汉化包的下载地址如下

wget https://gitlab.com/xhang/gitlab/-/archive/v11.11.8-zh/gitlab-v11.11.8-zh.tar.gz

  然后先停止gitlab

gitlab-ctl stop

  备份并替换文件

tar xvf gitlab-v11.11.8-zh.tar.gzcp -rp /opt/gitlab/embedded/service/gitlab-rails /opt/gitlab-rails.bakcp -rf gitlab-v11.11.8-zh/* /opt/gitlab/embedded/service/gitlab-rails/

  此时，汉化就完成了，可以直接启动gitlab了。就可以看到页面都变成了中文了，效果图如下。

  zabbix功能强大，可横向扩展、自定义监控项、支持多种监控方式、可监控网络与服务等。

zabbix功能简述

• 数据采集
  zabbix是周期性采集时序数据。
    采集对象可以有：服务器、路由器、交换机、存储、防火墙、IP、PORT、URL、自定义监控对象…
    采集目标：监控项，指标数据（metrics data）
    数据采集方式：zabbix-server，zabbix-proxy，zabbix-agent
    按照有无代理分类：
      Agentless：SNMP,Telnet,ssh, IPMI, JMX,
      Agent：zabbix agent
• 数据存储
  可以储存历史数据和局势数据，还有阈值。
    历史数据: 每个监控项采集到的每个监控值
    趋势数据: 趋势表里主要保留某个监控项一个小时内历史数据的最大值、最小值和平均值以及该监控项一个小时内所采集到的数据个数。
    阈值：可按照预定义的阈值等级实现分层报警
  支持的数据库类型有：
    SQL: MySQL/MariaDB(Zabbix)
    NoSQL：Redis(Open-falcon)
    rrd: Round Robin Database(Cacti)
• 数据展示
  可以使用原生的zabbix web界面可以展示graph -> screen -> slideshow(将多个screen以幻灯片的方式进行轮流展示)
  还支持以zabbix为数据源，在grafana展示更绚丽的界面。
• 报警通知
  支持email,短信,微信,语音等多种方式报警通知，也可以实现故障自治愈。
  host (host groups) <- templates #从模板继承告警配置
  host -> items -> triggers -> action (条件-conditions, 操作-operations) #自定义告警配置

  zabbix架构

    在zabbix服务中，一般都包含有zabbix-server、zabbix-agent、zabbix-proxy，及数据库，结构如下图所示：
  
    一般都需要在被监控端安装zabbix-agent服务来抓取数据，然后汇总到zabbix-server 端来展示分析监控报警，如果agent过多或者可能不同机房的数据，可以通过zabbix-proxy来暂存收集数据，之后在汇总至zabbix-server端，所以zabbix-proxy端及zabbix-server 端都需要一个mysql数据库来储存即时及历史监控数据的（zabbix-proxy处临时储存）。而且整个体系中最重要的就是数据库了，数据都在数据库中，只要数据库中的数据不丢失，重建一个zabbix监控架构还是比较容易的，所以可以对数据库做主从复制高可用，可参见之前文章。

  zabbix部署

  zabbix server

  包管理工具安装

    我们先来搭建zabbix-server端。
    对于Ubuntu系统：
  先下载配置镜像仓库,并apt安装zabbix-server-mysql 、zabbix-frontend-php 及zabbix-agent，其中zabbix-server的二进制程序及启动配置文件都在在zabbix-server-mysql安装包里。

  wget https://repo.zabbix.com/zabbix/4.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_4.0-3%2Bbionic_all.debdpkg -i zabbix-release_4.0-3+bionic_all.debapt updateapt -y install zabbix-server-mysql zabbix-frontend-php zabbix-agent

    然后开始安装zabbix-server的数据库。可以与zabbix-server复用一台主机，也可以单独一台主机。我们这里使用一台新的主机,apt安装好mariadb（与mysql操作一样）。
    先以root身份登陆mysql主机，然后为zabbix创建一个数据库，例如zabbix_server，再创建一个zabbix用户，并授权

  MariaDB [mysql]> create database zabbix_server character set utf8 collate utf8_bin;MariaDB [mysql]>grant all privileges on zabbix_server.* to zabbix@"192.168.32.%" identified by "zabbix";MariaDB [mysql]>flush privileges;

    然后回到zabbix-server主机，安装一个mysql客户端，并测试可否用之前创建的zabbix账号登录数据库。

  apt mysql-client -ymysql -uzabbix -pzabbix -h192.168.32.20

    确保可以登陆之后，导入数据库表结构

  zcat /usr/share/doc/zabbix-server-mysql/create.sql.gz | mysql -uzabbix -pzabbix -h192.168.32.20 zabbix_server

    此时在登入数据库服务器，使用命令查询，可以看到已经生成了很多表

  mysql> show tables from zabbix_server;

    然后编辑zabbix配置文件

  vim /etc/zabbix/zabbix_server.conf

    修改数据库相关信息，其他的可以不做修改。

  root@DockerUbuntu19:~# grep "^[a-Z]" /etc/zabbix/zabbix_server.confLogFile=/var/log/zabbix/zabbix_server.logLogFileSize=1PidFile=/var/run/zabbix/zabbix_server.pidSocketDir=/var/run/zabbixDBHost=192.168.32.20DBName=zabbix_serverDBUser=zabbixDBPassword=zabbixStartTrappers=10Timeout=30AlertScriptsPath=/usr/lib/zabbix/alertscriptsExternalScripts=/usr/lib/zabbix/externalscriptsFpingLocation=/usr/bin/fpingFping6Location=/usr/bin/fping6LogSlowQueries=3000

    重启zabbix服务。

  systemctl restart zabbix-server zabbix-agent apache2

    此时访问zabbix-server主机对应的IP或者域名,加上路径zabbix/setup.php就可以访问zabbix的web界面进行检查配置了。
  在环境检查时，可能会有一项报错，提示PHP option date.timezone检查unkown。虽然不影响服务启动，不过我们最好还是将他解决掉。

  vim /etc/zabbix/apache.conf

    搜索timezone,将值改为php_value date.timezone Asia/Shanghai。注意，有两个timezone设置，分别是针对PHP5.版本和PHP7.版本，我们修改7版本的就可以了，也可以都修改。然后重启服务。

  systemctl restart zabbix-server zabbix-agent apache2

    此时，再刷新一下网页，就可以看到所有检查都是OK状态了。正确填写数据库信息和server主机信息，点击Finish，配置就完成了，会自动跳转至登录界面，默认用户名为Admin，默认密码为zabbix。

编译安装zabbix

  源码编译安装zabbix的话,先下载源码包。
  下载路径为https://jaist.dl.sourceforge.net/project/zabbix/ZABBIX%20Latest%20Stable/。
  我们这里以4.015版本为例

cd /usr/local/srcwget https://jaist.dl.sourceforge.net/project/zabbix/ZABBIX%20Latest%20Stable/4.0.15/zabbix-4.0.15.tar.gztar xf zabbix-4.0.15.tar.gzcd zabbix-4.0.15/

  编译安装需要我们自己来创建zabbix用户组。

groupadd -g 1111 zabbix #创建zabbix用户和组useradd -u 1111 -g 1111 zabbix

  安装相关依赖的安装包
  CentOS:

yum install gcc libxml2-devel net-snmp net-snmp-devel curl curl-devel php phpbcmath php-mbstring mariadb mariadb-devel -y

  Ubuntu:

apt updateapt-get install apache2 apache2-bin apache2-data apache2-utils fontconfig-config fonts-dejavu-core fping libapache2-mod-php libapache2-mod-php7.2 libapr1 libaprutil1 libaprutil1-dbd-sqlite3 libaprutil1-ldap libfontconfig1 libgd3 libiksemel3 libjbig0 libjpeg-turbo8 libjpeg8 liblua5.2-0 libodbc1 libopenipmi0 libsensors4 libsnmp-base libsnmp30 libsodium23 libssh2-1 libtiff5 libwebp6 libxpm4 php-bcmath php-common php-gd php-ldap php-mbstring php-mysql php-xml php7.2-bcmath php7.2-cli php7.2-common php7.2-gd php7.2-json php7.2-ldap php7.2-mbstring php7.2-mysql php7.2-opcache php7.2-readline php7.2-xml snmpd ssl-cert ttf-dejavu-core libmysqlclient-dev libxml2-dev libxml2 snmp libsnmp-dev libevent-dev openjdk-8-jdk curl libcurl4-openssl-dev

  然后就可以编译并安装了。

./configure --prefix=/apps/zabbix_server \--enable-server --enable-agent --with-mysql \--with-net-snmp --with-libcurl --with-libxml2 --enable-javamake install

  之后流程就与之前一样。

设置中文web页面及乱码问题

如果Ubuntu系统安装时为选择中文语言，则web界面大概率是英文界面，可能会对我们的使用有一定影响。
点击右上角的用户头像标志，可以选择语音。不过如果系统没有安装中文时，是无法选择中文的。

  所以需要我们在ubuntu系统中安装并设置中文简体语言环境.。
  1、安装简体中文语言环境

apt-get install language-pack-zh*

  2、增加中文语言环境变量

vim /etc/environmentPATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games"LANG="zh_CN.UTF-8"

  3、重新设置本地配置

dpkg-reconfigure locales

  此时刷新网页，就可以选择中文Chinese(zh_CN)了，点Update修改保存。此时就可以看到界面变成中文了。不过这时，在图形等界面，大概率会出现字符无法显示的乱码情况，这是由于当前系统有些监控项部分显示有乱码，使由于web界面显示为中文但是系统没有相关字体支持，因此需要相关字体的支持才能正常显示。这时需要我们自己配置一个字体并修改zabbix的font设置。
  可以去网上下载字体,也可以从windows中获取已有字体。
  在windows中路径为控制面板\外观和个性化\字体（复制至地址栏就可以找到了）

  不过需要注意的是，里面有的字体是otf格式，zabbix无法识别，要选择ttf格式的字体才可以。


  将选好的或者下载好的ttf格式字体，拷贝至zabbix-server主机的zabbix安装目录下的fonts目录里。
  如果是ubuntu通过apt安装，则为/usr/share/zabbix/assets/fonts，如果是编译安装则可通过find命令搜索一下find /PATH(安装路径) -name fonts。
  可以看到里面已经有一个字体文件了的（虽然是个软链接）。

root@DockerUbuntu19:~# ll /usr/share/zabbix/assets/fonts总用量 11520drwxr-xr-x 2 root root     4096 12月 18 18:59 ./drwxr-xr-x 5 root root     4096 12月 18 17:43 ../lrwxrwxrwx 1 root root       38 12月 18 17:44 graphfont.ttf -> /etc/alternatives/zabbix-frontend-font-rw-r--r-- 1 root root 11785184 12月 18 18:59 simkai.ttf

  将我们准备好的ttf文件拷贝至此目录，修改zabbix环境变量配置文件(apt安装路径为/usr/share/zabbix/include/defines.inc.php)

cd /usr/share/zabbix/vim include/defines.inc.php

  搜索替换graphfont为我们期望的字体名称。一共有两处。都替换了即可。

#define('ZBX_GRAPH_FONT_NAME',          'graphfont'); // font file namedefine('ZBX_GRAPH_FONT_NAME',           'simkai'); // font file name- - -#define('ZBX_FONT_NAME', 'graphfont');define('ZBX_FONT_NAME', 'simkai');

  不需要重启zabbix及apache，修改后的字体文件即可直接生效。
  至此zabbix-server端的配置就完成了。

zabbix proxy

zabbix proxy对比zbbbix server

zabbix proxy版本选择

  zabbix proxy的大版本必须要和zabbix server版本一致，否则会导致出现zabbix server与zabbix proxy不兼容问题，会提示报错：

proxy "zabbix-proxy-active" protocol version 3.2 differs from server version 4.0

  确认下zabbix-server的版本

root@DockerUbuntu19:/usr/share/zabbix/assets/fonts# zabbix_server -Vzabbix_server (Zabbix) 4.0.15Revision 992445e02c 25 November 2019, compilation time: Nov 25 2019 09:01:31Copyright (C) 2019 Zabbix SIALicense GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>.This is free software: you are free to change and redistribute it according tothe license. There is NO WARRANTY, to the extent permitted by law.This product includes software developed by the OpenSSL Projectfor use in the OpenSSL Toolkit (http://www.openssl.org/).Compiled with OpenSSL 1.1.0g  2 Nov 2017Running with OpenSSL 1.1.1  11 Sep 2018

  所以我们最好也安装相同版本的zabbix-proxy。

zabbix proxy部署

  因为proxy也需要一个数据库，可以选择复用server端的数据库，或者再另外创建一个。我们这里复用之前server端的数据库。
  所以在之前的MariaDB数据库中，新建一个库，并创建对应权限用户。

MariaDB [(none)]> create database zabbix_proxy;Query OK, 1 row affected (0.01 sec)MariaDB [(none)]> grant all privileges on zabbix_proxy.* to proxy@"172.18.32.%" identified by "proxy";Query OK, 0 rows affected (0.10 sec)

  回到proxy主机，然后去官方镜像仓库https://repo.zabbix.com/zabbix/4.0/找到对应系统、对应版本的安装包路径
  CentOS：

yum install https://repo.zabbix.com/zabbix/4.0/rhel/7/x86_64/zabbix-proxy-mysql-4.0.15-1.el7.x86_64.rpm

  Ubuntu：

wget https://repo.zabbix.com/zabbix/4.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_4.0-3%2Bbionic_all.debdpkg -i zabbix-release_4.0-3+bionic_all.debapt updateapt install zabbix-proxy-mysql

  导入proxy的数据库表（CentOS和Ubuntu路径可能不同，不过名字都叫schema.sql.gz）

zcat /usr/share/doc/zabbix-proxy-mysql-4.0.15/schema.sql.gz | mysql -uproxy -pproxy -h192.168.32.20 zabbix_proxy

  修改配置文件

vim /etc/zabbix/zabbix_proxy.confProxyMode=1 #0为主动，1为被动Server=192.168.32.19 #zabbix server服务器的地址或主机名Hostname=Zabbix proxy #代理服务器名称，需要与zabbix server添加代理时候的proxyname是一致的！ListenPort=10051 #zabbix proxy监听端口LogFile=/var/log/zabbix/zabbix_proxy.logEnableRemoteCommands=1 #允许zabbix server执行远程命令PidFile=/var/run/zabbix/zabbix_proxy.pidSocketDir=/var/run/zabbixDBHost=192.168.32.20 #数据库服务器地址DBName=zabbix_proxy #使用的数据库名称DBUser=proxy #连接数据库的用户名称DBPassword=proxy #数据库用户密码DBPort=3306 #数据库端口ProxyLocalBuffer=720 #已经提交到zabbix server的数据保留时间ProxyOfflineBuffer=720 #未提交到zabbix server的时间保留时间HeartbeatFrequency=60 #心跳间隔检测时间，默认60秒，范围0-3600秒，被动模式不使用ConfigFrequency=5 #间隔多少秒从zabbix server获取监控项信息DataSenderFrequency=5 #数据发送时间间隔，默认为1秒，范围为1-3600秒，被动模式不使用StartPollers=20 #启动的数据采集器数量CacheSize=2G #保存监控项而占用的最大内存HistoryCacheSize=2G #保存监控历史数据占用的最大内存HistoryIndexCacheSize=128M #历史索引缓存的大小Timeout=30 #监控项超时时间，单位为秒LogSlowQueries=3000 #毫秒，多久的数据库查询会被记录到日志

  然后在web界面添加proxy，主动模式是proxy端主动向server端推送数据，所以不需要填写IP，被动模式是server端向proxy拉取数据，需要填写proxy端IP或者域名DNS。选在主动代理或者被动代理，视情况而定，要与配置文件中相同。
  至此，zabbix proxy端也就配置好了。

zabbix agent

agent工作模式

  一般来说，zabbix agent与proxy有两种工作模式，一个是主动模式，即被监控端主动向server端或者proxy端发起请求，请求监控项列表，并按照列表的内容主动定时推送监控信息，此时agent端使用随机端口访问server端或者proxy端的固定端口（10051端口）；另一个是被动模式，是server端或者proxy依照设定好的监控项条目，直接去agent段获取相应的数据，此时是agent端打开固定端口（10050）等待请求。
  主动模式与被动模式中的主动与被动，是相对于agent端来说的，agent主动的就叫做主动模式，agent端被动的就叫做被动模式。

zabbix agent部署

  在被监控主机上安装zabbix-agent安装包。流程与之前一样。

apt install zabbix-agent

  修改配置文件，主要需要设置Server和ServerActive，其他保持默认就可以了。Server是控制允许哪个主机可以从本机上拉取数据，一般把server端和paroxy端都写上，方便修改(，其实只写proxy端ip就可以了)，ServerActive是设置向哪个主机请求主动监控配置的，如果打算使用被动模式，则可不进行设置此项，而且设置了也不会生效。

root@DockerUbuntu21:~# grep "^[a-Z]" /etc/zabbix/zabbix_agentd.confPidFile=/var/run/zabbix/zabbix_agentd.pidLogFile=/var/log/zabbix-agent/zabbix_agentd.logLogFileSize=1Server=192.168.32.19,192.168.32.20ListenPort=10050StartAgents=4ServerActive=127.0.0.1Hostname=192.168.32.21Timeout=20Include=/etc/zabbix/zabbix_agentd.conf.d/*.conf

  重启agent服务，是配置生效

systemctl restart zabbix-agent

配置监控

  之前的一系列操作，只是完成了一个服务基础，之后的操作才是重点，也就是配置监控。
  进入zabbix的web管理界面，可以看到有很多项目，我们选择配置——主机——创建主机，来添加我们的监控对象。

  在创建主机界面，需要选择一个模版，也就是监控规则，因为我们还没有创建模版，所以可以使用系统自带的模版，可以搜索linux使用自带的一些监控项。
  需要注意的是，agent使用工作模式到底是主动模式还是被动模式，就在于监控项的类型是主动还是被动模式。系统默认模版都是被动式的，如果想使用主动式，可以批量修改模版监控项（模版的具体介绍会在之后文章介绍）。


  而且，agent端使用的主动式或者被动式方式，与proxy设置的主动模式还是被动模式没有关系。proxy创建时选择的模式要与proxy配置文件一致，而这个设定只是控制proxy与server之间的关系，而真正控制agent工作模式的就在于这个监控项目的设置了。也就是说如果监控项目都是被动式，ServerActive设不设置都不会生效，如果有一部分项目是主动式，若没有设置正确的ServerActive，则这些项目将会获取不到数据了。
  至此，对于zabbix的初步配置就生效了，等一下就可以看到添加的主机都显示绿色的可用状态。
  之后就可以在图形界面看到图形数据了。

  架构图如下所示

  根据kubeasz官方文档中高可用集群所需节点配置如下

配置集群环境

  此次部署节点设置如下：
ansible安装节点&master1：172.18.32.18
master2：172.18.32.19
harbor：172.19.32.20
node1：172.18.32.21
node2：172.18.32.22
etcd1：172.18.32.23
etcd2：172.18.32.24
etcd3：172.18.32.25
haproxy1+keepalived：172.18.32.183
haproxy2+keepalived：172.18.32.184 VIP：172.18.32.250

配置免密登录

  先将ansible安装节点也就是master1主机（可以不复用主机）的秘钥分发至各个主机。

vim fenfamiyao.sh#!/bin/bash#目标主机列表PASSWORD="password"PORT="22"IP="172.18.32.18172.18.32.19172.18.32.20172.18.32.21172.18.32.22172.18.32.23172.18.32.24172.18.32.25"[ -a /root/.ssh/id_rsa ] || ssh-keygen -t rsa which sshpass &> /dev/null || yum install sshpass -y #适用于CentOSfor node in ${IP};do        sshpass -p $PASSWORD ssh-copy-id -p$PORT -o StrictHostKeyChecking=no ${node}#        if [ $? -eq 0 ];then#                echo "${node} 秘钥 copy 完成,准备环境初始化....."#                ssh -p$PORT ${node} "mkdir /etc/docker/certs.d/harbor.hechao.com -p"#                echo "Harbor 证书目录创建成功!"#                scp -P$PORT /usr/local/src/harbor/certs/harbor-ca.crt ${node}:/etc/docker/certs.d/harbor.hechao.com/harbor-ca.crt#                echo "Harbor 证书拷贝成功!"#                scp -P$PORT /etc/hosts ${node}:/etc/hosts#                echo "host 文件拷贝完成"#                scp -r -P$PORT /root/.docker ${node}:/root/#                echo "Harbor 认证文件拷贝完成!"#                scp -r -P$PORT /etc/resolv.conf ${node}:/etc/                 echo "镜像加速链接同步!"                 ssh ${node} "mkdir -p /etc/docker"                 scp -r -p$PORT /etc/docker/daemon.json ${node}:/etc/docker/daemon.json#        else#                echo "${node} 秘钥 copy 失败"#        fidone

安装ansible环境

  因为要使用ansible批量自动化部署K8s集群，每个主机都要先安装ansible环境。
  ubuntu默认的python版本是3.6，而ansible需要python2.7。

apt updateapt install python2.7ln -s /usr/bin/python2.7 /usr/bin/python

  master1上安装ansible

apt install ansible

  centos一般是自带python2.X环境，所以一般不需要在进行额外操作。
  在master1上检查各节点连通性

ansible all -m ping

配置kubeasz

下载kubeasz

  官方文档地址为https://github.com/easzlab/kubeasz，根据适配的K8s版本选择合适的kubeasz版本。根据官方文档，目前支持以下版本

集群版本 kubernetes v1.13, v1.14, v1.15, v1.16
操作系统 CentOS/RedHat 7, Debian 9/10, Ubuntu 1604/1804
运行时 docker 18.06.x-ce, 18.09.x, containerd 1.2.6
网络 calico, cilium, flannel, kube-ovn, kube-router

  我们下载2.0.3版本的kubeasz,并给予执行权限

curl -C- -fLO --retry 3 https://github.com/easzlab/kubeasz/releases/download/2.0.3/easzupchmod +x easzup

  可以用file easzup命令看到这是一个ASCII文本文件，其实就是一个shell脚本。

root@DockerUbuntu18:~# file easzupeaszup: Bourne-Again shell script, ASCII text executable

  用vim编辑修改此文件。
  大部分地方无需修改，不过可以设置docker版本为18.09.9和K8s的版本为v1.15.5，其他地方不用动。

export DOCKER_VER=18.09.9export K8S_BIN_VER=v1.15.5

  执行-- help查看脚本使用方法。

root@DockerUbuntu18:~# ./easzup --help./easzup: illegal option -- -Usage: easzup [options] [args]  option: -{DdekSz}    -C         stop&clean all local containers    -D         download all into /etc/ansible    -S         start kubeasz in a container    -d <ver>   set docker-ce version, default "18.09.9"    -e <ver>   set kubeasz-ext-bin version, default "0.3.0"    -k <ver>   set kubeasz-k8s-bin version, default "v1.15.5"    -m <str>   set docker registry mirrors, default "CN"(used in Mainland,China)    -p <ver>   set kubeasz-sys-pkg version, default "0.3.2"    -z <ver>   set kubeasz version, default "2.0.3"see more at https://github.com/kubeasz/dockerfiles

  先将/etc/ansible目录下所有自带的配置文件以及hosts文件删掉

\rm -rf /etc/ansible/*

  执行脚本下载所有需要的镜像和二进制文件

./easzup -D

  稍等片刻之后，下载好需要的镜像和二进制文件，此时就可以开始ansible自动部署安装K8s集群了。

ansible部署K8s

  kubeasz工具都已经写好了playbook，只需要设定好hosts文件即可一键安装了。先进入/etc/ansible目录,然后复制提供好的host模版文件并编辑。

cd /etc/ansible/cp example/hosts.multi-node hostsvim hosts

root@DockerUbuntu18:/etc/ansible# grep -v ^# hosts|grep -v ^$[etcd]172.18.32.23 NODE_NAME=etcd1172.18.32.24 NODE_NAME=etcd2172.18.32.25 NODE_NAME=etcd3[kube-master]172.18.32.18172.18.32.19[kube-node]172.18.32.21172.18.32.22[harbor][ex-lb][chrony][all:vars]CONTAINER_RUNTIME="docker"CLUSTER_NETWORK="calico"SERVICE_CIDR="10.68.0.0/16"CLUSTER_CIDR="172.20.0.0/16"NODE_PORT_RANGE="30000-65000"CLUSTER_DNS_DOMAIN="cluster.local."bin_dir="/usr/kube/bin"ca_dir="/etc/kubernetes/ssl"base_dir="/etc/ansible"

  以为我本地已经搭好harbor服务器了，所以就不要设置harbor服务让他来安装了。除了各节点IP以外，需要修改的就是bin_dir目录，这样就省去了创建软链接的步骤，也省去配置PATH变量了。我选择的网卡是calico，也可以使用默认的flannel，之后具体区别会再详细介绍。
  直接执行 playbook剧本90.setup.yml可以直接一键安装完成，不过如果出现问题我们不好排错，推荐一个剧本一个剧本的来跑。

• 01.prepare.yml

ansible-playbook 01.prepare.yml

  这个剧本总共三个环节，一般来说都不会报错（如果提示软链接创建失败，则可忽略）。
  1.如果设置了chrony服务器，则master、node、etcd主机都会向chrony服务器同步时间。
  2.控制节点上创建CA、创建集群参数及客户端认证参数
  3分发证书工具CFSSL及kubeconfig配置文件

• 02.etcd.yml

ansible-playbook 02.etcd.yml

  这个剧本是在配置etcd服务器。在3个etcd节点上，创建etcd目录并分发证书，导入之前下载在控制端的二进制程序etcd及etcdctl及导入etcd的systemctl unit文件，设置开机自动启动etcd服务。这步也很简单，一般也不会出现什么问题。

• 03.docker.yml

  因为我们在hosts文件中设置了运行时为docker,所以我们第三个剧本选择03.docker.yml，选择执行03.containerd,yml剧本也不会执行，里面做了条件判断

root@DockerUbuntu18:/etc/ansible# cat 03.containerd.yml # to install containerd service- hosts:  - kube-master  - kube-node  roles:  - { role: containerd, when: "CONTAINER_RUNTIME == 'containerd'" } 

  这个阶段的剧本比较复杂，要在每一个节点上安装docker，在执行这一步之前，先检查一下模版二进制文件的docker版本是否和我们之前预设的一样。

/etc/ansible/bin/docker -vDocker version 18.09.6, build 481bc77

  如果不一样，可以去/opt/kube/bin/目录下找一下之前下好的二进制文件，确认下版本。

/opt/kube/bin/docker -v

  这个目录下的版本一般是不会错的，将此目录下的二进制文件复制至模版目录/etc/ansible/bin/。

cp /opt/kube/bin/* /etc/ansible/bin/

  执行ansible剧本

ansible-playbook 03.docker.yml

• 04.kube-master.yml

  这个剧本是对两个master节点操作，执行了以下操作
  1.创建kubernetes签名请求以及证书和私钥
  2.导入配置文件，启动kube-apiserver、kube-controller-manager及kube-scheduler服务
  3.设置主节点的kube-apiserver.service文件，并设置apiserver的IP地址并创建配置用户rbac权限。
  此时使用命令kubectl get node可以看到两个主节点都是出于ready状态了。

root@DockerUbuntu18:~# kubectl get nodeNAME           STATUS                     ROLES    AGE    VERSION172.18.32.18   Ready,SchedulingDisabled   master   1m    v1.15.5172.18.32.19   Ready,SchedulingDisabled   master   1m    v1.15.5

• 05..kube-node.yml

  这个剧本主要是将几个node节点加到集群中来。流程比较复杂，大致有以下步骤：
  1,创建kube-node目录:/var/lib/kubelet、/var/lib/kube-proxy和/etc/cni/net.d目录
  2.导入之前准备好的二进制可执行文件kubectl、kubelet、kube-proxy、bridge、host-local和loopback
  3.配置haproxy，监听本地的127.0.0.1：6443端口，代理至两个主节点的6443端口
  4.生成node节点的kubelet的配置文件，并分发至各个node节点。kubelet连接主节点的apiserver。
  5.node节点连接后，对node节点标记为kubernetes.io/role=node

  这步很容易出现kubelet服务无法启动，或者一直处于loaded状态，返回值为255。这是因为node节点的kubelet的认证失败。可以去node节点主机上查看服务kubelet服务状态。

systemctl status kubectljournalctl -u kubelet -e

  我遇到几次node节点kubelet无法正常启动的情况，但是换了个全新的node节点就可以加进去了，说明问题不是在主节点上，一般将node节点还原至干净系统都可以解决问题。
  还有一次返回值255但报错提示是，找不到/run/systemd/resolve/resolv.conf文件，于是创建一个

mkdir /run/systemd/resolve/;echo "nameserver 233.5.5.5" > /run/systemd/resolve/resolv.conf

  自己创建一个解析之后问题解决。
  顺利的话，使用kubectl get node可以看到主节点和node节点都处于ready状态。

root@DockerUbuntu18:/etc/ansible# kubectl get nodeNAME           STATUS                     ROLES    AGE   VERSION172.18.32.18   Ready,SchedulingDisabled   master   2h   v1.15.5172.18.32.19   Ready,SchedulingDisabled   master   2h   v1.15.5172.18.32.21   Ready                      node     2h   v1.15.5172.18.32.22   Ready                      node     2h   v1.15.5

• 06.network.yml

  在这个剧本中，主要是配置各个pod之间的网络访问。需要在每个物理节点上都生成一个calico-node服务的pod，再启动一个calico-kube-controllers服务的pod来管理他们，（因为默认主节点设置了不可调度，所以这个calico-kube-contronllers一般是在node节点上生成）。因为使用的是pod方式启动，所以这个剧本中，除了配置calicao证书及私钥外，主要是生成了一个calico DaemonSet yaml文件，路径为/opt/kube/kube-system/calico.yaml，所以之后如果修改网络配置，可以直接在此路径下修改这个yaml文件，例如如果想要修改镜像地址为私有harbor地址，则

kubectl delete -f /opt/kube/kube-system/calico.yamlvim /opt/kube/kube-system/calico.yamlkubectl apply -f /opt/kube/kube-system/calico.yaml

  需要注意的是，如果将yaml文件中拉取镜像的地址改为了私有harbor，则需要在yaml文件中加入Secret资源，使用imagePullSecrets拉取。
  当我们的node节点不需要跨网段时，通常会选择将IPIP模式（ip-in-ip叠加模式）关掉，使用calico的BGP模式，以节约大量主机内部访问时封装的性能损耗。
  查看路由，可以看到目前荣期间通信的网络接口为tunl0。

root@DockerUbuntu18:~# route -nKernel IP routing tableDestination     Gateway         Genmask         Flags Metric Ref    Use Iface0.0.0.0         172.18.0.1      0.0.0.0         UG    0      0        0 eth0172.17.0.0      0.0.0.0         255.255.0.0     U     0      0        0 docker0172.18.0.0      0.0.0.0         255.255.0.0     U     0      0        0 eth0172.20.185.64   0.0.0.0         255.255.255.192 U     0      0        0 *172.20.233.128  172.18.32.19    255.255.255.192 UG    0      0        0 tunl0172.20.250.128  172.18.32.22    255.255.255.192 UG    0      0        0 tunl0172.20.250.192  172.18.32.21    255.255.255.192 UG    0      0        0 tunl0192.168.0.0     0.0.0.0         255.255.0.0     U     0      0        0 eth1

  于是可以编辑/etc/ansible/roles/calico/defaults/main.yml或者直接修改/opt/kube/kube-system/calico.yaml文件，将其中的 CALICO_IPV4POOL_IPIP修改为off，将name: FELIX_IPINIPMTU属性注释掉，改为FELIX_IPINIPENABLED值为false。

            - name: CALICO_IPV4POOL_IPIP              value: "off"            - name: FELIX_IPINIPENABLED              value: "false"

  然后执行kubectl delete -f /opt/kube/kube-system/calico.yaml将网络组件calico的pod都先停掉，reboot重启后，使用命令ifconfig就会发现，之前使用的tunl0网卡就不见了。再使用命令kubectl apply -f /opt/kube/kube-system/calico.yaml，将k8s网络连接起来，使用命令route -n查看路由信息，就会发现，跨主机通信直接使用eth0网卡了。此时模式从IPIP修改为BGP模式。

root@DockerUbuntu18:~# route -nKernel IP routing tableDestination     Gateway         Genmask         Flags Metric Ref    Use Iface0.0.0.0         172.18.0.1      0.0.0.0         UG    0      0        0 eth0172.17.0.0      0.0.0.0         255.255.0.0     U     0      0        0 docker0172.18.0.0      0.0.0.0         255.255.0.0     U     0      0        0 eth0172.20.185.64   0.0.0.0         255.255.255.192 U     0      0        0 *172.20.233.128  172.18.32.19    255.255.255.192 UG    0      0        0 eth0172.20.250.128  172.18.32.22    255.255.255.192 UG    0      0        0 eth0172.20.250.192  172.18.32.21    255.255.255.192 UG    0      0        0 eth0192.168.0.0     0.0.0.0         255.255.0.0     U     0      0        0 eth1

• 07.cluster-addon.yml

  第七步是安装一些功能插件，如在node节点生成dns解析(默认使用的是coredns，可以在roles/cluster-addon/defaults/main.yml文件中设置），安装dashboard（可视化web界面）。我们也可以选择自己安装这些功能插件。
  可参考官方文档https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/#deploying-the-dashboard-ui
  dashboard默认是1.6.3版本的，比较老。我们这里手动安装dashboard1.10.1版本，过程如下

cd /etc/ansible/manifests/dashboardmkdir 1.10.1cp 1.6.3/ui* 1.10.1/cd 1.10.1

  先下载yaml文档

wget https://raw.githubusercontent.com/kubernetes/dashboard/v1.10.1/src/deploy/recommended/kubernetes-dashboard.yaml

  再创建admin tokenvim admin-user-sa-rbac.yaml

apiVersion: v1kind: ServiceAccountmetadata:  name: admin-user  namespace: kube-system---apiVersion: rbac.authorization.k8s.io/v1kind: ClusterRoleBindingmetadata:  name: admin-userroleRef:  apiGroup: rbac.authorization.k8s.io  kind: ClusterRole  name: cluster-adminsubjects:- kind: ServiceAccount  name: admin-user  namespace: kube-system

  创建集群角色vim read-user-sa-rbac.yaml

---apiVersion: rbac.authorization.k8s.io/v1kind: ClusterRolemetadata:  name: dashboard-read-clusterrolerules:- apiGroups:  - ""  resources:  - configmaps  - endpoints  - persistentvolumeclaims  - pods  - replicationcontrollers  - replicationcontrollers/scale  - serviceaccounts  - services  - nodes  - persistentvolumeclaims  - persistentvolumes  verbs:  - get  - list  - watch- apiGroups:  - ""  resources:  - bindings  - events  - limitranges  - namespaces/status  - pods/log  - pods/status  - replicationcontrollers/status  - resourcequotas  - resourcequotas/status  verbs:  - get  - list  - watch- apiGroups:  - ""  resources:  - namespaces  verbs:  - get  - list  - watch- apiGroups:  - apps  resources:  - daemonsets  - deployments  - deployments/scale  - replicasets  - replicasets/scale  - statefulsets  verbs:  - get  - list  - watch- apiGroups:  - autoscaling  resources:  - horizontalpodautoscalers  verbs:  - get  - list  - watch- apiGroups:  - batch  resources:  - cronjobs  - jobs  verbs:  - get  - list  - watch- apiGroups:  - extensions  resources:  - daemonsets  - deployments  - deployments/scale  - ingresses  - networkpolicies  - replicasets  - replicasets/scale  - replicationcontrollers/scale  verbs:  - get  - list  - watch- apiGroups:  - policy  resources:  - poddisruptionbudgets  verbs:  - get  - list  - watch- apiGroups:  - networking.k8s.io  resources:  - networkpolicies  verbs:  - get  - list  - watch- apiGroups:  - storage.k8s.io  resources:  - storageclasses  - volumeattachments  verbs:  - get  - list  - watch- apiGroups:  - rbac.authorization.k8s.io  resources:  - clusterrolebindings  - clusterroles  - roles  - rolebindings  verbs:  - get  - list  - watch

  此时目录结构如下

root@DockerUbuntu18:/etc/ansible/manifests/dashboard/1.10.1# tree.├── admin-user-sa-rbac.yaml├── kubernetes-dashboard.yaml├── read-user-sa-rbac.yaml├── ui-admin-rbac.yaml└── ui-read-rbac.yaml0 directories, 5 files

  然后通过yaml文件启动dashboard的pod

kubectl apply -f .

  可以通过命令查看pod 是否启动成功。

kubectl get pods --all-namespaces | grep dashboard

  看到状态running之后，输入命令开启认证生成登陆用户名密码

easzctl basic-auth -s

[INFO]basic-auth for apiserver is enabled!BASIC_AUTH_USER: 'admin'BASIC_AUTH_PASS: '4fe554e56c32f27b'[INFO] Action successed : basic-auth basic-auth -s`

  通过命令kubectl cluster-info查看集群信息来查看登陆url

kubectl cluster-info

  使用命令来获取token

kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}')

  这时就可以登陆web界面查看K8s集群信息了。

  架构结构示意图如下路所示

  环境搭建（master及node节点均为ubuntu1804）：
  master1：192.168.32.18
  master2：192.168.32.19
  harbor：192.168.32.20
  node1：192.168.32.21
  node2：192.168.32.22
  需要禁用 swap， selinux， iptables。

swapoff -a

搭建master节点

安装keepalived

  可以通过apt快速安装或者源码编译，下面以apt包管理工具安装为例

apt updateapt install keepalived -ycp /usr/share/doc/keepalived/samples/keepalived.conf.vrrp /etc/keepalived/keepalived.conf

  然后修改配置文件，实例如下

! Configuration File for keepalivedglobal_defs {   notification_email {     acassen   }   notification_email_from Alexandre.Cassen@firewall.loc   smtp_server 192.168.200.1   smtp_connect_timeout 30   router_id LVS_DEVEL}vrrp_instance VI_1 {    state MASTER    interface eth0    garp_master_delay 10    smtp_alert    virtual_router_id 32    priority 100    advert_int 1    authentication {        auth_type PASS        auth_pass 1111    }    virtual_ipaddress {        # optional label. should be of the form "realdev:sometext" for        # compatibility with ifconfig.        172.18.32.250 label eth0:1    }}

  另一个节点也安装keepalived，然后测试VIP是否可以漂移成功。

安装 docker

  在主节点上先安装docker，详细可参考之前文章。
  可以通过阿里云镜像，使用脚本来安装vim docker1806.sh

#!/bin/bash# step 1: 安装必要的一些系统工具apt-get updateapt-get -y install apt-transport-https ca-certificates curl software-properties-common# step 2: 安装GPG证书curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -# Step 3: 写入软件源信息sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"# Step 4: 更新并安装Docker-CEapt-get -y updateapt-get -y install docker-ce=18.06.0~ce~3-0~ubuntu# 安装指定版本的Docker-CE:# Step 1: 查找Docker-CE的版本:# apt-cache madison docker-ce#   docker-ce | 17.03.1~ce-0~ubuntu-xenial | https://mirrors.aliyun.com/docker-ce/linux/ubuntu xenial/stable amd64 Packages#   docker-ce | 17.03.0~ce-0~ubuntu-xenial | https://mirrors.aliyun.com/docker-ce/linux/ubuntu xenial/stable amd64 Packages# Step 2: 安装指定版本的Docker-CE: (VERSION例如上面的17.03.1~ce-0~ubuntu-xenial)# sudo apt-get -y install docker-ce=[VERSION]

bash docker1806.sh

配置阿里加速器

vim /etc/docker/daemon.json{        "registry-mirrors": ["https://360k4x9i.mirror.aliyuncs.com","https://registry.docker-cn.com"],        "insecure-registries": ["https://harbor.local.com"],        "bip": "10.20.0.1/24"}

安装kubeadm

  先配置k8s的镜像源,并安装kubeadm

curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add -  cat  >/etc/apt/sources.list.d/kubernetes.list <<EOFdeb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial mainEOFapt-get updateapt install kubeadm=1.16.1-00 kubectl=1.16.1-00 kubelet=1.16.1-00systemctl start kubelet && systemctl enable kubelet

安装K8s

  因为默认使用的是google的镜像仓库，国内是连接不上的，所以我们最好提前下载好镜像。本次演示安装版本为kubernetes v1.16.1
  先查看需要下载的镜像及版本
kubeadm config images list --kubernetes-version v1.16.1

k8s.gcr.io/kube-apiserver:v1.16.1k8s.gcr.io/kube-controller-manager:v1.16.1k8s.gcr.io/kube-scheduler:v1.16.1k8s.gcr.io/kube-proxy:v1.16.1k8s.gcr.io/pause:3.1k8s.gcr.io/etcd:3.3.15-0k8s.gcr.io/coredns:1.6.2

  我们先去阿里云镜像仓库提前下载好镜像，可以通过快速实现.。如果有harbor服务器，可以先上传到本地harbor。

#!/bin/bashdocker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-controller-manager:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-scheduler:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-proxy:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/etcd:3.3.15-0docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/coredns:1.6.2

master 初始化

  因为我们打算做master的高可用。所以我们在master初始化时，要加选项--control-plane-endpoint=172.18.32.250指定``VIP`。只需在一个master节点上做初始化即可。

kubeadm init \--apiserver-advertise-address=172.18.32.18 \--control-plane-endpoint=172.18.32.250 \--apiserver-bind-port=6443 \--kubernetes-version=v1.16.1 \--pod-network-cidr=10.10.0.0/16 \--service-cidr=10.20.0.0/16 \--service-dns-domain=k8s.local \--image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers \--ignore-preflight-errors=swap 

  也可以基于yaml文件而不是用命令行命令来进行初始化。可以使用命令kubeadm init --config kubeadm-init.yaml ，基于文件初始化。
  kubeadm config print init-defaults 输出默认初始化配置
  kubeadm config print init-defaults > kubeadm-init.yaml 将默认配置输出至文件

root@k8s-master1:~# cat kubeadm-init.yaml #修改后的初始化文件内容apiVersion: kubeadm.k8s.io/v1beta2bootstrapTokens:- groups:- system:bootstrappers:kubeadm:default-node-tokentoken: abcdef.0123456789abcdefttl: 24h0m0susages:- signing- authenticationkind: InitConfigurationlocalAPIEndpoint:advertiseAddress: 172.18.32.18bindPort: 6443nodeRegistration:criSocket: /var/run/dockershim.sockname: k8s-master1.k8s.localtaints:- effect: NoSchedulekey: node-role.kubernetes.io/master---apiServer:timeoutForControlPlane: 4m0sapiVersion: kubeadm.k8s.io/v1beta2certificatesDir: /etc/kubernetes/pkiclusterName: kubernetescontrolPlaneEndpoint: 172.18.32.250:6443 #添加基于 VIP 的 EndpointcontrollerManager: {}dns:type: CoreDNSetcd:local:dataDir: /var/lib/etcdimageRepository: registry.cn-hangzhou.aliyuncs.com/google_containerskind: ClusterConfigurationkubernetesVersion: v1.16.1networking:dnsDomain: k8s.localpodSubnet: 10.10.0.0/16serviceSubnet: 10.20.0.0/16scheduler: {}

  初始化成功，记录下来--token和--discovery-token-ca-cert-hash,，之后加入其他节点时需要用到。
  如果初始化失败了需要 使用命令kubeadm reset可以清除已有容器数据以便重新安装，PS：此命令如果在安装完成后使用会清除已创建的k8s集群。

配置kube证书

mkdir -p $HOME/.kubesudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/configsudo chown $(id -u):$(id -g) $HOME/.kube/config

配置网卡

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.ymlkubectl apply -f kube-flannel.yml

加入其他节点

  其他三台k8s节点也要安装docker及k8s，可以通过脚本快速实现

vim node.sh#!/bin/bash# step 1: 安装必要的一些系统工具apt-get updateapt-get -y install apt-transport-https ca-certificates curl software-properties-common# step 2: 安装GPG证书curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -# Step 3: 写入软件源信息sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"# Step 4: 更新并安装Docker-CEapt-get -y updateapt-get -y install docker-ce=18.06.0~ce~3-0~ubuntucat > /etc/docker/daemon.json << EOF{        "registry-mirrors": ["https://360k4x9i.mirror.aliyuncs.com","https://registry.docker-cn.com"],        "insecure-registries": ["https://harbor.local.com"],        "bip": "10.20.0.1/24"}EOFcurl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add - cat  >/etc/apt/sources.list.d/kubernetes.list <<EOFdeb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial mainEOFapt-get updateapt install kubeadm=1.16.1-00 kubectl=1.16.1-00 kubelet=1.16.1-00 -ysystemctl start kubelet && systemctl enable kubeletdocker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-controller-manager:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-scheduler:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-proxy:v1.16.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.1docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/etcd:3.3.15-0docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/coredns:1.6.2systemctl enable --now docker kubelet

  当前 maste 生成证书用于添加新控制节点：

kubeadm init phase upload-certs --upload-certs

  得到--certificate-key的值，也要记录下来。
  之后想加入哪个节点，就在哪个节点上操作。先加入另一个master节点。

kubeadm join 172.18.32.250:6443 --token 89beqy.13jxavbu7yz3187d \--discovery-token-ca-cert-hash sha256:7388af4f1662805a844cce7c1371facb83f32dddb998370d11bfb41957fe75bf \--certificate-key 3630d5719795c77e7071d77a206cc17078c912f9c3915e76e70bb26e75e26178 \--control-plane

  再加入各个node节点，命令区别是少了--control-plane选项以及控制秘钥。

kubeadm join 172.18.32.250:6443 --token 89beqy.13jxavbu7yz3187d \--discovery-token-ca-cert-hash sha256:7388af4f1662805a844cce7c1371facb83f32dddb998370d11bfb41957fe75bf

  之后通过命令,就可以看到4个主机都处于ready状态了。至此k8s集群的搭建就完成了。

kubectl get node

阿里云仓库

  docker官方仓库配置比较简单，而且大部分是默认配置，且速度不如阿里云镜像仓库速度快，所以我这里就不介绍了，使用方式和阿里云容器镜像仓库差不多类似。

注册账号

  使用阿里云仓库服务首先要注册阿里云账号，支付宝也可以登陆，比较快捷。点击上面的网址登陆即可。

创建仓库

  先创建一个命名空间，这相当于每个人独立的url，可以以代码类别或者性质命名创建（也可以凭个人喜好），每个账号只能创建5个命名空间，不过也够用了。
  然后创建镜像仓库。

  地域选择离自己比较近的地域，这样延迟会稍微低一些，选择已创建的命名空间，仓库名的命名一般是服务名或者软件名。公开或者私有看个人请款选择。

上传镜像

  有了仓库之后，我们就可以上传镜像了。

打标签

  要上传镜像，第一步，要先重新打标签，将阿里云的仓库源的地址，仓库名，以及版本号重新打标签，生成新镜像。例如对已有的haproxy镜像重新打标签，因为我选择的是北京节点，所以打标命令如下：

docker tag haproxy-base:v1 registry.cn-beijing.aliyuncs.com/【命名空间名称】/【仓库名】:【版本号】

登陆

  想上传或者下载镜像一般都需要授权才可以，这就要求我们要用有权限的帐号登陆，才可以上传镜像或者下载镜像。

root@DockerUbuntu:/opt/dockerfile/web/haproxy/2.0.5# docker login --username=【账号名】 registry.cn-beijing.aliyuncs.comPassword: WARNING! Your password will be stored unencrypted in /root/.docker/config.json.Configure a credential helper to remove this warning. Seehttps://docs.docker.com/engine/reference/commandline/login/#credentials-storeLogin Succeededroot@DockerUbuntu:/opt/dockerfile/web/haproxy/2.0.5# 

上传

  用docker images可以查看所有的镜像，选择已经打了阿里云网址的标签的镜像上传就可以了

root@DockerUbuntu:/opt/dockerfile/web/haproxy/2.0.5# docker push registry.cn-beijing.aliyuncs.com/【命名空间名称】/【仓库名】:【版本号】The push refers to repository [registry.cn-beijing.aliyuncs.com/命名空间名/仓库名]0ec88a00d427: Pushed 6a6e6f03a1a5: Pushed 965bdb9c5299: Pushed a1d450e33837: Pushed 837dac687863: Pushed b39d6a9ec3e2: Pushed 1e7fbf47b8df: Pushed dc298319f184: Pushed e4809dffd3aa: Pushed b3cdf76b6336: Pushed 2fc5c4732662: Pushed 2d03b9db6c3f: Pushed 89169d87dbe2: Pushed haproxy: digest: sha256:f0b4157cd18498e4bc373e333e4fb0b85a65d00e03de2d65015b0d0da9099af6 size: 3049

  这时就上传成功了

拉取镜像

  其他主机登陆成功之后，通过拉取命令就可以从阿里云端下载镜像了。

[root@DockerCentOS ~]# docker pull registry.cn-beijing.aliyuncs.com/【命名空间名称】/【仓库名】:【版本号】haproxy: Pulling from xxxxxxxxxx/webac9208207ada: Already exists 75c124fe932b: Pull complete 9ef7eb04bb69: Pull complete c5f97c472240: Pull complete 9dc49af65399: Pull complete a745615abdba: Pull complete ddcf37c0f462: Pull complete 0c406d186167: Pull complete 246fafa1cb32: Pull complete 057e62247ad8: Pull complete 770d7edff222: Pull complete b4064e1ed3ec: Pull complete d0a103ae1f19: Pull complete Digest: sha256:f0b4157cd18498e4bc373e333e4fb0b85a65d00e03de2d65015b0d0da9099af6Status: Downloaded newer image for registry.cn-beijing.aliyuncs.com/xxxxxxxxxx/web:haproxyregistry.cn-beijing.aliyuncs.com/xxxxxxxxxx/web:haproxy

  这时就可以在docker images的镜像列表中看到刚刚拉取的镜像了。

搭建私有仓库

  阿里云镜像仓库虽然很方便，但是在生产环境中，每次都从云端拉取或者上传至云端仓库，太消耗企业带宽，有时候数据繁忙的时候，很有可能会堵塞业务，而且速度也较慢。所以企业中都会基于内部局域网搭建企业内部使用的私有仓库。一般搭建私有仓库有两种解决方案，一个是docker自带的Docker Registry，还有就是由vmware公司开源的harbor。

Docker Registry

  Docker Registry 作为 Docker 的核心组件之一负责镜像内容的存储与分发， 客户端的 docker pull 以及 push 命令都将直接与 registry 进行交互,最初版本的 registry由Python实现,由于设计初期在安全性， 性能以及API的设计上有着诸多的缺陷，该版本在 0.9 之后停止了开发，由新的项目 distribution（新的 docker register 被称为 Distribution）来重新设计并开发下一代 registry，新的项目由 go 语言开发，所有的 API， 底层存储方式， 系统架构都进行了全面的重新设计已解决上一代registry 中存在的问题， 2016 年 4 月份 rgistry 2.0 正式发布， docker 1.6 版本开始支持 registry 2.0，而八月份随着 docker 1.8 发布， docker hub 正式启用 2.1 版本registry 全面替代之前版本 registry，新版 registry 对镜像存储格式进行了重新设计并和旧版不兼容， docker 1.5 和之前的版本无法读取 2.0 的镜像， 另外， Registry2.4 版本之后支持了回收站机制，也就是可以删除镜像了，在 2.4 版本之前是无法支持删除镜像的，所以如果你要使用最好是大于 Registry 2.4 版本的。
  Docker Registry的优势就是比较小（25M），但是功能表比较简单。

下载 docker registry 镜像

[root@DockerCentOS ~]# docker pull registryUsing default tag: latestlatest: Pulling from library/registryc87736221ed0: Pull complete 1cc8e0bb44df: Pull complete 54d33bcb37f5: Pull complete e8afc091c171: Pull complete b4541f6d3db6: Pull complete Digest: sha256:8004747f1e8cd820a148fb7499d71a76d45ff66bac6a29129bfdbfdc0154d146Status: Downloaded newer image for registry:latestdocker.io/library/registry:latest

搭建单机仓库

  先创建授权使用目录

mkdir -p /docker/auth

  创建一个用户并创建密码文件

cd /dockerdocker run --entrypoint htpasswd registry -Bbn Mice 123456 > auth/htpasswd #创建一个用户并生成密码

  验证用户名密码

[root@DockerCentOS docker]# cat auth/htpasswdMice:$2y$05$XqNS4BH3gkxodR9MQyhnIuL19uT4wfa6MjUgXvJUYuo0T0o0J8Tzy

  从registry镜像中启动 docker registry,指定容器名称为registry1，挂载本地/docker/auth目录至容器的/auth目录，传递账号密码变量至容器。

docker run -d -p 5000:5000 --restart=always \--name registry1 \-v /docker/auth:/auth \-e "REGISTRY_AUTH=htpasswd" \-e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" \-e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd\ registry

  此时如果用我们创建的用户名密码尝试登陆了，记得IP或者域名后面要加5000端口，否则会报502错误。

root@DockerUbuntu19:~# docker login 192.168.32.20Username: MicePassword: Error response from daemon: login attempt to http://192.168.32.20/v2/ failed with status: 502 Bad Gateway

  不过很有可能当你加上5000端口，可能还会有报错。ヾ(≧O≦)〃嗷~

root@DockerUbuntu19:~# docker login 192.168.32.20:5000Username: MicePassword: Error response from daemon: Get https://192.168.32.20:5000/v2/: http: server gave HTTP response to HTTPS client

  这是因为我们每一个docker主机要设置允许insecure-registries，加上我们registry仓库的IP或者域名。
  同样，可以修改/lib/systemd/system/docker.service启动脚本文件，或者/etc/docker/daemon.json文件，推荐修改/etc/docker/daemon.json文件。

{  "registry-mirrors": ["https://360k4x9i.mirror.aliyuncs.com"],  "insecure-registries": ["192.168.32.19","DockerCentOS20:5000"],  "bip": "10.20.0.1/24"}

  然后重启docker服务,此时再尝试登陆，就回提示登陆成功。

root@DockerUbuntu19:~# docker login DockerCentOS20:5000Username: MicePassword: WARNING! Your password will be stored unencrypted in /root/.docker/config.json.Configure a credential helper to remove this warning. Seehttps://docs.docker.com/engine/reference/commandline/login/#credentials-store

  之后就与阿里云的镜像仓库使用方法相同了，不过速度上会快很多（毕竟内网），可以如果要上传镜像至regist仓库，先打好标签就可以了，下载写明下载仓库源，也就可以正常下载了。ヾ(=ﾟ･ﾟ=)ﾉ喵♪

Harbor

  Harbor是一个用于存储和分发Docker镜像的企业级Registry服务器， 由vmware开源，其通过添加一些企业必需的功能特性，例如安全、标识和管理等， 扩展了开源 Docker Distribution。作为一个企业级私有Registry服务器，Harbor 提供了更好的性能和安全。提升用户使用Registry构建和运行环境传输镜像的效率。Harbor支持安装在多个Registry节点的镜像资源复制， 镜像全部保存在私有Registry中，确保数据和知识产权在公司内部网络中管控， 另外，Harbor也提供了高级的安全特性，诸如用户管理，访问控制和活动审计等 ，所以企业生产中，我们更多会选择Harbor。

下载harbor安装包

  下载地址： https://github.com/vmware/harbor/releases
  安装文档：https://github.com/vmware/harbor/blob/master/docs/installation_guide.md
  本次以harbor的1.75版本为例，演示harbor的安装过程。
  下载离线包，并解压。

cd /usr/local/srcwget https://storage.googleapis.com/harbor-releases/release-1.7.0/harbor-offline-installer-v1.7.5.tgztar xvf harbor-offline-installer-v1.7.5.tgz

  也可以下载在线安装包，但里面没有镜像，之后还要去拉取镜像，不适合生产环境。

安装docker-compose

  Harbor是需要使用docker编排工具docker-compose安装，docker-compose我们之后会专门介绍。而且对docker-compose版本是有要求的，可以查看上面的官方文档链接查看确切版本。

  而如果使用包管理工具yum或者apt直接安装的docker-compose可能版本会比较低，我们这里采用python包管理工具python-pip来安装docker-compose。

apt install python-pip -ypip install docker-compose

  然后可以通过命令docker compose -v看到docker-compose版本已经是最新稳定版1.25版本了。

root@DockerUbuntu19:/usr/local/src# docker-compose -vdocker-compose version 1.25.0, build b42d419

安装Harbor

  我们习惯于将源码包放在/usr/local/src下，而将主程序放在/usr/local/目录中，所以我们可以将harbor目录的的路径改为/usr/local/harbor，可以通过mv命令，也可以通过软链接方式实现

ln -sv /usr/local/src/harbor /usr/local/

  然后修改配置文件harbor.cfg

cd /usr/local/harborvim harbor.cfg

  修改其中主机名(改为IP或者域名)，管理员登录密码，及邮箱即可。

hostname = 192.168.32.19email_identity = harboremail_server = smtp.163.comemail_server_port = 25email_username = XXXXXXXXX@163.comemail_password = XXXXXXXXXXemail_from = admin <XXXXXXXX@163.com>harbor_admin_password = XXXXXXXXXXXXX

  然后更新配置文件中的环境变量到安装文件中,忘记更新环境变量会提示找不到环境变量文件ERROR: Couldn't find env file: /usr/local/src/harbor/common/config/core/env。

./prepare

  此时就可以执行命令,来创建并安装Harbor了。

docker-compose up -d

  或者执行官方脚本（两个都可以）

./install.sh

  这时候就可以通过浏览器访问我们刚刚搭建的harbor仓库了，至此企业私有仓库就算是搭建好了。

  管理员用户名为admin，密码为我们之前在配置文件中修改的harbor_admin_password。
  后期如果需要修改配置文件信息，需要先停止harbor，然后修改信息后，更新配置文件信息至harbor服务，之后再试用docker-compose up -d启动harbor服务即可,流程如下。

cd /usr/local/harbordocker-compose stopvim harbor.cfg./preparedocker-compose up -d

  推送流程与使用其他云镜像仓库相同，先打标签,开头加上ip/仓库名，然后直接推送即可。

docker网络基础

  之前我们说过，当我们安装完docker应用后，就会自动添加一块虚拟的docker0网卡，并基于docker0网卡，提供了3种可选网络类型供创建的容器使用，分别是bridge(桥接)，host(主机)，none(无外部网络)。其中默认是采用桥接模式，容器中的网卡桥接在docker的网桥上，且通过DHCP自动分配IP，与docker0在同一网段。
  当我们每创建一个容器，宿主机上就会新建一个网卡与容器中的网卡相对应，如下图所示。

  容器桥接模式跨网络访问的结构示意图如下图所示

  想实现不同宿主机上的容器跨主机肯定要经过宿主机来做网络转发，通过设置宿主机静态路由或者修改iptables规则来实现，可这时就面临一个问题：所有的容器服务默认的DHCP网段都是172.17.0.0/16网段，如果node1上的容器想直接访问node2宿主机上的容器，就会被直接当做docker0网桥的内部网段，数据报文根本都不会从node1主机的eth0网卡发出去，也根本到不了node2主机上。这种情况下，无论我们怎么修改iptables规则或者路由规则都无济于事的。所以我们想实现容器跨主机访问，首先要将不同宿主机上的容器分到不同的网段，然后才可以通过路由规则或者iptables进行跳转或转发。

修改docker网络的网段

  我们可以对每一个宿主机上的docker配置文件进行修改，实现每个宿主机的docker容器都在不同网段的目的,可以通过以下方式修改（未避免影响， 先在各服务器删除之前创建的所有容器，docker rm -f `docker ps -a -q`）。

• 修改启动system脚本文件docker.service

  vim /lib/systemd/system/docker.service

    在ExecStart=选项结尾加上--bip=10.1.0.1/24，就指定了10.1.0.0/24网段，然后执行命令重新加载配置文件和重启服务。

  systemctl daemon-reloadsystemctl restart docker

    注意:不能写10.1.0.0/24，会报错，虽然写网段结尾是0，如10.1.0.0/24更符合我们的习惯，不过确实会报错，报错信息如下：
  ```
  Dec 07 16:27:58 DockerUbuntu dockerd[14794]: failed to start daemon: Error initializing network controller: Error creating default “bridge” network: failed to allocate gateway (10.10.0.0): Address already in use
  Dec 07 16:27:58 DockerUbuntu systemd[1]: docker.service: Main process exited, code=exited, status=1/FAILURE
  Dec 07 16:27:58 DockerUbuntu systemd[1]: docker.service: Failed with result ‘exit-code’.
  Dec 07 16:27:58 DockerUbuntu systemd[1]: Failed to start Docker Application Container Engine.
• • Subject: Unit docker.service has failed
• • Defined-By: systemd
    ```
• 也可以修改daemon.json文件，在里面添加"bip": "10.2.0.1/24"，如下所示（上面那个是我的阿里云加速器链接，注册阿里账号免费获取，之前文章有详细介绍，需改成自己的或者删掉）：

  vim /etc/docker/daemon.json

{
“registry-mirrors”: [“https://xxxxxxxx.mirror.aliyuncs.com","https://registry.docker-cn.com"],
“bip”: “10.1.0.1/24”
}

  **daemon.json文件是json数据格式，需要遵守json语法，换行记得要加``,``逗号。**  直接重启docker服务后生效

systemctl restart docker

  此时看网卡的ip就已经变为了我们设置的网段，之后创建的容器服务器就会自动获取我们设置好的网段中的IP了。

root@DockerUbuntu:~# ifconfig
docker0: flags=4099<UP,BROADCAST,MULTICAST> mtu 1500
inet 10.10.0.1 netmask 255.255.255.0 broadcast 10.10.0.255
inet6 fe80::42:25ff:fe2b:ecbc prefixlen 64 scopeid 0x20
ether 02:42:25:2b:ec:bc txqueuelen 0 (Ethernet)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 41 bytes 3526 (3.5 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

  同样的操作，将node2宿主机中的docker0网段设置为10.2.0.0/24### 修改静态路由  我这里node1的eth0网卡ip为192.168.32.19，node2的eth0网卡ip为192.168.32.20，且两个宿主机之前网络是可以通过eth0网卡相互连接的。添加路由规则如下：  在node1上添加静态路由

ip r add 10.2.0.0/24 via 192.168.32.20 dev eth0

  在node2上添加静态路由

ip r add 10.1.0.0/24 via 192.168.32.19 dev eth0

### 修改iptables规则  宿主机如果为centos7，则不需要修改iptables规则，而宿主机如果为ubuntu系统则需要添加forward规则来放行。我仔细看了下这两个系统的iptables规则，发现在centos系统docker创建的iptables规则中对``Chain FORWARD``是默认``ACCEPT``，而ubuntu系统中docker创建的iptables对``Chain FORWARD``是默认``DROP``![dockecentosiptables](https://img-blog.csdnimg.cn/20191207185124292.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pY2VQcm8=,size_16,color_FFFFFF,t_70)![dockerubuntuiptables](https://img-blog.csdnimg.cn/20191207185139492.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pY2VQcm8=,size_16,color_FFFFFF,t_70)  之后两边各启动一个容器就可以实现相互通信或访问了。## docker网络进阶  之前我们演示了通过docker0网卡的桥接方式实现了容器跨主机访问。我们通过修改docker0网卡的网段设置来实现，每个主机上容器的网段不同。  这种实现方式有个问题就是，但当每次我们修改了docker0网段之后，如果之后打算变更网段，之前的容器都将无法与docker0网桥桥接，导致网络不通，不能使用。  对此我们有一个更灵活的方案来实现容器的跨主机通信。那就是我们还可以通过创建一个或多个自定义网络，将新创建的每个容器指定连接到我们创建的这个网络中，这样他们的网段就是我们设置的这个网络的网段，实现每个主机上容器网段都不相同。### 创建自定义网络  可以将我们之前对docker0网卡的修改还原了的（当然，也可以不修改，出于控制变量方便观察考虑，建议修改回去）。  我们可以通过``docker network create``命令来创建一个自定义网络

root@DockerUbuntu:~# docker network create –help

Usage: docker network create [OPTIONS] NETWORK

Create a network

Options:
–attachable Enable manual container attachment
–aux-address map Auxiliary IPv4 or IPv6 addresses used by Network driver
(default map[])
–config-from string The network from which copying the configuration
–config-only Create a configuration only network
-d, –driver string Driver to manage the Network (default “bridge”)
–gateway strings IPv4 or IPv6 Gateway for the master subnet
–ingress Create swarm routing-mesh network
–internal Restrict external access to the network
–ip-range strings Allocate container ip from a sub-range
–ipam-driver string IP Address Management Driver (default “default”)
–ipam-opt map Set IPAM driver specific options (default map[])
–ipv6 Enable IPv6 networking
–label list Set metadata on a network
-o, –opt map Set driver specific options (default map[])
–scope string Control the network’s scope
–subnet strings Subnet in CIDR format that represents a network segment

  例如我们在node1创建一个名为web1的桥接网络，网段为10.10.0.0/24,设置网关为10.10.0.1（可设置为此网段内任意ip）。

root@DockerUbuntu:# docker network create -d bridge –subnet 10.10.0.0/24 –gateway 10.10.0.1 web1
a817cf36502eea3469e1cb4b9b7577044f8dce96f015ba57a47f6809c00d72c7
root@DockerUbuntu:# docker network ls
NETWORK ID NAME DRIVER SCOPE
afd91b2e1731 bridge bridge local
241d3e94a6b3 host host local
7cc9cf9eb69e none null local
a817cf36502e web1 bridge local
root@DockerUbuntu:~#

  可以用``docker network ls``(或``docker network list``)看到网络类型多了一种，也就是我们刚刚创建的web1类型。而用``ifconfig``或者``ip a``命令也可以看到我们的网卡设备里多了一个``br-a817cf36502e``，ip也恰好是我们指定的``10.10.0.0/24``网段。![自定义网络](https://img-blog.csdnimg.cn/20191207192708651.png)  此时我们就可以通过``--net``选项指定我们刚刚创建的web1网络，来创建并启动容器了。

root@DockerUbuntu:# docker run -it -d -p 8080:8080 -p 8009:8009 –net=web1 tomcat-app1:v1
afc1e3db8a6a670d30cdd0756af65da74895976ce5ebbf876329b04b452a3710
root@DockerUbuntu:#

  同样，在宿主机node2上也创建一个自定义网络web2，然后新创建的容器，也指定网络为web2，再设置静态路由和修改iptables规则放行，也可以实现容器间跨主机访问。

Docker镜像

  之前我们提到，docker是一个运行容器的工具，可以单独隔离每个服务的运行环境，达到互不干扰和节约资源的目的。而docker运行的容器，是基于一层一层的镜像联合挂载构建而成。所以我们需要先有镜像。
  所谓镜像，其实可以理解为，一个个的最简化的安装包，里面只集成了一些必备的程序和文件，且每一层和每一层镜像是可以相互一样的，大大的节约了空间，提高了资源利用率。举个最简单的例子，我们从官方下载一个centos系统的镜像包centos:apline，大小才5.55兆，而centos差不多至少200兆了，而centos安装的ISO镜像文件也都差不多1G左右。这是因为容器使用的镜像系统，需要依赖宿主机内核来运行，容器本身是没有内核的，只包含一些基础功能命令而已。可用docker images查看本地镜像，从大小来看，就知道容器确实很精简。

root@DockerUbuntu:~# docker imagesREPOSITORY          TAG                 IMAGE ID            CREATED             SIZEalpine              latest              965ea09ff2eb        6 weeks ago         5.55MBcentos              latest              0f3e07c0138f        2 months ago        220MBcentos              7.6.1810            f1cb7c7d58b7        8 months ago        202MB

  我们可以在docker官方镜像仓库https://hub.docker.com查看官方镜像,也可以通过命令直接搜索centos的可用容器

docker search centos

  注意：官方仓库也有很多是个人的镜像，为避免未知风险，一定要采用官方镜像，千万别使用安全性未知或来源不明的的镜像。一般排在第一个是官方镜像。
  使用命令docker pull centos就可以自动从docker官方镜像仓库docker.io，下载centos镜像了，因为我们没有指定版本标签，所以这条命令会默认下载centos:latest版本，也就是最新版。生产中我们出于稳定性和便于管理，都会推荐使用指定的稳定版本，而不会采用latest版本（，随着版本发型，之前的latest版本和几个月之后的latest版很有可能就不是一个版本，不利于规范化统一）。我们本次以CentOS7.6中的最新版centos:7.6.1810最为本次演示的版本。下载镜像命令如下：

docker pull centos:7.6.1810

  使用docker image rm [ OPTION ] 容器ID可以删除不要的镜像，如果已有容器基于此镜像启动，则会提示错误，无法删除，需先停止容器，或直接加-f选项强制删除镜像，此时容器也会被停止。注意，当容器被停止时，上面的数据也都会丢失，所以需要谨慎关闭容器和删除镜像。
  此外，docker官方镜像站，因为在国外(美国，不过应该是有CDN或者国内镜像加速站点的，不过还是有点点慢)，肯定不如阿里的容器镜像仓库速度快。所以我们可以配置阿里的镜像加速器，需要注册阿里账号。
  进入阿里网站http://cr.console.aliyun.com，登陆之后，可以看到阿里的镜像仓库(之后再细说)还有镜像加速器，点击镜像加速器，可看到如图所示界面：
  执行将下面代码，便可实现镜像加速了。

sudo mkdir -p /etc/dockersudo tee /etc/docker/daemon.json <<-'EOF'{  "registry-mirrors": ["https://xxxxxxxx.mirror.aliyuncs.com"]}EOFsudo systemctl daemon-reloadsudo systemctl restart docker

  之后使用docker info命令就可以看到已经添加镜像仓库成功

Docker容器

  有了镜像之后我们就可以从中运行容器了。基础的命令有docker pull、docker push、docker create、docker run、docker ps、docker rm、docker start、docker stop、docker images、docker exec、docker inspect等等

pull push

root@DockerUbuntu:~# docker pull --helpUsage:    docker pull [OPTIONS] NAME[:TAG|@DIGEST]Pull an image or a repository from a registryOptions:  -a, --all-tags                Download all tagged images in the repository      --disable-content-trust   Skip image verification (default true)  -q, --quiet                   Suppress verbose output

  docker pull命令我们之前也使用过，可以用来拉镜像，相当于命令docker image pull。根据官方帮助信息，我们可以知道，docker pull 如果要拉去指定版本，需要加:tag版本标签，加-a选项可以拉取所有镜像，不过生产中一般都是用的时候公司内部的本地镜像仓库Harbor，所以拉取镜像时,格式要跟公司Harbor服务器的IP或者域名，指定拉取镜像的源仓库，如果不加，则默认从docker官网拉取。镜像名称格式为：Harbor IP/项目名/image 名字:版本号

docker pull 172.18.32.101/centos/centos-base:v1 

  docker push是用来推送本地镜像至仓库的,相当于命令docker image push，用法格式与pull相似。
使用pull推送至公司Harbor时，需要先在docker启动文件/lib/systemd/system/docker.service的ExecStart选项结尾加入参数--insecure-registry，表示加入不安全的镜像仓库，可加多个，示例如下。

ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --insecure-registry 192.168.32.19 --insecure-registry 192.168.32.20

tag

root@DockerUbuntu:~# docker tag --helpUsage:    docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]Create a tag TARGET_IMAGE that refers to SOURCE_IMAGEroot@DockerUbuntu:~# 

  docker tag命令可以用来打标记，格式如上。一般为了区分不同版本，我们会在每次制作完镜像后打上不同的标记，而且要分发到不同的镜像仓库时也要重新打一个对应仓库IP/项目名的镜像，才可以push或pull。

run

  docker run可以算是最常用的docker基础命令了，意思是创建并运行容器，相当于docker create和docker start的组合。用法格式如下。

docker run [ OPTION ] 镜像ID [ CMD ]

OPTION

  常用选项有-i、-t、-d、-p、-v、-e、--name、--net。

• -i，–interactive， Keep STDIN open even if not attached
    以交互式方式运行。不过只加-t是没法实现交互式的，通常需要-t参数配合，来给容器加一个伪终端实现交互式。
• -t，–tty， Allocate a pseudo-TTY
    给容器分配一个伪终端，与-i配合使用，通常写作-it。
• -d，–detach， Run container in background and print container ID
    使容器启动时后台运行，如果不加这个选项，则会占据宿主机当前终端，服务类容器等交互式容器一般都会加上这个选项。
• -p，–publish， list Publish a container’s port(s) to the host
    映射本地端口到容器的指定端口，同时映射多个端口，则写多个-p 宿主机端口:容器端口选项。
• -v，–volume， list Bind mount a volume
    使用-v 参数， 将宿主机目录映射到容器内部， 默认是可读写的。-v SOUCE:DEST:ro后面加ro则可实现只读。
• -e，–env， list Set environment variables
    可用-e选项为容器添加启动时的环境变量。虽然大多环境变量都是在制作容器时就写进容器里，不过此选项应用在环境变量经常变化的场景，方面修改。
• --name，Assign a name to the container
    给创建的容器命名。同一个宿主机上的容器之间可以通过自定义的容器名称相互访问，由于容器在启动的时候其内部 IP 地址是 DHCP 随机分配的，所以如果通过内部访问的话，自定义名称是相对比较固定的，因此设置容器别名比较适用于此场景。
• –link，Add link to another container
    为容器设置一个别名，相当于一个路径名。自定义的容器名称可能后期会发生变化， 那么一旦名称发生变化，程序之间也要随之发生变化，比如程序通过容器名称进行服务调用， 但是容器名称发生变化之后再使用之前的名称肯定是无法成功调用， 每次都进行更改的话又比较麻烦， 因此可以使用自定义别名的方式解决，即容器名称可以随意更，只要不更改别名即可。
• --net
    为容器指定网络。容器网络类型，常见的为bridge、host、null，也可以自己创建自定义网络。可用docker network list查看当前已有的网络。

  root@DockerUbuntu:~# docker network listNETWORK ID          NAME                DRIVER              SCOPE1eb441f702d2        bridge              bridge              local241d3e94a6b3        host                host                local7cc9cf9eb69e        none                null                local

    docker服务安装完成后，默认在每个宿主机会生成一个名称为 docker0 的网卡其 IP 地址都是 172.17.0.1/16，并且会生成三种不同类型的网络，也就是bridge、host和null，分别代表网桥（桥接）、宿主机网络和无网络访问。
    如果不加--net选项则默认使用bridge，相当于桥接在宿主机的docker0网卡上。
    host网络就是指容器使用宿主机网络，所以端口就不能重复使用，多个使用host网络的容器间端口也不能重复。
    null网络指容器只有回环网卡，没有外部网卡，无法与外部交流交流，不常使用，适用于某些不需要与外界通信的数据计算或图形、数据处理服务。
    还有一种比较特的类型就是container模式，就是指定与一个已有容器共享网络，格式为--net=container:指定名称或 ID 。使用此模式创建的容器需指定和一个已经存在的容器共享一个网络，而不是和宿主机共享网，新创建的容器不会创建自己的网卡也不会配置自己的 IP，而是和一个已经存在的被指定的容器东西 IP 和端口范围，因此这个容器的端口不能和被指定的端口冲突， 除了网络之外的文件系统、进程信息等仍然保持相互隔离，两个容器的进程可以通过 lo 网卡及容器 IP 进行通信。

  CMD

    docker run后面跟的CMD表示指定启动容器的命令，如果不指定，则为容器默认命令。可用 命令docker inspect 容器ID查看容器详细参数查看容器创建时的的CMD。
    因为容器中没有守护进程systemd，所以进程编号PID=1的根进程，就是我们启动容器时指定的CMD命令或创建容器设定的默认CMD。如果这个PID=1的守护进程结束，则整个容器就将被关闭。所以我们一般会指定一个可以占据前台终端的服务来作为守护进程，例如bash或者tail -f /etc/hosts命令，对于后台nginx等服务来说，想让他们作为守护进程启动容器，需要将在后台执行的这个选项关闭，如nginx可以通过docker run -it -d nginx:alpine nginx -g "daemon off;"命令，加上-g "daemon off"选项传递参数或者在配置文件中设置daemon off来关闭后台执行选项，否则容器启动就会因为没有前台进程而终止。为了方便我们修改配置或者重启服务，企业生产中我们都采用tail -f /etc/hosts来作为前台进程，这样我们重启服务容器就不受影响了。

  ps

  root@DockerUbuntu:~# docker ps --help

Usage: docker ps [OPTIONS]

List containers

Options:
-a, –all Show all containers (default shows just running)
-f, –filter filter Filter output based on conditions provided
–format string Pretty-print containers using a Go template
-n, –last int Show n last created containers (includes all states) (default -1)
-l, –latest Show the latest created container (includes all states)
–no-trunc Don’t truncate output
-q, –quiet Only display numeric IDs
-s, –size Display total file sizes

  ``docker ps``命令比较简单，较长使用的参数是``-a``、``-q``，分别是显示所有容器（包括为未运行容器，ps默认只显示正在运行的容器）和只显示容器ID。也可以使用``docker ps -aq``来显示所有容器的ID，可配合其他命令如``docker rm``命令使用。``docker rm -f `docker ps -aq` ``删除本地所有容器（很危险，小心操作！）。### rm  ``docker rm``命令是用来删除容器的，如果容器正在运行，使用``docker rm``命令删除时会报错提示``Error response from daemon: You cannot remove a running container XXX. Stop the container before attempting removal or force remove``，告诉我们无法删除运行中的容器，需要先将容器停止或者强制删除，使用``docker rm -f``命令强制删除，或者使用下面的停止命令### start stop  ``docker start 容器ID``启动容器，可以加选项``-i``，表示启动容器并输出容器内的标准输出至宿主机终端。需要注意的是，如果当时用``docker run``或者``docker create``命令创建容器时，没有加``-it``或``-d``等一些其它选项或者参数的话，在start容器这一步也没法作出更改了的。容器怎么创建的，启动时就会按照创建时设定好的模式运行，这些是没办法再次修改了的，包括启动CMD。  ``docker stop 容器ID``终止容器。需要注意：终止容器时，容器内的数据都将丢失，在备份重要数据之前不要终止容器。### images  ``docker images``命令其实相当于``docker image ls``,显示本地所有镜像。``docker image CMD``还有很多，之后介绍镜像管理的时候 在详细介绍。### exec  ``docker exec``命令可以向一个已运行容器发送命令。用法如下所示。

[root@DockerCentOS ~]# docker exec –help

Usage: docker exec [OPTIONS] CONTAINER COMMAND [ARG…]

Run a command in a running container

Options:
-d, –detach Detached mode: run command in the background
–detach-keys string Override the key sequence for detaching a container
-e, –env list Set environment variables
-i, –interactive Keep STDIN open even if not attached
–privileged Give extended privileges to the command
-t, –tty Allocate a pseudo-TTY
-u, –user string Username or UID (format: <name|uid>[:<group|gid>])
-w, –workdir string Working directory inside the container

  最常使用的格式是``docker exec -it 容器ID bash/sh``，可以进入正在运行的容器。

手动制作镜像

  因为镜像本身的不可修改性，有时候官方镜像中使用的工具的版本可能不是那么符合我们的生产环境，我们就需要自己制作镜像了。一般来说，我们都是基于官方镜像，作出修改来符合自身实际场景中使用，然后在导出保存为我们自己的镜像。
  以一个tomcat容器为例，我们如果需要tomcat8的容器，可以直接从官网拉取tomcat8的镜像docker pull tomcat:8.5.49-jdk8-openjdk修改完成后，还可以使用命令docker commit将已有容器制作为镜像.

root@DockerUbuntu:/opt/dockerfile/web/tomcat/tomcat-apps/app1# docker commit --helpUsage:    docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]Create a new image from a container's changesOptions:  -a, --author string    Author (e.g., "John Hannibal Smith <hannibal@a-team.com>")  -c, --change list      Apply Dockerfile instruction to the created image  -m, --message string   Commit message  -p, --pause            Pause container during commit (default true)

  -a添加镜像制作人信息，-m添加备注信息，-p选项是默认选项，在制作为镜像时暂停容器，-c使用Dockerfile指令来创建镜像，Dockerfile之后我们会详细讲解。例如

docker commit -a "example@163.com" -m "tomcat app1 v1" --change="EXPOSE 8080 8009" f5f8c13d0f9f centos-tomcat-app1:v1

Dockerfile

  不过如果业务场景要求的配置场景要修改nginx的编译参数或者要求底层是centos7系统这就没法更改了（官方镜像一般都是debian系统），我们只能修改最上层的镜像。此时我们可以通过分层构建的方式来制作镜像(，毕竟docker镜像本来就是分层构建的)。
  DockerfileDockerFile 可以说是一种可以被 Docker 程序解释的脚本， DockerFile 是由一条条的命令组成的，每条命令对应 linux 下面的一条命令， Docker 程序将这些 DockerFile 指令再翻译成真正的 linux 命令，其有自己的书写方式和支持的命令， Docker 程序读取 DockerFile 并根据指令生成 Docker 镜像，相比手动制作镜像的方式， DockerFile 更能直观的展示镜像是怎么产生的，有了写好的各种各样 DockerFile 文件，当后期某个镜像有额外的需求时，只要在之前的DockerFile 添加或者修改相应的操作即可重新生成新的 Docke 镜像，避免了重复手动制作镜像的麻烦。
  Docker中常用到的命令令有FROM（指定基础镜像名称）,MAINTAINER（镜像作者署名及联系方式）,USER（切换用户身份，初始一般为root）,WORKDIR（指定或切换工作目录），ADD（将当前宿主机目录的文件拷贝至容器指定位置，tar包可以自动解压）,RUN(运行命令，其实就是shell命令，可执行多条，用&&符号连接),ENV（设置环境变量）,CMD（设置默认镜像启动命令，要可以占据前台，否则基于此镜像启动的容器会直接停止），之后我们结合实际例子一一说明。

  例如我们使用Dockerfile来分层构建定制的tomcat镜像来运行app1服务（当然，也可以一步到位），步骤如下：

1. 构建目录架构
   我们通常将Dockerfile文件都放置在/opt/目录下

   mkdir /opt/dockerfile/{web/{nginx,tomcat,jdk},system/{centos,ubuntu,redhat}} -pv

2. 构建系统镜像

   cd /opt/dockerfile/system/centosmkdir 7.6cd 7.6docker pull centos:7.6.1810

     创建Dockerfile文件,注意D要大写

   vim Dockerfile#CentOS 7.6 镜像FROM centos:7.6.1810MAINTAINER Mice example@163.comRUN rpm -ivh http://mirrors.aliyun.com/epel/epel-release-latest-7.noarch.rpmRUN yum install -y vim wget tree lrzsz gcc gcc-c++ automake pcre pcre-devel zlib zlib-devel openssl openssl-devel iproute net-tools iotopCMD ["bash"]

     创建制作镜像脚本，来生成镜像。当然，也可以直接使用docker build命令配合-t参数（指定标签名）直接将当前目录的Dockerfile制作为镜像，使用脚本是为了日后修改不至于每次名称都不一样，可以保证每次打的镜像的名称和版本号统一，否则以后镜像多了会乱（脚本中也可以在标签中加上时间）。

   vim build_centos.sh#!/bin/bashdocker build -t centos-base:v7.6.1810 .

     当前目录结构为

   root@DockerUbuntu:/opt/dockerfile/system/centos/7.6# tree.├── build_centos.sh└── Dockerfile

0 directories, 2 files

  执行命令``bash build_centos.sh``来创建第一层镜像``centos-base:v7.6.1810``

root@DockerUbuntu:/opt/dockerfile/system/centos/7.6# bash build_centos.sh
Sending build context to Docker daemon 3.072kB
Step 1/5 : FROM centos:7.6.1810
—> f1cb7c7d58b7
Step 2/5 : MAINTAINER Mice example@163.com
—> Using cache
—> 3899d2446806
Step 3/5 : RUN rpm -ivh http://mirrors.aliyun.com/epel/epel-release-latest-7.noarch.rpm
—> Using cache
—> 5a72857ed63d
Step 4/5 : RUN yum install -y vim wget tree lrzsz gcc gcc-c++ automake pcre pcre-devel zlib zlib-devel openssl openssl-devel iproute net-tools iotop
—> Using cache
—> 705fed38cb94
Step 5/5 : CMD [“bash”]
—> Running in aea451be0461
Removing intermediate container aea451be0461
—> 160b9544f121
Successfully built 160b9544f121
Successfully tagged centos-base:v7.6.1810

  有时到yum那步会提示报错，无法解析IP。多执行几次脚本，多试几次就可以了。他会有缓存自动保存镜像，已经写好的层数会自动缓存的，如上面的`` ---> Using cache``。 3. 构建适合版本的jdk镜像

cd /opt/dockerfile/web/jdk/
mkdir 8u212
cd 8u212

  将准备好的jdk压缩包``jdk-8u212-linux-x64.tar.gz``放入此目录，然后还是编写``Dockerfile``以及``build_jdk.sh``脚本

vim Dockerfile
#JDK 8u212
FROM centos-base:v7.6.1810
MAINTAINER Mice example@163.com
ADD jdk-8u212-linux-x64.tar.gz /usr/local/src/
ADD env.sh /etc/profile.d/
RUN ln -sv /usr/local/src/jdk1.8.0_212 /usr/local/jdk && groupadd www -g 2019 && useradd www -u 2019 -g www

ENV JAVA_HOME /usr/java/default
ENV PATH $JAVA_HOME/bin:$PATH
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/:$JRE_HOME/lib/

RUN rm -rf /etc/localtime && ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo “Asia/Shanghai” > /etc/timezone

vim build_jdk.sh
#!/bin/bash
docker build -t jdk-base:v1.8.0_212 .

  需要注意的是，因为ENV环境变量是当前用户（当前终端）有效，也就是说对于容器本身来说，他运行的环境变量是已经通过ENV可以设置好，可是如果发生故障，我们需要连接进入容器时，这个ENV就对我们当前终端无效了，我们可能就无法使用那些ENV设置了的PATH变量了，所以我们需要添加一个``环境变量配置文件``至``/etc/profile.d目录``（也可直接替换profile文件），以便这些环境变量在我们连接至容器后也可以生效。

vim env.sh
JAVA_HOME=/usr/local/jdk
JRE_HOME=$JAVA_HOME/jre
CLASSPATH=$JAVA_HOME/lib/:$JRE_HOME/lib/
PATH=$PATH:$JAVA_HOME/bin

  目录结构如下所示

root@DockerUbuntu:/opt/dockerfile/web/jdk/8u212# tree
.
├── build_jdk.sh
├── Dockerfile
├── env.sh
└── jdk-8u212-linux-x64.tar.gz

0 directories, 4 files

  还是通过build脚本，构建jdk容器。 4. 构建适合版本的tomcat镜像先创建版本目录(，为日后可能需要不同版本的tomcat弄好框架)。

cd /opt/dockerfile/web/tomcat/
mkdir 8.5.47
cd 8

  将准备好的tomcat源码包拷到这个目录，或者wget下载

wget http://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat-8/v8.5.47/bin/apache-tomcat-8.5.47.tar.gz

  制作Dockerfile

vim Dockerfile
#tomcat 8-jdk 1.8.0_212-centos 7.6
FROM jdk-base:v1.8.0_212
MAINTAINER Mice example@163.com

ENV TZ “Asia/Shanghai”
ENV LANG en_US.UTF-8
ENV TERM xterm
ENV TOMCAT_MAJOR_VERSION 8
ENV TOMCAT_MINOR_VERSION 8.5.47
ENV CATALINA_HOME /apps/tomcat
ENV APP_DIR ${CATALINA_HOME}/webapps

RUN mkdir /apps
ADD apache-tomcat-8.5.47.tar.gz /apps/
RUN ln -sv /apps/apache-tomcat-8.5.47 /apps/tomcat

  老规矩，创建build脚本

vim build_tomcat.sh
#!/bin/bash
docker build -t tomcat-base:v8.5.47 .

  然后执行脚本打镜像~ 5. 放置项目app1至指定目录构建镜像  到现在，tomcat容器的环境都配置好了，不过里面还没有跑服务，所以可以针对不同的业务，创建不同的镜像，而他们底层都是共用的一个基础镜像``tomcat-base:v8.5.47``，所有底层镜像因为都是只读的，所以可以复用而互不干扰，也不会重复占用多余的空间。还是先创建业务APP目录。

mkdir -pv /opt/dockerfile/web/tomcat/myapps/app1/
cd /opt/dockerfile/web/tomcat/myapps/app1/

  因为当app1有变化时，tomcat服务可能会需要重启才会生效变化，而如果tomcat服务是容器的启动进程(即PID=1的进程)时，重启tomcat会导致容器终止，容器里面在运行的数据及session都会丢失。所以我们使用``tail -f``命令来作为这个容器的守护进程来启动容器。我们可以通过构建一个脚本``run_tomcat.sh``来实现，启动tomcat并让tail -f 最为前台进程。

vim run_tomcat.sh
#!/bin/bash
su - www -c “/apps/tomcat/bin/catalina.sh start”
su - www -c “tail -f /etc/hosts”

  且为了安全考虑，我们打算让tomcat服务以www用户身份启动，所以在构建容器时，需要注意权限问题，Dockerfile如下：

vim Dockerfile

tomcat-apps

FROM tomcat-base:v8.5.47
ADD run_tomcat.sh /apps/tomcat/bin/run_tomcat.sh
ADD app1/* /apps/tomcat/webapps/myapp/
RUN chown www.www /apps/ -R
EXPOSE 8080 8009
CMD [“/apps/tomcat/bin/run_tomcat.sh”]

  而且我们把``run_tomcat.sh``传进去后，要以脚本启动的话，要对脚本加执行权限，这样传进去的时候也是有执行权限的。

chmod +x run_tomcat.sh

  然后构建build脚本

vim build_app1.sh
#!/bin/bash
docker build -t tomcat-app1:v1 .

  然后将APP1的程序代码拷贝至当前目录，结构示意图如下：

root@DockerUbuntu:/opt/dockerfile/web/tomcat/myapps/app1# tree
.
├── build_app1.sh
├── Dockerfile
├── app1
│ └── index.html
└── run_tomcat.sh

1 directory, 4 files

  就可以执行build脚本打镜像啦。

bash build_app1.sh

  需要注意的是，启动镜像时记得加``端口映射``，命令如下

docker run -it -d -p 8080:8080 -p 8009:8009 tomcat-app1:v1

  此时通过``ss -tanl``命令就可以看到8080、80009端口已经被docker proxy监听了。说明服务启动成功。如果宿主机为centos，或者redhat（ubuntu默认是开启的），可能会需要先打开内核参数ip_forward选项，否则会报错网络不可用:

WARNING: IPv4 forwarding is disabled. Networking will not work.

  那就开启IP转发。

vim /etc/sysctl.conf
net.ipv4.ip_forward=1

  然后``sysctl -p``生效就可以正常使用容器网络了。## 注意事项  需要注意的是，``RUN``命令是类似启动一个新的进程或者是shell，来执行每一次命令，执行完毕后此次``RUN``进程结束，下一次是一个全新的``RUN``进程了，相互之间不会联系。这么说可能大家无法理解，举个最简单的例子吧，就是当我们想要编译安装haproxy的时候，需要进入编译目录然后执行``make``命令，编译完后还要在编译目录执行``make install``命令。所以可以写成

RUN cd /usr/localk/haproxy-2.0.5 && make –xxx参数选项省略xxxx && make install

  但是如果我们像写脚本那样，写成

RUN cd /usr/localk/haproxy-2.0.5
RUN make –xxx参数选项省略xxxx
RUN make install

  或者

RUN cd /usr/localk/haproxy-2.0.5 && make –xxx参数选项省略xxxx
RUN make install

  就会报错找不到路径，因为没一条命令都是一层独立的镜像，每层镜像开始都会在默认的初始目录，所以如果打算将``make``和``make install``分开写，则两次都加``cd /usr/local/haproxy-2.0.5``,或者直接切换工作目录，如下所示。

WORKDIR /usr/local/src/haproxy-2.0.5
RUN make ARCH=x86_64
TARGET=linux-glibc USE_PCRE=1
USE_OPENSSL=1
USE_ZLIB=1
USE_CPU_AFFINITY=1
USE_LUA=1
LUA_INC=../lua-5.3.5/src/
LUA_LIB=../lua-5.3.5/src/
PREFIX=/apps/haproxy
RUN make install PREFIX=/apps/haproxy

  ``WORKDIR``和``USER``很类似，都是修改后，对后续Dockerfile指令有效。且``WORKDIR``还支持相对路径，例如

WORKDIR /a
WORKDIR b
WORKDIR c

  则最终的工作目录为``/a/b/c``。

Docker简介

Docker 是什么

  首先 Docker 是一个在 2013 年开源的应用程序并且是一个基于 go 语言编写是一个开源的 PAAS 服务(Platform as a Service， 平台即服务的缩写)， go 语言是由google 开发， docker 公司最早叫 dotCloud 后由于 Docker 开源后大受欢迎就将公司改名为 Docker Inc， 总部位于美国加州的旧金山， Docker 是基于 linux 内核实现， Docker 最早采用 LXC 技术(LinuX Container 的简写， LXC 是 Linux 原生支持的容器技术， 可以提供轻量级的虚拟化， 可以说 docker 就是基于 LXC 发展起来的，提供 LXC 的高级封装，发展标准的配置方法)， 而虚拟化技术 KVM(Kernelbased Virtual Machine) 基于模块实现， Docker 后改为自己研发并开源的 runc 技术运行容器。

Dokcer与虚拟机技术对比

  Docker 相比虚拟机的交付速度更快， 资源消耗更低， Docker 采用客户端/服务端架构，使用远程 API 来管理和创建 Docker 容器，其可以轻松的创建一个轻量级的、 可移植的、自给自足的容器， docker 的三大理念是 build(构建)、ship(运输)、 run(运行)， Docker 遵从 apache 2.0 协议，并通过（namespace 及cgroup 等）来提供容器的资源隔离与安全保障等，所以 Docke 容器在运行时不需要类似虚拟机（空运行的虚拟机占用物理机 6-8%性能）的额外资源开销，因此可以大幅提高资源利用率,总而言之 Docker 是一种用了新颖方式实现的轻量级虚拟机.类似于 VM 但是在原理和应用上和 VM 的差别还是很大的，并且 docker的专业叫法是应用容器(Application Container)。
| 优势 | Docker | 虚拟机 |
|–|–|–|
| 资源利用率更高 | 一台物理机可以运行数百个容器 | 但是一般只能运行数十个虚拟机 |
| 开销更小 | 不需要启动单独的虚拟机占用硬件资源 | 需要启动单独的虚拟机占用硬件资源 |
| 启动速度更快 | 可以在数秒内完成启动 | 需要几十秒甚至数分钟 |

  使用虚拟机是为了更好的实现服务运行环境隔离， 每个虚拟机都有独立的内核，虚拟化可以实现不同操作系统的虚拟机，但是通常一个虚拟机只运行一个服务， 很明显资源利用率比较低且造成不必要的性能损耗， 我们创建虚拟机的目的是为了运行应用程序，比如 Nginx、 PHP、 Tomcat 等 web 程序， 使用虚拟机无疑带来了一些不必要的资源开销，但是容器技术则基于减少中间运行环节带来较大的性能提升。

Docker 的组成

• Docker 主机(Host)： 一个物理机或虚拟机，用于运行 Docker 服务进程和容器。
• Docker 服务端(Server)： Docker 守护进程， 运行 docker 容器。
• Docker 客户端(Client)： 客户端使用 docker 命令或其他工具调用 docker API。
• Docker 仓库(Registry): 保存镜像的仓库，类似于 git 或 svn 这样的版本控制系统，官方仓库: https://hub.docker.com/
• Docker 镜像(Images)： 镜像可以理解为创建实例使用的模板。
• Docker 容器(Container): 容器是从镜像生成对外提供服务的一个或一组服务。

详细介绍参见官方文档https://docs.docker.com/engine/docker-overview/

Docker实现需要解决的问题

  容器技术确实有很多优点，不过当使用多个容器时带来的以下问题怎么解决:
  1.怎么样保证每个容器都有不同的文件系统并且能互不影响？
  2.一个 docker 主进程内的各个容器都是其子进程，那么实现同一个主进程下不同类型的子进程？ 各个进程间通信能相互访问(内存数据)吗？
  3.每个容器怎么解决 IP 及端口分配的问题？
  4.多个容器的主机名能一样吗？
  5.每个容器都要不要有 root 用户？怎么解决账户重名问题？
  这就不得不引入一个Namespace的概念了。

Namespace

  namespace 是 Linux 系统的底层概念， 在内核层实现，即有一些不同类型的命名空间被部署在核内， 各个 docker 容器运行在同一个 docker 主进程并且共用同一个宿主机系统内核，各 docker 容器运行在宿主机的用户空间， 每个容器都要有类似于虚拟机一样的相互隔离的运行空间， 但是容器技术是在一个进程内实现运行指定服务的运行环境， 并且还可以保护宿主机内核不受其他进程的干扰和影响， 如文件系统空间、网络空间、进程空间等。
| 隔离类型 | 实现功能 | 系统调用参数 | 内核版本 |
|–|–|–|–|
| MNT Namespace(mount) | 提供磁盘挂载点和文件系统的隔离能力 | CLONE_NEWNS | Linux 2.4.19 |
| IPC Namespace(Inter-Process Communication) | 提供进程间通信的隔离能力 | CLONE_NEWIPC | Linux 2.6.19 |
| UTS Namespace(UNIX Timesharing System) | 提供主机名隔离能力 | CLONE_NEWUTS | Linux 2.6.19 |
| PID Namespace(Process Identification) | 提供进程隔离能力 | CLONE_NEWPID | Linux 2.6.24 |
| Net Namespace(network) | 提供网络隔离能力 | CLONE_NEWNET | Linux 2.6.29 |
| User Namespace(user) | 提供用户隔离能力 | CLONE_NEWUSER | Linux 3.8 |

• MNT Namespace：每个容器都要有独立的根文件系统有独立的用户空间， 以实现在容器里面启动服务并且使用容器的运行环境，容器里面是不能访问宿主机的资源， 宿主机是使用了 chroot 技术把容器锁定到一个指定的运行目录里面。
• IPC Namespace：一个容器内的进程间通信， 允许一个容器内的不同进程的(内存、 缓存等)数据访问，但是不能跨容器访问其他容器的数据。
• UTS Namespace：UTS namespace（UNIX Timesharing System 包含了运行内核的名称、版本、底层体系结构类型等信息）用于系统标识， 其中包含了 hostname 和域名domainname ， 它使得一个容器拥有属于自己 hostname 标识，这个主机名标识独立于宿主机系统和其上的其他容器。
• PID Namespace：Linux 系统中，有一个 PID 为 1 的进程(init/systemd)是其他所有进程的父进程， 那么在每个容器内也要有一个父进程来管理其下属的子进程，那么多个容器的进程通 PID namespace 进程隔离(比如 PID 编号重复、 器内的主进程生成与回收子进程等)。
• Net Namespace：每一个容器都类似于虚拟机一样有自己的网卡、 监听端口、 TCP/IP 协议栈等，Docker 使用 network namespace 启动一个 vethX 接口，这样你的容器将拥有它自己的桥接 ip 地址，通常是 docker0，而 docker0 实质就是 Linux 的虚拟网桥,网桥是在 OSI 七层模型的数据链路层的网络设备，通过 mac 地址对网络进行划分，并且在不同网络直接传递数据。
• User Namespace：User Namespace 允许在各个宿主机的各个容器空间内创建相同的用户名以及相同的用户 UID 和 GID， 只是会把用户的作用范围限制在每个容器内，即 A 容器和 B 容器可以有相同的用户名称和 ID 的账户，但是此用户的有效范围仅是当前容器内， 不能访问另外一个容器内的文件系统，即相互隔离、互补影响、 永不相见。

  通过这些内核级功能的实现，docker才可以正常工作，实现不同容器间的各种资源的隔离，形成共享同一组硬件及内核上却互不影响的独立应用级虚拟化系统。不过此时，我们还面临一个问题，就是资源使用率的控制。如果一个容器因为BUG或代码本身等原因导致无限制的使用宿主机上的资源，将会导致宿主机CPU或者内存不足进而极有可能影响到其他容器的正常运行。所以我们需要对每个容器的资源利用做一个限制，我们通过内核中的Linux Cgroups功能来限制每个容器能使用的资源的上限。

Linux Cgroups

  Linux Cgroups 的全称是 Linux Control Groups， 它最主要的作用，就是限制一个进程组能够使用的资源上限，包括 CPU、内存、磁盘、网络带宽等等。此外，还能够对进程进行优先级设置，以及将进程挂起和恢复等操作。
  Cgroups 在内核层默认已经开启，可通过下列命令验证查看Cgroups设置
  CentOS7.6:

[root@localhost ~]# cat /boot/config-3.10.0-957.el7.x86_64 |grep CGROUPCONFIG_CGROUPS=y# CONFIG_CGROUP_DEBUG is not setCONFIG_CGROUP_FREEZER=yCONFIG_CGROUP_PIDS=yCONFIG_CGROUP_DEVICE=yCONFIG_CGROUP_CPUACCT=yCONFIG_CGROUP_HUGETLB=yCONFIG_CGROUP_PERF=yCONFIG_CGROUP_SCHED=yCONFIG_BLK_CGROUP=y# CONFIG_DEBUG_BLK_CGROUP is not setCONFIG_NETFILTER_XT_MATCH_CGROUP=mCONFIG_NET_CLS_CGROUP=yCONFIG_NETPRIO_CGROUP=y[root@localhost ~]# 

  ubuntu1804中:

root@DockerUbuntu:~# cat /boot/config-4.15.0-70-generic |grep CGROUPCONFIG_CGROUPS=yCONFIG_BLK_CGROUP=y# CONFIG_DEBUG_BLK_CGROUP is not setCONFIG_CGROUP_WRITEBACK=yCONFIG_CGROUP_SCHED=yCONFIG_CGROUP_PIDS=yCONFIG_CGROUP_RDMA=yCONFIG_CGROUP_FREEZER=yCONFIG_CGROUP_HUGETLB=yCONFIG_CGROUP_DEVICE=yCONFIG_CGROUP_CPUACCT=yCONFIG_CGROUP_PERF=yCONFIG_CGROUP_BPF=y# CONFIG_CGROUP_DEBUG is not setCONFIG_SOCK_CGROUP_DATA=yCONFIG_NETFILTER_XT_MATCH_CGROUP=mCONFIG_NET_CLS_CGROUP=mCONFIG_CGROUP_NET_PRIO=yCONFIG_CGROUP_NET_CLASSID=yroot@DockerUbuntu:~# 

  可以看到内核较新的 ubuntu 支持的功能更多。

cgroups 参数具体解释：

blkio：块设备 IO 限制。cpu：使用调度程序为 cgroup 任务提供 cpu 的访问。cpuacct：产生 cgroup 任务的 cpu 资源报告。cpuset：如果是多核心的 cpu，这个子系统会为 cgroup 任务分配单独的 cpu和内存。devices：允许或拒绝 cgroup 任务对设备的访问。freezer：暂停和恢复 cgroup 任务。memory：设置每个 cgroup 的内存限制以及产生内存资源报告。net_cls：标记每个网络包以供 cgroup 方便使用。ns：命名空间子系统。perf_event：增加了对每 group 的监测跟踪的能力，可以监测属于某个特定的group 的所有线程以及运行在特定 CPU 上的线程。

  可以通过命令ll /sys/fs/cgroup/查看系统Cgroups

Docker依赖的技术

  Docker容器技术如果真正想在企业中应用，还必须依赖下面的一些技术，会在之后的文章中详细介绍。

容器网络：

  docker 自带的网络 docker network 仅支持管理单机上的容器网络， 当多主机运行的时候需要使用第三方开源网络，例如 calico、 flannel 等。

服务发现：

  容器的动态扩容特性决定了容器 IP 也会随之变化， 因此需要有一种机制可以自动识别并将用户请求动态转发到新创建的容器上， kubernetes 自带服务发现功能，需要结合 kube-dns 服务解析内部域名。

容器监控：

  可以通过原生命令 docker ps/top/stats 查看容器运行状态，另外也可以使
heapster/ Prometheus 等第三方监控工具监控容器的运行状态。

数据管理：

  容器的动态迁移会导致其在不同的 Host 之间迁移，因此如何保证与容器相关的数据也能随之迁移或随时访问，可以使用逻辑卷/存储挂载等方式解决。

日志收集：

  docker 原生的日志查看工具 docker logs， 但是容器内部的日志需要通过 ELK 等专门的日志收集分析和展示工具进行处理。

Docker部署

  我们初步知道了Docker的概念和实现原理，也知道了Docker在使用中可能会遇到的问题，说了这么多，现在我们先将Docker部署一下。
  Docker常见的安装方式有三种，可以通过rpm包下载，或者二进制安装，也可以通过epel源安装。
  官方 rpm 包下载地址:
  https://download.docker.com/linux/centos/7/x86_64/stable/Packages/
  二进制下载地址：
  https://download.docker.com/
https://mirrors.aliyun.com/docker-ce/linux/static/stable/x86_64/
  阿里镜像下载地址：
  https://mirrors.aliyun.com/docker-ce/linux/centos/7/x86_64/stable/Packages/
  Ubuntu的安装docker-ce阿里云镜像仓库方式如下（使用 apt-get 进行安装）:

# step 1: 安装必要的一些系统工具sudo apt-get updatesudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common# step 2: 安装GPG证书curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -# Step 3: 写入软件源信息sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"# Step 4: 更新并安装Docker-CEsudo apt-get -y updatesudo apt-get -y install docker-ce# 安装指定版本的Docker-CE:# Step 1: 查找Docker-CE的版本:# apt-cache madison docker-ce#   docker-ce | 17.03.1~ce-0~ubuntu-xenial | https://mirrors.aliyun.com/docker-ce/linux/ubuntu xenial/stable amd64 Packages#   docker-ce | 17.03.0~ce-0~ubuntu-xenial | https://mirrors.aliyun.com/docker-ce/linux/ubuntu xenial/stable amd64 Packages# Step 2: 安装指定版本的Docker-CE: (VERSION例如上面的17.03.1~ce-0~ubuntu-xenial)# sudo apt-get -y install docker-ce=[VERSION]

  注意：在与 kubernetes 结合使用的时候，要安装经过 kubernetes 官方测试通过的 docker版本， 避免出现不兼容等未知的及不可预估的问题发生， kubernetes 测试过的docker 版本可以在 github 查询， 具体如下：
https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.14.md#external-dependencies
  安装完成后就可以用systemctl start docker命令启动Docker了。
  然后用docker info命令来验证当前容器信息

docker info

Containers: 0 #当前主机运行的容器总数Running: 0 #有几个容器是正在运行的Paused: 0 #有几个容器是暂停的Stopped: 0 #有几个容器是停止的Images: 0 #当前服务器的镜像数Server Version: 18.09.9 #服务端版本Storage Driver: overlay2 #正在使用的存储引擎Backing Filesystem: extfs #后端文件系统，即服务器的磁盘文件系统Supports d_type: true #是否支持 d_typeNative Overlay Diff: true #是否支持差异数据存储Logging Driver: json-file #日志类型Cgroup Driver: cgroupfs #Cgroups 类型Plugins: #插件Volume: local #卷Network: bridge host macvlan null overlay # overlay 夸主机通信Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog #日志类型Swarm: inactive #是否支持 swarmRuntimes: runc #已安装的容器运行时Default Runtime: runc #默认使用的容器运行时Init Binary: docker-init #初始化容器的守护进程，即 pid 为 1 的进程containerd version: 894b81a4b802e4eb2a91d1ce216b8817763c29fb #版本runc version: 425e105d5a03fabd737a126ad93d62a9eeede87f # runc 版本init version: fec3683 #init 版本Security Options: #安全选项Apparmor #安全模块， https://docs.docker.com/engine/security/apparmor/seccomp #审计(操作)， https://docs.docker.com/engine/security/seccomp/Profile: default #默认的配置文件Kernel Version: 4.15.0-55-generic #宿主机内核版本Operating System: Ubuntu 18.04.3 LTS #宿主机操作系统OSType: linux #宿主机操作系统类型Architecture: x86_64 #宿主机架构CPUs: 2 #宿主机 CPU 数量Total Memory: 3.83GiB #宿主机总内存Name: DockerUbuntu #宿主机 hostnameID: ZFPD:UIA5:SR6E:Y6SS:52QL:5MPT:VDY3:ATVI:QMVG:HAFF:MN74:2HPD #宿主机IDDocker Root Dir: /var/lib/docker #宿主机数据保存目录Debug Mode (client): false #client 端是否开启 debugDebug Mode (server): false #server 端是否开启 debugRegistry: https://index.docker.io/v1/ #镜像仓库Labels: #其他标签Experimental: false #是否测试版Insecure Registries: #非安全的镜像仓库127.0.0.0/8Live Restore Enabled: false #是否开启活动重启(重启 docker-daemon 不关闭容器)Product License: Community Engine #产品许可信息

在结尾可能会有类似warning警报,

WARNING: No swap limit support

这是提示说我们没有开启 swap 资源限制，这就需要我们通过修改内核参数，来限制swap资源的使用。

vim /etc/default/grub

GRUB_CMDLINE_LINUX="net.ifnames=0 biosdevname=0 cgroup_enable=memory swapaccount=1"

 update-grub reboot

  重启生效。至此，docker工具部署就完成了~

  可参考红帽官方对kvm的定义：https://www.redhat.com/zh/topics/virtualization/what-is-KVM
  KVM的虚拟化需要硬件支持（如Intel VT技术或者AMD V技术)，是基于硬件的完全虚拟化，而Xen早期则是基于软件模拟的半虚拟化，新版本则是支持基于硬件支持的完全虚拟化，但Xen本身有自己的进程调度器，存储管理模块等，所以代码较为庞大，广为流传的商业系统虚拟化软件VMware ESXI系列是Full-Virtualization，（IBM文档：http://www.ibm.com/developerworks/cn/linux/l-using-kvm/ ）
  简单地说，KVM就是基于硬件支持实现，将单台主机，分隔成多个互不干扰的虚拟主机的技术，不受困于底层操作系统，可以为每个主机提供单独的、所需的的运行环境，如下图所示：

  如果每个节点都是用共享存储如NAS，则可实现跨主机的虚拟机快速迁移，这也是我们在生产环境中经常采用的架构。本文将以下面架构，来具体展示KVM在实际生产中的应用。
  三个主机，其中两个主机node1和node2上运行KVM，另一台是NAS共享存储服务器，通过10.0.0.0/16网段内网连接。在node1上的用KVM构建虚拟机H1和W1分别运行haproxy+keepalived服务和nginx服务，其中H1桥接方式到node1的两块网卡上，W1桥接到内网网卡eth1上。node2节点中也是如此。于是，将Client端请求通过haproxy反向代理只内网的web服务集群中，保证负载均衡和高可用，哪怕一个物理节点服务器down掉也不影响客户服务访问。
  NAS服务器的搭建很容易，这里就先不详细介绍了，本文之后主要介绍KVM服务的配置及虚拟机集群的搭建。

宿主机环境准备：

  KVM需要宿主机CPU必须支持虚拟化功能，因此如果是在vmware workstation上使用虚拟机做宿主机，那么必须要在虚拟机配置界面的处理器选项中开启虚拟机化功能（VMware支持嵌套虚拟化，而KVM不支持，大部分云服务器如阿里云就是基于KVM技术二次研发制作的，所以云服务器都不支持从中再建虚拟机）。
  KVM模块因为已经被集成到linux内核之中，所以我们只需要安装KVM管理工具就可以直接使用KVM创建虚拟机了。
  可用命令验证是否开启虚拟化（也可通过lscpu命令,grep -o选项只看匹配词本身，也可以用egrep代替grep -E）

[root@localhost ~]# grep -Eo "vmx|svm" /proc/cpuinfo | wc -lvmxvmx

KVM软件包安装

  在Ubuntu 18.04中：
  可参考官网https://ubuntu.com/server/docs/virtualization-libvirt

apt install qemu-kvm virt-manager libvirt-daemon-systemkvm-ok #验证是否支持kvm

INFO: /dev/kvm existsKVM acceleration can be used

  CentOS 7.X：

yum install qemu-kvm qemu-kvm-tools libvirt libvirt-client virt-manager virt-install

systemctl start libvirtdsystemctl enable libvirtd

网络环境配置

  为了让三个节点间虚拟机可以直接相互之间通信，需要将KVM上的虚拟机以桥接模式与宿主机的网卡连接，这就需要我们提前在宿主机上配置好网桥。
  若宿主机为Ubuntu18.04：

sudo vim /etc/netplan/01-netcfg.yaml

# This file describes the network interfaces available on your system# For more information, see netplan(5).network:  version: 2  renderer: networkd  ethernets:    eth0:      dhcp4: no      dhcp6: no    eth1:      dhcp4: no      dhcp6: no  bridges:    br0:      dhcp4: no      dhcp6: no      addresses: [172.18.0.75/16]      gateway4: 172.18.0.1      nameservers:        addresses: [180.76.76.76]      interfaces:        - eth0    br1:      dhcp4: no      dhcp6: no      addresses: [10.0.0.75/16]      interfaces:        - eth1

  修改网卡配置后，使用netplan apply命令使配置文件的修改生效

netplan apply

  若宿主机为CentOS：

cd /etc/sysconfig/network-scripts/

vim ifcfg-eh0

TYPE=EthernetBOOTPROTO=staticNAME=eth0DEVICE=eth0ONBOOT=yesBRIDGE=br0

vim ifcfg-eh1

TYPE=EthernetBOOTPROTO=staticNAME=eth1DEVICE=eth1ONBOOT=yesBRIDGE=br1

vim ifcfg-br0

TYPE=BridgeBOOTPROTO=staticNAME=br0DEVICE=br0ONBOOT=yesIPADDR=172.18.32.75NETMASK=255.255.0.0GATEWAY=172.18.0.1DNS1=180.76.76.76

vim ifcfg-br1

TYPE=BridgeBOOTPROTO=staticNAME=br1DEVICE=br1ONBOOT=yesIPADDR=10.0.0.75NETMASK=255.255.0.0

  重启网络服务，生效配置

systemctl restart network

  ip a命令或ifconfig查看桥接网卡是否生效

KVM虚拟机创建

创建虚拟磁盘

[root@localhost ~]# ll /var/lib/libvirt/images/ #默认保存虚拟机磁盘的路径total 0[root@localhost ~]# 

  使用qemu-img create命令可以创建磁盘,如果创建raw格式磁盘文件，则理解占据实际大小，若创建qcow2稀疏格式磁盘，则磁盘文件会随着使用的增大而增大

qemu-img create -f raw /var/lib/libvirt/images/CentOS7.raw 10G建磁盘

ll -h /var/lib/libvirt/images/CentOS7.raw-rw-r--r-- 1 root root 10G Nov 29 16:34 /var/lib/libvirt/images/centos.raw

qemu-img create -f qcow2 /var/lib/libvirt/images/CentOS7.qcow2 10G

ll -h /var/lib/libvirt/images/CentOS7.qcow2-rw-r--r-- 1 root root 193K Nov 29 16:36 /var/lib/libvirt/images/centos.qcow2

  我们选用qcow2格式的磁盘，先创建H1虚拟机，

qemu-img create -f qcow2 /var/lib/libvirt/images/H1.qcow2 10G

创建虚拟机

  先导入ISO光盘镜像文件,可以使用共享存储上的ISO文件，也可本机导入，本机上传的话一般习惯性放到/usr/local/src/目录下
  使用virt-install命令创建虚拟机，参数可virt-install --help查看帮助信息

virt-install --help

usage: virt-install --name NAME --ram RAM STORAGE INSTALL [options]使用指定安装介质新建虚拟机。optional arguments:-h, --help show this help message and exit--version show program's version number and exit--connect URI 使用 libvirt URI 连接到 hypervisor通用选项:-n NAME, --name NAME 客户端事件名称--memory MEMORY 配置虚拟机内存分配。例如：--memory 1024 (in MiB)--memory 512,maxmemory=1024--vcpus VCPUS 为虚拟机配置的 vcpus 数。例如：--vcpus 5--vcpus 5,maxcpus=10,cpuset=1-4,6,8--vcpus sockets=2,cores=4,threads=2,--cpu CPU CPU 型号及功能。例如：--cpu coreduo,+x2apic--cpu host--metadata METADATA 配置虚拟机元数据。例如：--metadata name=foo,title="My pretty title",uuid=...--metadata description="My nice long description"安装方法选项:--cdrom CDROM 光驱安装介质-l LOCATION, --location LOCATION安装源(例如：nfs:host:/path、http://host/pathftp://host/path)--pxe 使用 PXE 协议从网络引导--import 在磁盘映像中构建虚拟机--livecd 将光驱介质视为 Live CD-x EXTRA_ARGS, --extra-args EXTRA_ARGS附加到使用 --location 引导的内核的参数--initrd-inject INITRD_INJECT使用 --location 为 initrd 的 root添加给定文件--os-variant DISTRO_VARIANT在其中安装 OS 变体的虚拟机，比如'fedora18'、'rhel6'、'winxp' 等等。--boot BOOT 配置虚拟机引导设置。例如：--boot hd,cdrom,menu=on--boot init=/sbin/init (for containers)--idmap IDMAP 为 LXC 容器启用用户名称空间。例如：--idmap uid_start=0,uid_target=1000,uid_count=10设备选项:--disk DISK 使用不同选项指定存储。例如：--disk size=10 (new 10GiB image in default location)--disk /my/existing/disk,cache=none--disk device=cdrom,bus=scsi--disk=?-w NETWORK, --network NETWORK配置虚拟机网络接口。例如：--network bridge=mybr0--network network=my_libvirt_virtual_net--network network=mynet,model=virtio,mac=00:11...--network none--network help--graphics GRAPHICS 配置虚拟机显示设置。例如：--graphics vnc--graphics spice,port=5901,tlsport=5902--graphics none--graphics vnc,password=foobar,port=5910,keymap=ja--controller CONTROLLER配置虚拟机控制程序设备。例如：--controller type=usb,model=ich9-ehci1--input INPUT 配置虚拟机输入设备。例如：--input tablet--input keyboard,bus=usb--serial SERIAL 配置虚拟机串口设备--parallel PARALLEL 配置虚拟机并口设备--channel CHANNEL 配置虚拟机沟通频道--console CONSOLE 配置虚拟机与主机之间的文本控制台连接--hostdev HOSTDEV 将物理 USB/PCI/etc主机设备配置为与虚拟机共享--filesystem FILESYSTEM将主机目录传递给虚拟机。例如：--filesystem /my/source/dir,/dir/in/guest--filesystem template_name,/,type=template--sound [SOUND] 配置虚拟机声音设备模拟--watchdog WATCHDOG 配置虚拟机 watchdog 设备--video VIDEO 配置虚拟机视频硬件。--smartcard SMARTCARD配置虚拟机智能卡设备。例如：--smartcard mode=passthrough--redirdev REDIRDEV 配置虚拟机重定向设备。例如：--redirdev usb,type=tcp,server=192.168.1.1:4000--memballoon MEMBALLOON配置虚拟机 memballoon 设备。例如：--memballoon model=virtio--tpm TPM 配置虚拟机 TPM 设备。例如：--tpm /dev/tpm--rng RNG 配置虚拟机 RNG 设备。例如：--rng /dev/random--panic PANIC 配置虚拟机 panic 设备。例如：--panic default虚拟机配置选项:--security SECURITY 设定域安全驱动器配置。--numatune NUMATUNE 为域进程调整 NUMA 策略。--memtune MEMTUNE 为域进程调整内粗策略。--blkiotune BLKIOTUNE为域进程调整 blkio 策略。--memorybacking MEMORYBACKING为域进程设置内存后备策略。例如：--memorybacking hugepages=on--features FEATURES 设置域 <features> XML。例如：--features acpi=off--features apic=on,eoi=on--clock CLOCK 设置域 <clock> XML。例如：--clock offset=localtime,rtc_tickpolicy=catchup--pm PM 配置 VM 电源管理功能--events EVENTS 配置 VM 生命周期管理策略--resource RESOURCE 配置 VM 资源分区（cgroups）虚拟化平台选项:-v, --hvm 客户端应该是一个全虚拟客户端-p, --paravirt 这个客户端一个是一个半虚拟客户端--container 这台虚拟机需要一个容器客户端--virt-type HV_TYPE 要使用的管理程序名称(kvm、qemu、xen等等)--arch ARCH 模拟的 CPU 构架--machine MACHINE 要模拟的机器类型其它选项:--autostart 引导主机时自动启动域。--wait WAIT 等待安装完成的分钟数。--noautoconsole 不要自动尝试连接到客户端控制台--noreboot 完成安装后不要引导虚拟机。--print-xml [XMLONLY]输出所生成域 XML，而不是创建虚拟机。--dry-run 完成安装步骤，但不要创建设备或者定义虚拟机。--check CHECK 启用或禁用验证检查。例如：--check path_in_use=off--check all=off-q, --quiet 禁止无错误输出-d, --debug 输入故障排除信息

  我们使用命令创建虚拟机(网卡配置选择default的话默认是nat模式)

virt-install --virt-type kvm \--name H1 --ram 1024 --vcpus 2 \--cdrom=/usr/local/src/CentOS-7-x86_64-Minimal-1908.iso \--disk=/var/lib/libvirt/images/H1.qcow2 \--network network=default \--graphics vnc,listen=0.0.0.0 \--noautoconsole

  输入virt-manager可开启xshellmanager的终端窗口如下图
  双击图标打开，可以看到已经开始自动从光盘启动安装了，配置完毕，手动安装CentOS7系统。
如果输入virt-manage不能启动xmanager的窗口，检查一下项目

• 确认已经安装xmanager
• xshell文件—属性—连接—隧道—设置转发x11到xmanager
• ssh服务配置文件是否开启X11Forwarding选项 设置为yes

  以上都没问题，建议重装xmanager，我就是配置都对，但是输入virt-manage命令没反应，重装了一下xmanager和xshell之后就可以正常使用了。

  安装好CentOS7系统重启后，在vrit-manager的窗口中点击虚拟机info，给H1虚拟机添加一块网卡，并将两块网卡分别选择为主机的桥接网卡br0和br1，如下图所示

  在虚拟机中配置两个网卡的IP，配置分别如下

vi /etc/sysconfig/network-scripts/ifcfg-eth0TYPE="Ethernet"BOOTPROTO="static"IPADDR="172.18.32.85"GATEWAY="172.18.0.1"DNS1="180.76.76.76"DEFROUTE="yes"NAME="eth0"DEVICE="eth0"ONBOOT="yes"

vi /etc/sysconfig/network-scripts/ifcfg-eth1TYPE="Ethernet"BOOTPROTO="static"IPADDR="10.0.0.85"DEFROUTE="no"NAME="eth1"DEVICE="eth1"ONBOOT="yes"

  此时H1的基本配置就算完成了。
  查看/var/lib/libvirt/images/目录下，看到已经有一个镜像了了

[root@localhost ~]# ll /var/lib/libvirt/images/total 1594308-rw-r--r-- 1 root root 1632632832 Nov 29 18:54 H1.qcow2

  可以直接将此文件cp一份来当web1的磁盘文件

cd /var/lib/libvirt/images/cp H1.qcow2 W1.qcow2

  也可以在node2节点上的H2和web2虚拟机的磁盘文件。
我们直接拷贝改名后，执行virt-install命令，创建另外三个虚拟机。

virt-install --virt-type kvm \--name W1 --ram 1024 --vcpus 2 \--cdrom=/usr/local/src/CentOS-7-x86_64-Minimal-1908.iso \--disk=/var/lib/libvirt/images/W1.qcow2 \--network network=default \--graphics vnc,listen=0.0.0.0 \--noautoconsole

  然后将W1强制终止，因为第一次是默认从光驱启动的，我们已经有系统了，不需要重装，重启后就发现已经是装好的系统，与H1一模一样的。
  然后修改主机名为web1，将网卡桥接在eth1上,修改网卡配置。

TYPE="Ethernet"BOOTPROTO="static"IPADDR="10.0.0.175"PREFIX="16"DEFROUTE="yes"NAME="eth0"DEVICE="eth0"ONBOOT="yes"

  对node2上的两个虚拟机采用同样方式创建。
  之后分别通过脚本装HAProxy+keepadlived服务和nginx+PHP服务。
  修改完几个服务的配置文件(可参考之前文章企业级应用：负载均衡层——haproxy(一))之后，就可以将通过客户机就可以访问，后端web服务器了。

附一键安装脚本

HAProxy一键安装脚本

[root@HAProxy1 haproxy]# tree.├── haproxy-2.0.8.tar.gz├── haproxy84.cfg├── haproxy.cfg├── haproxy.service├── haproxy.sh└── lua-5.3.5.tar.gz0 directories, 6 files[root@HAProxy1 haproxy]# bash haproxy.sh

#!/bin/bashDST="/apps"[ -a haproxy.cfg ] || { echo ' the absence of haproxy.conf' ;exit 1;}[ -a haproxy-2.0.8.tar.gz ] || { echo ' the absence of haproxy-2.0.8.tar.gz' ;exit 1;}[ -a haproxy.service ] || { echo ' the absence of haproxy.service' ;exit 2;}[ -a /usr/lib/systemd/system/haproxy.service ] && { echo ' haproxy is aready installed' ;exit 3;}id haproxy &>/dev/null && { echo 'user haproxy is exist' ; exit 4;} || useradd -r -s /sbin/nologin -u 79 haproxyyum install -y libtermcap-devel ncurses-devel libevent-devel readline-devel gcc make[ -a lua-5.3.5.tar.gz ] || wget http://www.lua.org/ftp/lua-5.3.5.tar.gztar xvf lua-5.3.5.tar.gzcd lua-5.3.5make linux testyum install gcc gcc-c++ glibc glibc-devel pcre pcre-devel openssl openssl-devel systemd-devel -ymkdir -p $DST/haproxy#[ -a haproxy-2.0.8.tar.gz ] || wget http://www.haproxy.org/download/2.0/src/haproxy-2.0.8.tar.gzcd ..tar xvf haproxy-2.0.8.tar.gzsleep 1cd haproxy-2.0.8make ARCH=x86_64 \TARGET=linux-glibc USE_PCRE=1 \USE_OPENSSL=1 \USE_ZLIB=1 \USE_SYSTEMD=1 \USE_CPU_AFFINITY=1 \USE_LUA=1 \LUA_INC=../lua-5.3.5/src/ \LUA_LIB=../lua-5.3.5/src/ \PREFIX=$DST/haproxymake install PREFIX=$DST/haproxycat > /usr/lib/systemd/system/haproxy.service << "END"[Unit]Description=HAProxy Load BalancerAfter=syslog.target network.target[Service]ExecStartPre=/usr/sbin/haproxy -f /etc/haproxy/haproxy.cfg -c -qExecStart=/usr/sbin/haproxy -Ws -f /etc/haproxy/haproxy.cfg -p /var/lib/haproxy/haproxy.pidExecReload=/bin/kill -USR2 $MAINPID[Install]WantedBy=multi-user.target\ENDsed -i "s@/usr@$DST/haproxy@" /usr/lib/systemd/system/haproxy.servicemkdir -p /etc/haproxycd ..cp haproxy.cfg /etc/haproxy/sed -i "s@chroot /apps/haproxy@chroot $DST/haproxy@" /etc/haproxy/haproxy.cfgmkdir -p /var/lib/haproxychown 99.99 /var/lib/haproxy/ -Rcat >> /etc/sysctl.conf << ENDnet.ipv4.ip_forward = 1net.ipv4.ip_nonlocal_bind = 1ENDsysctl -p #修改内核参数之后生效，systemctl daemon-reload 是重读启动脚本systemctl enable --now haproxysystemctl status haproxy

Nginx+PHP一键安装脚本

[root@Web1 web]# tree.├── nginx│   ├── nginx-1.16.1.tar.gz│   ├── nginx.conf│   ├── nginx.service│   └── nginx.sh├── php-fpm│   ├── php-7.3.10.tar.xz│   └── php-fpm.sh└── web.sh2 directories, 7 files[root@Web1 web]# bash web.sh

vim web.sh#!/bin/bashcd nginxbash nginx.shcd ../php-fpmbash php-fpm.sh

vim nginx/nginx.sh#!/bin/bashDST="/apps"[ -a nginx.conf ] || { echo ' the absence of nginx.conf' ;exit 1;}[ -a nginx.service ] || { echo ' the absence of nginx.service' ;exit 2;}[ -a /usr/lib/systemd/system/nginx.service ] && { echo ' nginx is aready installed' ;exit 3;}id nginx &>/dev/null && { echo 'user nginx is exist' ; exit 4;} || useradd -r -s /sbin/nologin -u 80 nginxyum install -y gcc gcc-c++ glibc glibc-devel pcre pcre-devel openssl openssl-devel systemd-devel net-tools iotop bc zip unzip zlib-devel bash-completion nfs-utils automake libxml2 libxml2-devel libxslt libxslt-devel perl perl-ExtUtils-Embed   vim lrzsz tree psmisc wget || { echo 'Dependencies is not installed';exit 5;}#mkdir -p $DST/nginxmkdir -p /data/apps/nginxln -s /data/apps/  /apps[ -a nginx-1.16.1.tar.gz ] || wget https://nginx.org/download/nginx-1.16.1.tar.gztar xvf nginx-1.16.1.tar.gzcd nginx-1.16.1./configure --prefix=$DST/nginx --user=nginx --group=nginx --with-http_ssl_module --with-http_v2_module --with-http_realip_module --with-http_stub_status_module --with-http_gzip_static_module --with-pcre --with-stream --with-stream_ssl_module --with-stream_realip_module --with-select_module --with-file-aiomake -j 4 && make installcp ../nginx.conf $DST/nginx/conf/cp ../nginx.service /usr/lib/systemd/system/systemctl enable --now nginxsystemctl status nginx

vim nginx/nginx.service[Unit]Description=The nginx HTTP and reverse proxy serverAfter=network.target remote-fs.target nss-lookup.target[Service]Type=forkingPIDFile=/apps/nginx/logs/nginx.pid# Nginx will fail to start if /run/nginx.pid already exists but has the wrong# SELinux context. This might happen when running `nginx -t` from the cmdline.# https://bugzilla.redhat.com/show_bug.cgi?id=1268621ExecStartPre=/usr/bin/rm -f /apps/nginx/logs/nginx.pidExecStartPre=/apps/nginx/sbin/nginx -tExecStart=/apps/nginx/sbin/nginxExecReload=/bin/kill -s HUP $MAINPIDKillSignal=SIGQUITTimeoutStopSec=5KillMode=processPrivateTmp=true[Install]WantedBy=multi-user.target

vim nginx/nginx.confuser  nginx;worker_processes  2;worker_cpu_affinity 0001 0010;worker_priority -10;error_log  logs/error.log  info;error_log  /apps/nginx/logs/error.log  error;events {    worker_connections  65536;    use epoll;    accept_mutex on;    multi_accept on;}http {    include       mime.types;    default_type  application/octet-stream;    log_format access_json '{"@timestamp":"$time_iso8601",'        '"host":"$server_addr",'        '"clientip":"$remote_addr",'        '"size":$body_bytes_sent,'        '"responsetime":$request_time,'        '"upstreamtime":"$upstream_response_time",'        '"upstreamhost":"$upstream_addr",'        '"http_host":"$host",'        '"uri":"$uri",'        '"domain":"$host",'        '"xff":"$http_x_forwarded_for",'        '"referer":"$http_referer",'        '"tcp_xff":"$proxy_protocol_addr",'        '"http_user_agent":"$http_user_agent",'        '"status":"$status"}';    access_log  /apps/nginx/logs/access_json.log  access_json;    sendfile        on;    keepalive_timeout  65 65;    server_tokens off;    charset utf-8;    gzip  on;    server {        listen       80;        server_name  www.example.net;        location = / {            root   html;            index  index.html index.htm;        }        error_page   500 502 503 504  /50x.html;        location = /50x.html {            root   html;        }        location ~ ^/(status|ping)$ {             include fastcgi_params;             fastcgi_pass 127.0.0.1:9000;             fastcgi_param PATH_TRANSLATED $document_root$fastcgi_script_name;             fastcgi_hide_header X-Powered-By;        }        location ~ \.php$ {            root           html;            fastcgi_pass   127.0.0.1:9000;            fastcgi_index  index.php;            fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;            include        fastcgi_params;        }    }}

vim php-fpm/php-fpm.sh#!/bin/bashDST="/apps"[ -a php-*.tar.* ] || { echo ' the absence of php-7.3.10.tar.xz' ;exit 1;}[ -a /usr/lib/systemd/system/php-fpm.service ] && { echo ' php-fpm is aready installed' ;exit 2;}[ -a $DST/php* ] && { echo ' php is aready installed' ;exit 2;}mkdir -p $DST/phpyum install libxml2-devel bzip2-devel libmcrypt-devel -y || { echo 'Dependencies is not installed';exit 5;}#wget https://www.php.net/distributions/php-7.3.10.tar.xztar xvf php-*.tar.*cd php-7.3.10./configure \--prefix=$DST/php \--enable-mysqlnd \--with-mysqli=mysqlnd \--with-pdo-mysql=mysqlnd \--with-openssl \--with-freetype-dir \--with-jpeg-dir \--with-png-dir \--with-zlib \--with-libxml-dir=/usr \--with-config-file-path=/etc \--with-config-file-scan-dir=/etc/php.d \--enable-mbstring \--enable-xml \--enable-sockets \--enable-fpm \--enable-maintainer-zts \--disable-fileinfo make -j 4 && make installcp php.ini-production  /etc/php.inicp sapi/fpm/php-fpm.service /usr/lib/systemd/system/cp $DST/php/etc/php-fpm.conf.default  $DST/php/etc/php-fpm.confcp $DST/php/etc/php-fpm.d/www.conf.default $DST/php/etc/php-fpm.d/www.confsed -i 's@nobody@nginx@g' $DST/php/etc/php-fpm.d/www.confsed -i '/#/!s@index  index.html index.htm@index index.php index.html index.htm@' $DST/nginx/conf/nginx.confsed -i 's@/scripts$fastcgi_script_name@$document_root$fastcgi_script_name@g' $DST/nginx/conf/nginx.conf$DST/nginx/sbin/nginx -s reloadsystemctl enable --now php-fpm

部署OpenVPN

部署OpenVPN服务器

下载安装OpenVPN

  OpenVPN的rpm包可以在epel源中直接下载安装，所以我们需要先配置epel源，推荐选用阿里的epel源，CentOS67命令如下：

cat > /etc/yum.repos.d/aliyunepel.repo << "END"[aliyun-epel]name=aliyun-epelbaseurl=https://mirrors.aliyun.com/epel/$releasever/$basearch/gpgcheck=1gpgkey=https://mirrors.aliyun.com/epel/RPM-GPG-KEY-EPEL-$releaseverenabled=1END

  CentOS8路径有所变化，命令如下：

cat > /etc/yum.repos.d/aliyunepel.repo << "END"[aliyun-epel]name=aliyun-epelbaseurl=https://mirrors.aliyun.com/epel/$releasever/Everything/$basearch/gpgcheck=1gpgkey=https://mirrors.aliyun.com/epel/RPM-GPG-KEY-EPEL-$releaseverenabled=1END

  或者直接安装官方的epel源(6、7、8通用）。

yum install epel-release -y

  配置好epel源之后，直接yum安装服务器端软件和证书管理工具就可以了。

yum install openvpn -y #openvpn服务端yum install easy-rsa -y #证书管理工具

OpenVPN配置

  将模版配置文件及证书管理工具复制到指定目录

cp /usr/share/doc/openvpn-2.4.8/sample/sample-config-files/server.conf /etc/openvpn/  #openvpn server 配置文件cp -r /usr/share/easy-rsa/ /etc/openvpn/easyrsa-server #证书管理工具cp /usr/share/doc/easy-rsa-3.0.6/vars.example /etc/openvpn/easyrsa-server/3/vars

  配置文件模版如果没有，那可能是在路径为/usr/share/doc/openvpn/sample/sample-config-files/server.conf，easy-rsa如果CentOS8yum安装不上，只能去github上https://github.com/OpenVPN/easy-rsa下载，将里面的easyrsa3目录复制出来就是证书管理工具,并且不需要复制vars.example文件，里面已经有了,改个名字就可以。

cp -r easyrsa3 /etc/openvpn/easyrsa-server

  先进入证书管理工具目录（若github上下载的则是cd /etc/openvpn/easyrsa-server/，之后则都没有3的子目录，或者也创建一个3的子目录保持一致性）

cd /etc/openvpn/easyrsa-server/3

  若easyrsa为github下载的话，目录结果如下

[root@aws-host easyrsa-server]#tree.├── easyrsa├── openssl-easyrsa.cnf├── vars.example└── x509-types    ├── ca    ├── client    ├── code-signing    ├── COMMON    ├── email    ├── server    └── serverClient1 directory, 10 files[root@aws-host easyrsa-server]#

  OpenVPN的server端配置文件如下：

vim /etc/openvpn/server.conflocal 172.18.200.101 #本机监听IP,写公网IPport 1194 #端口# TCP or UDP server?proto tcp #协议，指定OpenVPN创建的通信隧道类型#proto udp#dev tap：创建一个以太网隧道，以太网使用tapdev tun：创建一个路由IP隧道，互联网使用tun一个TUN设备大多时候，被用于基于IP协议的通讯。一个TAP设备允许完整的以太网帧通过Openvpn隧道，因此提供非ip协议的支持，比如IPX协议和AppleTalk协议#dev-node MyTap #TAP-Win32适配器。非windows不需要#topology subnet #网络拓扑，不需要配置server 10.8.0.0 255.255.255.0 #客户端连接后分配IP的地址池，服务器默认会占用第一个IP 10.8.0.1#ifconfig-pool-persist ipp.txt #为客户端分配固定IP，不需要配置#server-bridge 10.8.0.4 255.255.255.0 10.8.0.50 10.8.0.100 #配置网桥模式，不需要push "route 10.20.0.0 255.255.0.0" #给客户端生成的静态路由表，下一跳为openvpn服务器的10.8.0.1,地址段为openvpn服务器后的公司内部网络，可以是多个网段push "route 172.31.0.0 255.255.248.0";client-config-dir ccd #为指定的客户端添加路由，改路由通常是客户端后面的内网网段而不是服务端的，也不需要设置;route 192.168.40.128 255.255.255.248;client-config-dir ccd;route 10.9.0.0 255.255.255.252;learn-address ./script #运行外部脚本，创建不同组的iptables 规则，不配置;push "redirect-gateway def1 bypass-dhcp" #启用后，客户端所有流量都将通过VPN服务器，因此不需要配置#;push "dhcp-option DNS 208.67.222.222" #推送DNS服务器，不需要配置#;push "dhcp-option DNS 208.67.220.220"#client-to-client #允许不同的client通过openvpn server直接通信，不开启#;duplicate-cn #多个用户共用一个账户，一般用于测试环境，生产环境都是一个用户一个证书keepalive 10 120 #设置服务端检测的间隔和超时时间，默认为每 10 秒 ping一次，如果 120 秒没有回应则认为对方已经 down

  所以最终配置如下

local 172.18.32.71    #写公网IP，测试环境无所谓port 1194proto tcpdev tunca /etc/openvpn/certs/ca.crtcert /etc/openvpn/certs/server.crtkey /etc/openvpn/certs/server.key  # This file should be kept secretdh /etc/openvpn/certs/dh.pemserver 10.8.0.0 255.255.255.0   #默认设置，不需要修改push "route 10.0.0.0 255.255.255.0"    #内网网段，不需要修改，科学上网则为 push "redirect-gateway def1 bypass-dhcp"client-to-clientkeepalive 10 120cipher AES-256-CBCmax-clients 100user nobodygroup nobodypersist-tunstatus openvpn-status.loglog-append  /var/log/openvpn/openvpn.logverb 9mute 20

搭建CA并签发证书

  初始化pki环境

./easyrsa init-pki #生成pki目录用于保存证书

  创建CA签发机构，然后直接回车

./easyrsa build-ca nopass #创建ca并不使用密码

  创建服务端证书(私钥)，直接回车

./easyrsa gen-req server nopass #生成server证书且不使用密码

  然后使用自建ca签发服务器证书，即生成服务端crt公钥。crt公钥后期将用户发送给客户端，从而实现与openvpnserver端加密传输数据。

./easyrsa sign server server #签发服务端证书，备注信息为server

  然后输入yes输入。

创建非对称秘钥对

  还在easyrsa-server目录下，生成秘钥，这可能会花费一段时间。

./easyrsa gen-dh

  到此服务端证书环境配置完成，下面是配置客户端证书配置

创建客户端证书及配置文件

  证书还是使用easyrsa工具，（github下载的也还是那个目录easyrsa3，不需要复制vars.example文件,改个名字就可以）

cp -r /usr/share/easy-rsa/ /etc/openvpn/easyrsa-client/cp /usr/share/doc/easy-rsa-3.0.6/vars.example /etc/openvpn/easyrsa-client/3/vars

cd /etc/openvpn/easyrsa-client/3./easyrsa init-pki

  例如员工为Mice，则创建名为Mice的证书

./easyrsa gen-req Mice nopass #客户证书为Mice，没有设置密码

  然后直接回车，便生成了Mice的证书申请和私钥。进入easyrsa的server目录中，(注意，一定要进入easyrsa-server目录，否则会报错)，导入证书申请并给客户端的证书请求签发证书,记得输入yes确认。

./easyrsa import-req /etc/openvpn/easyrsa-client/3/pki/reqs/Mice.req Mice./easyrsa sign client Mice

  复制证书到server目录：

 mkdir /etc/openvpn/certs cd /etc/openvpn/certs/ cp /etc/openvpn/easyrsa-server/3/pki/dh.pem . cp /etc/openvpn/easyrsa-server/3/pki/ca.crt . cp /etc/openvpn/easyrsa-server/3/pki/issued/server.crt . cp /etc/openvpn/easyrsa-server/3/pki/private/server.key .

  创建客户端配置文件

mkdir /etc/openvpn/client/Mice/vim /etc/openvpn/client/Mice/client.ovpn

client #声明自己是个客户端dev tun #接口类型，必须和服务端保持一致proto tcp #使用的协议，必须和服务端保持一致remote 172.18.32.71 1194 #server端的ip和端口，可以写域名但是需要可以解析成IPresolv-retry infinite #如果是写的server端的域名，那么就始终解析，如果域名发生变化，会重新连接到新>的域名对应的IPnobind #本机不绑定监听端口，客户端是随机打开端口连接到服务端的1194persist-key #persist-tunca ca.crtcert Mice.crtkey Mice.keyremote-cert-tls server #指定采用服务器校验方式#tls-auth ta.key 1cipher AES-256-CBCverb 3

  对签发的客户端证书及配置文件进行归档,并打包发送给客户端主机。

cd /etc/openvpn/client/Mice/cp /etc/openvpn/easyrsa-server/3/pki/ca.crt .cp /etc/openvpn/easyrsa-server/3/pki/issued/Mice.crt .cp /etc/openvpn/easyrsa-client/3/pki/private/Mice.key .tar czvf  Mice.tar.gz *

配置防火墙转发规则

  开启路由转发功能：

# vim /etc/sysctl.conf# sysctl -pnet.ipv4.ip_forward = 1

  先清除现有防火墙策略以免发生干扰，如果CentOS7/8或Redhat7/8没有iptables命令就yum install -y iptables-services安装一个，之后设置IP伪装需要用到。
  清空已有规则

iptables -Fiptables -Xiptables -Ziptables -t nat -Fiptables -t nat -Xiptables -t nat -Z

  创建iptables 规则：

iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -j MASQUERADE #此IP是server端默认ip，不要改iptables -A INPUT -p TCP --dport 1194 -j ACCEPTiptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

  CentOS6/7的话可以用保存iptables规则（适用未安装iptables-services，俩方式选一个就好）:

service iptables save

  显示OK说明保存成功

iptables: Saving firewall rules to /etc/sysconfig/iptables:[ OK ]

  如果用的services，则systemctl enable --now iptables（会自动从/etc/sysconfig/iptables文件中读取防火墙策略）

  创建日志目录并授权：

mkdir /var/log/openvpnchown nobody.nobody /var/log/openvpn

启动OpenVPN服务

  启动openvpn服务

systemctl enable --now openvpn@server

  如果没有openvpn@server.service文件，那就自己编写一个吧

vim /usr/lib/systemd/system/openvpn@.service 

[Unit]Description=OpenVPN Robust And Highly Flexible Tunneling Application On %IAfter=network.target[Service]Type=notifyPrivateTmp=trueExecStart=/usr/sbin/openvpn --cd /etc/openvpn/ --config %i.conf[Install]WantedBy=multi-user.target

  验证日志：

tail /var/log/openvpn/openvpn.logTue Nov 19 13:27:27 2019 Socket Buffers: R=[87380->87380] S=[16384->16384]Tue Nov 19 13:27:27 2019 Listening for incoming TCP connection on[AF_INET]172.18.32.71:1194Tue Nov 19 13:27:27 2019 TCPv4_SERVER link local (bound):[AF_INET]172.18.32.71:1194Tue Nov 19 13:27:27 2019 TCPv4_SERVER link remote: [AF_UNSPEC]Tue Nov 19 13:27:27 2019 GID set to rootTue Nov 19 13:27:27 2019 UID set to rootTue Nov 19 13:27:27 2019 MULTI: multi_init called, r=256 v=256Tue Nov 19 13:27:27 2019 IFCONFIG POOL: base=10.8.0.4 size=62, ipv6=0Tue Nov 19 13:27:27 2019 MULTI: TCP INIT maxclients=4096 maxevents=4100Tue Nov 19 13:27:27 2019 Initialization Sequence Completed

OpenVPN客户端

  官方客户端下载地址： https://openvpn.net/community-downloads/
  非官方地址：https://sourceforge.net/projects/securepoint/files/
  如果是默认安装路径的话，保存证书到openvpn 客户端安装目录：C:\Program Files\OpenVPN\config
  之后就可以直接启动OpenVPN。此时就可以用浏览器直接访问内网IP或者直接ssh登陆内部服务器了。

关于科学上网

  经过本人尝试多次，使用OpenVPN做代理转发来实现科学上网，还是有点难度。理论上简单可行的东西，搞了好几次都没成功。
  本人有亚马逊的海外云主机，在上面搭建了OpenVPN之后怎么也没法成功，甚至云主机都登陆不上了。开始以为是GW将数据包拦截了，导致云主机被封掉。后来使用其他海外主机直接连接均无法连接失联的云主机，使用端口检查工具发现，那个云主机的所有端口都被关闭了。猜测应该是被亚马逊给封掉了，无奈之下只能释放实例，重新搭建服务器。弄了数次发现，结局均以实例被封告终。猜测亚马逊应该是检查到异常流量，直接把实例的数据连接都断掉了（据说OpenVPN的收费版本不会被封掉），绝望之下，尝试了下UDP协议来代替TCP协议，将客户端设置和服务端设置都改为UPD，竟然发现可以访问外网了，而且服务器至今也平安无事~有需求的小伙伴可以尝试UDP协议。另外附上我云主机的server端配置,希望对大家有所帮助。

grep ^[a-Z] /etc/openvpn/server.conflocal 0.0.0.0port 11094proto udpdev tunca  /etc/openvpn/certs/ca.crtcert /etc/openvpn/certs/server.crtkey /etc/openvpn/certs/server.keydh /etc/openvpn/certs/dh.pemserver 10.8.0.0 255.255.255.0push "redirect-gateway def1 bypass-dhcp"push "dhcp-option DNS 8.8.8.8"keepalive 10 120cipher AES-256-CBCmax-clients 10user openvpngroup openvpnpersist-keypersist-tunstatus openvpn-status.loglog-append  /var/log/openvpn/openvpn.logverb 3mute 20explicit-exit-notify 1

  本文写得很简略，发现有小伙伴对相关问题很有兴趣，欢迎留言讨论。

会话保持实现

  一般tomcat的会话保持有三种方案实现：

• nginx、httpd或者haproxy的调度实现session绑定,一般是源地址哈希方式实现
  优点:简单易配置
  缺点：
  ①如果目标服务器故障后,没有做持久化的话就会丢失session;
  ②即便做了持久化,当服务器故障后,nginx或者haproxy会不得不重新分配一个tomcat服务器,而这时因为新的tomcat服务器上没有原来的sessionID,所以无法找到相应会话信息,会重新分配一个sessionID给客户端,就算原来的tomcat服务器重新上线,又被分配到原来的tomcat服务器中,可此时客户端已经有了新的sessionID,也不会去读取最开始的session信息,那些会话信息就相当于永远丢失了。
• session复制集群,官方给出的tomcat会话共享解决方案
    tomcat自己提供的多播集群，通过多播将任何一台的session同步到其他节点。
  缺点：
  ①tomcat的同步节点不宜过多，互相即时通信session需要太多带宽；
  ②每一台tomcat服务器都拥有全部session信息，内存占用太多。
• session server
    session 共享服务器，一般使用memcached、redis做共享的session服务器。
  目前最理想的解决方案，不过会需要额外的机器来配置共享服务器。

  反向代理的session绑定

    这种实现session保持的方案，一般是使用的不多，一般用于公司内部中的会话保持场景。只需在haproxy或者nginx中的调度算法中，加入基于源地址hash即可（调度算法参考之前博客）。于是，用户每次访问都会被调度到同一台tomcat服务器上，上面已有他的session信息，便实现了会话保持。

  配置实现

    我们用一台nginx服务器做反向代理，两台tomcat服务器来演示实现过程。

&gt nginx主机ip：192.168.32.207
&gt tomcat主机1ip：192.168.32.231
&gt tomcat主机2ip：192.168.32.232

  将3台机子中的nginx或tomcat服务启动之后，分别检查80端口和8080端口是否都已监听，确保服务启动。

iptables -Fgetenforce 0

  确保防火墙和SELinux设置不会干扰我们几台主机间的相互通信。
  nginx主机反向代理的配置

upstream tomcat {    #ip_hash; #先关闭原地址iphash，观察效果    server 192.168.32.231:8080 weight=1 fail_timeout=5s max_fails=3;    server 192.168.32.232:8080 weight=1 fail_timeout=5s max_fails=3;}server {    listen 80;    index index.jsp#    server_name www.example.net;#    location ~* \.(jsp|do)$ {    location / {        proxy_pass http://tomcat;    }}

  可启用主机名，也可不启用直接用端口访问。用域名访问还需要改DNS或者hosts设置，比较麻烦，我们就直接通过IP+端口访问就可以了。
  tomcat服务器中可以新建一个host，也可使用原先的localhost默认主机。我们这次不用之前的localhost，而是自己新创建一个host标签，指定appBase在/data/myapp目录下。两个tomcat服务器都要执行如下操作：

vim /apps/tomcat/conf/server.xml

  找到Engine标签，将默认主机修改为myapp

    &ltEngine name="Catalina" defaultHost="myapp"&gt

  找到localhost的&lt/Host&gt标签，在下面创建新的主机myapp,指定appBase为/data/myapp

      &ltHost name="myapp"  appBase="/data/myapp"            unpackWARs="true" autoDeploy="true"&gt      &lt/Host&gt

  PS：Host name一般为主机域名，当一个tomcat中有多个host服务时，就是通过http报文请求头部的host信息来判断去访问哪个host服务的，当找不到对应的主机之后才访问defaultHost，我们这里因为只有启用了一个host，且为defaultHost，所以就无所谓，可以任意命名了，只需对应上就好。
  之后我们要在/data/myapp目录下创建一个ROOT目录来作为tomcat访问的默认目录，注意ROOT是大写的。

mkdir -p /data/myapp/ROOT

  为了方便我们看到效果，我们编写index.jsp时，调用一些函数，方便我们看到我们访问的tomcat主机的IP和端口、sessionID、访问时间。

vim /data/myapp/ROOT/index.jsp

&lt%@ page import="java.util.*" %&gt&lt!DOCTYPE html&gt&lthtml lang="en"&gt&lthead&gt&ltmeta charset="UTF-8"&gt&lttitle&gtlbjsptest&lt/title&gt&lt/head&gt&ltbody&gt&ltdiv&gtOn &lt%=request.getServerName() %&gt&lt/div&gt&ltdiv&gt&lt%=request.getLocalAddr() + ":" + request.getLocalPort() %&gt&lt/div&gt&ltdiv&gtSessionID = &ltspan style="color:blue"&gt&lt%=session.getId() %&gt&lt/span&gt&lt/div&gt&lt%=new Date()%&gt&lt/body&gt&lt/html&gt

  此时，我们访问nginx的80端口，就可以被反向代理到后端的两个tomcat服务器上去。而这时，是轮询的调度方式，也就是一边一次，可以看到访问的主机和sessionID都是一直在变化的。
效果如下图所示：

  每一次的sessionID都没有重复过，这肯定不满足我们的需要。所以我们将nginx配置中#ip_hash;的#注释去掉，重启nginx服务，再看效果，如下图所示：

  可以看到，每次刷新，主机IP和sessionID都不再变化，说明绑定session成功。

session复制集群

  这是tomcat官方提供的解决方案，所有tomcat上都有全量的session，不过同步session信息会消耗带宽，而且所有服务器保存所有session信息也比较占用资源，对于tomcat这种本身就处于效率瓶颈的服务来说，高并发场景下超过若五个tomcat服务器，就不再建议使用。
  配置详细可以参见官网配置说明。

        &ltCluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"                 channelSendOptions="8"&gt          &ltManager className="org.apache.catalina.ha.session.DeltaManager"                   expireSessionsOnShutdown="false"                   notifyListenersOnReplication="true"/&gt          &ltChannel className="org.apache.catalina.tribes.group.GroupChannel"&gt            &ltMembership className="org.apache.catalina.tribes.membership.McastService"                        address="228.0.0.4"                        port="45564"                        frequency="500"                        dropTime="3000"/&gt            &ltReceiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"                      address="auto"                      port="4000"                      autoBind="100"                      selectorTimeout="5000"                      maxThreads="6"/&gt            &ltSender className="org.apache.catalina.tribes.transport.ReplicationTransmitter"&gt              &ltTransport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender"/&gt            &lt/Sender&gt            &ltInterceptor className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector"/&gt            &ltInterceptor className="org.apache.catalina.tribes.group.interceptors.MessageDispatchInterceptor"/&gt          &lt/Channel&gt          &ltValve className="org.apache.catalina.ha.tcp.ReplicationValve"                 filter=""/&gt          &ltValve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/&gt          &ltDeployer className="org.apache.catalina.ha.deploy.FarmWarDeployer"                    tempDir="/tmp/war-temp/"                    deployDir="/tmp/war-deploy/"                    watchDir="/tmp/war-listen/"                    watchEnabled="false"/&gt          &ltClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener"/&gt        &lt/Cluster&gt

  将官网上的这段集群配置，插入到两个tomcat服务器中我们创建的host标签中（也可插入引擎标签中，就相当于所有主机都生效），即&ltHost name标签与&lt/Host&gt标签的中间。
  配置说明：

Cluster 集群配置Manager 会话管理器配置Channel 信道配置        Membership 成员判定。使用什么多播地址、端口多少、间隔时长ms、超时时长ms。同一个多播地址和端口认为同属一个组。使用时修改这个多播地址，以防冲突        Receiver 接收器，多线程接收多个其他节点的心跳、会话信息。默认会从4000到4100依次尝试可用端口。        address="auto"，auto可能绑定到127.0.0.1上，所以一定要改为可以用的IP上去        Sender 多线程发送器，内部使用了tcp连接池。        Interceptor 拦截器ReplicationValve 检测哪些请求需要检测Session，Session数据是否有了变化，需要启动复制过程ClusterSessionListener 集群session侦听器

  复制完官方文档里的配置，我们还需要修改接收器的ip为本机ip，不能使用auto，否则会无法同步session信息。
  此外，还需要在应用的web.xml文件中最后一行&lt/web-app&gt标签的上面一行插入子标签&ltdistributable/&gt表示可分配。
  操作如下：

mkdir /data/myapp/ROOT/WEB-INFcp /apps/tomcat/conf/web.xml /data/myapp/ROOT/WEB-INF/sed -i '/&lt\/web-app&gt/i&ltdistributable/&gt' /data/myapp/ROOT/WEB-INF/web.xml

  此时，如果我们将前端Nginx或者其他反向代理服务器中的源地址hash去掉，我们就可以看到，虽然访问的tomcat服务器在变化（服务器ip变化），而sessionID却是不变的，因为每个tomcat服务器上都有全量的相同的session信息。

session 共享服务器

  这种实现方式其实才是本文标题中真正的session共享，毕竟共享经济炒的很热，我们都知道，所谓共享，共用才叫共享，前面提到的那种tomcat集群里会话信息人手一份可不能称作是共享。于是乎，我们想到用将session放到外部存储，所有的tomcat服务器都去外部存储中去查找sessionID。
  储存session信息肯定不能存储在磁盘文件中，这样的读取写入性能都会很慢，放在mysql数据库中或者以硬盘文件的方式保存，高并发场景下的读取写入速度都将会大打折扣。所以我们要使用类似memcached或者redis这种Key/Value的非关系型数据库里，也被称作NoSQL。
  memcached和redis这种键值对型数据库的数据信息都是存储在内存中的，读写效率都很高，而且由于没有复杂的表关系，采用的是哈希算法，他们对于信息的查找都是O(1)，而不是类似mysql等数据库的O(n)，意思就是说耗时/耗空间与总数据量大小无关，不会随着数据量的增大导致查找时间几何倍数的增长。
  但也因为memcached和redis的数据都是储存在内存中的，而且memcached还不支持持久化，所以我们一定要做好高可用，一旦发生故障，会话信息将立即丢失，几乎没有恢复的可能。
  要实现tomcat共享session服务器，首先，我们要让tomcat将session储存到memcached或者redis等外部存储上，这就需要我们对tomcat进行配置，其次我们要将session信息序列化为变为字节流以便能储存在session服务器中，还要能将session服务器中的数据反序列化为可以识别的session信息，最后，当然我们还需要一个客户端来跟后端的session服务器通信，才能将数据写入和读取。
  这想实现确实也比较复杂，不过在github已有开源解决方案（网址是https://github.com/magro/memcached-session-manager），memcached-session-manager，简称msm，后端采用memcached或者redis都可以（之前只支持memcached，因而得名msm，后来支持redis后，人们还是习惯叫它msm），且已经完成了对tomcat的session共享的配置支持（支持tomcat6.X、7.X、8.X、9.X），我们直接去下载对应版本的去使用就可以了。
  根据项目的介绍文档，我们知道，想实现tomcat的session共享，我们至少需要配套的工具有：

• tomcat的session管理工具 memcached-session-manager
• 与session服务器通信的客户端
  如果是memcached，则建议使用spymemcached.jar
  如果是redis，则建议使用jedis.jar
• 将session信息序列化的工具，作者推荐使用kryo。

  这些工具官网上也都提供了下载链接，我们直接下载下来即可。
  kryo如下图所示

  其他工具包如下图所示

  将这些jar包统统拷贝到tomcat服务器的lib目录下（改变lib目录下的jar包需重启tomcat服务才能生效）
  使用msm搭建session共享服务器，如果后端为memcached，则有两种模式可以选，分别是sticky模式和non-sticky模式，后端为redis，则使用类似non-sticky模式。

sticky模式

  以两台服务器为例，将tomcat1和memcached1部署在一台服务器上（简称为t1、m1），tomcat2和memcached2部署在另一台服务器上（简称为t2、m2）为例，结构图如下图所示。

&ltt1&gt   &ltt2&gt  . \ / .  .  X  .  . / \ .&ltm1&gt   &ltm2&gt

  实现原理：当请求结束时Tomcat的session会送给memcached备份。即Tomcat session为主session，memcached session为备session，使用memcached相当于备份了一份Session。查询Session时Tomcat会优先使用自己内存的Session，Tomcat通过jvmRoute发现不是自己的Session，便从memcached中找到该Session，更新本机Session，请求完成后更新memcached。
  可能有的朋友看的一头雾水，这到底是个什么结构。其实很简单，sticky模式就是t1的session信息还是储存在t1上，不过以m2为备用数据库，t2的session信息也是放在t2中储存，以m1服务器为备用服务器。这就意味着，用户在访问t1时，是从t1获取session信息，当t1挂掉或者整个节点1服务器挂掉之后，用户会被调度到t2上，而t2本地中没有session信息时，就会去m2中上找相关sessionID，而m2因为是t1的备用存储，所以有跟t1完全相同的session信息，于是用户的sessionID就可以被t2识别；而当m2备用存储服务挂掉之后，t1服务会通过检测发现自己没有备用存储，就会自动将m1也指定为自己的备用存储，将备份信息也同步至m1中，于是用户若再从t2访问时，虽然因为m2挂掉，其中的数据都无法访问，但t2就可以从m1上读取到对应的sessionID并同步到t2本身的存储中，也可以保持之前的会话信息。
  修改的配置也很简单，依照官网说明，将下面的代码标签插入/conf/context.xml文件中的context标签结尾就可以了

&ltManager className="de.javakaffee.web.msm.MemcachedBackupSessionManager"memcachedNodes="n1:192.168.32.231:11211,n2:192.168.32.232:11211"failoverNodes="n1"requestUriIgnorePattern=".*\.(ico|png|gif|jpg|css|js)$"transcoderFactoryClass="de.javakaffee.web.msm.serializer.kryo.KryoTranscoderFactory"/&gt

  n1、n2只是memcached的节点别名，可以重新命名。
failoverNodes是指故障转移节点，也就是发生故障之后的备用节点，所以在n1节点上，n1是备用节点，n2是主存储节点。另一台Tomcat中配置将failoverNodes改为n2，意思是其主节点是n1，备用节点是n2。
若配置成功，在/apps/tomcat/log/catalina.out文件中看到如下信息。

tail -n 20 /apps/tomcat/logs/catalina.out

23-Nov-2019 13:35:54.187 INFO [myapp-startStop-1] de.javakaffee.web.msm.MemcachedSessionService.startInternal ---------  finished initialization:- sticky: true- operation timeout: 1000- node ids: [n1]- failover node ids: [n2]- storage key prefix: null- locking mode: null (expiration: 5s)--------

此时在访问我们的前端代理（取消ipHASH绑定）就会看到下面界面，将节点2 关机，可以看到访问ip固定为192.168.32.231，而使用的memcached变成了n1节点。

non-sticky模式

  从msm 1.4.0之后开始支持non-sticky模式。
Tomcat session为中转Session，如果n1为主session，n2为备session，则产生的新的Session会发送给主、备memcached，并清除本地Session，也就是说tomcat本身不储存session信息，只负责产生session。
  需要注意的是，如果n1下线，n2转换为主节点。n1再次上线，n2依然是主Session存储节点。
  配置方法与sticky大致相同，不过在/conf/context.xml文件中的context标签结尾插入代码略有不同，具体代码如下

&ltManager className="de.javakaffee.web.msm.MemcachedBackupSessionManager"memcachedNodes="n1:192.168.32.231:11211,n2:192.168.32.232:11211"sticky="false"sessionBackupAsync="false"lockingMode="uriPattern:/path1|/path2"requestUriIgnorePattern=".*\.(ico|png|gif|jpg|css|js)$"transcoderFactoryClass="de.javakaffee.web.msm.serializer.kryo.KryoTranscoderFactory"/&gt

  重启tomcat服务后生效。此时在/apps/tomcat/log/catalina.out文件中看到如下信息。

tail -n 20 /apps/tomcat/logs/catalina.out

23-Nov-2019 13:43:05.863 INFO [myapp-startStop-1] de.javakaffee.web.msm.MemcachedSessionService.startInternal ---------  finished initialization:- sticky: false- operation timeout: 1000- node ids: [n1, n2]- failover node ids: []- storage key prefix: null- locking mode: uriPattern:/path1|/path2 (expiration: 5s)--------

  再次尝试访问负载代理服务器，发现同样实现了访问tomcatIP变化，sessionID不变，说明配置成功。
  而后端使用redis作为session共享服务器时，仅支持non-stricky模式。建议用另外的服务器安装redis服务，并修改监听IP后启动，tomcat服务器中将jedis.jarjar包拷贝至tomcat安装路径下lib目录，同样在/conf/context.xml文件中的context标签结尾插入下面的代码即可（例如redis服务器IP端口为192.168.32.233:6379，可配置redis集群，可参考我之前博客redis高可用配置）。

&ltManager className="de.javakaffee.web.msm.MemcachedBackupSessionManager"memcachedNodes="redis://192.168.32.233:6379"sticky="false"sessionBackupAsync="false"lockingMode="uriPattern:/path1|/path2"requestUriIgnorePattern=".*\.(ico|png|gif|jpg|css|js)$"transcoderFactoryClass="de.javakaffee.web.msm.serializer.kryo.KryoTranscoderFactory"/&gt