def test_hpa_walkthrough(self):
"""
https://kubernetes.io/docs/user-guide/horizontal-pod-autoscaling/walkthrough/
https://github.com/kubernetes/community/blob/master/contributors/design-proposals/horizontal-pod-autoscaler.md
"""
k8s_dep = _utils.create_deployment(name="php-apache")
k8s_dep.model = Deployment(_constants.hpa_example_deployment())
k8s_svc = _utils.create_service(name="php-apache")
k8s_svc.model = Service(_constants.hpa_example_service())
k8s_hpa = _utils.create_hpa(name="php-apache")
k8s_hpa.model = HorizontalPodAutoscaler(
_constants.hpa_example_autoscaler())
if _utils.is_reachable(k8s_hpa.config):
# //--- Step One: Run & expose php-apache server
k8s_dep.create()
k8s_svc.create()
# // --- Step Two: Create Horizontal Pod Autoscaler
k8s_hpa.create()
# // --- Step Three: Increase Load
# $ kubectl run -i --tty load-generator --image=busybox /bin/sh
# $ while true; do wget -q -O- http://php-apache.default.svc.cluster.local; done
# watch 'kubectl config current-context; echo; kubectl get deployments; echo; kubectl get replicasets; echo; kubectl get pods; echo; kubectl top nodes; echo; kubectl top pods'
time.sleep(10) # wait for 10 secs; set a breakpoint if you need.
def get_by_name(config=None, name=None):
service_list = []
data = {'labelSelector': 'name={}'.format(name)}
services = K8sService(config=config, name=name).get_with_params(data=data)
for svc in services:
service_name = Service(svc).metadata.name
service_list.append(K8sService(config=config, name=service_name).get())
return service_list
def list(self, pattern=None, labels=None):
ls = super(K8sService, self).list(labels=labels)
svcs = list(map(lambda x: Service(x), ls))
if pattern is not None:
svcs = list(filter(lambda x: pattern in x.name, svcs))
k8s = []
for x in svcs:
j = K8sService(config=self.config, name=x.name).from_model(m=x)
k8s.append(j)
return k8s
def test_stateful_nginx(self):
svc = Service(headless_service())
sset = StatefulSet(stateful_set())
k8s_svc = K8sService(name='headless')
k8s_sset = K8sStatefulSet(name='sset')
k8s_svc.model = svc
k8s_sset.model = sset
if utils.is_reachable(k8s_svc.config.api_host):
k8s_svc.create()
k8s_sset.create()
def test_update_with_full_model(self):
data = {
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "frontend",
"namespace": "default",
"labels": {
"name": "frontend"
}
},
"spec": {
"ports": [
{
"protocol": "TCP",
"port": 8082,
"targetPort": "feport",
"nodePort": 8082
}
],
"selector": {
"name": "frontend"
},
"clusterIP": "10.250.1.27",
"type": "NodePort",
"sessionAffinity": "None"
},
"status": {
"loadBalancer": {}
}
}
svc = Service(data)
k8s_service = utils.create_service(name=svc.name)
k8s_service.model = svc
k8s_service.add_port(
name="frontend",
port=8082,
target_port="feport",
node_port=8082,
protocol='tcp'
)
self.assertEqual(1, len(k8s_service.ports))
def test_cassandra_setup(self):
svc = Service(utils.cassandra_service())
k8s_service = utils.create_service(name="cassandra")
k8s_service.model = svc
rc = ReplicationController(utils.cassandra_rc())
k8s_rc = utils.create_rc(name="cassandra")
k8s_rc.model = rc
ds = DaemonSet(utils.cassandra_daemonset())
k8s_ds = utils.create_daemonset(name="cassandra")
k8s_ds.model = ds
if utils.is_reachable(k8s_rc.config.api_host):
k8s_service.create()
k8s_rc.create()
self.assertIsInstance(k8s_service, K8sService)
self.assertIsInstance(k8s_rc, K8sReplicationController)
def get(self):
self.model = Service(self.get_model())
return self
def get(self):
self.model = Service(model=self.get_model())
return self
def __init__(self, config=None, name=None):
K8sObject.__init__(self, config=config, obj_type='Service', name=name)
self.model = Service(name=name, namespace=self.config.namespace)
class K8sService(K8sObject):
def __init__(self, config=None, name=None):
K8sObject.__init__(self, config=config, obj_type='Service', name=name)
self.model = Service(name=name, namespace=self.config.namespace)
# ------------------------------------------------------------------------------------- add
def add_annotation(self, k=None, v=None):
self.model.add_annotation(k=k, v=v)
return self
def add_label(self, k=None, v=None):
self.model.add_label(k=k, v=v)
return self
def add_port(self, name=None, port=None, target_port=None, protocol=None, node_port=None):
self.model.add_port(name=name, port=port, target_port=target_port, protocol=protocol, node_port=node_port)
return self
def add_selector(self, selector=None):
self.model.add_selector(selector=selector)
return self
# ------------------------------------------------------------------------------------- del
def del_meta_creation_timestamp(self):
return self.model.del_meta_creation_timestamp()
def del_meta_generation(self):
return self.model.del_meta_generation()
def del_meta_resource_version(self):
return self.model.del_meta_resource_version()
def del_meta_self_link(self):
return self.model.del_meta_self_link()
def del_meta_uid(self):
return self.model.del_meta_uid()
def del_server_generated_meta_attr(self):
return self.model.del_server_generated_meta_attr()
# ------------------------------------------------------------------------------------- get
def get(self):
self.model = Service(model=self.get_model())
return self
def get_annotation(self, k=None):
return self.model.get_annotation(k=k)
def get_annotations(self):
return self.model.get_annotations()
def get_cluster_ip(self):
return self.model.get_cluster_ip()
def get_external_ips(self):
return self.model.get_external_ips()
def get_label(self, k=None):
return self.model.get_label(k=k)
def get_labels(self):
return self.model.get_labels()
def get_meta_creation_timestamp(self):
return self.model.get_meta_creation_timestamp()
def get_meta_generation(self):
return self.model.get_meta_generation()
def get_meta_resource_version(self):
return self.model.get_meta_resource_version()
def get_meta_self_link(self):
return self.model.get_meta_self_link()
def get_meta_uid(self):
return self.model.get_meta_uid()
# ------------------------------------------------------------------------------------- set
def set_annotations(self, dico=None):
self.model.set_annotations(dico=dico)
return self
def set_cluster_ip(self, ip=None):
self.model.set_cluster_ip(ip=ip)
return self
def set_external_ips(self, ips=None):
self.model.set_external_ips(ips=ips)
return self
def set_labels(self, dico=None):
self.model.set_labels(dico=dico)
return self
def set_load_balancer_ip(self, ip=None):
self.model.set_load_balancer_ip(ip=ip)
return self
def set_namespace(self, name=None):
self.model.set_namespace(name=name)
return self
def set_meta_creation_timestamp(self, ts=None):
return self.model.set_meta_creation_timestamp(ts=ts)
def set_meta_generation(self, gen=None):
return self.model.set_meta_generation(gen=gen)
def set_meta_resource_version(self, ver=None):
return self.model.set_meta_resource_version(ver=ver)
def set_meta_self_link(self, link=None):
return self.model.set_meta_self_link(link=link)
def set_meta_uid(self, uid=None):
return self.model.set_meta_uid(uid=uid)
def set_session_affinity(self, affinity_type=None):
self.model.set_session_affinity(affinity_type=affinity_type)
return self
def set_service_type(self, service_type=None):
self.model.set_service_type(service_type=service_type)
return self
# ------------------------------------------------------------------------------------- filter
@staticmethod
def get_by_name(config=None, name=None):
try:
service_list = list()
data = dict(labelSelector="name={svc_name}".format(svc_name=name))
services = K8sService(config=config, name=name).get_with_params(data=data)
for svc in services:
try:
service_name = Service(model=svc).get_name()
service_list.append(K8sService(config=config, name=service_name).get())
except NotFoundException:
pass
except Exception as e:
message = "Got an exception of type {my_type} with message {my_msg}"\
.format(my_type=type(e), my_msg=e.message)
raise Exception(message)
return service_list
def __init__(self, config=None, name=None):
super(K8sService, self).__init__(config=config, obj_type='Service', name=name)
self.model = Service(name=name, namespace=self.config.namespace)
