def predict(service_name, input_json):
isvc = KFServing.get(service_name, namespace=KFSERVING_TEST_NAMESPACE)
# temporary sleep until this is fixed https://github.com/kubeflow/kfserving/issues/604
time.sleep(10)
api_instance = client.CoreV1Api(client.ApiClient())
service = api_instance.read_namespaced_service("istio-ingressgateway",
"istio-system",
exact='true')
if service.status.load_balancer.ingress is None:
cluster_ip = service.spec.cluster_ip
else:
cluster_ip = service.status.load_balancer.ingress[0].ip
host = urlparse(isvc['status']['url']).netloc
url = "http://{}/v1/models/{}:predict".format(cluster_ip, service_name)
headers = {'Host': host}
with open(input_json) as json_file:
data = json.load(json_file)
logging.info("Sending request data: %s", json.dumps(data))
response = requests.post(url, json.dumps(data), headers=headers)
logging.info("Got response code %s, content %s", response.status_code,
response.content)
probs = json.loads(response.content.decode('utf-8'))["predictions"]
return probs
def get_api_client(self):
"""
Create Kubernetes API client with configuration from string.
Returns:
str: Kubeconfig file path
"""
# This super-ugly code configuration is causes by wrong design of config-loading
# functions in https://github.com/kubernetes-client/python
client_config = type.__call__(client.Configuration)
kubeconfig = self.cluster.get_kubeconfig()
if kubeconfig is None:
raise ValueError(
"Could not create kubernetes API client: kubeconfig is not found "
)
kcl = KubeConfigLoader(config_dict=kubeconfig, )
kcl.load_and_set(client_config)
if self.cluster.provisioner.engine == 'kqueen.engines.OpenstackKubesprayEngine':
client_config.assert_hostname = False
return client.ApiClient(configuration=client_config)
def process_file(file):
base_folder = file[:file.rindex('/')]
with open(file, "r") as a_file:
capture_metadata = json.loads(a_file.read())
build_service_map(capture_metadata["services"]["items"])
build_pod_map(capture_metadata["pods"]["items"])
build_rs_map(capture_metadata["rs"]["items"])
build_deployments_map(capture_metadata["deployments"]["items"])
for pod_metadata in capture_metadata["pod_metadata"]:
handle_capture_per_pod(pod_metadata["pod"],
base_folder + '/' + pod_metadata["file"],
pod_metadata["IP"])
print_graph()
result = create_network_policy()
policy_folder = base_folder + '/network-policies'
create_clean_policies_directory(policy_folder)
for policy in result:
policy_content = client.ApiClient().sanitize_for_serialization(policy)
with open(
policy_folder + '/network_policy_{}.json'.format(
policy_content["metadata"]["name"]), "w") as policy_file:
policy_file.write(json.dumps(policy_content, indent=4))
def __init__(self, config):
""" Initialize connection to Kubernetes.
Connects to Kubernetes configuration using an environment appropriate method.
"""
super(KubernetesCompute, self).__init__()
self.config = config
if os.getenv('KUBERNETES_SERVICE_HOST'):
""" We're running inside K8S. Load the config appropriately. """
k8s_config.load_incluster_config()
else:
""" We're running outside of K8S. Load the config. """
k8s_config.load_kube_config()
api_client = k8s_client.ApiClient()
self.api = k8s_client.CoreV1Api(api_client)
self.rbac_api = k8s_client.RbacAuthorizationV1Api(api_client)
# self.extensions_api = k8s_client.ExtensionsV1beta1Api(api_client)
self.extensions_api = k8s_client.AppsV1Api(api_client)
self.networking_api = k8s_client.NetworkingV1Api(api_client)
self.try_minikube = True
self.namespace = self.get_namespace (
namespace=os.environ.get("NAMESPACE", self.get_namespace ()))
logger.debug (f"-- using namespace: {self.namespace}")
def check_backend(backend):
if backend == "kubernetes":
try:
from kubernetes import client as k8sclient
from kubernetes import config as k8sconfig
k8sconfig.load_kube_config()
_, rc, _ = k8sclient.ApiClient().call_api(
"/apis/yadage.github.io/v1/namespaces/default/workflows",
"GET")
return rc == 200
except ImportError:
pass
except k8sclient.rest.ApiException:
pass
return False
if backend == "local":
try:
import yadage
assert yadage
rc = subprocess.check_call(["docker", "info"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
return rc == 0
except:
pass
return False
if backend == "docker":
try:
rc = subprocess.check_call(["docker", "info"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
return rc == 0
except:
pass
return False
async def test_build_and_deploy(ops_test):
charm = await ops_test.build_charm(".")
role_binding_file = Path("/tmp/k8s-rolebinding.yaml")
model_name = ops_test._default_model_name
with open("docs/gatekeeper-rb.yaml.template", "r") as fh:
template = Template(fh.read())
role_binding_file.write_text(
template.render(
service_account_user=
f"system:serviceaccount:{model_name}:kubernetes-operator"))
role_binding = yaml.load_all(role_binding_file.read_text(),
Loader=yaml.FullLoader)
with client.ApiClient() as api_client:
api_instance = client.RbacAuthorizationV1Api(api_client)
try:
for k8s_obj in role_binding:
if k8s_obj["kind"] == "ClusterRoleBinding":
api_instance.create_cluster_role_binding(body=k8s_obj)
if k8s_obj["kind"] == "ClusterRole":
api_instance.create_cluster_role(body=k8s_obj)
except ApiException as err:
if err.status == 409:
# ignore "already exists" errors so that we can recover from
# partially failed setups
pass
else:
raise
resources = {"gatekeeper-image": "openpolicyagent/gatekeeper:v3.2.3"}
for series in meta["series"]:
await ops_test.model.deploy(charm,
application_name="opa-audit-test",
series=series,
resources=resources)
await ops_test.model.wait_for_idle(wait_for_active=True, timeout=60 * 60)
def main():
# Define the barer token we are going to use to authenticate.
# See here to create the token:
# https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/
aToken = ""
# disable warnings
#urllib3.disable_warnings()
yaml.warnings({'YAMLLoadWarning': False})
# Create a configuration object
# aConfiguration = client.Configuration()
aConfiguration = config.load_kube_config()
# Specify the endpoint of your Kube cluster
# aConfiguration.host = "https://172.26.138.146:6443"
# aConfiguration.host = str(apiserver)
# aConfiguration.api_key = {"Authorization": "Bearer " + str(aToken)}
# Create a ApiClient with our config
aApiClient = client.ApiClient(aConfiguration)
# Do calls
v1 = client.CoreV1Api(aApiClient)
print("Name\tType\tCluster IP\tExternal IP\tPorts")
namespaces = {"default", "kube-system"}
for namespace in namespaces:
print("namespace: %s" % namespace)
ret = v1.list_namespaced_service(namespace)
for i in ret.items:
#print("pods: %s"%i)
portRef = ""
for p in i.spec.ports:
portRef = portRef + str(p.port) + "/" + p.protocol + ","
print("%s\t%s\t%s\t%s\t%s" %
(i.metadata.name, i.spec.type, i.spec.cluster_ip,
i.spec.external_i_ps, portRef.strip(",")))
def deploy(self, pod_spec):
self.job_id = str(uuid.uuid1())
self.labels['fairing-id'] = self.job_id
pod_template_spec = self.generate_pod_template_spec(pod_spec)
pod_template_spec.spec.containers[0].command = [
"seldon-core-microservice", self.serving_class, "REST",
"--service-type=MODEL", "--persistence=0"
]
self.deployment_spec = self.generate_deployment_spec(pod_template_spec)
self.service_spec = self.generate_service_spec()
if self.output:
api = k8s_client.ApiClient()
job_output = api.sanitize_for_serialization(self.deployment_spec)
logger.warn(json.dumps(job_output))
service_output = api.sanitize_for_serialization(self.service_spec)
logger.warn(json.dumps(service_output))
v1_api = k8s_client.CoreV1Api()
apps_v1 = k8s_client.AppsV1Api()
self.deployment = apps_v1.create_namespaced_deployment(
self.namespace, self.deployment_spec)
self.service = v1_api.create_namespaced_service(
self.namespace, self.service_spec)
if self.service_type == "LoadBalancer":
url = self.backend.get_service_external_endpoint(
self.service.metadata.name, self.service.metadata.namespace,
self.service.metadata.labels)
else:
# TODO(jlewi): The suffix won't always be cluster.local since
# its configurable. Is there a way to get it programmatically?
url = "http://{0}.{1}.svc.cluster.local".format(
self.service.metadata.name, self.service.metadata.namespace)
logging.info("Cluster endpoint: %s", url)
return url
def modify_k8s_autoscaler(action):
"""
Pauses or resumes the Kubernetes autoscaler
"""
try:
config.load_incluster_config()
except config.ConfigException:
try:
config.load_kube_config()
except config.ConfigException:
raise Exception("Could not configure kubernetes python client")
# Configure API key authorization: BearerToken
configuration = client.Configuration()
# create an instance of the API class
k8s_api = client.AppsV1Api(client.ApiClient(configuration))
if action == 'pause':
logger.info('Pausing k8s autoscaler...')
body = {'spec': {'replicas': 0}}
elif action == 'resume':
logger.info('Resuming k8s autoscaler...')
body = {'spec': {'replicas': app_config['K8S_AUTOSCALER_REPLICAS']}}
else:
logger.info('Invalid k8s autoscaler option')
sys.exit(1)
try:
k8s_api.patch_namespaced_deployment(
app_config['K8S_AUTOSCALER_DEPLOYMENT'],
app_config['K8S_AUTOSCALER_NAMESPACE'], body)
logger.info('K8s autoscaler modified to replicas: {}'.format(
body['spec']['replicas']))
except ApiException as e:
logger.info(
'Scaling of k8s autoscaler failed. Error code was {}, {}. Exiting.'
.format(e.reason, e.body))
sys.exit(1)
def pass_to_scheduler(name_,
namespace_,
scheduler_name_='default-scheduler'):
"""
Pass deployment to be scheduled by different scheduler
:param str scheduler_name_: name of new scheduler, which will
schedule this deployment
:param str name_: name of deployment
:param str namespace_: namespace of deployment
:return str: return http response code
"""
url = '/apis/extensions/v1beta1/namespaces/' + namespace_ + '/deployments/' + name_
headers = {
'Accept': 'application/json',
'Content-Type': 'application/strategic-merge-patch+json'
}
body = {
"spec": {
"template": {
"spec": {
"schedulerName": scheduler_name_
}
}
}
}
api_client = client.ApiClient()
response = []
try:
response = api_client.call_api(url,
'PATCH',
header_params=headers,
body=body)
except Exception as e:
return int(str(e)[1:4])
return response[1]
def main():
config.load_kube_config()
v1 = client.CoreV1Api()
k8s_client = client.ApiClient()
k8s_api = client.ExtensionsV1beta1Api(k8s_client)
pp = pprint.PrettyPrinter(indent=4)
try:
# checks if deployment, service, configmap already created
check = k8s_api.read_namespaced_deployment_status(name="login-node-n",
namespace="default")
print("deployment already exists")
except Exception:
pass
# rendering template and creating configmap
config_data = yaml.load(open('vals.yaml'), Loader=yaml.FullLoader)
#itemp_up = render_template('condor_config.local.j2', request_name = "request",inventory_hostname = "hostname")
env = Environment(loader=FileSystemLoader('./templates'),
trim_blocks=True,
lstrip_blocks=True)
template = env.get_template('condor_config.local.j2')
temp_up = template.render(config_data)
name = 'temcon'
namespace = 'default'
body = kubernetes.client.V1ConfigMap()
body.data = dict([("condor_config.local", temp_up)])
body.metadata = kubernetes.client.V1ObjectMeta()
body.metadata.name = name
configuration = kubernetes.client.Configuration()
api_instance = kubernetes.client.CoreV1Api(
kubernetes.client.ApiClient(configuration))
try:
api_response = api_instance.create_namespaced_config_map(
namespace, body)
except ApiException as e:
print(
"Exception when calling CoreV1Api->create_namespaced_config_map: %s\n"
% e)
def wait_for_jobs(self, namespace, label_filter):
"""Wait for all the jobs with the specified label to finish.
Args:
label_filter: A label filter expression e.g. "group=mygroup"
"""
if not util.is_in_cluster():
util.load_kube_config(persist_config=False)
else:
config.load_incluster_config()
# Create an API client object to talk to the K8s master.
api_client = k8s_client.ApiClient()
jobs = util.wait_for_jobs_with_label(api_client, namespace,
label_filter)
done = 0
succeeded = 0
for job in jobs.items:
project = job.metadata.labels.get("project", "")
if not job.status.conditions:
logging.info("Project %s Job %s.%s missing condition", project,
job.metadata.namespace, job.metadata.name)
continue
last_condition = job.status.conditions[-1]
if last_condition.type in ["Failed", "Complete"]:
logging.info("Project %s Job %s.%s has condition %s", project,
job.metadata.namespace, job.metadata.name,
last_condition.type)
done += 1
if last_condition.type in ["Complete"]:
succeeded += 1
logging.info("%s of %s jobs finished", done, len(jobs.items))
logging.info("%s of %s jobs finished successfully", succeeded,
len(jobs.items))
def run(self):
"""Runs the Tekton pipeline async.
"""
client = k8s_client.ApiClient()
crd_api = k8s_client.CustomObjectsApi(client)
group, version = self.config["apiVersion"].split("/")
try:
result = crd_api.create_namespaced_custom_object(
group=group,
version=version,
namespace=self.namespace,
plural=PLURAL,
body=self.config)
logging.info("Created workflow:\n%s", yaml.safe_dump(result))
except rest.ApiException as e:
logging.error("Could not create workflow: %s")
if e.body:
body = None
if isinstance(e.body, six.string_types):
body = {}
try:
logging.info("Parsing ApiException body: %s", e.body)
body = json.loads(e.body)
except json.JSONDecodeError as json_e:
logging.error("Error parsing body: %s", json_e)
else:
body = e.body
logging.error("Could not create workflow; %s", body)
else:
logging.error("Could not create workflow: %s", e)
raise
self.name = result.get("metadata", {}).get("name")
logging.info("Submitted Tekton Pipeline %s.%s", self.namespace,
self.name)
return result
def main():
api_token = "eyJhbGciOiJSUzI1NiIsImtpZCI6IjBRZDIyWUhqQmJQLThHM2pndl93djBuazRucXVkZVh6U1BiclNwQVJrdWMifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJkZWZhdWx0Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZWNyZXQubmFtZSI6ImRlZmF1bHQtdG9rZW4tem13Z2giLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoiZGVmYXVsdCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjI3YTAzMmEwLTNjM2UtNGNlOC05MmY1LWYxMTBkNWM1MGVjNiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDpkZWZhdWx0OmRlZmF1bHQifQ.u0mDrFD3kPit7FaUIeTnjh1Ph9EGk-s_T4Rn5CRub_WCZ9M31Y4uWkFFK4Sdibez4Lea7maW4J9nq2SP0zoLWxxGgD1aR4ZK2qqyD2QmwfOzUdPdkK1ubII2GZMld5DPbrelA2F58DoFOrwkj_YDNmdZ-pSe1etTWcG4Q_KCoaMSUyDDNa-ZFeKjn8LAoWk1VckW-pSYIq2RcUbbdgHeURfY_qXr0G42eyC7tWnTGZK-k3ZxWneRFAc6fAF0JQD8x6QTMsxH2fc9XFM5yAnniSW2T_oaPF1HgzuMJxATQlTZZT25CwFQcgQwhExH81p8RDjzCLCAP_APRq7fiItyRQ"
configuration = kubernetes.client.Configuration()
configuration.api_key = {"authorization": "Bearer " + api_token}
configuration.host = "https://192.168.1.123:6443"
configuration.verify_ssl = False
# configuration.assert_hostname = False
configuration.debug = True
ApiClient = client.ApiClient(configuration)
# Configs can be set in Configuration class directly or using helper
# utility. If no argument provided, the config will be loaded from
# default location.
# config.load_kube_config(ApiClient)
apps_v1 = client.AppsV1Api(ApiClient)
# Uncomment the following lines to enable debug logging
# c = client.Configuration()
# c.debug = True
# apps_v1 = client.AppsV1Api(api_client=client.ApiClient(configuration=c))
# Create a deployment object with client-python API. The deployment we
# created is same as the `nginx-deployment.yaml` in the /examples folder.
deployment = create_deployment_object()
def main():
"""Main"""
config.load_incluster_config()
core_v1_client = client.CoreV1Api()
k8s_client = client.ApiClient()
# ConfigMap
deploy_config_map(core_v1_client)
# CSI Pods
deploy_csi_pods(core_v1_client)
# Storage Class
deploy_storage_class()
# Send Analytics Tracker
# The information from this analytics is available for
# developers to understand and build project in a better
# way
send_analytics_tracker("operator")
# Watch CRD
crd_watch(core_v1_client, k8s_client)
def test_create_from_list_in_multi_resource_yaml(self):
"""
Should be able to create the items in the PodList and a deployment
specified in the multi-resource file
"""
result = []
# Create a configuration object
aConfiguration = config.load_kube_config()
# Create a ApiClient with our config
aApiClient = client.ApiClient(aConfiguration)
core_v1 = client.CoreV1Api(aApiClient)
utils.create_from_yaml(
aApiClient,
filepath + "cluster/files/" + "multi-resource-with-list.yaml")
core_api = client.CoreV1Api(aApiClient)
app_api = client.AppsV1Api(aApiClient)
pod_0 = core_api.read_namespaced_pod(name="mock-pod-0",
namespace="default")
self.assertIsNotNone(pod_0)
pod_1 = core_api.read_namespaced_pod(name="mock-pod-1",
namespace="default")
self.assertIsNotNone(pod_1)
dep = app_api.read_namespaced_deployment(name="mock",
namespace="default")
self.assertIsNotNone(dep)
core_api.delete_namespaced_pod(name="mock-pod-0",
namespace="default",
body={})
core_api.delete_namespaced_pod(name="mock-pod-1",
namespace="default",
body={})
app_api.delete_namespaced_deployment(name="mock",
namespace="default",
body={})
def check_async(name, backend):
assert backend == "kubernetes"
from kubernetes import client as k8sclient
from kubernetes import config as k8sconfig
k8sconfig.load_kube_config()
a, rc, d = k8sclient.ApiClient().call_api(
"/apis/yadage.github.io/v1/namespaces/default/workflows/{}".format(
name),
"GET",
_preload_content=False,
)
try:
status = json.loads(a.read())["status"]["workflow"]
except:
return {"status": "UNKNOWN"}
if status.get("succeeded") == 1:
return {"status": "SUCCEEDED"}
if status.get("active") == 1:
return {"status": "INPROGRESS"}
if status.get("failed") == 1:
return {"status": "FAILED"}
return {"status": "UNKNOWN"}
def bind_role_with_api(name,
namespace,
labels,
subject_name,
subject_kind='ServiceAccount'):
# Using API because of bug https://github.com/canonical/operator/issues/390
logging.info('Creating role binding with K8s API')
_load_kube_config()
with client.ApiClient() as api_client:
api_instance = client.RbacAuthorizationV1Api(api_client)
body = client.V1RoleBinding(metadata=client.V1ObjectMeta(
name=name, namespace=namespace, labels=labels),
role_ref=client.V1RoleRef(
api_group='rbac.authorization.k8s.io',
kind='Role',
name=name,
),
subjects=[
client.V1Subject(kind=subject_kind,
name=subject_name),
])
try:
api_instance.create_namespaced_role_binding(namespace,
body,
pretty=True)
return True
except ApiException as err:
logging.exception(
"Exception when calling RbacAuthorizationV1Api->create_namespaced_role_binding."
)
if err.status != 409:
# ignoring 409 (AlreadyExists) errors
return False
else:
return True
def _run_sql_on_maildb(api_url, api_token, namespace, label, sql):
configuration = _get_k8s_conf(api_url,api_token)
v1 = client.CoreV1Api(client.ApiClient(configuration))
sql_command = f"mysql -u postfix -p$MYSQL_PASSWORD -D postfix -e '{sql}'"
print(sql_command)
exec_command = [
'/bin/bash',
'-c',
sql_command,
]
c = configuration
c.assert_hostname = False
name = _get_pod_name(api_url, api_token, namespace, label, search='mariadb')
resp = stream(v1.connect_get_namespaced_pod_exec,
name,
namespace,
command=exec_command,
stderr=True, stdin=False,
stdout=True, tty=False)
return resp
def login_pending(self, request):
config.load_kube_config(config_file='/etc/kubernetes/admin.conf')
v1 = client.CoreV1Api()
k8s_client = client.ApiClient()
k8s_api = client.ExtensionsV1beta1Api(k8s_client)
configuration = kubernetes.client.Configuration()
api_instance = kubernetes.client.CoreV1Api(
kubernetes.client.ApiClient(configuration))
deps = k8s_api.read_namespaced_deployment_status(name="login-node-n-" +
str(request.name),
namespace="default")
while (deps.status.available_replicas != 1):
k8s_api = client.ExtensionsV1beta1Api(k8s_client)
deps = k8s_api.read_namespaced_deployment_status(
name="login-node-n-" + str(request.name), namespace="default")
self.log.info("LOGIN POD CREATED")
deps.metadata.name = deps.metadata.name + "-" + request.name
service = v1.read_namespaced_service(name="login-node-service-" +
str(request.name),
namespace="default")
config1 = api_instance.read_namespaced_config_map(name="new-config-" +
str(request.name),
namespace="default")
return login_info(self, request)
def ensure_namespace_cleanup(configuration):
api_instance = kube_client.CoreV1Api(kube_client.ApiClient(configuration))
timeout = time.time() + 180
while True:
if time.time() > timeout:
telemetry.set_user_fault()
logger.warning(
"Namespace 'azure-arc' still in terminating state. Please ensure that you delete the 'azure-arc' namespace before onboarding the cluster again."
)
return
try:
api_response = api_instance.list_namespace(
field_selector='metadata.name=azure-arc')
if not api_response.items:
return
time.sleep(5)
except Exception as e: # pylint: disable=broad-except
logger.warning("Error while retrieving namespace information: " +
str(e))
kubernetes_exception_handler(
e,
consts.Get_Kubernetes_Namespace_Fault_Type,
'Unable to fetch kubernetes namespace',
raise_error=False)
def test_node_status(self):
"""
verify that all nodes are online
"""
result = ""
# Create a configuration object
aConfiguration = config.load_kube_config()
# Create a ApiClient with our config
aApiClient = client.ApiClient(aConfiguration)
core_v1 = client.CoreV1Api(aApiClient)
response = core_v1.list_node(watch=False)
for i in response.items:
for cond in i.status.conditions:
if "KubeletReady" in cond.reason:
stat = str(cond.type)
node = i.metadata.name
# check whether node is notready
if "None" in stat:
result = "Not Ready"
#self.assertEqual("Ready", stat, msg="Node %s is not ready!"%node)
self.assertIsNotNone(result)
def test_node_role(self):
"""
verify that all nodes are online
"""
result = ""
# Create a configuration object
aConfiguration = config.load_kube_config()
# Create a ApiClient with our config
aApiClient = client.ApiClient(aConfiguration)
core_v1 = client.CoreV1Api(aApiClient)
response = core_v1.list_node(watch=False)
for i in response.items:
for label in i.metadata.labels:
if "node-role" in label:
nodelabel = label.split("/")
noderole = nodelabel[1].strip()
node = i.metadata.name
if "None" in noderole:
result = "None"
#self.assertEqual("master", noderole, msg="Node %s does not have a role!"%node)
self.assertIsNotNone(result)
def apply_kfp(modify, cop, runtime):
modify(cop)
# Have to do it here to avoid circular dependencies
from .pod import AutoMountType
if AutoMountType.is_auto_modifier(modify):
runtime.spec.disable_auto_mount = True
api = client.ApiClient()
for k, v in cop.pod_labels.items():
runtime.metadata.labels[k] = v
for k, v in cop.pod_annotations.items():
runtime.metadata.annotations[k] = v
if cop.container.env:
env_names = [
e.name if hasattr(e, "name") else e["name"]
for e in runtime.spec.env
]
for e in api.sanitize_for_serialization(cop.container.env):
name = e["name"]
if name in env_names:
runtime.spec.env[env_names.index(name)] = e
else:
runtime.spec.env.append(e)
env_names.append(name)
cop.container.env.clear()
if cop.volumes and cop.container.volume_mounts:
vols = api.sanitize_for_serialization(cop.volumes)
mounts = api.sanitize_for_serialization(cop.container.volume_mounts)
runtime.spec.update_vols_and_mounts(vols, mounts)
cop.volumes.clear()
cop.container.volume_mounts.clear()
return runtime
def get_more_info(driver, user):
try:
WebDriverWait(driver, 280).until(
EC.presence_of_element_located((By.ID, 'refresh_notebook_list')))
print('{} notebook spawned successfully'.format(user['username']))
except TimeoutException as e: # notebook didn't spin up
print('What happened here {} '.format(driver.page_source))
with open('/run/secrets/kubernetes.io/serviceaccount/token') as f:
token = f.read()
with open('/run/secrets/kubernetes.io/serviceaccount/namespace') as f:
namespace = f.read()
configuration = client.Configuration()
configuration.api_key['authorization'] = 'Bearer {}'.format(token)
configuration.host = 'https://kubernetes.default'
configuration.ssl_ca_cert = '/run/secrets/kubernetes.io/serviceaccount/ca.crt'
api_instance = client.CoreV1Api(client.ApiClient(configuration))
try:
api_response = api_instance.read_namespaced_pod(
'jupyter-{}'.format(user['username']), namespace)
pprint('😡 read_namespaced_pod {}'.format(str(api_response)))
except Exception as e:
pprint(
"Exception when calling CoreV1Api->read_namespaced_pod: %s\n" %
e)
try:
api_response = api_instance.read_namespaced_pod_log(
'jupyter-{}'.format(user['username']), namespace)
pprint('😡 {} read_namespaced_pod_log'.format(str(api_response)))
except Exception as e:
pprint(
"Exception when calling CoreV1Api->read_namespaced_pod_log: %s\n"
% e)
def crud_crd_object(namespace, obj, action):
"""Create Custom Resource Definitino object"""
# Using the API because of LP:1886694
logging.info("Creating CRD object with K8s API")
_load_kube_config()
body = client.V1beta1CustomResourceDefinition(**obj)
with client.ApiClient() as api_client:
api_instance = client.ApiextensionsV1beta1Api(api_client)
try:
if action.lower() == "create":
api_instance.create_custom_resource_definition(body,
pretty=True)
elif action.lower() == "delete":
api_instance.delete_custom_resource_definition(
name=obj["metadata"]["name"], pretty=True)
except ApiException as err:
if err.status == 409:
# ignore "already exists" errors so that we can recover from
# partially failed setups
return
else:
raise
def __init__(self, k8s_config=None, k8s_namespace=None):
from kubernetes import config, client
from gevent.threadpool import ThreadPool
if k8s_config is not None:
self._k8s_config = k8s_config
elif os.environ.get('KUBE_API_ADDRESS'):
self._k8s_config = client.Configuration()
self._k8s_config.host = os.environ['KUBE_API_ADDRESS']
else:
self._k8s_config = config.load_incluster_config()
verify_ssl = bool(int(os.environ.get('KUBE_VERIFY_SSL', '1').strip('"')))
if not verify_ssl:
c = client.Configuration()
c.verify_ssl = False
client.Configuration.set_default(c)
self._k8s_namespace = k8s_namespace or os.environ.get('MARS_K8S_POD_NAMESPACE') or 'default'
self._full_label_selector = None
self._client = client.CoreV1Api(client.ApiClient(self._k8s_config))
self._pool = ThreadPool(1)
self._service_pod_to_ep = dict()
def warmup(self):
kube_configs = self._get_config_files()
if kube_configs:
self._kube_config = os.path.join(self._kube_dir, kube_configs[0])
try:
configuration = client.Configuration()
config.load_kube_config(self._kube_config,
client_configuration=configuration)
if os.environ.get('HTTPS_PROXY'):
configuration.proxy = os.environ['HTTPS_PROXY']
api_client = client.ApiClient(configuration)
self._set_all_clients(api_client)
except Exception as e:
if 'Invalid kube-config file. No configuration found.' not in str(
e):
self.services.logging_service.warning(
'Experienced the following error while attempting to create kubernetes client from cluster configuration:'
'\n%s'
'\nDisconnecting and reconnecting may resolve the issue.'
'\nPlease try running:'
f'\n\t{CLI_NAME} cluster disconnect -a',
str(e),
)
self._set_all_clients(None)
def handle_order():
orderid = request.json['orderid']
weight = int(request.json['products'][0]['amount']) * 700
prodid = create_random_prod()
logging.warning('Received Order with ID {}'.format(orderid))
f = open("job_{}.yaml".format(prodid), "a")
f.write(
job_template.render(prodid=prodid.lower(),
registry="mimaurer",
version="v1",
orderid=orderid,
weight=weight))
f.close()
ns = load_env_file("NAMESPACE")
config.load_incluster_config()
k8s_client = client.ApiClient()
utils.create_from_yaml(k8s_client,
'./job_{}.yaml'.format(prodid),
namespace=ns)
os.remove('./job_{}.yaml'.format(prodid))
# SEND REPLY
reply = {'orderid': orderid, 'prodid': prodid, 'status': 'success'}
time.sleep(
random.randint(int(load_env_file("MIN_RANDOM")),
int(load_env_file("MAX_RANDOM"))) / 1000)
return json.dumps(reply)
def handler(event, context):
# Get Token
token = get_token(CLUSTER_NAME)
print("TOKEN: " + token)
# Configure
config.load_kube_config(KUBE_FILEPATH)
configuration = client.Configuration()
configuration.api_key['authorization'] = token
configuration.api_key_prefix['authorization'] = 'Bearer'
# API
api = client.ApiClient(configuration)
v1 = client.CoreV1Api(api)
# Get all the pods
ret = v1.list_namespaced_pod("default")
if not ret.items:
print("No Pods Found in namespace default")
for i in ret.items:
print("%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name))
