def get_resource_count(cluster_id, namespace_id=None):
"""
Get count of resources for requested cluster and namespace
:param cluster_id:
:param namespace_id:
:return:
"""
# fetching namespaced resource count
if namespace_id:
# Deployment count
deployment_count = len(
client.AppsV1beta2Api().list_namespaced_deployment(
namespace_id).items)
# Pod count
pod_items = client.CoreV1Api().list_namespaced_pod(namespace_id).items
pod_count = len([
pod_item for pod_item in pod_items
if pod_item.status.phase == 'Running'
])
# Cell count
cell_pod_map = get_cell_pod_map(cluster_id)
pods_list = [pod_item.metadata.name for pod_item in pod_items]
cell_count = len(
[cell_pod_map[pods] for pods in pods_list if pods in cell_pod_map])
# fetching resource count for entire cluster
else:
# Deployment count
deployment_count = len(
client.AppsV1beta2Api().list_deployment_for_all_namespaces().items)
# Pod count
pod_count = len(client.CoreV1Api().list_pod_for_all_namespaces().items)
# Cell count
cell_count = len(get_compute_cell_data()['items'])
# Removing resources related to the excluded namespace
if namespace_is_hidden == 'true':
resources_to_hide = get_hidden_namespace_resources(
cluster_id, 'dashboard')
deployment_count = 0 if deployment_count == 0 else deployment_count - resources_to_hide[
'deployments']
pod_count = 0 if pod_count == 0 else pod_count - resources_to_hide[
'pods']
cell_count = 0 if cell_count == 0 else cell_count - resources_to_hide[
'cells']
return {
"deployments": deployment_count,
"pods": pod_count,
'cells': cell_count
}
def create_deployment(self, deployment_object):
container_port = client.V1ContainerPort(
container_port=deployment_object.container_port, name=deployment_object.name
)
container = client.V1Container(
image=deployment_object.image,
name=deployment_object.name,
env=deployment_object.env,
ports=[container_port],
)
metadata = client.V1ObjectMeta(
name=deployment_object.name, labels=deployment_object.labels
)
template = client.V1PodTemplateSpec(
metadata=metadata, spec=client.V1PodSpec(containers=[container])
)
strategy = client.ExtensionsV1beta1DeploymentStrategy(
type=deployment_object.strategy_type
)
selector = client.V1LabelSelector(match_labels=deployment_object.labels)
spec = client.ExtensionsV1beta1DeploymentSpec(
selector=selector, strategy=strategy, template=template
)
deployment = client.ExtensionsV1beta1Deployment(
api_version="apps/v1beta2", kind="Deployment", metadata=metadata, spec=spec
)
api_client = client.AppsV1beta2Api()
api_client.create_namespaced_deployment(body=deployment, namespace="default")
def __init__(self, name, queue, timer_timeout=300):
"""
For each controller that needs updated, write a custom annotation
and maybe restart the necessary pods
Receives a queue with what needs updating
Main run thread is the only worker. Another thread is spawn for the update function.
The main class thread and the update thread both use for_update dict
to write/delete, so a lock is used to ensure they don't step on each other toes
"""
threading.Thread.__init__(self)
self.log = logging.getLogger(__name__ + " " + name)
self.log.info("Init threadApplyChanges")
global opsguru_signature
self.timer_timeout = timer_timeout
self.q = queue
self.v1 = client.CoreV1Api()
self.v1b1 = client.AppsV1beta1Api()
self.v1b2 = client.AppsV1beta2Api()
self.v1b1e = client.ExtensionsV1beta1Api()
self.ann = annotations.Annotations()
self.for_update = {}
self.for_update_lock = threading.Lock()
t = threading.Thread(target=self.update)
t.daemon = True
t.start()
def post(self, request, types):
if types == 'img':
pj_id = request.POST.get('pid', None)
print(pj_id)
a = repitl.get_image_name(project_id=pj_id)
print(a)
return JsonResponse(a, safe=False)
if types == 'tags':
repo_name = request.POST.get('image')
tags = repitl.get_tags(repo_name)
print('tags:', tags)
return JsonResponse(tags, safe=False)
if types == 'dep':
ns = request.POST.get('ns')
config.load_kube_config()
v1 = client.AppsV1beta2Api()
ret = []
tmp = v1.list_namespaced_deployment(namespace=ns).items
for i in tmp:
ret.append(i.metadata.name)
return JsonResponse(ret, safe=False)
if types == 'svc':
ns = request.POST.get('ns')
print(ns)
config.load_kube_config()
v1 = client.CoreV1Api()
ret = []
tmp = v1.list_namespaced_service(ns).items
for i in tmp:
ret.append(i.metadata.name)
return JsonResponse(ret, safe=False)
def createDeployment(applyName, image, servicePort):
V1ContainerPort = client.V1ContainerPort(
container_port=int(servicePort), protocol="TCP")
V1Container = client.V1Container(name=applyName,
image=image,
ports=[V1ContainerPort])
V1PodTemplateSpec = client.V1PodTemplateSpec(
spec=client.V1PodSpec(containers=[V1Container]),
metadata={"labels": {
'k8s-app': applyName
}})
V1beta2DeploymentSpec = client.V1beta2DeploymentSpec(
replicas=1,
selector=client.V1LabelSelector(
match_labels={"k8s-app": applyName}),
template=V1PodTemplateSpec)
V1ObjectMeta = client.V1ObjectMeta(namespace="default", name=applyName)
V1beta2Deployment = client.V1beta2Deployment(
spec=V1beta2DeploymentSpec,
api_version="apps/v1beta2",
kind="Deployment",
metadata=V1ObjectMeta)
pprint(V1beta2Deployment)
k8s_api = client.AppsV1beta2Api()
deployment = k8s_api.create_namespaced_deployment(
body=V1beta2Deployment, namespace="default")
pprint("Deployment create. status= '%s'" % deployment)
return deployment
def get(self, request, *args, **kwargs):
config.load_kube_config()
k8s_api = client.AppsV1beta2Api()
deployments = k8s_api.list_deployment_for_all_namespaces().items
return render(request,
template_name='dashboard/kubernetes/applications.html',
context={"deployments": deployments})
def get_context_data(self, **kwargs):
config.load_kube_config()
v1 = client.AppsV1beta2Api()
context = super(Dp_list, self).get_context_data(**kwargs)
dp_list = v1.list_deployment_for_all_namespaces().items
context['dp_list'] = dp_list
return context
def check_existing():
try:
cluster_list = list_cluster_mongodb_object()
except client.rest.ApiException as e:
# If for any reason, k8s api gives us an error here, there is
# nothing for us to do but retry later
logging.exception(e)
return False
core_api = client.CoreV1Api()
apps_api = client.AppsV1beta2Api()
for cluster_object in cluster_list['items']:
name = cluster_object['metadata']['name']
namespace = cluster_object['metadata']['namespace']
# Check service exists
try:
service = core_api.read_namespaced_service(name, namespace)
except client.rest.ApiException as e:
if e.status == 404:
# Create missing service
created_service = create_service(cluster_object)
if created_service:
# Store latest version in cache
cache_version(created_service)
else:
logging.exception(e)
else:
if not is_version_cached(service):
# Update since we don't know if it's configured correctly
updated_service = update_service(cluster_object)
if updated_service:
# Store latest version in cache
cache_version(updated_service)
# Check statefulset exists
try:
statefulset = apps_api.read_namespaced_stateful_set(
name, namespace)
except client.rest.ApiException as e:
if e.status == 404:
# Create missing statefulset
created_statefulset = create_statefulset(cluster_object)
if created_statefulset:
# Store latest version in cache
cache_version(created_statefulset)
else:
logging.exception(e)
else:
if not is_version_cached(statefulset):
# Update since we don't know if it's configured correctly
updated_statefulset = update_statefulset(cluster_object)
if updated_statefulset:
# Store latest version in cache
cache_version(updated_statefulset)
# Check replica set status
check_if_replicaset_needs_setup(cluster_object)
def delete_deploy(namespace, name):
config.load_kube_config()
k8s_api = client.AppsV1beta2Api()
body = client.V1DeleteOptions(api_version="apps/v1beta2",
propagation_policy='Foreground')
V1status = k8s_api.delete_namespaced_deployment(body=body,
name=name,
namespace=namespace)
return V1status
def __init__(self, host, api_key=None, namespace='default'):
self._config = Configuration()
self._config.host = host
if api_key:
self._config.api_key['authorization'] = api_key
self._api_client = ApiClient(self._config)
self.apps_v1_beta2 = client.AppsV1beta2Api(api_client=self._api_client)
self.core_v1 = client.CoreV1Api(api_client=self._api_client)
self.batch_v1 = client.BatchV1Api(api_client=self._api_client)
self.namespace = namespace
def create_resources(args):
print("Creating cluster...")
apps_v1beta2 = client.AppsV1beta2Api()
core_v1 = client.CoreV1Api()
create_secret_from_file(core_v1,
"scripts/kubernetes/kube-bootstrap-node.config")
create_headless_service(core_v1)
create_pod_service(core_v1, "us1", "chainweb-0")
create_stateful_set(apps_v1beta2, args)
def create_deployment(self, body):
try:
dep = yaml.load(body)
k8s = client.AppsV1beta2Api()
resp = k8s.create_namespaced_deployment(body=dep,
namespace=os.environ.get(
"NAMESPACE",
"default"))
return resp
except Exception as e:
return e
def delete_resources(args):
print("Deleting cluster...")
apps_v1beta2 = client.AppsV1beta2Api()
core_v1 = client.CoreV1Api()
try_delete(delete_stateful_set, apps_v1beta2)
try_delete(delete_secret, core_v1)
try_delete(delete_headless_service, core_v1)
try_delete(delete_pod_service, core_v1, "chainweb-0")
try_delete(delete_persistent_volume, core_v1, "data-chainweb-0")
def __init__(self, namespace='default'):
self.client = kubernetes_client
self.namespace = namespace
kubernetes_config.load_incluster_config()
self.v1 = kubernetes_client.CoreV1Api()
self.v1b1 = kubernetes_client.AppsV1beta1Api()
self.v1b2 = kubernetes_client.AppsV1beta2Api()
self.v1b1Storage = kubernetes_client.StorageV1beta1Api()
self.v1b1Extensions = kubernetes_client.ExtensionsV1beta1Api()
self.AppsV1Api = kubernetes_client.AppsV1Api()
self.v1_body_delete = kubernetes_client.V1DeleteOptions()
self.batch_api = kubernetes_client.BatchV1Api()
def k8s_configuration():
eks = auth.EKSAuth(cluster_id=CLUSTER_NAME)
token = eks.get_token()
# Configure
config.load_kube_config(KUBE_FILEPATH)
configuration = client.Configuration()
configuration.api_key['authorization'] = K8S_TOKEN
configuration.api_key_prefix['authorization'] = 'Bearer'
# API
api = client.ApiClient(configuration)
v1 = client.CoreV1Api(api)
v1_beta = client.AppsV1beta1Api(api)
api_v1=client.AppsV1Api(api)
v1_beta2 = client.AppsV1beta2Api(api)
return v1, v1_beta, api_v1, v1_beta2
def changeDeployment(deployment, namespace, image, port):
config.load_kube_config()
k8s_api = client.AppsV1beta2Api()
body = k8s_api.read_namespaced_deployment(name=deployment,
namespace=namespace)
if image != None:
body.spec.template.spec.containers[0].image = image
else:
print(image + "is none")
if port != None:
body.spec.template.spec.containers[0].ports[
0].container_port = int(port)
else:
print(port + "is none")
resp = k8s_api.patch_namespaced_deployment(name=deployment,
namespace=namespace,
body=body)
return resp
def kube_controller(self):
# configuration = client.Configuration()
# configuration.host = "https://c5b1d0b4a27474d47adeeb5132a397197.k8s-g1.cn-hangzhou.aliyuncs.com:6443"
# configuration.verify_ssl = False
# client.Configuration.set_default(configuration)
config.load_kube_config()
k8s_beta = client.AppsV1beta2Api()
k8s_core = client.CoreV1Api()
# deployment_list = self.kube_get_dep_list(k8s_beta)
# return deployment_list
# 处理deployment
deployment_list = self.kube_get_dep_list(k8s_beta)
if self.app_name in deployment_list:
print("Deployment already exists, replace ...")
try:
self.kube_replace_dep(k8s_beta)
except Exception as e:
print("Deployment replace Failed!, message:")
print(e)
else:
print("Deployment not exists, creat ...")
try:
self.kube_create_dep(k8s_beta)
except Exception as e:
print("Deployment create Failed! message:")
print(e)
# 处理Service
# svc = v1.list_namespaced_service(namespace=self.namespace)
# for i in svc.items:
# if re.search():
# pass
service_list = self.kube_get_svc_list(k8s_core)
if self.app_name in service_list:
print("Service already exists, if not necessary, do not change!")
else:
print("None Services exists, create")
try:
self.kube_create_svc(k8s_core)
except Exception as e:
print("Service create Failed! message:")
print(e)
def get_hidden_namespace_resources(cluster_id, namespace_id):
"""
Get the resource details for the namespace to be excluded
:param cluster_id:
:param namespace_id:
:return:
"""
# Deployment count
deployment_count = len(
client.AppsV1beta2Api().list_namespaced_deployment(namespace_id).items)
# Pod count
pod_items = client.CoreV1Api().list_namespaced_pod(namespace_id).items
pod_count = len(pod_items)
# Cell count
cell_pod_map = get_cell_pod_map(cluster_id)
pods_list = [pod_item.metadata.name for pod_item in pod_items]
cell_count = len([cell_pod_map[pods] for pods in pods_list])
return {
'deployments': deployment_count,
'pods': pod_count,
'cells': cell_count
}
def main():
config_logger()
log().info('Starting kube-job-cleaner')
parser = argparse.ArgumentParser()
parser.add_argument('--dry-run', action='store_true', help='Dry run mode')
args = parser.parse_args()
if os.getenv('IN_CLUSTER', 'true') in ("yes", "true"):
config.load_incluster_config()
else:
config.load_kube_config()
log().info('Looking for expired "Deployment" objects')
# create an instance of the API class
api_instance = client.AppsV1beta2Api()
# label_selector = 'label_selector_example'
try:
api_response = api_instance.list_deployment_for_all_namespaces(watch=False)
for deployment in api_response.items:
log().info("Checking namespace {} deployment {} for expiration".format(deployment.metadata.namespace, deployment.metadata.name))
delete_if_expired(args.dry_run, deployment, deployment_expired(deployment), api_instance)
except ApiException as e:
log().error("Exception when calling AppsV1beta2Api->list_deployment_for_all_namespaces: {}\n".format(e))
def list_replica_sets(self):
k8s = client.AppsV1beta2Api()
return k8s.list_namespaced_replica_set(namespace=os.environ.get(
"NAMESPACE", "default"),
pretty=True)
def createDeployment(name, namespace, image, port, protocol, **kwargs):
print(name, namespace, image, port, protocol, kwargs)
labels = {}
pprint(kwargs)
if isinstance(kwargs['labelKey'], list) and isinstance(
kwargs['labelValue'], list):
for (key, value) in zip(kwargs['labelKey'], kwargs['labelValue']):
labels[key] = value
else:
labels[kwargs['labelKey']] = kwargs['labelValue']
V1ObjectMeta = client.V1ObjectMeta(namespace="default",
name=name,
labels=labels)
ports = []
if isinstance(port, str):
ports.append(
client.V1ContainerPort(container_port=int(port),
protocol=protocol))
else:
for (Port, Protocol) in zip(port, protocol):
ports.append(
client.V1ContainerPort(container_port=int(Port),
protocol=Protocol))
env = []
if 'envKay' in kwargs.keys() and 'envValue' in kwargs.keys():
for (k, v) in zip(kwargs['envKey'], ['envValue']):
env.append(client.V1EnvVar(name=k, value=v))
if kwargs['command']:
command = kwargs['command']
print('命令错误')
else:
command = None
if kwargs['args']:
args = kwargs['args']
else:
args = None
V1Container = client.V1Container(name=name,
image=image,
ports=ports,
command=command,
args=args,
env=env)
V1PodTemplateSpec = client.V1PodTemplateSpec(
spec=client.V1PodSpec(containers=[V1Container]), metadata=V1ObjectMeta)
V1beta2DeploymentSpec = client.V1beta2DeploymentSpec(
replicas=int(kwargs['rc']),
selector=client.V1LabelSelector(match_labels=labels),
template=V1PodTemplateSpec)
V1beta2Deployment = client.V1beta2Deployment(
spec=V1beta2DeploymentSpec,
# api_version="apps/v1beta2",
kind="Deployment",
metadata=V1ObjectMeta)
pprint(V1beta2Deployment)
config.load_kube_config()
k8s_api = client.AppsV1beta2Api()
deployment = k8s_api.create_namespaced_deployment(body=V1beta2Deployment,
namespace=namespace)
pprint("Deployment create. status= '%s'" % deployment)
return deployment
def update_cluster_config():
#获取环境变量
namespace = os.environ['POD_NAMESPACE']
service_name = os.environ['REDIS_SERVICE_NAME']
conf_file = os.environ['REDIS_CONFIG_FILE']
apiserver = 'https://' + os.environ[
'KUBERNETES_SERVICE_HOST'] + ":" + os.environ['KUBERNETES_SERVICE_PORT']
pod_name = os.environ['POD_NAME']
st_name = pod_name[0:pod_name.rfind('-')]
redis_conf = get_redis_conf(conf_file)
#调用API获取service所有endpoint
with open('/var/run/secrets/kubernetes.io/serviceaccount/token',
'r') as file:
Token = file.read().strip('\n')
configuration = client.Configuration()
configuration.host = apiserver
configuration.verify_ssl = False
configuration.api_key = {"authorization": "Bearer " + Token}
client.Configuration.set_default(configuration)
v1 = client.CoreV1Api()
endpoints = v1.list_namespaced_endpoints(namespace,
field_selector='metadata.name=' +
service_name)
redis_port = 0
pods = []
if endpoints.items[0].subsets and endpoints.items[0].subsets != 'None':
redis_port = endpoints.items[0].subsets[0].ports[0].port
pods = endpoints.items[0].subsets[0].addresses
myip = get_myself_ip()
myport = redis_conf['port']
if 'requirepass' in redis_conf:
redis_passwd = redis_conf['requirepass']
else:
redis_passwd = ''
#读取cluter.conf文件
cluster_file = redis_conf['cluster-config-file']
lines = ''
line_new = ''
if os.path.exists(cluster_file):
conf = open(cluster_file, 'r+')
lines = conf.read()
line_new = lines
#本脚本先于redis-server启动,判断本节点是否已加入集群
if not os.path.exists(cluster_file) or (lines
and len(lines.split('\n')) < 4):
print("%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
'info', 'this node is not a part of cluster yet!'))
#判断是否已存在集群
clusters = []
cluster_exists = 0
if pods:
for pod in pods:
cluster_info = get_redis_cluster_info(pod.ip, redis_port,
redis_passwd)
if cluster_info['in_cluster'] == 1: cluster_exists = 1
clusters.append(cluster_info)
print(clusters)
if cluster_exists == 1:
print("%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), 'info',
'there is a redis cluster exists,do nothing'))
return
#判断当前是否最后一个启动的Pod
v1b2 = client.AppsV1beta2Api()
st = v1b2.list_namespaced_stateful_set(
namespace, field_selector='metadata.name=' + st_name)
if not st.items:
print(
"%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(
time.time())), 'error', st_name + ' not exists'))
return
replicas = st.items[0].spec.replicas
current_replicas = st.items[0].status.current_replicas
if current_replicas == replicas:
print("%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), 'info',
'this pod is the last replica,begin create cluster!'))
cluster_instances = [myip + ':' + str(myport)]
for pod in pods:
if pod.ip + ':' + str(redis_port) not in cluster_instances:
cluster_instances.append(pod.ip + ':' + str(redis_port))
start_redis = os.system("echo 'daemonize yes' >> " + conf_file)
start_redis = os.system('redis-server ' + conf_file)
rs = os.popen(
"echo 'yes'|redis-cli --cluster create --cluster-replicas 1 -a %s --no-auth-warning %s"
% (redis_passwd, (' ').join(cluster_instances)))
res = rs.read()
print("%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), 'info', res))
os.system('pkill redis-server')
start_redis = os.system("echo 'daemonize no' >> " + conf_file)
else:
print("%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), 'info',
'this pod is not the last replica,do nothing!'))
return
redis_nodes = []
if myip:
for line in lines.split('\n'):
row = line.split(' ')
if len(row) > 7 and row[2].split(',')[0] == 'myself':
line_new = re.sub(
row[0] + ' ' + row[1], row[0] + ' ' + myip + ':' +
str(myport) + '@' + row[1].split('@')[1], line_new)
try:
#把IP和Node_id对应起来
print("%s [%s] %s" % (time.strftime(
'%Y-%m-%d %H:%M:%S', time.localtime(time.time())), 'info', pods))
if pods:
for pod in pods:
cluster_info = get_redis_cluster_info(pod.ip, redis_port,
redis_passwd)
if cluster_info:
redis_nodes.append({
'host': pod.ip,
'port': redis_port,
'node_id': cluster_info['node_id']
})
print(
"%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(
time.time())), 'info', redis_nodes))
#根据node_id替换cluster.conf文件中的ip
for line in lines.split('\n'):
row = line.split(' ')
for node in redis_nodes:
if len(row) > 7 and node['node_id'] == row[0]:
line_new = re.sub(
row[0] + ' ' + row[1],
row[0] + ' ' + node['host'] + ':' +
str(node['port']) + '@' + row[1].split('@')[1],
line_new)
except Exception as e:
print("%s [%s] %s" %
(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(
time.time())), 'error', str(e)))
#重写cluster.conf文件
conf.seek(0)
conf.truncate()
conf.write(line_new)
conf.close()
def deployments_list(request):
config.load_kube_config()
k8s_api = client.AppsV1beta2Api()
deployments = k8s_api.list_deployment_for_all_namespaces().items
return render(request, 'dashboard/kubernetes/deployments.html',
{"deployments": deployments})
def getDeployment(name, namespace):
config.load_kube_config()
k8s_api = client.AppsV1beta2Api()
resp = k8s_api.read_namespaced_deployment(name, namespace)
return resp
def get_deployment_data(cluster_id, namespace_id=None, deployment_id=None):
"""
Fetch deployment listing and detail
:param deployment_id:
:param namespace_id:
:param cluster_id
:return:
"""
# global pods_for_resource_calculation
# deployment detail
if deployment_id and namespace_id is not None:
# creating cell-pod mapping for getting cell details
cell_pod_map = get_cell_pod_map(cluster_id)
# getting pod count
pods_data = [
pod
for pod in get_pod_data(cluster_id, namespace_id, deployment_id)
]
core_api = client.CoreV1Api()
apps_api = client.AppsV1Api()
deployment_cell_list = list()
deployment_pod_list = list()
for pod_name in pods_data:
if pod_name['name'] in cell_pod_map:
namespaced_pod_info = core_api.read_namespaced_pod(
pod_name['name'],
namespace_id).metadata.owner_references[0]
if namespaced_pod_info.kind == 'ReplicaSet':
replica_set = apps_api.read_namespaced_replica_set(
core_api.read_namespaced_pod(
pod_name['name'],
namespace_id).metadata.owner_references[0].name,
namespace_id)
if replica_set.metadata.owner_references[0].name == deployment_id and pod_name['name'] in cell_pod_map \
and pod_name['status']=='Running':
# fetching pods based on deployment
deployment_pod_list.append(pod_name['name'])
# fetching cells based on pods and deployment
deployment_cell_list.append(
cell_pod_map[pod_name['name']]['cell_name'])
else:
continue
else:
continue
# if there are no pods for the passed deployment
if len(deployment_pod_list) == 0:
pods_for_resource_calculation = 'no_pod_resource'
else:
pods_for_resource_calculation = deployment_pod_list
deployments_info = {
'resource_count': {
'cells': len(deployment_cell_list),
'pods': len(deployment_pod_list)
},
'resource_info':
get_resource_info(cluster_id, 'pods', namespace_id,
pods_for_resource_calculation)
}
# deployment listing
else:
if namespace_id:
deployments_info = [{
'value': deployment_item.metadata.name,
'label': deployment_item.metadata.name
} for deployment_item in client.AppsV1beta2Api().
list_namespaced_deployment(namespace_id).items]
else:
deployments_info = [{
'value': deployment_item.metadata.name,
'label': deployment_item.metadata.name
} for deployment_item in client.AppsV1beta2Api().
list_deployment_for_all_namespaces().items]
return deployments_info
def collect_garbage():
core_api = client.CoreV1Api()
apps_api = client.AppsV1beta2Api()
label_selector = get_default_label_selector()
# Find all services that match our labels
try:
service_list = core_api.list_service_for_all_namespaces(
label_selector=label_selector)
except client.rest.ApiException as e:
logging.exception(e)
else:
# Check if service belongs to an existing cluster
for service in service_list.items:
name = service.metadata.name
namespace = service.metadata.namespace
try:
get_namespaced_mongodb_object(name, namespace)
except client.rest.ApiException as e:
if e.status == 404:
# Delete service
delete_service(name, namespace)
else:
logging.exception(e)
# Find all statefulsets that match our labels
try:
statefulset_list = apps_api.list_stateful_set_for_all_namespaces(
label_selector=label_selector)
except client.rest.ApiException as e:
logging.exception(e)
else:
# Check if statefulsets belongs to an existing cluster
for statefulset in statefulset_list.items:
name = statefulset.metadata.name
namespace = statefulset.metadata.namespace
try:
get_namespaced_mongodb_object(name, namespace)
except client.rest.ApiException as e:
if e.status == 404:
# Gracefully delete statefulsets and pods
delete_statefulset(name, namespace)
else:
logging.exception(e)
# Find all secrets that match our labels
try:
secret_list = core_api.list_secret_for_all_namespaces(
label_selector=label_selector)
except client.rest.ApiException as e:
logging.exception(e)
else:
# Check if secrets belongs to an existing cluster
for secret in secret_list.items:
cluster_name = secret.metadata.labels['cluster']
secret_name = secret.metadata.name
namespace = secret.metadata.namespace
try:
get_namespaced_mongodb_object(cluster_name, namespace)
except client.rest.ApiException as e:
if e.status == 404:
# Delete service
delete_secret(secret_name, namespace)
else:
logging.exception(e)
def main():
contexts, active_context = config.list_kube_config_contexts()
if not contexts:
print("Cannot find any context in kube-config file.")
return
contexts = [context['name'] for context in contexts]
active_index = contexts.index(active_context['name'])
clusterName, _ = pick(contexts,
title="Pick the context to load",
default_index=active_index)
config.load_kube_config(context=clusterName)
all_rows = []
new_row = {}
appsV1Beta2Api = client.AppsV1beta2Api()
coreV1Api = client.CoreV1Api()
networkingV1Api = client.NetworkingV1Api()
networkingV1beta1Api = client.NetworkingV1beta1Api()
extensionsV1beta1Api = client.ExtensionsV1beta1Api()
api_response = coreV1Api.list_namespace(watch=False,
_preload_content=False)
api_response = json.loads(api_response.data)
namespaces = api_response["items"]
api_response = coreV1Api.list_endpoints_for_all_namespaces(
watch=False, _preload_content=False)
api_response = json.loads(api_response.data)
endpoints = api_response["items"]
api_response = extensionsV1beta1Api.list_ingress_for_all_namespaces(
watch=False, _preload_content=False)
api_response = json.loads(api_response.data)
ingresses = api_response["items"]
for namespace in namespaces:
ingress_row = {
'kind': 'Ingress',
'name': "missing",
'className': 'missing',
'children': []
}
new_row = {
"kind": "Namespace",
"name": namespace["metadata"]["name"],
"className": "namespace",
"children": []
}
new_row["children"].append(ingress_row)
all_rows.append(new_row)
for ingress in ingresses:
namespace = ingress["metadata"]["namespace"]
for idx, item in enumerate(all_rows):
if item["className"] == "namespace" and item["name"] == namespace:
if ingress["metadata"]["name"] not in [
x['name'] for x in item["children"]
]:
new_row = {
'kind': 'Ingress',
'name': ingress["metadata"]["name"],
'className': 'ingress',
'children': []
}
item["children"].append(new_row)
for rule in ingress["spec"]["rules"]:
for service in rule["http"]["paths"]:
serviceName = service["backend"]["serviceName"]
path = service["path"]
for namespace_idx, namespace_item in enumerate(all_rows):
if namespace_item[
"className"] == "namespace" and namespace_item[
"name"] == namespace:
for ingress_idx, ingress_item in enumerate(
all_rows[namespace_idx]["children"]):
if ingress_item[
"className"] == "ingress" and ingress_item[
"name"] == ingress["metadata"]["name"]:
if serviceName not in [
x['name']
for x in ingress_item["children"]
]:
new_row = {
'kind': 'Service',
'name': serviceName,
'ingressPath': path,
'className': 'service',
'children': []
}
ingress_item["children"].append(new_row)
'''
The endpoints response contains namespace, services name, pod name, node name and endpoint IP so we
will parse all endpoints and add them to the required structure for the org chart
'''
for endpoint in endpoints:
namespace = endpoint["metadata"]["namespace"]
if namespace not in [x['name'] for x in all_rows]:
new_row = {
'kind': 'Namespace',
'name': namespace,
'className': 'namespace',
'children': []
}
all_rows.append(new_row)
serviceName = endpoint["metadata"]["name"]
missing_ingress_idx = 0
ingress_missing = True
for namespace_idx, namespace_item in enumerate(all_rows):
if namespace_item["className"] == "namespace" and namespace_item[
"name"] == namespace:
for ingress_idx, ingress_item in enumerate(
all_rows[namespace_idx]["children"]):
for service_idx, service_item in enumerate(
all_rows[namespace_idx]["children"][ingress_idx]
["children"]):
if serviceName in service_item["name"]:
ingress_missing = False
if "subsets" in endpoint:
for subset in endpoint["subsets"]:
for address in subset["addresses"]:
if "ip" in address:
ip = address["ip"]
if "nodeName" in address:
nodeName = address["nodeName"]
if "targetRef" in address:
podName = address["targetRef"][
"name"]
new_row = {
'kind': 'Pod',
'name': podName,
'node': nodeName,
'ip': ip,
"className": "pod"
}
service_item["children"].append(
new_row)
# No ingress was found with this service name so add it to the "Missing" ingress which will be invisible
if ingress_missing:
if serviceName not in [
x['name'] for x in all_rows[namespace_idx]
["children"][missing_ingress_idx]["children"]
]:
pod_row = {}
if "subsets" in endpoint:
for subset in endpoint["subsets"]:
for address in subset["addresses"]:
if "ip" in address:
ip = address["ip"]
if "nodeName" in address:
nodeName = address["nodeName"]
if "targetRef" in address:
podName = address["targetRef"]["name"]
pod_row = {
'kind': 'Pod',
'name': podName,
'node': nodeName,
'ip': ip,
"className": "pod"
}
new_row = {
'kind': 'Service',
'name': serviceName,
'className': 'service',
'children': []
}
new_row["children"].append(pod_row)
all_rows[namespace_idx]["children"][
missing_ingress_idx]["children"].append(new_row)
cluster_row = {
"kind": "K8s Cluster",
"name": clusterName,
"children": all_rows
}
final_output = "var datasource = {};".format(cluster_row)
with open("assets/data/k8s_data.js", "w") as out:
out.write(final_output)
webbrowser.open('file://' + os.path.realpath("index.html"))
def delete_replica_set(self, name):
k8s = client.AppsV1beta2Api()
resp = k8s.delete_namespaced_replica_set(name=name,
namespace=os.environ.get(
"NAMESPACE", "default"))
return resp
try:
config.load_incluster_config()
except config.config_exception.ConfigException:
config.load_kube_config()
namespace = os.environ.get('NAMESPACE', 'default')
kinds_lookup = {
'pods': {
'should_watch': os.environ.get('WATCH_PODS', False),
'stream': partial(client.CoreV1Api().list_namespaced_pod, namespace=namespace)
},
'deployments': {
'should_watch': os.environ.get('WATCH_DEPLOYMENTS', True),
'stream': partial(client.AppsV1beta2Api().list_namespaced_deployment, namespace=namespace)
},
'services': {
'should_watch': os.environ.get('WATCH_SERVICES', False),
'stream': partial(client.CoreV1Api().list_namespaced_service, namespace=namespace)
},
'configmaps': {
'should_watch': os.environ.get('WATCH_CONFIGMAPS', False),
'stream': partial(client.CoreV1Api().list_namespaced_config_map, namespace=namespace)
},
'secrets': {
'should_watch': os.environ.get('WATCH_SECRETS', False),
'stream': partial(client.CoreV1Api().list_namespaced_secret, namespace=namespace)
},
'serviceaccounts': {
'should_watch': os.environ.get('WATCH_SERVICEACCOUNTS', False),
def __init__(self, kubernetes_admin_conf):
config.load_kube_config(config_file=kubernetes_admin_conf)
self.core_v1 = client.CoreV1Api()
self.apps_v1 = client.AppsV1beta2Api()
