def __init__(self, name):
self.name = name
self.deployment = Deployment.objects(kube_api).get_or_none(name=name)
self.service = Service.objects(kube_api).get_or_none(name=name)
self.secret = Secret.objects(kube_api).get_or_none(name=name)
self.app = self.app_from_objects()
self.linked_deployments = self._get_linked_deployments()
def build_registry_svc(self, namespace):
return Service(self.api,
{
"metadata":
{
"labels":
{
"app": "registry",
"role": "registry",
"tier": "backend",
# Not sure if this label is important
"docker-registry": "default"
},
"name": "docker-registry",
"namespace": namespace
},
"spec":
{
"ports":
[{
"name": "registry",
"targetPort": "registry",
"port": 5000,
"protocol": "TCP"
}],
"selector":
{
"docker-registry": "default"
}
}
})
def build_etcd_service(self):
return Service(self.api,
{
"metadata":
{
"name": "etcd",
"namespace": "openshift-origin"
},
"spec":
{
"ports":
[{
"name": "client",
"port": 4001,
"targetPort": "client"
}, {
"name": "server",
"port": 7001,
"targetPort": "server"
}],
"selector":
{
"app": "etcd",
"purpose": "etcd"
},
"type": "ClusterIP"
}
})
def deploy_service(template_pod, template_service, branch, domain_zone):
#api = HTTPClient(KubeConfig.from_file("{0}/.kube/config".format(os.environ['HOME'])))
api = HTTPClient(KubeConfig.from_service_account())
with open(template_service) as t_file:
ts = yaml.load(t_file)
svc_name = ts['metadata']['name']
name = "{0}-{1}".format(svc_name, branch)
ts['spec']['type'] = 'LoadBalancer'
ts['spec']['selector']['name'] = name
ts['metadata']['name'] = name
ts['metadata']['labels']['name'] = name
new = Service(api, ts)
new.create()
print "New service created"
with open(template_pod) as t_file:
tp = yaml.load(t_file)
name = tp['metadata']['name']
name = "{0}-{1}".format(name, branch)
image = tp['spec']['containers'][0]['image']
image = "{0}:{1}".format(image, branch)
tp['spec']['containers'][0]['image'] = image
tp['spec']['containers'][0]['name'] = name
tp['metadata']['name'] = name
tp['metadata']['labels']['name'] = name
new = Pod(api, tp)
new.create()
print "New pod created"
print "Waiting for ELB to spawn"
lb_name = get_service_lb.wait_for_lb_name(name)
print "Got ELB {0}".format(lb_name)
return lb_name, svc_name
def build_os_service(self, use_load_balancer):
return Service(self.api,
{
"metadata":
{
"name": "openshift",
"namespace": "openshift-origin"
},
"spec":
{
"ports":
[{
"name": "web",
"port": 443,
"targetPort": "web"
}],
"selector":
{
"app": "openshift",
"tier": "backend"
},
"type": "LoadBalancer" if use_load_balancer else "NodePort"
}
})
"edge_location": edge_location,
"edge_target": edge_target,
"run_id": pod_run_id ,
"additional" : additional}
else:
print('Unable to get details of the tool {} from API due to errors. Empty endpoints will be returned'.format(docker_image))
else:
print('Unable to get details of the tool {} from API due to errors. Empty endpoints will be returned'.format(docker_image))
else:
print('Unable to get details of a RunID {} from API due to errors'.format(pod_run_id))
return service_list
kube_api = HTTPClient(KubeConfig.from_service_account())
kube_api.session.verify = False
edge_kube_service = Service.objects(kube_api).filter(selector={EDGE_SVC_ROLE_LABEL: EDGE_SVC_ROLE_LABEL_VALUE})
if len(edge_kube_service.response['items']) == 0:
print('EDGE service is not found by label: cloud-pipeline/role=EDGE')
exit(1)
else:
edge_kube_service_object = edge_kube_service.response['items'][0]
edge_kube_service_object_metadata = edge_kube_service_object['metadata']
if 'labels' in edge_kube_service_object_metadata and EDGE_SVC_HOST_LABEL in edge_kube_service_object_metadata['labels']:
edge_service_external_ip = edge_kube_service_object_metadata['labels'][EDGE_SVC_HOST_LABEL]
if 'labels' in edge_kube_service_object_metadata and EDGE_SVC_PORT_LABEL in edge_kube_service_object_metadata['labels']:
edge_service_port = edge_kube_service_object_metadata['labels'][EDGE_SVC_PORT_LABEL]
if not edge_service_external_ip:
edge_service_external_ip = edge_kube_service_object['spec']['externalIPs'][0]
if str in ['true', 'True']:
return True
return False
def parse_service(service):
data = Bunch(service.annotations)
data.ip = service.obj['spec']['clusterIP']
data.proxy_web_socket = str2bool(data.proxy_web_socket)
data.proxy_http = str2bool(data.proxy_http)
data.proxy_https = str2bool(data.proxy_https)
data.proxy_https_redirect = str2bool(data.proxy_https_redirect)
data.port = service.obj['spec']['ports'][0]['port']
return data
if __name__ == "__main__":
config = KubeConfig.from_service_account()
api = HTTPClient(config)
services = []
for namespace in os.getenv('PROXYED_NAMESPACES', 'default').split(','):
services += Service.objects(api).filter(namespace=namespace, selector={'proxied': 'true'})
data = []
for service in services:
data.append(parse_service(service))
result = render(data)
with open('/etc/nginx/nginx.conf', 'w') as file:
file.write(result)
def find_service_object_by_name(pykube_api, service_name, namespace=None):
if not service_name:
raise ValueError("service name must not be empty")
return Service.objects(pykube_api).filter(
field_selector={"metadata.name": service_name}, namespace=namespace)
def load_from_kube(self, kube):
self.pods = Pod.objects(kube).filter(namespace=self.namespace)
self.services = Service.objects(kube).filter(namespace=self.namespace)
self.replication_controllers = ReplicationController.objects(kube).filter(namespace=self.namespace)
logging.debug("Loaded from kube " + str(len(self.pods)) + " pods, " + str(len(self.services)) + " services, and " + str(len(self.replication_controllers)) + " rcs.")