def create_api_client(api="BatchV1"):
"""Create Kubernetes API client using config.
:param api: String which represents which Kubernetes API to spawn. By
default BatchV1.
:returns: Kubernetes python client object for a specific API i.e. BatchV1.
"""
k8s_config.load_incluster_config()
api_configuration = client.Configuration()
api_configuration.verify_ssl = False
if api == "extensions/v1beta1":
api_client = client.ExtensionsV1beta1Api()
elif api == "CoreV1":
api_client = client.CoreV1Api()
elif api == "StorageV1":
api_client = client.StorageV1Api()
elif api == "AppsV1":
api_client = client.AppsV1Api()
elif api == "networking.k8s.io/v1beta1":
api_client = client.NetworkingV1beta1Api()
elif api == "CustomObjectsApi":
api_client = client.CustomObjectsApi()
else:
api_client = client.BatchV1Api()
return api_client
def resource_deploy(namespace,resourceid,serviceid,versionid,resourcename,versionname,dockerhost,imagename,buildtag,portnumber):
# config.load_kube_config("/home/ubuntu/.kube/config")
config.load_kube_config("/home/app/web/kubeconfig")
try:
api_instance=client.AppsV1Api()
status,status_message,data = create_deployment(api_instance,namespace,dockerhost,imagename,buildtag,resourceid,portnumber)
api_instancestatus = status
print("api_instancestatus: ", api_instancestatus)
print(status_message)
print(data)
if status == "success":
api_instance=client.CoreV1Api()
status,status_message,data = create_service(api_instance,namespace,resourceid,portnumber)
createservicestatus = status
print("createservicestatus: ", createservicestatus)
if status == "success":
api_instance=client.NetworkingV1beta1Api()
resourceurl="/"+versionname+"/"+resourcename+'/$2'
resourceendpoint="/liveapp/"+serviceid+"/"+versionname+"/"+resourcename+'(/|$)(.*)'
status,status_message,data = create_ingress(api_instance,namespace,resourceendpoint,resourceurl,resourceid)
create_ingress_status = status
print("create_ingress_status: ", create_ingress_status)
else:
raise Exception(data)
else:
raise Exception(data)
except Exception as Error:
status= "error"
status_message= "Error in Deployment",
data= str(Error)
return(status, status_message ,data)
def __init__(self, config_path=None):
if config_path is None:
config.load_incluster_config()
else:
config.load_kube_config(config_path)
self._core = client.CoreV1Api()
self._networking = client.NetworkingV1beta1Api()
def __init__(self,
api_client,
name,
issuer,
host,
paths=[],
namespace='default'):
self.api = client.NetworkingV1beta1Api(api_client)
self.name = name
self.namespace = namespace
self._issuer = issuer
self._host = host
self._paths = paths
context = {
'name': name,
'issuer': issuer,
'host': host,
'paths': paths,
}
config = yaml.safe_load(
self.generate_template('ingress.yaml.j2', context))
NetworkingV1beta1Ingress.__init__(self,
api_version=config['apiVersion'],
kind=config['kind'],
metadata=config['metadata'],
spec=config['spec'],
status=None)
def __init__(self, **kwargs):
aToken = None
with open('/var/run/secrets/kubernetes.io/serviceaccount/token',
'r') as fToken:
aToken = fToken.read()
# Create a configuration object
aConfiguration = client.Configuration()
# Specify the endpoint of your Kube cluster
aConfiguration.host = "https://{}:{}".format(
os.getenv('KUBERNETES_SERVICE_HOST'),
os.getenv('KUBERNETES_SERVICE_PORT'))
# Security part.
# In this simple example we are not going to verify the SSL certificate of
# the remote cluster (for simplicity reason)
aConfiguration.verify_ssl = False
# Nevertheless if you want to do it you can with these 2 parameters
# configuration.verify_ssl=True
# ssl_ca_cert is the filepath to the file that contains the certificate.
# configuration.ssl_ca_cert="certificate"
aConfiguration.api_key = {"authorization": "Bearer " + aToken}
# Create a ApiClient with our config
aApiClient = client.ApiClient(aConfiguration)
self._client_deployment = client.AppsV1Api(aApiClient)
self._client_service = client.CoreV1Api(aApiClient)
self.api_instance = client.NetworkingV1beta1Api(aApiClient)
def read_ingress(site_name):
not_set = "NOT_SET"
k8s_settings = frappe.get_single("K8s Bench Settings")
if not k8s_settings.namespace:
frappe.local.response["http_status_code"] = 501
return {
"namespace": k8s_settings.namespace or not_set,
}
load_config()
networking_v1_api = client.NetworkingV1beta1Api()
try:
ingress = networking_v1_api.read_namespaced_ingress(
site_name, k8s_settings.namespace
)
return to_dict(ingress)
except (ApiException, Exception) as e:
status_code = getattr(e, "status", 500)
out = {
"error": e,
"params": {"site_name": site_name, "namespace": k8s_settings.namespace},
}
reason = getattr(e, "reason")
if reason:
out["reason"] = reason
frappe.log_error(
out, "Exception: NetworkingV1beta1Api->read_namespaced_ingress"
)
frappe.local.response["http_status_code"] = status_code
return out
def test_list_namespaced_ingress_namespace_doesnt_exist():
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
with pytest.raises(ApiException) as err:
v1.list_namespaced_ingress("no-namespace")
assert err.value.status == 404
assert err.value.reason == "Not Found"
def test_list_ingress_for_all_namespaces(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
assert len(v1.list_ingress_for_all_namespaces().items) == 0
v1.create_namespaced_ingress("default", body=body)
assert len(v1.list_ingress_for_all_namespaces().items) == 1
def delete_ingress(name, namespace):
try:
config.load_kube_config("/home/app/web/kubeconfig")
api_instance = client.NetworkingV1beta1Api()
api_response = api_instance.delete_namespaced_ingress(name, namespace)
return ("success", "Ingress_deleted")
except Exception as error:
return ("Failed", str(error))
def list_ingresses(namespace: str = 'default', core_api: Optional[client.NetworkingV1beta1Api] = None):
# Creation of the Deployment in specified namespace
# (Can replace "default" with a namespace you may have created)
networking_v1_beta1_api = core_api or client.NetworkingV1beta1Api()
try:
return networking_v1_beta1_api.list_namespaced_ingress(namespace=namespace)
except (ApiException, ApiTypeError) as e:
raise api.ApiError(400, f"Error when listing ingresses in namespace {namespace}: {str(e)}")
def crea():
config.load_kube_config()
apps_v1_api = client.AppsV1Api()
networking_v1_beta1_api = client.NetworkingV1beta1Api()
create_deployment(apps_v1_api)
create_service()
create_ingress(networking_v1_beta1_api)
def __init__(self, namespace=K8S_NAMESPACE):
self.ns = namespace
# config.load_kube_config(context="docker-desktop")
config.load_incluster_config()
self.app_api = client.AppsV1Api()
self.core_api = client.CoreV1Api()
self.net_api = client.NetworkingV1beta1Api()
def main():
# Fetching and loading local Kubernetes Information
config.load_kube_config()
apps_v1_api = client.AppsV1Api()
networking_v1_beta1_api = client.NetworkingV1beta1Api()
create_deployment(apps_v1_api)
create_service()
create_ingress(networking_v1_beta1_api)
def test_patch_namespaced_ingress_ingress_doesnt_exist(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
body = generate_ingress(yaml.safe_load(ingress_yaml))
new_body = None
v1.create_namespaced_ingress("default", body=body)
with pytest.raises(ValueError) as err:
v1.patch_namespaced_ingress("no-service", "default", new_body)
assert "Missing the required parameter `body`" in str(err.value)
def get_resource_api(api_client: client.ApiClient = None,
**kwargs) -> "client.NetworkingV1beta1Api":
"""
Returns an instance of the kubernetes API client associated with
this object.
"""
if api_client:
kwargs["apl_client"] = api_client
return client.NetworkingV1beta1Api(**kwargs)
def test_list_ingress_for_all_namespaces_label_selector(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
assert len(v1.list_ingress_for_all_namespaces().items) == 0
v1.create_namespaced_ingress("default", body=body)
assert len(v1.list_ingress_for_all_namespaces().items) == 1
filtered = v1.list_ingress_for_all_namespaces(label_selector="app=foo")
assert len(filtered.items) == 1
def test_patch_namespaced_ingress_namespace_doesnt_exist(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
body = generate_ingress(yaml.safe_load(ingress_yaml))
new_body = None
v1.create_namespaced_ingress("default", body=body)
with pytest.raises(ApiException) as err:
v1.patch_namespaced_ingress("foobar", "no-namespace", new_body)
assert err.value.status == 404
assert err.value.reason == "Not Found"
def test_read_namespaced_ingress_ingress_doesnt_exist(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
v1.create_namespaced_ingress("default", body=body)
with pytest.raises(ApiException) as err:
v1.read_namespaced_ingress("no-ingress", "default")
assert err.value.status == 404
assert err.value.reason == "Not Found"
def test_create_namespaced_ingress_already_exists(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
v1.create_namespaced_ingress("default", body=body)
with pytest.raises(ApiException) as err:
v1.create_namespaced_ingress("default", body=body)
assert err.value.status == 409
assert err.value.reason == "AlreadyExists"
def test_create_namespaced_ingress_wrong_kind(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
ingress_yaml = ingress_yaml.replace("kind: Ingress", "kind: Igres")
raw_body = yaml.safe_load(ingress_yaml)
with pytest.raises(ApiException) as err:
body = generate_ingress(raw_body)
v1.create_namespaced_ingress("default", body=body)
assert err.value.status == 400
assert err.value.reason == "Bad Request"
def test_list_namespaced_ingress_field_selector(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
v1.create_namespaced_ingress("default", body=body)
ingresss = v1.list_namespaced_ingress("default")
ingresss_filter = v1.list_namespaced_ingress(
"default", field_selector="metadata.name=foobar")
assert len(ingresss.items) == 1
assert len(ingresss_filter.items) == 1
def init(self, config_path: Optional[str] = None):
# Sets config
if config_path is None:
kubernetes.config.load_incluster_config()
else:
kubernetes.config.load_kube_config(config_path)
# Inits API clients
self.core = client.CoreV1Api()
self.crds = client.CustomObjectsApi()
self._networking = client.NetworkingV1beta1Api()
self._app = client.AppsV1Api()
def networking_v1_beta1_api(self):
"""Networking client used for creating the ingress
:return: networking client
"""
if not self._networking_v1_beta1_api:
from kubernetes import client
self._networking_v1_beta1_api = client.NetworkingV1beta1Api(
api_client=self._k8s_client)
return self._networking_v1_beta1_api
def test_replace_namespaced_ingress_invalid_body(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
with pytest.raises(ApiException) as err:
new_ingress_yaml = ingress_yaml.replace("kind: Ingress", "kind: Igres")
body = generate_ingress(yaml.safe_load(ingress_yaml))
new_body = generate_ingress(yaml.safe_load(new_ingress_yaml))
v1.create_namespaced_ingress("default", body=body)
v1.replace_namespaced_ingress("foobar", "default", new_body)
assert err.value.status == 400
assert err.value.reason == "Bad Request"
def __init__(self, provider_data, deck=None):
self._provider_data = provider_data
self._deck = deck
if self._deck:
self._namespace = self._deck["environment"][0][
"namespace"] or "default"
else:
self._namespace = "default"
self._api_client = config.new_client_from_config(
provider_data.kubeconfig_path)
self._core_api = client.CoreV1Api(self._api_client)
self._networking_api = client.NetworkingV1beta1Api(self._api_client)
def test_patch_namespaced_ingress(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
new_ingress_yaml = ingress_yaml.replace('"app": "foo"', '"app": "bar"')
body = generate_ingress(yaml.safe_load(ingress_yaml))
new_body = generate_ingress(yaml.safe_load(new_ingress_yaml))
new_ingress = v1.create_namespaced_ingress("default", body=body)
assert new_ingress.metadata.labels == {"app": "foo"}
patched_ingress = v1.patch_namespaced_ingress("foobar", "default",
new_body)
assert new_ingress == patched_ingress
assert patched_ingress.metadata.labels == {"app": "bar"}
def test_create_namespaced_ingress(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
assert len(v1.list_ingress_for_all_namespaces().items) == 0
new_ingress = v1.create_namespaced_ingress("default", body=body)
assert new_ingress.metadata.name == "foobar"
assert new_ingress.metadata.namespace == "default"
assert new_ingress.kind == "Ingress"
assert new_ingress.spec.rules[0].host == "example.com"
assert len(v1.list_ingress_for_all_namespaces().items) == 1
def test_read_namespaced_ingress(ingress_yaml):
config.load_kube_config()
v1 = client.NetworkingV1beta1Api()
raw_body = yaml.safe_load(ingress_yaml)
body = generate_ingress(raw_body)
new_ingress = v1.create_namespaced_ingress("default", body=body)
read_ingress = v1.read_namespaced_ingress("foobar", "default")
assert read_ingress.metadata.name == "foobar"
assert read_ingress.metadata.namespace == "default"
assert read_ingress.metadata.labels == {"app": "foo"}
assert read_ingress.kind == "Ingress"
assert read_ingress == new_ingress
def main():
# Configs can be set in Configuration class directly or using helper utility
config_file = os.path.join(os.path.dirname(__file__), "kubeconfig-sa")
config.load_kube_config(config_file)
v1 = client.CoreV1Api()
namespace = "spark-jobs"
options = []
# List all Spark applications
ret = v1.list_namespaced_pod(namespace=namespace,
label_selector="spark-role=driver")
for pod in ret.items:
options.append(pod.metadata.labels["app-name"])
title = "Please choose a Spark Application: "
if options:
app_name, index = pick(options, title)
else:
print("No Spark app")
sys.exit()
# ---
# NodePort URL
# ui_service_name = app_name + "-ui-svc"
# core_v1_api = client.CoreV1Api()
#
# ui_svc = core_v1_api.read_namespaced_service(name=ui_service_name, namespace="spark-jobs")
# node_port = ui_svc.spec.ports[0].node_port
#
# # Choose a random node
# nodes = core_v1_api.list_node()
# n = random.randint(0, len(nodes.items) - 1)
# node = nodes.items[n]
#
# external_ip = filter(lambda addr: addr.type == "ExternalIP", node.status.addresses)[0].address
#
# print("The Spark Web UI is available at http://%s:%s" % (external_ip, node_port))
# Ingress URL
ui_ingress_name = app_name + "-ui-ingress"
networking_v1_beta1_api = client.NetworkingV1beta1Api()
ui_ingress_status = networking_v1_beta1_api.read_namespaced_ingress_status(
name=ui_ingress_name, namespace="spark-jobs")
if ui_ingress_status.status.load_balancer.ingress is not None:
external_ip = ui_ingress_status.status.load_balancer.ingress[0].ip
print("The Spark Web UI is available at http://%s/%s" %
(external_ip, app_name))
else:
print("Ingress not yet available")
def __init__(self, config_path=None):
if config_path is None:
config.load_incluster_config()
else:
config.load_kube_config(config_path)
self._core = client.CoreV1Api()
self._networking = client.NetworkingV1beta1Api()
self._app = client.AppsV1Api()
self._custom_object = client.CustomObjectsApi()
self._client = client.ApiClient()
self._api_server_url = 'http://{}:{}'.format(
os.environ.get('FL_API_SERVER_HOST', 'fedlearner-apiserver'),
os.environ.get('FL_API_SERVER_PORT', 8101))
