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 post(self, request):
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
name = request.POST.get("name", None)
namespace = request.POST.get("namespace", None)
container = request.POST.get('container')
try:
log_text = core_api.read_namespaced_pod_log(name=name,
namespace=namespace,
container=container,
tail_lines=500)
except client.exceptions.ApiException as e:
code = e.status
if e.status == 403:
msg = '你没有查看日志权限'
else:
msg = f'获取日志失败<br>{e}'
result = {'code': code, 'msg': msg}
else:
code = 0
if len(log_text) == 0:
msg = "没有日志！"
log_text = "没有日志！"
else:
msg = "获取日志成功！"
result = {'code': code, 'msg': msg, 'data': log_text}
return JsonResponse(result)
def get(self, request):
k8s.load_auth(request=self.request)
apps_api = client.AppsV1Api()
dp_name = request.GET.get('name', None)
namespace = request.GET.get('namespace', None)
data = list()
for rs in apps_api.list_namespaced_replica_set(
namespace=namespace).items:
current_dp_name = rs.metadata.owner_references[0].name
rs_name = rs.metadata.name
if dp_name == current_dp_name:
namespace = rs.metadata.namespace
replicas = rs.status.replicas
available_replicas = rs.status.available_replicas
ready_replicas = rs.status.ready_replicas
revision = rs.metadata.annotations[
"deployment.kubernetes.io/revision"]
create_time = k8s.dt_format(rs.metadata.creation_timestamp)
containers = {}
for c in rs.spec.template.spec.containers:
containers[c.name] = c.image
rs = dict(name=rs_name,
namespace=namespace,
replicas=replicas,
available_replicas=available_replicas,
ready_replicas=ready_replicas,
revision=revision,
containers=containers,
create_time=create_time)
data.append(rs)
count = len(data)
result = dict(code=0, 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)
core_api = client.CoreV1Api()
node_name = self.request.GET.get('node_name', None)
n_r = node_data.node_resource(core_api, node_name)
n_i = node_data.node_info(core_api, node_name)
result = {
'node_name': node_name,
'node_resouces': n_r,
'node_info': n_i
}
return render(request, 'kube/node_details.html', 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 put(self, request):
request_data = QueryDict(self.request.body)
name = request_data.get('name', None)
namespace = request_data.get('namespace', None)
replicas = request_data.get('replicas')
k8s.load_auth(request=self.request)
apps_api = client.AppsV1Api()
try:
body = apps_api.read_namespaced_deployment(name=name,
namespace=namespace)
current_replicas = body.spec.replicas
min_replicas = 0
max_replicas = 10
try:
replicas = int(replicas)
except ValueError:
raise client.exceptions.ApiException(reason='输入格式错误，请输入数字！')
msg = ''
if current_replicas < replicas < max_replicas:
msg = '扩容成功'
elif current_replicas > replicas > min_replicas:
msg = '缩容成功'
elif replicas == current_replicas:
msg = '副本数一致'
raise client.exceptions.ApiException(reason=msg)
elif replicas > max_replicas:
msg = '副本数设置过大！请联系管理员操作'
raise client.exceptions.ApiException(reason=msg)
elif replicas == min_replicas:
msg = '副本数不能设置为0！'
raise client.exceptions.ApiException(reason=msg)
body.spec.replicas = replicas
apps_api.patch_namespaced_deployment(name=name,
namespace=namespace,
body=body)
code = 0
except client.exceptions.ApiException as e:
code = e.status
if e.status == 403:
msg = '没有创建权限！'
elif e.status == 409:
msg = 'Deployment已经存在！'
elif e.status == 422:
msg = f'reason:"{e.reason}"<br>message:{json.loads(e.body).get("message")}'
else:
print(e)
msg = e.reason
result = {'code': code, 'msg': msg}
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 delete(self, request):
request_data = QueryDict(self.request.body)
name = request_data.get('name')
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
try:
core_api.delete_namespace(name)
code, msg = 0, '删除成功！'
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有删除权限！'
else:
msg = '删除失败！'
result = {'code': code, 'msg': msg}
return JsonResponse(result)
def post(self, request):
data = self.request.POST
name = str.lower(data.get('name', None))
capacity = data.get('capacity', None)
access_mode = data.get('access_mode', None)
storage_class = data.get('storage_class', None)
if storage_class == 'nfs':
storage_class_name = 'nfs-storageclass-provisioner'
else:
storage_class_name = None
server_ip = data.get('server_ip', None)
mount_path = str.lower(data.get('mount_path', name))
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
body = client.V1PersistentVolume(
api_version='v1',
kind='PersistentVolume',
metadata=client.V1ObjectMeta(name=name),
spec=client.V1PersistentVolumeSpec(
capacity={'storage': capacity},
access_modes=[access_mode],
storage_class_name=storage_class_name,
nfs=client.V1NFSVolumeSource(
server=server_ip,
path='/ifs/kubernetes/{}'.format(mount_path))))
try:
core_api.create_persistent_volume(body=body)
except client.exceptions.ApiException as e:
code = e.status
if e.status == 403:
msg = '没有创建权限！'
elif e.status == 409:
msg = 'PV名称冲突'
elif e.status == 422:
e = json.loads(e.body)
msg = e.get('message')
else:
print(e)
msg = '创建失败！'
else:
code, msg = 0, '创建{}成功！'.format(name)
result = {'code': code, 'msg': msg}
return JsonResponse(result)
def connect(self):
# self.scope 请求头信息
self.pod_name = self.scope["url_route"]["kwargs"]["pod_name"]
self.container = self.scope["url_route"]["kwargs"]["container"]
self.namespace = self.scope["url_route"]["kwargs"]["namespace"]
k8s_auth = self.scope["query_string"].decode(
) # b'auth_type=kubeconfig&token=7402e616e80cc5d9debe66f31b7a8ed6'
auth_type = k8s_auth.split('&')[0].split('=')[1]
token = k8s_auth.split('&')[1].split('=')[1]
k8s.load_auth(auth_type, token)
core_api = client.CoreV1Api()
exec_command = [
"/bin/sh", "-c", 'export LINES=20; export COLUMNS=100; '
'TERM=xterm-256color; export TERM; [ -x /bin/bash ] '
'&& ([ -x /usr/bin/script ] '
'&& /usr/bin/script -q -c "/bin/bash" /dev/null || exec /bin/bash) '
'|| exec /bin/sh'
]
try:
self.conn_stream = stream(core_api.connect_get_namespaced_pod_exec,
name=self.pod_name,
namespace=self.namespace,
command=exec_command,
container=self.container,
stderr=True,
stdin=True,
stdout=True,
tty=True,
_preload_content=False)
kube_stream = K8sStreamThread(self, self.conn_stream)
kube_stream.start()
except Exception as e:
print(e)
status = getattr(e, "status")
if status == 403:
msg = "你没有进入容器终端权限！"
else:
msg = "连接容器错误，可能是传递的参数有问题！"
print(msg)
self.accept()
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 post(self, request):
name = request.POST.get('name', None)
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
body = client.V1Namespace(api_version='v1',
kind='Namespace',
metadata=client.V1ObjectMeta(name=name))
try:
core_api.create_namespace(body=body)
code, msg = 0, '创建{}成功！'.format(name)
except client.exceptions.ApiException as e:
code = 1
if e.status == 403:
msg = '没有创建权限！'
elif e.status == 409:
msg = '命名空间冲突'
else:
msg = '创建失败！'
result = {'code': code, 'msg': msg}
return JsonResponse(result)
def post(self, request):
k8s.load_auth(request=self.request)
apps_beta_api = client.ExtensionsV1beta1Api()
dp_name = request.POST.get('dn_name', None)
namespace = request.POST.get('namespace', None)
reversion = request.POST.get('reversion', None)
body = dict(name=dp_name, rollback_to=dict(reversion=reversion))
try:
apps_beta_api.create_namespaced_deployment_rollback(
name=dp_name, namespace=namespace, body=body)
except client.exceptions.ApiException as e:
code = e.status
if e.status == 403:
msg = '没有回滚权限！'
elif e.status == 422:
e = json.loads(e.body)
msg = e.get('message')
else:
msg = f'{e.reason}'
else:
code, msg = 0, '回滚成功'
result = dict(code=code, msg=msg)
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)
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):
import yaml
import json
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
apps_api = client.AppsV1Api()
networking_api = client.NetworkingV1beta1Api()
namespace = self.request.GET.get('namespace', None)
resource = self.request.GET.get('resource', None)
name = self.request.GET.get('name', None)
try:
if resource == 'namespace':
data_dict = core_api.read_namespace(
name=name, _preload_content=False).read()
elif resource == 'deployment':
data_dict = apps_api.read_namespaced_deployment(
name=name, namespace=namespace,
_preload_content=False).read()
elif resource == 'replicaset':
data_dict = apps_api.read_namespaced_replica_set(
name=name, namespace=namespace,
_preload_content=False).read()
elif resource == 'daemonset':
data_dict = apps_api.read_namespaced_daemon_set(
namespace=namespace, name=name,
_preload_content=False).read()
elif resource == 'statefulset':
data_dict = apps_api.read_namespaced_stateful_set(
name=name, namespace=namespace,
_preload_content=False).read()
elif resource == 'pod':
data_dict = core_api.read_namespaced_pod(
name=name, namespace=namespace,
_preload_content=False).read()
elif resource == 'service':
data_dict = core_api.read_namespaced_service(
name=name, namespace=namespace,
_preload_content=False).read()
elif resource == 'ingress':
data_dict = networking_api.read_namespaced_ingress(
namespace=namespace, name=name,
_preload_content=False).read()
elif resource == 'pvc':
data_dict = core_api.read_namespaced_persistent_volume_claim(
name=name, namespace=namespace,
_preload_content=False).read()
elif resource == 'pv':
data_dict = core_api.read_persistent_volume(
name=name, _preload_content=False).read()
elif resource == 'node':
data_dict = core_api.read_node(name=name,
_preload_content=False).read()
elif resource == 'configmap':
data_dict = core_api.read_namespaced_config_map(
namespace=namespace, name=name,
_preload_content=False).read()
elif resource == 'secret':
data_dict = core_api.read_namespaced_secret(
namespace=namespace, name=name,
_preload_content=False).read()
else:
raise client.exceptions.ApiException(status=400,
reason='未选择资源')
except client.exceptions.ApiValueError as e:
result = {'code': 1, 'msg': '{}'.format(e)}
except client.exceptions.ApiException as e:
result = {'code': 1, 'msg': '{}'.format(e)}
else:
try:
data_str = str(data_dict, 'utf-8')
data_yaml = yaml.safe_dump(json.loads(data_str))
except Exception as e:
result = {'code': 1, 'msg': '{}'.format(e)}
else:
result = {'code': 0, 'msg': '获取数据成功', 'data': data_yaml}
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)
def get(self, request):
namespace = self.request.GET.get('namespace', None)
dp_name = self.request.GET.get('name', None)
if not namespace or not dp_name:
return redirect('deployment')
k8s.load_auth(request=self.request)
core_api = client.CoreV1Api()
apps_api = client.AppsV1Api()
networking_api = client.NetworkingV1beta1Api()
dp_info = list()
for dp in apps_api.list_namespaced_deployment(
namespace=namespace).items:
if dp_name == dp.metadata.name:
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
# 通过deployment反向查询对应service
service = list()
svc_name = None
for svc in core_api.list_namespaced_service(
namespace=namespace).items:
if svc.spec.selector == selector:
svc_name = svc.metadata.name
svc_type = svc.spec.type
cluster_ip = svc.spec.cluster_ip
ports = svc.spec.ports
service.append({
'type': svc_type,
'cluster_ip': cluster_ip,
'ports': ports
})
# service没有创建，ingress也没有
ingress = {'rules': None, 'tls': None}
for ing in networking_api.list_namespaced_ingress(
namespace=namespace).items:
for r in ing.spec.rules:
for b in r.http.paths:
if b.backend.service_name == svc_name:
ingress['rules'] = ing.spec.rules
ingress['tls'] = ing.spec.tls
containers = list()
for c in dp.spec.template.spec.containers:
c_name = c.name
image = c.image
liveness_probe = c.liveness_probe
readiness_probe = c.readiness_probe
resources = c.resources # 在前端处理
env = c.env
ports = c.ports
volume_mounts = c.volume_mounts
args = c.args
command = c.command
container = {
"name": c_name,
"image": image,
"liveness_probe": liveness_probe,
"readiness_probe": readiness_probe,
"resources": resources,
"env": env,
"ports": ports,
"volume_mounts": volume_mounts,
"args": args,
"command": command
}
containers.append(container)
tolerations = dp.spec.template.spec.tolerations
rolling_update = dp.spec.strategy.rolling_update
volumes = []
if dp.spec.template.spec.volumes is not None:
for v in dp.spec.template.spec.volumes:
volume = {}
if v.config_map is not None:
volume["config_map"] = v.config_map
elif v.secret is not None:
volume["secret"] = v.secret
elif v.empty_dir is not None:
volume["empty_dir"] = v.empty_dir
elif v.host_path is not None:
volume["host_path"] = v.host_path
elif v.config_map is not None:
volume["downward_api"] = v.downward_api
elif v.config_map is not None:
volume["glusterfs"] = v.glusterfs
elif v.cephfs is not None:
volume["cephfs"] = v.cephfs
elif v.rbd is not None:
volume["rbd"] = v.rbd
elif v.persistent_volume_claim is not None:
volume[
"persistent_volume_claim"] = v.persistent_volume_claim
else:
volume["unknown"] = "unknown"
volumes.append(volume)
rs_number = dp.spec.revision_history_limit
create_time = k8s.dt_format(dp.metadata.creation_timestamp)
dp_info = {
"name": name,
"namespace": namespace,
"replicas": replicas,
"available_replicas": available_replicas,
"labels": labels,
"selector": selector,
"containers": containers,
"rs_number": rs_number,
"rolling_update": rolling_update,
"create_time": create_time,
"volumes": volumes,
"tolerations": tolerations,
"service": service,
"ingress": ingress
}
result = {
'dp_name': dp_name,
'namespace': namespace,
'dp_info': dp_info
}
return render(request, 'workload/deployment_details.html', result)
def post(self, request):
k8s.load_auth(request=self.request)
apps_api = client.AppsV1Api()
data = self.request.POST
name = data.get('name', None)
namespace = data.get('namespace', None)
image = data.get('image', None)
replicas = int(data.get('replicas', None))
try:
labels = dict()
for p in data.get('labels', None).split(','):
c = p.split('=')
if not len(c) == 2:
raise IndexError('标签格式错误')
k, v = c[0], c[1]
labels[k] = v
except IndexError:
code, msg = 1, '标签格式错误！'
result = {'code': code, 'msg': msg}
return JsonResponse(result)
resources = data.get('resources', None)
# health_liveness = data.get('health[liveness]', None)
# health_readiness = data.get('health[readiness]', None)
if resources == '1c2g':
cpu, memory = 1, 2
elif request == '2c4g':
cpu, memory = 2, 4
elif request == '':
cpu, memory = 4, 8
else:
cpu, memory = 0.5, 1
requests_cpu = cpu - cpu * 0.2
requests_memory = memory - memory * 0.2
resources = client.V1ResourceRequirements(
limits={
'cpu': cpu,
'memory': '{}Gi'.format(memory)
},
requests={
'cpu': requests_cpu,
'memory': '{}Gi'.format(requests_memory)
})
# if health_liveness == 'on':
# livenss_probe = client.V1Probe(http_get='/', timeout_seconds=30, initial_delay_seconds=30)
# else:
# livenss_probe = ''
#
# if health_readiness == 'on':
# readiness_probe = client.V1Probe(http_get='/', timeout_seconds=30, initial_delay_seconds=30)
# else:
# readiness_probe = ''
body = client.V1Deployment(
api_version='apps/v1',
kind='Deployment',
metadata=client.V1ObjectMeta(name=name, labels=labels),
spec=client.V1DeploymentSpec(
replicas=replicas,
selector={'matchLabels': labels},
template=client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels=labels),
spec=client.V1PodSpec(containers=[
client.V1Container(
name='web',
image=image,
env=[{
'name': 'TEST',
'value': '123'
}, {
'name': 'DEV',
'value': '456'
}],
ports=[client.V1ContainerPort(container_port=80)],
resources=resources)
]))))
try:
apps_api.create_namespaced_deployment(namespace=namespace,
body=body)
except client.exceptions.ApiException as e:
code = e.status
if e.status == 403:
msg = '没有创建权限！'
elif e.status == 409:
msg = 'Deployment已经存在！'
elif e.status == 422:
e = json.loads(e.body)
msg = e.get('message')
else:
print(e)
msg = '创建失败！'
else:
code, msg = 0, '创建{}成功！'.format(name)
result = {'code': code, 'msg': msg}
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)
