cloudpilot/cli.py at main · fraware/cloudpilot · 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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
from __future__ import annotations

import argparse
import logging
import sys
from importlib.metadata import PackageNotFoundError, version

from cloudpilot.cost_optimizer import get_aws_cost_optimization
from cloudpilot.k8s_autotuner import tune_deployment
from cloudpilot.scaling import recommend_scaling

try:
    _VERSION = version("cloudpilot")
except PackageNotFoundError:
    _VERSION = "0.0.0-dev"


def main() -> None:
    logging.basicConfig(
        level=logging.INFO,
        format="%(levelname)s %(name)s: %(message)s",
    )
    parser = argparse.ArgumentParser(
        description="CloudPilot CLI Utility - AI-Driven Infrastructure Optimization"
    )
    parser.add_argument("--version", action="version", version=f"CloudPilot {_VERSION}")

    subparsers = parser.add_subparsers(dest="command", help="Sub-commands")

    parser_scale = subparsers.add_parser(
        "scale", help="Get scaling recommendation using the RL-based model."
    )
    parser_scale.add_argument(
        "--cpu",
        type=float,
        required=True,
        help="Average CPU utilization percentage (e.g., 75.0).",
    )
    parser_scale.add_argument(
        "--mem",
        type=float,
        required=True,
        help="Average memory utilization percentage (e.g., 65.0).",
    )
    parser_scale.add_argument(
        "--req",
        type=float,
        required=True,
        help="Average request rate (normalized or raw, e.g., 0.8).",
    )
    parser_scale.add_argument(
        "--latency",
        type=float,
        required=True,
        help="Average network latency in milliseconds (e.g., 100).",
    )
    parser_scale.add_argument(
        "--demand",
        type=float,
        required=True,
        help="Normalized user demand between 0 and 1 (e.g., 0.9).",
    )

    parser_cost = subparsers.add_parser(
        "cost", help="Get cost optimization recommendation for an AWS instance type."
    )
    parser_cost.add_argument(
        "--instance-type",
        type=str,
        default="m5.large",
        help="Current AWS instance type (default: m5.large).",
    )

    parser_tune = subparsers.add_parser(
        "tune", help="Auto-tune a Kubernetes deployment and check for anomalies."
    )
    parser_tune.add_argument(
        "--deployment",
        type=str,
        required=True,
        help="Name of the Kubernetes deployment.",
    )
    parser_tune.add_argument(
        "--namespace",
        type=str,
        default="default",
        help="Kubernetes namespace (default: 'default').",
    )

    args = parser.parse_args()

    if args.command == "scale":
        if not 0 <= args.demand <= 1:
            sys.exit("Error: --demand must be between 0 and 1.")
        recommendation = recommend_scaling(
            args.cpu, args.mem, args.req, args.latency, args.demand
        )
        print("Scaling Recommendation:", recommendation)
    elif args.command == "cost":
        recommendation = get_aws_cost_optimization(args.instance_type)
        print("Cost Optimization Recommendation:", recommendation)
    elif args.command == "tune":
        result = tune_deployment(args.deployment, args.namespace)
        print("Kubernetes Auto-Tuning Result:", result)
    else:
        parser.print_help()
        sys.exit(1)


if __name__ == "__main__":
    main()