mirror of
https://github.com/hanzo-ml/kuberay.git
synced 2026-10-30 19:48:47 +00:00
API server already provides support for Ray Job, but its usage is not very convenient for Python developer. Its not easy to get execution log, stop running job, etc. This functionality is provided by Ray job submission API, but requires knowledge about endpoint and corresponding security when used outside the cluster. This implementation provides all the functionality through the API server (with the well known URL) and corresponding Python client --------- Signed-off-by: Anish Asthana <[email protected]> Signed-off-by: Boris Lublinsky <[email protected]> Co-authored-by: ted chang <[email protected]> Co-authored-by: Anish Asthana <[email protected]> Co-authored-by: David Xia <[email protected]> Co-authored-by: Antonin Stefanutti <[email protected]> Co-authored-by: Laurentiu Bradin <[email protected]> Co-authored-by: Kai-Hsun Chen <[email protected]>
194 lines
8.3 KiB
Python
194 lines
8.3 KiB
Python
from .headnode import *
|
|
from .workernode import *
|
|
|
|
class Environment(enum.Enum):
|
|
DEV = 0
|
|
TESTING = 1
|
|
STAGING = 2
|
|
PRODUCTION = 3
|
|
|
|
|
|
class ClusterSpec:
|
|
"""
|
|
ClusterSpec is used to define Ray cluster.
|
|
It provides APIs to create, stringify, convert to dict and json.
|
|
|
|
Methods:
|
|
- Create cluster spec from: gets the following parameters:
|
|
head_group_spec - required, specification of the head node
|
|
worker_group_spec - optional, list of worker group specs
|
|
- to_string() -> str: convert toleration to string for printing
|
|
- to_dict() -> dict[str, any] convert to dict
|
|
"""
|
|
def __init__(self, head_node: HeadNodeSpec, worker_groups: list[WorkerNodeSpec] = None) -> None:
|
|
self.head_node = head_node
|
|
self.worker_groups = worker_groups
|
|
|
|
def to_string(self) -> str:
|
|
val = f"head_group_spec: {self.head_node.to_string()}"
|
|
if self.worker_groups is not None:
|
|
val += "\nworker groups: "
|
|
for w in self.worker_groups:
|
|
val += f"\nworker_group_spec = {w.to_string()}]"
|
|
return val
|
|
|
|
def to_dict(self) -> dict[str, any]:
|
|
dst = {"headGroupSpec": self.head_node.to_dict()}
|
|
if self.worker_groups is not None:
|
|
dst["workerGroupSpec"] = [w.to_dict() for w in self.worker_groups]
|
|
return dst
|
|
|
|
|
|
class ClusterEvent:
|
|
"""
|
|
Cluster event is used to define events emitted during cluster creation.
|
|
It provides APIs to create and stringify. Its output only data, so we do not need to implement to_dict
|
|
|
|
Methods:
|
|
- Create event: gets the dictionary with the following parameters:
|
|
id - unique Event Id
|
|
name - human readable event name
|
|
created_at - event creation time
|
|
first_timestamp - first time the event occur
|
|
last_timestamp - last time the event occur
|
|
reason - reason for the transition into the object's current status
|
|
message - human-readable description of the status of this operation
|
|
type - type of this event (Normal, Warning), new types could be added in the future
|
|
count - number of times this event has occurred
|
|
"""
|
|
def __init__(self, dst: dict[str, any]) -> None:
|
|
self.id = dst.get("id", "")
|
|
self.name = dst.get("name", "")
|
|
self.created_at = dst.get("created_at", "")
|
|
self.first_timestamp = dst.get("first_timestamp", "")
|
|
self.last_timestamp = dst.get("last_timestamp", "")
|
|
self.reason = dst.get("reason", "")
|
|
self.message = dst.get("message", "")
|
|
self.type = dst.get("type", "")
|
|
self.count = dst.get("count", "0")
|
|
|
|
def to_string(self) -> str:
|
|
return (f"id = {self.id}, name = {self.name}, created_at = {self.created_at}, "
|
|
f"first_timestamp = {self.first_timestamp}, last_timestamp = {self.last_timestamp},"
|
|
f"reason = {self.reason}, message = {self.message}, type = {self.type}, count = {self.count}")
|
|
|
|
|
|
class Cluster:
|
|
"""
|
|
Cluster is used to define Ray cluster.
|
|
It provides APIs to create, stringify, convert to dict and json.
|
|
|
|
Methods:
|
|
- Create env variable from: gets the following parameters:
|
|
name - required, unique (per namespace) cluster name
|
|
namespace - required, cluster's namespace (should exist)
|
|
user - required, user who owns the cluster
|
|
version - required, Ray cluster version - typically Ray version
|
|
deployment_environment - optional (see Environment)
|
|
cluster_spec - required, ray cluster configuration
|
|
annotations - optional, annotations, for example, "kubernetes.io/ingress.class" to define Ingress class
|
|
cluster_environment - optional, cluster environment variables
|
|
created_at - output, cluster creation ts
|
|
deleted_at - output, cluster deletion ts
|
|
cluster_status - output, cluster status
|
|
events - output, cluster events
|
|
service_endpoint - output, cluster service endpoints
|
|
- to_string() -> str: convert toleration to string for printing
|
|
- to_dict() -> dict[str, any] convert to dict
|
|
"""
|
|
def __init__(self, name: str, namespace: str, user: str, version: str, cluster_spec: ClusterSpec,
|
|
deployment_environment: Environment = None, annotations: dict[str, str] = None,
|
|
cluster_environment: EnvironmentVariables = None, created_at: str = None,
|
|
deleted_at: str = None, cluster_status: str = None, events: list[ClusterEvent] = None,
|
|
service_endpoint: dict[str, str] = None) -> None:
|
|
self.name = name
|
|
self.namespace = namespace
|
|
self.user = user
|
|
self.version = version
|
|
self.cluster_spec = cluster_spec
|
|
self.environment = deployment_environment
|
|
self.annotations = annotations
|
|
self.envs = cluster_environment
|
|
self.created_at = created_at
|
|
self.deleted_at = deleted_at
|
|
self.cluster_status = cluster_status
|
|
self.events = events
|
|
self.service_endpoint = service_endpoint
|
|
|
|
def to_string(self) -> str:
|
|
val = (f"name: {self.name}, namespace = {self.namespace}, user = {self.user}, version = {self.version} "
|
|
f"cluster_spec = {self.cluster_spec.to_string()}")
|
|
if self.environment is not None:
|
|
val += f"deployment environment = {self.environment.name}"
|
|
if self.annotations is not None:
|
|
val += f" ,annotations = {str(self.annotations)}"
|
|
if self.envs is not None:
|
|
val = val + f",cluster environment = {self.envs.to_string()}"
|
|
val += "\ncluster output\n"
|
|
if self.created_at is not None:
|
|
val += f" ,created_at = {self.created_at}"
|
|
if self.deleted_at is not None:
|
|
val += f" ,deleted_at = {self.deleted_at}"
|
|
if self.cluster_status is not None:
|
|
val += f" ,cluster status = {self.cluster_status}"
|
|
if self.events is not None:
|
|
val = val + ",\n cluster events = ["
|
|
first = True
|
|
for e in self.events:
|
|
if first:
|
|
first = False
|
|
else:
|
|
val += ", "
|
|
val = val + "{" + e.to_string() + "}"
|
|
val = val + "]"
|
|
if self.service_endpoint is not None:
|
|
val += f" ,service endpoints = {str(self.service_endpoint)}"
|
|
return val
|
|
|
|
def to_dict(self) -> dict[str, any]:
|
|
# only convert input variables
|
|
dst = {"name": self.name, "namespace": self.namespace, "user": self.user, "version": self.version,
|
|
"clusterSpec": self.cluster_spec.to_dict()}
|
|
if self.environment is not None:
|
|
dst["environment"] = self.environment.value
|
|
if self.annotations is not None:
|
|
dst["annotations"] = self.annotations
|
|
if self.envs is not None:
|
|
dst["envs"] = self.envs.to_dict()
|
|
return dst
|
|
|
|
|
|
"""
|
|
Creates new cluster from dictionary, used for unmarshalling json. Python does not
|
|
support multiple constructors, so do it this way
|
|
"""
|
|
|
|
|
|
def cluster_spec_decoder(dct: dict[str, any]) -> ClusterSpec:
|
|
workers = None
|
|
if "workerGroupSpec" in dct:
|
|
workers = [worker_node_spec_decoder(w) for w in dct["workerGroupSpec"]]
|
|
return ClusterSpec(head_node=head_node_spec_decoder(dct.get("headGroupSpec")), worker_groups=workers)
|
|
|
|
|
|
def cluster_decoder(dct: dict[str, any]) -> Cluster:
|
|
environment = None
|
|
if "environment" in dct:
|
|
environment = Environment(int(dct.get("environment", "0")))
|
|
events = None
|
|
if "events" in dct:
|
|
events = [ClusterEvent(c) for c in dct["events"]]
|
|
envs = None
|
|
if "envs" in dct:
|
|
envs = environmentvariables_decoder(dct.get("envs"))
|
|
return Cluster(name=dct.get("name", ""), namespace=dct.get("namespace", ""), user=dct.get("user", ""),
|
|
version=dct.get("version", ""), cluster_spec=cluster_spec_decoder(dct.get("clusterSpec")),
|
|
deployment_environment=environment, annotations=dct.get("annotations"),
|
|
cluster_environment=envs, created_at=dct.get("createdAt"), deleted_at=dct.get("deletedAt"),
|
|
cluster_status=dct.get("clusterState"), events=events,
|
|
service_endpoint=dct.get("serviceEndpoint"))
|
|
|
|
|
|
def clusters_decoder(dct: dict[str, any]) -> list[Cluster]:
|
|
return [cluster_decoder(cluster) for cluster in dct["clusters"]]
|