标签：node Kubernetes ping host dimension metrics prom registry 节点

 冯旭松 译 分布式实验室

在诊断Kubernetes集群问题的时候，我们经常注意到集群中某一节点在闪烁*，而这通常是随机的且以奇怪的方式发生。这就是为什么我们一直需要一种工具，它可以测试一个节点与另一个节点之间的可达性，并以Prometheus度量形式呈现结果。有了这个工具，我们还希望在Grafana中创建图表并快速定位发生故障的节点（并在必要时将该节点上所有Pod进行重新调度并进行必要的维护）。
“闪烁”这里我是指某个节点随机变为“NotReady”但之后又恢复正常的某种行为。这会影响例如部分流量可能无法到达相邻节点上的Pod。
为什么会发生这种情况？常见原因之一是数据中心交换机中的连接问题。例如，我们曾经在Hetzner中设置一个vswitch，其中一个节点已无法通过该vswitch端口使用，并且恰好在本地网络上完全不可访问。
我们的最后一个要求是可直接在Kubernetes中运行此服务，因此我们将能够通过Helm图表部署所有内容。（例如在使用Ansible的情况下，我们必须为各种环境中的每个角色定义角色：AWS、GCE、裸机等）。由于我们尚未找到针对此环境的现成解决方案，因此我们决定自己来实现。

脚本和配置

我们解决方案的主要组件是一个脚本，该脚本监视每个节点的.status.addresses值。如果某个节点的该值已更改（例如添加了新节点），则我们的脚本使用Helm value方式将节点列表以ConfigMap的形式传递给Helm图表：

.Values.pingExporter.targets类似以下：

下面是Python脚本：

1. #!/usr/bin/env python3

2. 
   

3. import subprocess

4. import prometheus_client

5. import re

6. import statistics

7. import os

8. import json

9. import glob

10. import better_exchook

11. import datetime

12. 
    

13. better_exchook.install()

14. 
    

15. FPING_CMDLINE = "/usr/sbin/fping -p 1000 -C 30 -B 1 -q -r 1".split(" ")

16. FPING_REGEX = re.compile(r"^(\S*)\s*: (.*)$", re.MULTILINE)

17. CONFIG_PATH = "/config/targets.json"

18. 
    

19. registry = prometheus_client.CollectorRegistry()

20. 
    

21. prometheus_exceptions_counter = \

22.    prometheus_client.Counter('kube_node_ping_exceptions', 'Total number of exceptions', [], registry=registry)

23. 
    

24. prom_metrics_cluster = {"sent": prometheus_client.Counter('kube_node_ping_packets_sent_total',

25. 'ICMP packets sent',

26. ['destination_node', 'destination_node_ip_address'],

27.                                                  registry=registry),

28. "received": prometheus_client.Counter('kube_node_ping_packets_received_total',

29. 'ICMP packets received',

30. ['destination_node', 'destination_node_ip_address'],

31.                                                     registry=registry),

32. "rtt": prometheus_client.Counter('kube_node_ping_rtt_milliseconds_total',

33. 'round-trip time',

34. ['destination_node', 'destination_node_ip_address'],

35.                                                registry=registry),

36. "min": prometheus_client.Gauge('kube_node_ping_rtt_min', 'minimum round-trip time',

37. ['destination_node', 'destination_node_ip_address'],

38.                                               registry=registry),

39. "max": prometheus_client.Gauge('kube_node_ping_rtt_max', 'maximum round-trip time',

40. ['destination_node', 'destination_node_ip_address'],

41.                                               registry=registry),

42. "mdev": prometheus_client.Gauge('kube_node_ping_rtt_mdev',

43. 'mean deviation of round-trip times',

44. ['destination_node', 'destination_node_ip_address'],

45.                                                registry=registry)}

46. 
    

47. 
    

48. prom_metrics_external = {"sent": prometheus_client.Counter('external_ping_packets_sent_total',

49. 'ICMP packets sent',

50. ['destination_name', 'destination_host'],

51.                                                  registry=registry),

52. "received": prometheus_client.Counter('external_ping_packets_received_total',

53. 'ICMP packets received',

54. ['destination_name', 'destination_host'],

55.                                                     registry=registry),

56. "rtt": prometheus_client.Counter('external_ping_rtt_milliseconds_total',

57. 'round-trip time',

58. ['destination_name', 'destination_host'],

59.                                                registry=registry),

60. "min": prometheus_client.Gauge('external_ping_rtt_min', 'minimum round-trip time',

61. ['destination_name', 'destination_host'],

62.                                               registry=registry),

63. "max": prometheus_client.Gauge('external_ping_rtt_max', 'maximum round-trip time',

64. ['destination_name', 'destination_host'],

65.                                               registry=registry),

66. "mdev": prometheus_client.Gauge('external_ping_rtt_mdev',

67. 'mean deviation of round-trip times',

68. ['destination_name', 'destination_host'],

69.                                                registry=registry)}

