Lightweight Python 3+ client library for Kubernetes (pykube-ng) https://pykube.readthedocs.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

610 lines
19 KiB

import copy
import json
from inspect import getmro
from typing import Any
from typing import Optional
from typing import Type
from urllib.parse import urlencode
from requests import Response
from .exceptions import ObjectDoesNotExist
from .http import HTTPClient
from .mixins import ReplicatedMixin
from .mixins import ScalableMixin
from .query import Query
from .utils import join_url_path
from .utils import obj_merge
class ObjectManager:
def __call__(self, api: HTTPClient, namespace: str = None):
if namespace is None and NamespacedAPIObject in getmro(self.api_obj_class):
namespace = api.config.namespace
return Query(api, self.api_obj_class, namespace=namespace)
def __get__(self, obj, api_obj_class: Type):
assert obj is None, "cannot invoke objects on resource object."
self.api_obj_class = api_obj_class
return self
class APIObject:
"""
Baseclass for all Kubernetes API objects
"""
objects = ObjectManager()
base = None
def __init__(self, api: HTTPClient, obj: dict):
self.api = api
self.set_obj(obj)
def set_obj(self, obj: dict):
self.obj = obj
self._original_obj = copy.deepcopy(obj)
def __repr__(self):
return f"<{self.kind} {self.name}>"
def __str__(self):
return self.name
@property
def name(self) -> str:
"""
Name of the Kubernetes resource (metadata.name)
Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation
of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition.
Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names
"""
return self.obj["metadata"]["name"]
@property
def namespace(self) -> Optional[str]:
return None
@property
def metadata(self):
return self.obj["metadata"]
@property
def labels(self) -> dict:
"""
Labels of the Kubernetes resource (metadata.labels)
Map of string keys and values that can be used to organize and categorize (scope and select) objects.
May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels
"""
return self.obj["metadata"].setdefault("labels", {})
@property
def annotations(self) -> dict:
"""
Annotations of the Kubernetes resource (metadata.annotations)
Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata.
They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations
"""
return self.obj["metadata"].setdefault("annotations", {})
def api_kwargs(self, **kwargs):
kw = {}
# Construct url for api request
obj_list = kwargs.pop("obj_list", False)
if obj_list:
kw["url"] = self.endpoint
else:
subresource = kwargs.pop("subresource", None) or ""
operation = kwargs.pop("operation", "")
kw["url"] = join_url_path(self.endpoint, self.name, subresource, operation)
params = kwargs.pop("params", None)
if params is not None:
query_string = urlencode(params)
kw["url"] = "{}{}".format(
kw["url"], f"?{query_string}" if query_string else ""
)
if self.base:
kw["base"] = self.base
kw["version"] = self.version
if self.namespace is not None:
kw["namespace"] = self.namespace
kw.update(kwargs)
return kw
def exists(self, ensure=False):
r = self.api.get(**self.api_kwargs())
if r.status_code not in {200, 404}:
self.api.raise_for_status(r)
if not r.ok:
if ensure:
raise ObjectDoesNotExist(f"{self.name} does not exist.")
else:
return False
return True
def create(self):
r = self.api.post(**self.api_kwargs(data=json.dumps(self.obj), obj_list=True))
self.api.raise_for_status(r)
self.set_obj(r.json())
def reload(self):
r = self.api.get(**self.api_kwargs())
self.api.raise_for_status(r)
self.set_obj(r.json())
def watch(self):
return (
self.__class__.objects(self.api, namespace=self.namespace)
.filter(field_selector={"metadata.name": self.name})
.watch()
)
def patch(self, strategic_merge_patch, *, subresource=None):
"""
Patch the Kubernetes resource by calling the API with a "strategic merge" patch.
"""
r = self.api.patch(
**self.api_kwargs(
subresource=subresource,
headers={"Content-Type": "application/merge-patch+json"},
data=json.dumps(strategic_merge_patch),
)
)
self.api.raise_for_status(r)
self.set_obj(r.json())
def update(self, is_strategic=True, *, subresource=None):
"""
Update the Kubernetes resource by calling the API (patch)
"""
self.obj = obj_merge(self.obj, self._original_obj, is_strategic)
self.patch(self.obj, subresource=subresource)
def delete(self, propagation_policy: str = None):
"""
Delete the Kubernetes resource by calling the API.
The parameter propagation_policy defines whether to cascade the delete. It can be "Foreground", "Background" or "Orphan".
See https://kubernetes.io/docs/concepts/workloads/controllers/garbage-collection/#setting-the-cascading-deletion-policy
"""
if propagation_policy:
options = {"propagationPolicy": propagation_policy}
else:
options = {}
r = self.api.delete(**self.api_kwargs(data=json.dumps(options)))
if r.status_code != 404:
self.api.raise_for_status(r)
class NamespacedAPIObject(APIObject):
@property
def namespace(self) -> str:
"""
Namespace scope of the Kubernetes resource (metadata.namespace)
Namespace defines the space within each name must be unique.
Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces
"""
if self.obj["metadata"].get("namespace"):
return self.obj["metadata"]["namespace"]
else:
return self.api.config.namespace
def object_factory(api, api_version, kind) -> Type[APIObject]:
"""
Dynamically builds a Python class for the given Kubernetes object in an API.
For example:
api = pykube.HTTPClient(...)
NetworkPolicy = pykube.object_factory(api, "networking.k8s.io/v1", "NetworkPolicy")
This enables construction of any Kubernetes object kind without explicit support
from pykube.
Currently, the HTTPClient passed to this function will not be bound to the returned type.
It is planned to fix this, but in the mean time pass it as you would normally.
"""
resource_list = api.resource_list(api_version)
try:
resource = next(
resource
for resource in resource_list["resources"]
if resource["kind"] == kind
)
except StopIteration:
raise ValueError("unknown resource kind {!r}".format(kind)) from None
base = NamespacedAPIObject if resource["namespaced"] else APIObject
return type(
kind,
(base,),
{"version": api_version, "endpoint": resource["name"], "kind": kind},
)
class ConfigMap(NamespacedAPIObject):
version = "v1"
endpoint = "configmaps"
kind = "ConfigMap"
class CronJob(NamespacedAPIObject):
version = "batch/v1beta1"
endpoint = "cronjobs"
kind = "CronJob"
class DaemonSet(NamespacedAPIObject):
version = "apps/v1"
endpoint = "daemonsets"
kind = "DaemonSet"
class Deployment(NamespacedAPIObject, ReplicatedMixin, ScalableMixin):
version = "apps/v1"
endpoint = "deployments"
kind = "Deployment"
@property
def ready(self):
return (
self.obj["status"]["observedGeneration"]
>= self.obj["metadata"]["generation"]
and self.obj["status"]["updatedReplicas"] == self.replicas
)
def rollout_undo(self, target_revision=None):
"""Produces same action as kubectl rollout undo deployment command.
Input variable is revision to rollback to (in kubectl, --to-revision)
"""
if target_revision is None:
revision = {}
else:
revision = {"revision": target_revision}
params = {
"kind": "DeploymentRollback",
"apiVersion": self.version,
"name": self.name,
"rollbackTo": revision,
}
kwargs = {
"version": self.version,
"namespace": self.namespace,
"operation": "rollback",
}
r = self.api.post(**self.api_kwargs(data=json.dumps(params), **kwargs))
r.raise_for_status()
return r.text
class Endpoint(NamespacedAPIObject):
version = "v1"
endpoint = "endpoints"
kind = "Endpoint"
class Event(NamespacedAPIObject):
version = "v1"
endpoint = "events"
kind = "Event"
class LimitRange(NamespacedAPIObject):
version = "v1"
endpoint = "limitranges"
kind = "LimitRange"
class ResourceQuota(NamespacedAPIObject):
version = "v1"
endpoint = "resourcequotas"
kind = "ResourceQuota"
class ServiceAccount(NamespacedAPIObject):
version = "v1"
endpoint = "serviceaccounts"
kind = "ServiceAccount"
class Ingress(NamespacedAPIObject):
version = "networking.k8s.io/v1beta1"
endpoint = "ingresses"
kind = "Ingress"
class Job(NamespacedAPIObject, ScalableMixin):
version = "batch/v1"
endpoint = "jobs"
kind = "Job"
scalable_attr = "parallelism"
@property
def parallelism(self):
return self.obj["spec"]["parallelism"]
@parallelism.setter
def parallelism(self, value):
self.obj["spec"]["parallelism"] = value
class Namespace(APIObject):
version = "v1"
endpoint = "namespaces"
kind = "Namespace"
class Node(APIObject):
version = "v1"
endpoint = "nodes"
kind = "Node"
@property
def unschedulable(self):
if "unschedulable" in self.obj["spec"]:
return self.obj["spec"]["unschedulable"]
return False
@unschedulable.setter
def unschedulable(self, value):
self.obj["spec"]["unschedulable"] = value
self.update()
def cordon(self):
self.unschedulable = True
def uncordon(self):
self.unschedulable = False
class Pod(NamespacedAPIObject):
version = "v1"
endpoint = "pods"
kind = "Pod"
@property
def ready(self):
cs = self.obj["status"].get("conditions", [])
condition = next((c for c in cs if c["type"] == "Ready"), None)
return condition is not None and condition["status"] == "True"
def logs(
self,
container=None,
pretty=None,
previous=False,
since_seconds=None,
since_time=None,
timestamps=False,
tail_lines=None,
limit_bytes=None,
):
"""
Produces the same result as calling kubectl logs pod/<pod-name>.
Check parameters meaning at
http://kubernetes.io/docs/api-reference/v1/operations/,
part 'read log of the specified Pod'. The result is plain text.
"""
log_call = "log"
params = {}
if container is not None:
params["container"] = container
if pretty is not None:
params["pretty"] = pretty
if previous:
params["previous"] = "true"
if since_seconds is not None and since_time is None:
params["sinceSeconds"] = int(since_seconds)
elif since_time is not None and since_seconds is None:
params["sinceTime"] = since_time
if timestamps:
params["timestamps"] = "true"
if tail_lines is not None:
params["tailLines"] = int(tail_lines)
if limit_bytes is not None:
params["limitBytes"] = int(limit_bytes)
query_string = urlencode(params)
log_call += f"?{query_string}" if query_string else ""
kwargs = {
"version": self.version,
"namespace": self.namespace,
"operation": log_call,
}
r = self.api.get(**self.api_kwargs(**kwargs))
r.raise_for_status()
return r.text
class ReplicationController(NamespacedAPIObject, ReplicatedMixin, ScalableMixin):
version = "v1"
endpoint = "replicationcontrollers"
kind = "ReplicationController"
@property
def ready(self):
return (
self.obj["status"]["observedGeneration"]
>= self.obj["metadata"]["generation"]
and self.obj["status"]["readyReplicas"] == self.replicas
)
class ReplicaSet(NamespacedAPIObject, ReplicatedMixin, ScalableMixin):
version = "apps/v1"
endpoint = "replicasets"
kind = "ReplicaSet"
class Secret(NamespacedAPIObject):
version = "v1"
endpoint = "secrets"
kind = "Secret"
class Service(NamespacedAPIObject):
version = "v1"
endpoint = "services"
kind = "Service"
def proxy_http_request(
self, method: str, path: str, port: Optional[int] = None, **kwargs: Any
) -> Response:
"""Issue a HTTP request with specific HTTP method to proxy of a Service.
Args:
:param method: The http request method e.g. 'GET', 'POST' etc.
:param path: The URI path for the request.
:param port: This value can be used to override the
default (first defined) port used to connect to the Service.
:param kwargs: Keyword arguments for the proxy_http_get function.
They are the same as for requests.models.Request object.
Returns:
The requests.Response object.
"""
if port is None:
port = self.obj["spec"]["ports"][0]["port"]
kwargs["url"] = f"services/{self.name}:{port}/proxy/{path}"
kwargs["namespace"] = self.namespace
kwargs["version"] = self.version
return self.api.request(method, **kwargs)
def proxy_http_get(
self, path: str, port: Optional[int] = None, **kwargs
) -> Response:
"""Issue a HTTP GET request to proxy of a Service.
Args:
:param path: The URI path for the request.
:param port: This value can be used to override the
default (first defined) port used to connect to the Service.
:param kwargs: Keyword arguments for the proxy_http_get function.
They are the same as for requests.models.Request object
plus the additional 'port' kwarg, which can be used to override the
default (first defined) port used to connect to the Service.
Returns:
The requests.Response object.
"""
return self.proxy_http_request("GET", path, port, **kwargs)
def proxy_http_post(
self, path: str, port: Optional[int] = None, **kwargs
) -> Response:
"""Issue a HTTP POST request to proxy of a Service.
Args:
:param path: The URI path for the request.
:param port: This value can be used to override the
default (first defined) port used to connect to the Service.
:param kwargs: Keyword arguments for the proxy_http_get function.
They are the same as for requests.models.Request object
plus the additional 'port' kwarg, which can be used to override the
default (first defined) port used to connect to the Service.
Returns:
The requests.Response object.
"""
return self.proxy_http_request("POST", path, port, **kwargs)
def proxy_http_put(
self, path: str, port: Optional[int] = None, **kwargs
) -> Response:
"""Issue a HTTP PUT request to proxy of a Service.
Args:
:param path: The URI path for the request.
:param port: This value can be used to override the
default (first defined) port used to connect to the Service.
:param kwargs: Keyword arguments for the proxy_http_get function.
They are the same as for requests.models.Request object
plus the additional 'port' kwarg, which can be used to override the
default (first defined) port used to connect to the Service.
Returns:
The requests.Response object.
"""
return self.proxy_http_request("PUT", path, port, **kwargs)
def proxy_http_delete(
self, path: str, port: Optional[int] = None, **kwargs
) -> Response:
"""Issue a HTTP DELETE request to proxy of a Service.
Args:
:param path: The URI path for the request.
:param port: This value can be used to override the
default (first defined) port used to connect to the Service.
:param kwargs: Keyword arguments for the proxy_http_get function.
They are the same as for requests.models.Request object
plus the additional 'port' kwarg, which can be used to override the
default (first defined) port used to connect to the Service.
Returns:
The requests.Response object.
"""
return self.proxy_http_request("DELETE", path, port, **kwargs)
class PersistentVolume(APIObject):
version = "v1"
endpoint = "persistentvolumes"
kind = "PersistentVolume"
class PersistentVolumeClaim(NamespacedAPIObject):
version = "v1"
endpoint = "persistentvolumeclaims"
kind = "PersistentVolumeClaim"
class HorizontalPodAutoscaler(NamespacedAPIObject):
version = "autoscaling/v1"
endpoint = "horizontalpodautoscalers"
kind = "HorizontalPodAutoscaler"
class StatefulSet(NamespacedAPIObject, ReplicatedMixin, ScalableMixin):
version = "apps/v1"
endpoint = "statefulsets"
kind = "StatefulSet"
class Role(NamespacedAPIObject):
version = "rbac.authorization.k8s.io/v1"
endpoint = "roles"
kind = "Role"
class RoleBinding(NamespacedAPIObject):
version = "rbac.authorization.k8s.io/v1"
endpoint = "rolebindings"
kind = "RoleBinding"
class ClusterRole(APIObject):
version = "rbac.authorization.k8s.io/v1"
endpoint = "clusterroles"
kind = "ClusterRole"
class ClusterRoleBinding(APIObject):
version = "rbac.authorization.k8s.io/v1"
endpoint = "clusterrolebindings"
kind = "ClusterRoleBinding"
class PodSecurityPolicy(APIObject):
version = "policy/v1beta1"
endpoint = "podsecuritypolicies"
kind = "PodSecurityPolicy"
class PodDisruptionBudget(NamespacedAPIObject):
version = "policy/v1beta1"
endpoint = "poddisruptionbudgets"
kind = "PodDisruptionBudget"
class CustomResourceDefinition(APIObject):
version = "apiextensions.k8s.io/v1"
endpoint = "customresourcedefinitions"
kind = "CustomResourceDefinition"