1 pod自动更新

k8s的list-watch机制使得k8s的资源可以实现动态更改。

  1. import os, sys, django
  2. import logging
  4. pwd = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
  5. sys.path.append(pwd)
  6. os.environ.setdefault("DJANGO_SETTINGS_MODULE", "devops_backend.settings")
  7. django.setup()
  9. from kubernetes import client, watch
  10. from cmdb import models as cmdb_models
  12. logger = logging.getLogger(__name__)
  15. class ClientKubernetes(object):
  17.     def __init__(self, apitoken, apiserverUrl):
  18.         """
  19.         method one:   copy ~/.kube/config to local~/.kube then do the following
  21.         config.load_kube_config()
  22.         self.client = client.CoreV1Api()
  24.         method two:  as you can see in below
  25.         """
  26.         ApiToken = "****"
  27.         configuration = client.Configuration()
  28.         setattr(configuration, 'verify_ssl', False)
  29.         client.Configuration.set_default(configuration)
  30.         configuration.host = apiserverUrl
  31.         # configuration.verify_ssl = False
  32.         # configuration.debug = True
  33.         configuration.api_key = {"authorization": "Bearer " + apitoken}
  34.         client.Configuration.set_default(configuration)
  35.         self.clientInstance = client.CoreV1Api(client.ApiClient(configuration))
  36.         self.clientIngress = client.ExtensionsV1beta1Api()
  37.         self.apis_api = client.AppsV1Api()
  39.     def get_pod_for_all_namesapces(self):
  40.         """
  41.         一共有5个属性api_version,kind,metadata,spec,status
  42.         先暂时取出status属性
  43.         :return:
  44.         """
  45.         result = self.clientInstance.list_pod_for_all_namespaces(watch=False)
  46.         temp_result = []
  47.         count = 0
  48.         for item in result.items:
  49.             count += 1
  50.             item_dict = item.to_dict()
  51.             print(item_dict)
  52.             temp_result.append({'podname': item_dict['metadata']['name'], 'kind': item_dict['kind'],
  53.                                 'annotations': item_dict['metadata']['annotations'],
  54.                                 'cluster_name': item_dict['metadata']['cluster_name'],
  55.                                 'labels': item_dict['metadata']['labels'],
  56.                                 'namespace': item_dict['metadata']['namespace']})
  57.             break
  58.         return {'pod': temp_result, 'podcount': count}
  60.     def get_deployment_pods(self, namespace):
  61.         """获取deployment所有的pod"""
  62.         if namespace:
  63.             result = self.apis_api.list_namespaced_deployment(namespace=namespace).to_dict()
  64.         else:
  65.             result = self.apis_api.list_deployment_for_all_namespaces().to_dict()
  66.         temp_result = []
  67.         count = 0
  68.         for item in result["items"]:
  69.             # print(item)
  70.             name = item['metadata']['name']
  71.             namespace = item['metadata']['namespace']
  72.             replicas = item['spec']['replicas']
  73.             selector = item['spec']['selector']
  74.             temp_result.append({'name': name, 'namespace': namespace, 'replicas': replicas, 'selector': selector})
  75.             count += 1
  76.         return {'podcount': count, 'pod': temp_result}
  78.     def get_statefulset_pods(self, namespace):
  79.         """获取所有的statefulset 所有的pod"""
  81.         if namespace:
  82.             result = self.apis_api.list_namespaced_stateful_set(namespace=namespace).to_dict()
  83.         else:
  84.             result = self.apis_api.list_stateful_set_for_all_namespaces().to_dict()
  85.         temp_result = []
  86.         count = 0
  87.         for item in result["items"]:
  88.             name = item['metadata']['name']
  89.             namespace = item['metadata']['namespace']
  90.             replicas = item['spec']['replicas']
  91.             selector = item['spec']['selector']
  92.             temp_result.append({'name': name, 'namespace': namespace, 'replicas': replicas, 'selector': selector})
  93.             count += 1
  94.         return {'podcount': count, 'pod': temp_result}
  96.     def get_daemonset_pods(self, namespace):
  97.         """获取所有的daemonset"""
  99.         if namespace:
  100.             result = self.apis_api.list_namespaced_daemon_set(namespace=namespace).to_dict()
  101.         else:
  102.             result = self.apis_api.list_daemon_set_for_all_namespaces().to_dict()
  103.         temp_result = []
  104.         count = 0
  105.         for item in result["items"]:
  106.             name = item['metadata']['name']
  107.             namespace = item['metadata']['namespace']
  108.             selector = item['spec']['selector']
  109.             temp_result.append({'name': name, 'namespace': namespace, 'selector': selector})
  110.             count += 1
  111.         return {'podcount': count, 'pod': temp_result}
  113.     def get_all_namespace(self):
  114.         """获取所有的namespace"""
  116.         result = self.clientInstance.list_namespace().to_dict()
  117.         temp_result = []
  118.         for item in result['items']:
  119.             name = item['metadata']['name']
  120.             creation_timestamp = item['metadata']['creation_timestamp']
  121.             labels = item['metadata']['labels']
  122.             status = item['status']['phase']
  123.             temp_result.append(
  124.                 {'name': name, 'creation_timestamp': creation_timestamp, 'labels': labels, 'status': status})
  125.         return temp_result
  127.     def get_all_service(self, namespace):
  128.         """获取所有的service"""
  129.         if namespace:
  130.             result = self.clientInstance.list_namespaced_service(namespace=namespace)
  131.         else:
  132.             result = self.clientInstance.list_service_for_all_namespaces().to_dict()
  133.         temp_result = []
  134.         count = 0
  135.         for item in result['items']:
  136.             name = item['metadata']['name']
  137.             labels = item['metadata']['labels']
  138.             namespace = item['metadata']['namespace']
  139.             cluster_ip = item['spec']['cluster_ip']
  140.             ports = item['spec']['ports']
  141.             temp_result.append(
  142.                 {'name': name, 'labels': labels, 'namespace': namespace, 'cluster_ip': cluster_ip, 'ports': ports})
  143.             count += 1
  144.         return {'podcount': count, 'pod': temp_result}
  146.     def get_all_ingress(self, namespace):
  147.         """获取所有的ingress"""
  148.         if namespace:
  149.             result = self.clientIngress.list_namespaced_ingress(namespace=namespace).to_dict()
  150.         else:
  151.             result = self.clientIngress.list_ingress_for_all_namespaces().to_dict()
  152.         temp_result = []
  153.         count = 0
  154.         for item in result['items']:
  155.             name = item['metadata']['name']
  156.             namespace = item['metadata']['namespace']
  157.             rules = item['spec']['rules']
  158.             tls = item['spec']['tls']
  159.             temp_result.append(
  160.                 {'name': name, 'rules': rules, 'namespace': namespace, 'tls': tls})
  161.             count += 1
  162.         return {'podcount': count, 'pod': temp_result}
  164.     def get_all_node(self):
  165.         """获取集群所有的节点"""
  166.         result = self.clientInstance.list_node().to_dict()
  167.         temp_result = []
  168.         count = 0
  169.         for item in result['items']:
  170.             name = item['metadata']['name']
  171.             labels = item['metadata']['labels']
  172.             pod_cidr = item['spec']['pod_cidr']
  173.             taints = item['spec']['taints']
  174.             temp_result.append({'name': name, 'labels': labels, 'pod_cidr': pod_cidr, 'taints': taints})
  175.             count += 1
  176.         return {'nodecount': count, 'node': temp_result}
  178.     def watch_kubernetes_resouce(self):
  179.         w = watch.Watch()
  180.         for event in w.stream(self.apis_api.list_namespaced_deployment, namespace='kube-system'):
  181.             print(event)
  182.             print(type(event))
  184.     def get_all_pod_watch(self, clusterId):
  185.         """"""
  186.         w = watch.Watch()
  187.         for event in w.stream(self.apis_api.list_namespaced_deployment, namespace='kube-system'):
  188.             result_type = event.get('type')
  189.             result_object = event.get('object').to_dict()
  190.             result_api_version = result_object.get('api_version')
  191.             result_kind = result_object.get('kind')
  192.             metadata = result_object.get('metadata')
  193.             podname = metadata.get('name')
  194.             namespace = metadata.get('namespace')
  195.             status = result_object.get('status')
  196.             logger.info(
  197.                 f"result_type: {result_type}, result_api_version: {result_api_version}, result_kind: {result_kind}, podname: {podname}, namespace: {namespace}")
  198.             cluster_obj = cmdb_models.Cluster.objects.get(id=clusterId)
  199.             namespace_obj = cmdb_models.Namespace.objects.get(namespaceName=namespace, cluster=cluster_obj)
  200.             filter_object = cmdb_models.KubernetesApplicationInstance.objects.filter(applicationName=podname,
  201.                                                                                      namespace=namespace_obj,
  202.                                                                                      cluster=cluster_obj)
  203.             if filter_object:
  204.                 filter_object.update(kind=result_kind)
  205.             else:
  206.                 cmdb_models.KubernetesApplicationInstance.objects.create(applicationName=podname, kind=result_kind,
  207.                                                                          namespace=namespace_obj,
  208.                                                                          cluster=cluster_obj)
  209.             # w.stop()
  212. if __name__ == '__main__':
  213.     apitoken = "***"
  214.     apiserverUrl = "https://ip:6443"
  215.     instance = ClientKubernetes(apitoken=apitoken, apiserverUrl=apiserverUrl)
  216.     result = instance.get_all_pod_watch(clusterId=1)

这个程序可以单独独立出django执行