网上找了零散的，然后看了k8s 的python api，里面很有方法，大致整理了一下操作的封装，很多操作返回都有to_dict()方法可以直接将返回的对象转为字典，之前没注意，后面懒得改了，写的比较乱，直接记录下来方便以后使用。

#!/usr/bin/python3
#coding:utf-8
__author__ = 'yang.su'
from kubernetes import client, config
from app.common import format_time

class KubeApi():
    def __init__(self, config_file):
        config.load_kube_config(config_file)
        self.core_api = client.CoreV1Api() # namespace,pod,service,pv,pvc
        self.apps_api = client.AppsV1Api() # deployment
        self.net_api = client.NetworkingV1Api() # ingress
        self.storage_api = client.StorageV1Api() # storage

    #转换标签
    @staticmethod
    def conv_labels(labels):
        if labels:
            labels = ",".join(["{}={}".format(p, labels[p]) for p in labels if "kubernetes" not in p])
        else:
            labels = ""
        return labels
   
    #获取命名空间列表
    def get_namespace(self):
        namespaces = []
        for p in self.core_api.list_namespace().items:
            namespaces.append(p.metadata.name)
        return namespaces
   
    #获取节点列表
    def get_nodes(self):
        node_list = []
        for p in self.core_api.list_node().items:
            node_list.append({
                "name": p.metadata.name,
                "addresses": p.status.addresses[0].address,
                "status": p.status.conditions[-1].type,
                "kubelet_version": p.status.node_info.kubelet_version,
                "operating_system": p.status.node_info.operating_system,
                "kernel_version": p.status.node_info.kernel_version,
                "container_runtime_version": p.status.node_info.container_runtime_version,
                "os_image": p.status.node_info.os_image,
                "allocatable": p.status.allocatable,
                "capacity": p.status.capacity,
                "labels": self.conv_labels(p.metadata.labels),
                "unschedulable": p.spec.unschedulable,
                "creation_time": format_time(p.metadata.creation_timestamp)
            })
        return node_list
   
    #获取node配置
    def read_node(self, node_name):
        return self.core_api.read_node(node_name)
   
    #修改调度状态
    def node_schedule(self, node_name, schedule_flag):
        body = {
            "spec": {
                "unschedulable": schedule_flag
            }
        }
        ret = self.core_api.patch_node(node_name, body)
        return ret
   
    #添加标签
    def node_label_modify(self, node_name, labels):
        body = {
            "metadata": {
                "labels": labels
            }
        }
        ret = self.core_api.patch_node(node_name, body)
        return ret

    #获取POD列表
    def get_pods(self, namespaced):
        pod_list = []
        for pod in self.core_api.list_namespaced_pod(namespaced).items:
            if pod.status.container_statuses:
                restart_count = sum([p.restart_count for p in pod.status.container_statuses])
                ready = "{}/{}".format([p.ready for p in pod.status.container_statuses].count(True), len([p.ready for p in pod.status.container_statuses]))
            else:
                restart_count = ""
                ready = ""
            pod_list.append({
                "name": pod.metadata.name,
                "uid": pod.metadata.uid,
                "node_name": pod.spec.node_name,
                "phase": pod.status.phase,
                "host_ip": pod.status.host_ip,
                "pod_ip": pod.status.pod_ip,
                "node_selector": self.conv_labels(pod.spec.node_selector),
                "containers": [p.name for p in pod.spec.containers],
                "labels": self.conv_labels(pod.metadata.labels),
                "owner_kind": pod.metadata.owner_references[0].kind,
                "restart_count": restart_count,
                "ready": ready,
                "start_time": format_time(pod.status.start_time)          
            })
        return pod_list
   
    #读取pod配置
    def read_pod(self, namespaced, pod_name):
        return self.core_api.read_namespaced_pod(pod_name, namespaced)
   
    #获取POD日志
    def read_pod_log(self, namespaced, pod_name, container, tail_lines=1000):
        return self.core_api.read_namespaced_pod_log(pod_name, namespaced, container=container, tail_lines=tail_lines)
   
    #重启POD
    def delete_pod(self, namespaced, pod_name):
        return self.core_api.delete_namespaced_pod(pod_name, namespaced)
   
    #获取deploy列表
    def get_deploy(self, namespaced):
        deploy_list = []
        for dp in self.apps_api.list_namespaced_deployment(namespaced).items:
            deploy_list.append({
                "name": dp.metadata.name,
                "node_selector": dp.spec.template.spec.node_selector,
                "replicas": dp.status.replicas,
                "ready_replicas": dp.status.ready_replicas,
                "available_replicas": dp.status.available_replicas,
                "unavailable_replicas": dp.status.unavailable_replicas,
                "labels": self.conv_labels(dp.metadata.labels),
                "rolling_update": self.conv_labels(dp.spec.strategy.rolling_update.to_dict()),
                "update_type": dp.spec.strategy.type,
                "uid": dp.metadata.uid,
                "creation_timestamp": format_time(dp.metadata.creation_timestamp)
            })
        return deploy_list
   
    #读取deploy配置
    def read_deploy(self, namespaced, deploy_name):
        return self.apps_api.read_namespaced_deployment(deploy_name, namespaced)
   
    #删除deploy资源
    def delete_deploy(self, namespaced, deploy_name):
        return self.apps_api.delete_namespaced_deployment(deploy_name, namespaced)
   
    #修改deploy资源
    def modify_deploy(self, namespaced, deploy_name, deploy_yaml):
        return self.apps_api.patch_namespaced_deployment(deploy_name, namespaced, deploy_yaml)
   
    #创建deploy资源
    def create_deploy(self, namespaced, deploy_yaml):
        return self.apps_api.create_namespaced_deployment(namespaced, deploy_yaml)

    #获取services列表
    def get_svc(self, namespaced):
        svc_list = []
        for svc in self.core_api.list_namespaced_service(namespaced).items:
            svc_list.append({
                "name": svc.metadata.name,
                "uid": svc.metadata.uid,
                "cluster_ip": svc.spec.cluster_ip,
                "type": svc.spec.type,
                "labels": self.conv_labels(svc.metadata.labels),
                "creation_timestamp": format_time(svc.metadata.creation_timestamp)
            })
        return svc_list
   
    #读取svc配置
    def read_svc(self, namespaced, svc_name):
        return self.core_api.read_namespaced_service(svc_name, namespaced)
   
    #删除svc资源
    def delete_svc(self, namespaced, svc_name):
        return self.core_api.delete_namespaced_service(svc_name, namespaced)

    #修改svc资源
    def modify_svc(self, namespaced, svc_name, svc_yaml):
        return self.core_api.patch_namespaced_service(svc_name, namespaced, svc_yaml)

    #获取damemon_set列表
    def get_ds(self, namespaced):
        ds_list = []
        for ds in self.apps_api.list_namespaced_daemon_set(namespaced).items:
            ds_list.append({
                "name": ds.metadata.name,
                "uid": ds.metadata.uid,
                "node_selector": self.conv_labels(ds.spec.template.spec.node_selector),
                "labels": self.conv_labels(ds.metadata.labels),
                "number_ready": ds.status.number_ready,
                "desired_number_scheduled": ds.status.desired_number_scheduled,
                "current_number_scheduled": ds.status.current_number_scheduled,
                "number_available": ds.status.number_available,
                "number_misscheduled": ds.status.number_misscheduled,
                "number_unavailable": ds.status.number_unavailable,
                "creation_timestamp": format_time(ds.metadata.creation_timestamp)
            })
        return ds_list
   
    #读取ds配置
    def read_ds(self, namespaced, ds_name):
        return self.apps_api.read_namespaced_daemon_set(ds_name, namespaced)
   
    #删除ds资源
    def delete_ds(self, namespaced, ds_name):
        return self.apps_api.delete_namespaced_daemon_set(ds_name, namespaced)

    #修改ds资源
    def modify_ds(self, namespaced, ds_name, ds_yaml):
        return self.apps_api.patch_namespaced_daemon_set(ds_name, namespaced, ds_yaml)

    #获取stateful_set列表
    def get_sts(self, namespaced):
        sts_list = []
        for sts in self.apps_api.list_namespaced_stateful_set(namespaced).items:
            sts_list.append({
                "name": sts.metadata.name,
                "node_selector": self.conv_labels(sts.spec.template.spec.node_selector),
                "labels": self.conv_labels(sts.metadata.labels),
                "replicas": sts.status.replicas,
                "ready_replicas": sts.status.ready_replicas,
                "current_replicas": sts.status.current_replicas,
                "uid": sts.metadata.uid,
                "creation_timestamp": format_time(sts.metadata.creation_timestamp)
            })
        return sts_list
   
    #读取sts配置
    def read_sts(self, namespaced, sts_name):
        return self.apps_api.read_namespaced_stateful_set(sts_name, namespaced)
   
    #删除sts资源
    def delete_sts(self, namespaced, sts_name):
        return self.apps_api.delete_namespaced_stateful_set(sts_name, namespaced)
   
    #修改sts资源
    def modify_sts(self, namespaced, sts_name, sts_yaml):
        return self.apps_api.patch_namespaced_stateful_set(sts_name, namespaced, sts_yaml)

    #获取configmap列表
    def get_cm(self, namespaced):
        cm_list = []
        for cm in self.core_api.list_namespaced_config_map(namespaced).items:
            cm_list.append({
                "name": cm.metadata.name,
                "uid": cm.metadata.uid,
                "labels": self.conv_labels(cm.metadata.labels),
                "creation_timestamp": format_time(cm.metadata.creation_timestamp)
            })
        return cm_list
   
    #读取cm配置
    def read_cm(self, namespaced, cm_name):
        return self.core_api.read_namespaced_config_map(cm_name, namespaced)
   
    #删除cm资源
    def delete_cm(self, namespaced, cm_name):
        return self.core_api.delete_namespaced_config_map(cm_name, namespaced)

    #获取service_account列表
    def get_sa(self, namespaced):
        sa_list = []
        for sa in self.core_api.list_namespaced_service_account(namespaced).items:
            sa_list.append({
                "name": sa.metadata.name,
                "uid": sa.metadata.uid,
                "labels": self.conv_labels(sa.metadata.labels),
                "creation_timestamp": format_time(sa.metadata.creation_timestamp)
            })
        return sa_list
   
    #读取service_account配置
    def read_sa(self, namespaced, sa_name):
        return self.core_api.read_namespaced_service_account(sa_name, namespaced)
   
    #删除service_account资源
    def delete_sa(self, namespaced, sa_name):
        return self.core_api.delete_namespaced_service_account(sa_name, namespaced)

    #获取secret列表
    def get_secret(self, namespaced):
        sc_list = []
        for sc in self.core_api.list_namespaced_secret(namespaced).items:
            sc_list.append({
                "name": sc.metadata.name,
                "uid": sc.metadata.uid,
                "labels": self.conv_labels(sc.metadata.labels),
                "type": sc.type,
                "creation_timestamp": format_time(sc.metadata.creation_timestamp)
            })
        return sc_list
   
    #读取secret配置
    def read_secret(self, namespaced, secret_name):
        return self.core_api.read_namespaced_secret(secret_name, namespaced)
   
    #删除secret资源
    def delete_secret(self, namespaced, secret_name):
        return self.core_api.delete_namespaced_secret(secret_name, namespaced)

    #获取pvc列表
    def get_pvc(self, namespaced):
        pvc_list = []
        for pvc in self.core_api.list_namespaced_persistent_volume_claim(namespaced).items:
            pvc_list.append({
                "name": pvc.metadata.name,
                "uid": pvc.metadata.uid,
                "labels": self.conv_labels(pvc.metadata.labels),
                "access_modes": pvc.spec.access_modes,
                "storage_class_name": pvc.spec.storage_class_name,
                "volume_mode": pvc.spec.volume_mode,
                "volume_name": pvc.spec.volume_name,
                "capacity": self.conv_labels(pvc.status.to_dict()),
                "requests": self.conv_labels(pvc.spec.resources.to_dict()),
                "phase": pvc.status.phase,
                "creation_timestamp": format_time(pvc.metadata.creation_timestamp)
            })
        return pvc_list
   
    #读取pvc配置
    def read_pvc(self, namespaced, pvc_name):
        return self.core_api.read_namespaced_persistent_volume_claim(pvc_name, namespaced)
   
    #删除pvc资源
    def delete_pvc(self, namespaced, pvc_name):
        return self.core_api.delete_namespaced_persistent_volume_claim(pvc_name, namespaced)

然后顺便附下时间转换的函数

def format_time(utc_datetime):
    dt = time.mktime(utc_datetime.timetuple())
    dtime = time.localtime(int(dt))
    return time.strftime("%Y-%m-%d %H:%M:%S", dtime)