70. 
    

71. def validate_envs():

72.    envs = {"MY_NODE_NAME": os.getenv("MY_NODE_NAME"), "PROMETHEUS_TEXTFILE_DIR": os.getenv("PROMETHEUS_TEXTFILE_DIR"),

73. "PROMETHEUS_TEXTFILE_PREFIX": os.getenv("PROMETHEUS_TEXTFILE_PREFIX")}

74. 
    

75. for k, v in envs.items():

76. if not v:

77. raise ValueError("{} environment variable is empty".format(k))

78. 
    

79. return envs

80. 
    

81. 
    

82. @prometheus_exceptions_counter.count_exceptions()

83. def compute_results(results):

84.    computed = {}

85. 
    

86.    matches = FPING_REGEX.finditer(results)

87. for match in matches:

88.        host = match.group(1)

89.        ping_results = match.group(2)

90. if "duplicate" in ping_results:

91. continue

92.        splitted = ping_results.split(" ")

93. if len(splitted) != 30:

94. raise ValueError("ping returned wrong number of results: \"{}\"".format(splitted))

95. 
    

96.        positive_results = [float(x) for x in splitted if x != "-"]

97. if len(positive_results) > 0:

98.            computed[host] = {"sent": 30, "received": len(positive_results),

99. "rtt": sum(positive_results),

100. "max": max(positive_results), "min": min(positive_results),

101. "mdev": statistics.pstdev(positive_results)}

102. else:

103.            computed[host] = {"sent": 30, "received": len(positive_results), "rtt": 0,

104. "max": 0, "min": 0, "mdev": 0}

105. if not len(computed):

106. raise ValueError("regex match\"{}\" found nothing in fping output \"{}\"".format(FPING_REGEX, results))

107. return computed

108. 
     

109. 
     

110. @prometheus_exceptions_counter.count_exceptions()

111. def call_fping(ips):

112.    cmdline = FPING_CMDLINE + ips

113.    process = subprocess.run(cmdline, stdout=subprocess.PIPE,

114.                             stderr=subprocess.STDOUT, universal_newlines=True)

115. if process.returncode == 3:

116. raise ValueError("invalid arguments: {}".format(cmdline))

117. if process.returncode == 4:

118. raise OSError("fping reported syscall error: {}".format(process.stderr))

119. 
     

120. return process.stdout

121. 
     

122. 
     

123. envs = validate_envs()

124. 
     

125. files = glob.glob(envs["PROMETHEUS_TEXTFILE_DIR"] + "*")

126. for f in files:

127.    os.remove(f)

128. 
     

129. labeled_prom_metrics = {"cluster_targets": [], "external_targets": []}

130. 
     

131. while True:

132. with open(CONFIG_PATH, "r") as f:

133.        config = json.loads(f.read())

134.        config["external_targets"] = [] if config["external_targets"] is None else config["external_targets"]

135. for target in config["external_targets"]:

136.            target["name"] = target["host"] if "name" not in target.keys() else target["name"]

137. 
     

138. if labeled_prom_metrics["cluster_targets"]:

139. for metric in labeled_prom_metrics["cluster_targets"]:

140. if (metric["node_name"], metric["ip"]) not in [(node["name"], node["ipAddress"]) for node in config['cluster_targets']]:

141. for k, v in prom_metrics_cluster.items():

142.                    v.remove(metric["node_name"], metric["ip"])

143. 
     

144. if labeled_prom_metrics["external_targets"]:

145. for metric in labeled_prom_metrics["external_targets"]:

146. if (metric["target_name"], metric["host"]) not in [(target["name"], target["host"]) for target in config['external_targets']]:

147. for k, v in prom_metrics_external.items():

148.                    v.remove(metric["target_name"], metric["host"])

149. 
     

150. 
     

151.    labeled_prom_metrics = {"cluster_targets": [], "external_targets": []}

152. 
     

153. for node in config["cluster_targets"]:

154.        metrics = {"node_name": node["name"], "ip": node["ipAddress"], "prom_metrics": {}}

155. 
     

156. for k, v in prom_metrics_cluster.items():

157.            metrics["prom_metrics"][k] = v.labels(node["name"], node["ipAddress"])

158. 
     

159.        labeled_prom_metrics["cluster_targets"].append(metrics)

160. 
     

161. for target in config["external_targets"]:

