def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for ns in core_api.list_namespace().items:
name = ns.metadata.name
labels = ns.metadata.labels
create_time = k8s.dt_format(ns.metadata.creation_timestamp)
namespace = {
"name": name,
"labels": labels,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(namespace)
else:
data.append(namespace)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for pv in core_api.list_persistent_volume().items:
name = pv.metadata.name
capacity = pv.spec.capacity["storage"]
access_modes = pv.spec.access_modes
if access_modes[0] == 'ReadWriteMany':
access_modes = '多节点读写'
elif access_modes[0] == 'ReadOnlyMany':
access_modes = '多节点只读'
elif access_modes[0] == 'ReadWriteOnce':
access_modes = '单节点读写'
reclaim_policy = pv.spec.persistent_volume_reclaim_policy
if reclaim_policy == 'Retain':
reclaim_policy = '回收后保留'
elif reclaim_policy == 'Delete':
reclaim_policy = '回收后删除'
status = pv.status.phase
if status == 'Available':
status = '可用'
if pv.spec.claim_ref is not None:
pvc_ns = pv.spec.claim_ref.namespace
pvc_name = pv.spec.claim_ref.name
pvc = "%s / %s" % (pvc_ns, pvc_name)
else:
pvc = "未绑定"
storage_class = pv.spec.storage_class_name
create_time = k8s.dt_format(pv.metadata.creation_timestamp)
pv = dict(name=name,
capacity=capacity,
access_modes=access_modes,
reclaim_policy=reclaim_policy,
status=status,
pvc=pvc,
storage_class=storage_class,
create_time=create_time)
if search_key:
if search_key in name:
data.append(pv)
else:
data.append(pv)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
apps_api = client.AppsV1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for sts in apps_api.list_namespaced_stateful_set(namespace).items:
name = sts.metadata.name
namespace = sts.metadata.namespace
labels = sts.metadata.labels
selector = sts.spec.selector.match_labels
replicas = sts.spec.replicas
ready_replicas = ("0" if sts.status.ready_replicas is None else
sts.status.ready_replicas)
# current_replicas = sts.status.current_replicas
service_name = sts.spec.service_name
containers = {}
for c in sts.spec.template.spec.containers:
containers[c.name] = c.image
create_time = k8s.dt_format(sts.metadata.creation_timestamp)
ds = {
"name": name,
"namespace": namespace,
"labels": labels,
"replicas": replicas,
"ready_replicas": ready_replicas,
"service_name": service_name,
"selector": selector,
"containers": containers,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(ds)
else:
data.append(ds)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for pvc in core_api.list_namespaced_persistent_volume_claim(
namespace=namespace).items:
name = pvc.metadata.name
namespace = pvc.metadata.namespace
labels = pvc.metadata.labels
storage_class_name = pvc.spec.storage_class_name
access_modes = pvc.spec.access_modes
capacity = (pvc.status.capacity if pvc.status.capacity is None
else pvc.status.capacity["storage"])
volume_name = pvc.spec.volume_name
status = pvc.status.phase
create_time = k8s.dt_format(pvc.metadata.creation_timestamp)
pvc = {
"name": name,
"namespace": namespace,
"lables": labels,
"storage_class_name": storage_class_name,
"access_modes": access_modes,
"capacity": capacity,
"volume_name": volume_name,
"status": status,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(pvc)
else:
data.append(pvc)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
apps_api = client.AppsV1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for ds in apps_api.list_namespaced_daemon_set(namespace).items:
name = ds.metadata.name
namespace = ds.metadata.namespace
desired_number = ds.status.desired_number_scheduled
available_number = ds.status.number_available
labels = ds.metadata.labels
selector = ds.spec.selector.match_labels
containers = {}
for c in ds.spec.template.spec.containers:
containers[c.name] = c.image
create_time = k8s.dt_format(ds.metadata.creation_timestamp)
ds = {
"name": name,
"namespace": namespace,
"labels": labels,
"desired_number": desired_number,
"available_number": available_number,
"selector": selector,
"containers": containers,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(ds)
else:
data.append(ds)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for node in core_api.list_node_with_http_info()[0].items:
name = node.metadata.name
labels = node.metadata.labels
status = node.status.conditions[-1].status
scheduler = ("是" if node.spec.unschedulable is None else "否")
cpu = node.status.capacity['cpu']
memory = k8s.memory_convert(node.status.capacity['memory'])
kebelet_version = node.status.node_info.kubelet_version
cri_version = node.status.node_info.container_runtime_version
create_time = k8s.dt_format(node.metadata.creation_timestamp)
node = {
"name": name,
"labels": labels,
"status": status,
"scheduler": scheduler,
"cpu": cpu,
"memory": memory,
"kebelet_version": kebelet_version,
"cri_version": cri_version,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(node)
else:
data.append(node)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
result = {'code': code, 'msg': msg}
else:
code, msg = 0, '数据返回成功！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for secret in core_api.list_namespaced_secret(
namespace=namespace).items:
name = secret.metadata.name
namespace = secret.metadata.namespace
data_length = (len(secret.data)
if secret.data is not None else "空")
create_time = k8s.dt_format(secret.metadata.creation_timestamp)
se = {
"name": name,
"namespace": namespace,
"data_length": data_length,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(se)
else:
data.append(se)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
namespace = self.request.GET.get('namespace', None)
search_key = self.request.GET.get('search_key', None)
node_name = self.request.GET.get('node_name', None)
try:
if namespace is not None:
data = list()
for po in core_api.list_namespaced_pod(namespace).items:
name = po.metadata.name
namespace = po.metadata.namespace
labels = po.metadata.labels
pod_ip = po.status.pod_ip
containers = [] # [{},{},{}]
status = "None"
# 只为None说明Pod没有创建（不能调度或者正在下载镜像）
if po.status.container_statuses is None:
status = po.status.conditions[-1].reason
else:
for c in po.status.container_statuses:
c_name = c.name
c_image = c.image
# 获取重启次数
restart_count = c.restart_count
# 获取容器状态
c_status = "None"
if c.ready is True:
c_status = "Running"
elif c.ready is False:
if c.state.waiting is not None:
c_status = c.state.waiting.reason
elif c.state.terminated is not None:
c_status = c.state.terminated.reason
elif c.state.last_state.terminated is not None:
c_status = c.last_state.terminated.reason
c = {
'c_name': c_name,
'c_image': c_image,
'restart_count': restart_count,
'c_status': c_status
}
containers.append(c)
create_time = k8s.dt_format(po.metadata.creation_timestamp)
po = {
"name": name,
"namespace": namespace,
"pod_ip": pod_ip,
"labels": labels,
"containers": containers,
"status": status,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(po)
else:
data.append(po)
elif node_name is not None:
data = node_data.node_pods(core_api, node_name)
else:
raise client.exceptions.ApiException
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
result = {'code': code, 'msg': msg}
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
result = {'code': code, 'msg': msg}
else:
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
apps_api = client.AppsV1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for dp in apps_api.list_namespaced_deployment(
namespace=namespace).items:
name = dp.metadata.name
namespace = dp.metadata.namespace
replicas = dp.spec.replicas
available_replicas = (0 if dp.status.available_replicas is None
else dp.status.available_replicas)
labels = dp.metadata.labels
selector = dp.spec.selector.match_labels
if len(dp.spec.template.spec.containers) > 1:
images = ""
n = 1
for c in dp.spec.template.spec.containers:
status = ("运行中" if dp.status.conditions[0].status
== "True" else "异常")
image = c.image
images += "[%s]: %s / %s" % (n, image, status)
images += "<br>"
n += 1
else:
status = ("运行中" if dp.status.conditions[0].status == "True"
else "异常")
image = dp.spec.template.spec.containers[0].image
images = "%s / %s" % (image, status)
create_time = k8s.dt_format(dp.metadata.creation_timestamp)
dp = {
"name": name,
"namespace": namespace,
"replicas": replicas,
"available_replicas": available_replicas,
"labels": labels,
"selector": selector,
"images": images,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(dp)
else:
data.append(dp)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for svc in core_api.list_namespaced_service(
namespace=namespace).items:
name = svc.metadata.name
namespace = svc.metadata.namespace
labels = svc.metadata.labels
types = svc.spec.type
cluster_ip = svc.spec.cluster_ip
ports = []
for p in svc.spec.ports: # 不是序列，不能直接返回
port_name = p.name
port = p.port
target_port = p.target_port
protocol = p.protocol
node_port = ""
if type == "NodePort":
node_port = "NodePort: %s <br>" % p.node_port
port = {
'port_name': port_name,
'port': port,
'protocol': protocol,
'target_port': target_port,
'node_port': node_port
}
ports.append(port)
selector = svc.spec.selector
create_time = k8s.dt_format(svc.metadata.creation_timestamp)
# 确认是否关联Pod
endpoint = ""
for ep in core_api.list_namespaced_endpoints(
namespace=namespace).items:
if ep.metadata.name == name and ep.subsets is None:
endpoint = "未关联"
else:
endpoint = "已关联"
svc = {
"name": name,
"namespace": namespace,
"type": types,
"cluster_ip": cluster_ip,
"ports": ports,
"labels": labels,
"selector": selector,
"endpoint": endpoint,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(svc)
else:
data.append(svc)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
networking_api = client.NetworkingV1beta1Api()
namespace = self.request.GET.get('namespace')
search_key = self.request.GET.get('search_key', None)
data = list()
try:
for ing in networking_api.list_namespaced_ingress(
namespace=namespace).items:
name = ing.metadata.name
namespace = ing.metadata.namespace
labels = ing.metadata.labels
service = "None"
http_hosts = "None"
for h in ing.spec.rules:
host = h.host
path = ("/" if h.http.paths[0].path is None else
h.http.paths[0].path)
service_name = h.http.paths[0].backend.service_name
service_port = h.http.paths[0].backend.service_port
http_hosts = {
'host': host,
'path': path,
'service_name': service_name,
'service_port': service_port
}
https_hosts = "None"
if ing.spec.tls is None:
https_hosts = ing.spec.tls
else:
for tls in ing.spec.tls:
host = tls.hosts[0]
secret_name = tls.secret_name
https_hosts = {
'host': host,
'secret_name': secret_name
}
create_time = k8s.dt_format(ing.metadata.creation_timestamp)
ing = {
"name": name,
"namespace": namespace,
"labels": labels,
"http_hosts": http_hosts,
"https_hosts": https_hosts,
"service": service,
"create_time": create_time
}
if search_key:
if search_key in name:
data.append(ing)
else:
data.append(ing)
code, msg = 0, '数据返回成功！'
except client.exceptions.ApiValueError as e:
code, msg = 1, '{}'.format(e)
except ValueError as e:
code, msg = 1, '{}'.format(e)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有访问权限！，默认使用default空间'
else:
msg = '获取数据失败！'
count = len(data)
page = self.request.GET.get('page', None)
limit = self.request.GET.get('limit', None)
if limit and page:
data = k8s.paging_data(page=page, limit=limit, data=data)
result = {'code': code, 'msg': msg, 'count': count, 'data': data}
return JsonResponse(result)
