caus/controller.py at main · t2-project/caus · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
import os
import time
from caus import CAUS, SimpleCAUS
from config import get_config
from kubernetes import client, config as kubernetes_config
from elasticity import Elasticity
from prometheusclient import PrometheusMonitor
from configparser import ConfigParser
from debug_controller import create_deployment

config: ConfigParser = get_config()

def scale_deployment(
    deployment: client.V1Deployment,
    caus: CAUS,
    elasticity: Elasticity,
    publishing_rate: float,
):
    desired_replicas, buffered_replicas = caus.calculate_replicas(
        publishing_rate, deployment.spec.replicas
    )
    print(
        f"Computed desired replicas: {desired_replicas} and buffered: {buffered_replicas}"
    )
    deployment.spec.replicas = desired_replicas
    elasticity.buffered_replicas = buffered_replicas


def main():
    print("Load kube config...")
    try:
        kubernetes_config.load_incluster_config()
    except kubernetes_config.ConfigException:
        print("didnt find incluster config, loading file manually...")
        kubernetes_config.load_kube_config(
            config_file=os.environ.get("KUBECONFIG", "k8s-cluster3-admin.conf")
        )

    # setup deployment, prometheus monitoring, scaling method etc
    # initialize necessary apis
    core_api = client.CoreV1Api()
    apis_api = client.AppsV1Api()
    deployment: client.V1Deployment = create_deployment()
    monitor = PrometheusMonitor()
    elasticity = Elasticity(
        capacity=config.getint("elasticity", "elastic-capacity", fallback=8),
        min_replicas=config.getint("elasticity", "elastic-min-replicas", fallback=1),
        max_replicas=config.getint("elasticity", "elastic-max-replicas", fallback=10),
        buffer_threshold=config.getfloat(
            "elasticity", "elastic-buffer-threshold", fallback=50.0
        ),
        initial_buffer=config.getint(
            "elasticity", "elastic-initial-buffer", fallback=1
        ),
        buffered_replicas=config.getint(
            "elasticity", "elastic-buffered-replicas", fallback=1
        ),
    )
    # setup scaling method, e.g: CAUS, ML-CAUS or others
    caus: CAUS = SimpleCAUS(elasticity)
    print(f"start {deployment.spec.replicas} replicas")

    timeout: float = config.getfloat("caus", "update-rate", fallback=10.0)
    # TODO update loop
    while True:
        scale_deployment(
            deployment,
            caus,
            elasticity,
            float(monitor.get_current_metric_value()),
        )
        time.sleep(timeout)


if __name__ == "__main__":
    main()