162.        metrics = {"target_name": target["name"], "host": target["host"], "prom_metrics": {}}

163. 
     

164. for k, v in prom_metrics_external.items():

165.            metrics["prom_metrics"][k] = v.labels(target["name"], target["host"])

166. 
     

167.        labeled_prom_metrics["external_targets"].append(metrics)

168. 
     

169. out = call_fping([prom_metric["ip"] for prom_metric in labeled_prom_metrics["cluster_targets"]] + \

170. [prom_metric["host"] for prom_metric in labeled_prom_metrics["external_targets"]])

171.    computed = compute_results(out)

172. 
     

173. for dimension in labeled_prom_metrics["cluster_targets"]:

174.        result = computed[dimension["ip"]]

175.        dimension["prom_metrics"]["sent"].inc(computed[dimension["ip"]]["sent"])

176.        dimension["prom_metrics"]["received"].inc(computed[dimension["ip"]]["received"])

177.        dimension["prom_metrics"]["rtt"].inc(computed[dimension["ip"]]["rtt"])

178.        dimension["prom_metrics"]["min"].set(computed[dimension["ip"]]["min"])

179.        dimension["prom_metrics"]["max"].set(computed[dimension["ip"]]["max"])

180.        dimension["prom_metrics"]["mdev"].set(computed[dimension["ip"]]["mdev"])

181. 
     

182. for dimension in labeled_prom_metrics["external_targets"]:

183.        result = computed[dimension["host"]]

184.        dimension["prom_metrics"]["sent"].inc(computed[dimension["host"]]["sent"])

185.        dimension["prom_metrics"]["received"].inc(computed[dimension["host"]]["received"])

186.        dimension["prom_metrics"]["rtt"].inc(computed[dimension["host"]]["rtt"])

187.        dimension["prom_metrics"]["min"].set(computed[dimension["host"]]["min"])

188.        dimension["prom_metrics"]["max"].set(computed[dimension["host"]]["max"])

189.        dimension["prom_metrics"]["mdev"].set(computed[dimension["host"]]["mdev"])

190. 
     

191.    prometheus_client.write_to_textfile(

192.        envs["PROMETHEUS_TEXTFILE_DIR"] + envs["PROMETHEUS_TEXTFILE_PREFIX"] + envs["MY_NODE_NAME"] + ".prom", registry)

该脚本在每个Kubernetes节点上运行，并且每秒两次发送ICMP数据包到Kubernetes集群的所有实例。收集的结果会存储在文本文件中。
该脚本会包含在Docker镜像中：

另外，我们还创建了一个ServiceAccount和一个具有唯一权限的对应角色用于获取节点列表（这样我们就可以知道它们的IP地址）：

最后，我们需要DaemonSet来运行在集群中的所有实例：



该解决方案的最后操作细节是：

• Python脚本执行时，其结果（即存储在主机上/var/run/node-exporter-textfile目录中的文本文件）将传递到DaemonSet类型的node-exporter。

• node-exporter使用--collector.textfile.directory /host/textfile参数启动，这里的/host/textfile是hostPath目录/var/run/node-exporter-textfile。（你可以点击这里[1]了解关于node-exporter中文本文件收集器的更多信息。）

• 最后node-exporter读取这些文件，然后Prometheus从node-exporter实例上收集所有数据。

那么结果如何？

现在该来享受期待已久的结果了。指标创建之后，我们可以使用它们，当然也可以对其进行可视化。以下可以看到它们是怎样的。
首先，有一个通用选择器可让我们在其中选择节点以检查其“源”和“目标”连接。你可以获得一个汇总表，用于在Grafana仪表板中指定的时间段内ping选定节点的结果：

以下是包含有关选定节点的组合统计信息的图形：

另外，我们有一个记录列表，其中每个记录都链接到在“源”节点中选择的每个特定节点的图：

如果将记录展开，你将看到从当前节点到目标节点中已选择的所有其他节点的详细ping统计信息：

下面是相关的图形：

节点之间的ping出现问题的图看起来如何？

如果你在现实生活中观察到类似情况，那就该进行故障排查了！
最后，这是我们对外部主机执行ping操作的可视化效果：

我们可以检查所有节点的总体视图，也可以仅检查任何特定节点的图形：

当你观察到仅影响某些特定节点的连接问题时，这可能会有所帮助。
相关链接：

1. https://github.com/prometheus/node_exporter#textfile-collector

原文链接：https://medium.com/flant-com/ping-monitoring-between-kubernetes-nodes-11e815f4eff1

标签：node,Kubernetes,ping,host,dimension,metrics,prom,registry,节点
来源： https://blog.51cto.com/u_15127630/2764305

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。