opengris-scaler 1.12.28__cp313-cp313-musllinux_1_2_x86_64.whl

scaler/entry_points/scheduler.py

@@ -0,0 +1,144 @@
+import argparse
+
+from scaler.cluster.object_storage_server import ObjectStorageServerProcess
+from scaler.cluster.scheduler import SchedulerProcess
+from scaler.config.loader import load_config
+from scaler.config.section.scheduler import SchedulerConfig
+from scaler.config.types.object_storage_server import ObjectStorageConfig
+from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
+from scaler.scheduler.controllers.scaling_policies.types import ScalingControllerStrategy
+from scaler.utility.event_loop import EventLoopType
+from scaler.utility.network_util import get_available_tcp_port
+
+
+def get_args():
+    parser = argparse.ArgumentParser("scaler_scheduler", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument("--config", "-c", type=str, default=None, help="Path to the TOML configuration file.")
+    parser.add_argument("--io-threads", type=int, help="number of io threads for zmq")
+    parser.add_argument(
+        "--max-number-of-tasks-waiting",
+        "-mt",
+        type=int,
+        help="max number of tasks can wait in scheduler while all workers are full",
+    )
+    parser.add_argument("--client-timeout-seconds", "-ct", type=int, help="discard client when timeout seconds reached")
+    parser.add_argument("--worker-timeout-seconds", "-wt", type=int, help="discard worker when timeout seconds reached")
+    parser.add_argument(
+        "--object-retention-seconds", "-ot", type=int, help="discard function in scheduler when timeout seconds reached"
+    )
+    parser.add_argument(
+        "--load-balance-seconds", "-ls", type=int, help="number of seconds for load balance operation in scheduler"
+    )
+    parser.add_argument(
+        "--load-balance-trigger-times",
+        "-lbt",
+        type=int,
+        help="exact number of repeated load balance advices when trigger load balance operation in scheduler",
+    )
+    parser.add_argument("--event-loop", "-e", choices=EventLoopType.allowed_types(), help="select event loop type")
+    parser.add_argument(
+        "--protected", "-p", action="store_true", help="protect scheduler and worker from being shutdown by client"
+    )
+    parser.add_argument(
+        "--allocate-policy",
+        "-ap",
+        choices=[p.name for p in AllocatePolicy],
+        help="specify allocate policy, this controls how scheduler will prioritize tasks, including balancing tasks",
+    )
+    parser.add_argument(
+        "--logging-paths",
+        "-lp",
+        nargs="*",
+        type=str,
+        help="specify where scheduler log should logged to, it can accept multiple files, default is /dev/stdout",
+    )
+    parser.add_argument("--logging-level", "-ll", type=str, help="specify the logging level")
+    parser.add_argument(
+        "--logging-config-file",
+        "-lc",
+        type=str,
+        help="use standard python the .conf file the specify python logging file configuration format, this will "
+        "bypass --logging-path",
+    )
+    parser.add_argument(
+        "--object-storage-address",
+        "-osa",
+        type=str,
+        help="specify the object storage server address, if not specified, the address is scheduler address with port "
+        "number plus 1, e.g.: if scheduler address is tcp://localhost:2345, then object storage address is "
+        "tcp://localhost:2346",
+    )
+    parser.add_argument(
+        "--monitor-address",
+        "-ma",
+        type=str,
+        help="specify monitoring address, if not specified, the monitoring address is scheduler address with port "
+        "number plus 2, e.g.: if scheduler address is tcp://localhost:2345, then monitoring address is "
+        "tcp://localhost:2347",
+    )
+    parser.add_argument(
+        "--scaling-controller-strategy",
+        "-scs",
+        choices=[s.name for s in ScalingControllerStrategy],
+        help="specify the scaling controller strategy, if not specified, no scaling controller will be used",
+    )
+    parser.add_argument(
+        "--adapter-webhook-urls",
+        "-awu",
+        nargs="*",
+        type=str,
+        help="specify the adapter webhook urls for the scaling controller to send scaling events to",
+    )
+    parser.add_argument(
+        "scheduler_address", nargs="?", type=str, help="scheduler address to connect to, e.g.: `tcp://localhost:6378`"
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = get_args()
+
+    scheduler_config = load_config(SchedulerConfig, args.config, args, section_name="scheduler")
+
+    object_storage_address = scheduler_config.object_storage_address
+    object_storage = None
+
+    if object_storage_address is None:
+        object_storage_address = ObjectStorageConfig(
+            host=scheduler_config.scheduler_address.host, port=get_available_tcp_port()
+        )
+        object_storage = ObjectStorageServerProcess(
+            object_storage_address=object_storage_address,
+            logging_paths=scheduler_config.logging_paths,
+            logging_config_file=scheduler_config.logging_config_file,
+            logging_level=scheduler_config.logging_level,
+        )
+        object_storage.start()
+        object_storage.wait_until_ready()  # object storage should be ready before starting the cluster
+
+    scheduler = SchedulerProcess(
+        address=scheduler_config.scheduler_address,
+        object_storage_address=object_storage_address,
+        monitor_address=scheduler_config.monitor_address,
+        scaling_controller_strategy=scheduler_config.scaling_controller_strategy,
+        adapter_webhook_urls=scheduler_config.adapter_webhook_urls,
+        io_threads=scheduler_config.io_threads,
+        max_number_of_tasks_waiting=scheduler_config.max_number_of_tasks_waiting,
+        client_timeout_seconds=scheduler_config.client_timeout_seconds,
+        worker_timeout_seconds=scheduler_config.worker_timeout_seconds,
+        object_retention_seconds=scheduler_config.object_retention_seconds,
+        load_balance_seconds=scheduler_config.load_balance_seconds,
+        load_balance_trigger_times=scheduler_config.load_balance_trigger_times,
+        protected=scheduler_config.protected,
+        allocate_policy=scheduler_config.allocate_policy,
+        event_loop=scheduler_config.event_loop,
+        logging_paths=scheduler_config.logging_paths,
+        logging_config_file=scheduler_config.logging_config_file,
+        logging_level=scheduler_config.logging_level,
+    )
+    scheduler.start()
+
+    scheduler.join()
+    if object_storage is not None:
+        object_storage.join()

scaler/entry_points/top.py

@@ -0,0 +1,286 @@
+import argparse
+import curses
+import functools
+from typing import Dict, List, Literal, Union
+
+from scaler.config.loader import load_config
+from scaler.config.section.top import TopConfig
+from scaler.io.sync_subscriber import ZMQSyncSubscriber
+from scaler.protocol.python.message import StateScheduler
+from scaler.protocol.python.mixins import Message
+from scaler.utility.formatter import (
+    format_bytes,
+    format_integer,
+    format_microseconds,
+    format_percentage,
+    format_seconds,
+)
+
+SORT_BY_OPTIONS = {
+    ord("g"): "group",
+    ord("n"): "worker",
+    ord("C"): "agt_cpu",
+    ord("M"): "agt_rss",
+    ord("c"): "cpu",
+    ord("m"): "rss",
+    ord("F"): "rss_free",
+    ord("f"): "free",
+    ord("w"): "sent",
+    ord("d"): "queued",
+    ord("s"): "suspended",
+    ord("l"): "lag",
+}
+
+SORT_BY_STATE: Dict[str, Union[str, bool]] = {"sort_by": "cpu", "sort_by_previous": "cpu", "sort_reverse": True}
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        "monitor scheduler as top like", formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument("--config", "-c", type=str, default=None, help="Path to the TOML configuration file.")
+    parser.add_argument("--timeout", "-t", type=int, help="timeout seconds")
+    parser.add_argument("monitor_address", nargs="?", type=str, help="scheduler monitor address to connect to")
+    return parser.parse_args()
+
+
+def main():
+    args = get_args()
+    top_config = load_config(TopConfig, args.config, args, section_name="top")
+    curses.wrapper(poke, top_config)
+
+
+def poke(screen, config: TopConfig):
+    screen.nodelay(1)
+
+    try:
+        subscriber = ZMQSyncSubscriber(
+            address=config.monitor_address,
+            callback=functools.partial(show_status, screen=screen),
+            topic=b"",
+            daemonic=False,
+            timeout_seconds=config.timeout,
+        )
+        subscriber.run()
+    except KeyboardInterrupt:
+        pass
+
+
+def show_status(status: Message, screen):
+    if not isinstance(status, StateScheduler):
+        return
+
+    __change_option_state(screen.getch())
+
+    scheduler_table = __generate_keyword_data(
+        "scheduler",
+        {
+            "cpu": format_percentage(status.scheduler.cpu),
+            "rss": format_bytes(status.scheduler.rss),
+            "rss_free": format_bytes(status.rss_free),
+        },
+    )
+
+    task_manager_table = __generate_keyword_data(
+        "task_manager",
+        dict(sorted((k.name, v) for k, v in status.task_manager.state_to_count.items())),
+        format_integer_flag=True,
+    )
+    object_manager = __generate_keyword_data("object_manager", {"num_of_objs": status.object_manager.number_of_objects})
+    sent_table = __generate_keyword_data("scheduler_sent", status.binder.sent, format_integer_flag=True)
+    received_table = __generate_keyword_data("scheduler_received", status.binder.received, format_integer_flag=True)
+    client_table = __generate_keyword_data(
+        "client_manager", status.client_manager.client_to_num_of_tasks, key_col_length=18
+    )
+
+    worker_group_map = {}
+    if status.scaling_manager.worker_groups:
+        for worker_group_id, worker_ids in status.scaling_manager.worker_groups.items():
+            worker_group_id_str = worker_group_id.decode()
+            for worker_id in worker_ids:
+                worker_group_map[worker_id.decode()] = worker_group_id_str
+
+    # Include 'group' as the first column for each worker; empty if not found
+    worker_manager_table = __generate_worker_manager_table(
+        [
+            {
+                "group": worker_group_map.get(worker.worker_id.decode(), ""),
+                "worker": worker.worker_id.decode(),
+                "agt_cpu": worker.agent.cpu,
+                "agt_rss": worker.agent.rss,
+                "cpu": sum(p.resource.cpu for p in worker.processor_statuses),
+                "rss": sum(p.resource.rss for p in worker.processor_statuses),
+                "os_rss_free": worker.rss_free,
+                "free": worker.free,
+                "sent": worker.sent,
+                "queued": worker.queued,
+                "suspended": worker.suspended,
+                "lag": worker.lag_us,
+                "last": worker.last_s,
+                "ITL": worker.itl,
+            }
+            for worker in status.worker_manager.workers
+        ],
+        worker_group_length=10,
+        worker_length=20,
+    )
+
+    table1 = __merge_tables(scheduler_table, object_manager, padding="|")
+    table1 = __merge_tables(table1, task_manager_table, padding="|")
+    table1 = __merge_tables(table1, sent_table, padding="|")
+    table1 = __merge_tables(table1, received_table, padding="|")
+
+    table3 = __merge_tables(worker_manager_table, client_table, padding="|")
+
+    screen.clear()
+    try:
+        new_row, max_cols = __print_table(screen, 0, table1, padding=1)
+    except curses.error:
+        __print_too_small(screen)
+        return
+
+    try:
+        screen.addstr(new_row, 0, "-" * max_cols)
+        screen.addstr(new_row + 1, 0, "Shortcuts: " + " ".join([f"{v}[{chr(k)}]" for k, v in SORT_BY_OPTIONS.items()]))
+        screen.addstr(
+            new_row + 3,
+            0,
+            f"Total {len(status.scaling_manager.worker_groups)} worker group(s) "
+            f"with {len(status.worker_manager.workers)} worker(s)",
+        )
+        _ = __print_table(screen, new_row + 4, table3)
+    except curses.error:
+        pass
+
+    screen.refresh()
+
+
+def __generate_keyword_data(title, data, key_col_length: int = 0, format_integer_flag: bool = False):
+    table = [[title, ""]]
+
+    def format_integer_func(value):
+        if format_integer_flag:
+            return format_integer(value)
+
+        return value
+
+    table.extend([[__truncate(k, key_col_length), format_integer_func(v)] for k, v in data.items()])
+    return table
+
+
+def __generate_worker_manager_table(
+    wm_data: List[Dict], worker_group_length: int, worker_length: int
+) -> List[List[str]]:
+    if not wm_data:
+        headers = [["No workers"]]
+        return headers
+
+    wm_data = sorted(
+        wm_data, key=lambda item: item[SORT_BY_STATE["sort_by"]], reverse=bool(SORT_BY_STATE["sort_reverse"])
+    )
+
+    for row in wm_data:
+        row["group"] = __truncate(row["group"], worker_group_length, how="left")
+        row["worker"] = __truncate(row["worker"], worker_length, how="left")
+        row["agt_cpu"] = format_percentage(row["agt_cpu"])
+        row["agt_rss"] = format_bytes(row["agt_rss"])
+        row["cpu"] = format_percentage(row["cpu"])
+        row["rss"] = format_bytes(row["rss"])
+        row["os_rss_free"] = format_bytes(row["os_rss_free"])
+
+        last = row.pop("last")
+        last = f"({format_seconds(last)}) " if last > 5 else ""
+        row["lag"] = last + format_microseconds(row["lag"])
+
+    worker_manager_table = [[f"[{v}]" if v == SORT_BY_STATE["sort_by"] else v for v in wm_data[0].keys()]]
+    worker_manager_table.extend([list(worker.values()) for worker in wm_data])
+    return worker_manager_table
+
+
+def __print_table(screen, line_number, data, padding: int = 1):
+    if not data:
+        return
+
+    col_widths = [max(len(str(row[i])) for row in data) for i in range(len(data[0]))]
+
+    for i, header in enumerate(data[0]):
+        screen.addstr(line_number, sum(col_widths[:i]) + (padding * i), str(header).rjust(col_widths[i]))
+
+    for i, row in enumerate(data[1:], start=1):
+        for j, cell in enumerate(row):
+            screen.addstr(line_number + i, sum(col_widths[:j]) + (padding * j), str(cell).rjust(col_widths[j]))
+
+    return line_number + len(data), sum(col_widths) + (padding * len(col_widths))
+
+
+def __merge_tables(left: List[List], right: List[List], padding: str = "") -> List[List]:
+    if not left:
+        return right
+
+    if not right:
+        return left
+
+    result = []
+    for i in range(max(len(left), len(right))):
+        if i < len(left):
+            left_row = left[i]
+        else:
+            left_row = [""] * len(left[0])
+
+        if i < len(right):
+            right_row = right[i]
+        else:
+            right_row = [""] * len(right[0])
+
+        if padding:
+            padding_column = [padding]
+            result.append(left_row + padding_column + right_row)
+        else:
+            result.append(left_row + right_row)
+
+    return result
+
+
+def __concat_tables(up: List[List], down: List[List], padding: int = 1) -> List[List]:
+    max_cols = max([len(row) for row in up] + [len(row) for row in down])
+    for row in up:
+        row.extend([""] * (max_cols - len(row)))
+
+    padding_rows = [[""] * max_cols] * padding
+
+    for row in down:
+        row.extend([""] * (max_cols - len(row)))
+
+    return up + padding_rows + down
+
+
+def __truncate(string: str, number: int, how: Literal["left", "right"] = "left") -> str:
+    if number <= 0:
+        return string
+
+    if len(string) <= number:
+        return string
+
+    if how == "left":
+        return f"{string[:number]}+"
+    else:
+        return f"+{string[-number:]}"
+
+
+def __print_too_small(screen):
+    screen.clear()
+    screen.addstr(0, 0, "Your terminal is too small to show")
+    screen.refresh()
+
+
+def __change_option_state(option: int):
+    if option not in SORT_BY_OPTIONS.keys():
+        return
+
+    SORT_BY_STATE["sort_by_previous"] = SORT_BY_STATE["sort_by"]
+    SORT_BY_STATE["sort_by"] = SORT_BY_OPTIONS[option]
+    if SORT_BY_STATE["sort_by"] != SORT_BY_STATE["sort_by_previous"]:
+        SORT_BY_STATE["sort_reverse"] = True
+        return
+
+    SORT_BY_STATE["sort_reverse"] = not SORT_BY_STATE["sort_reverse"]

scaler/entry_points/webui.py

@@ -0,0 +1,48 @@
+import argparse
+
+from scaler.config.loader import load_config
+from scaler.config.section.webui import WebUIConfig
+from scaler.ui.webui import start_webui
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        "web ui for scaler monitoring", formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument("--config", "-c", type=str, default=None, help="Path to the TOML configuration file.")
+    parser.add_argument("--web-host", type=str, help="host for webserver to connect to")
+    parser.add_argument("--web-port", type=int, help="port for webserver to connect to")
+    parser.add_argument(
+        "--logging-paths",
+        "-lp",
+        nargs="*",
+        type=str,
+        help="specify where webui log should be logged to, it can accept multiple files, default is /dev/stdout",
+    )
+    parser.add_argument("--logging-level", "-ll", type=str, help="specify the logging level")
+    parser.add_argument(
+        "--logging-config-file",
+        "-lc",
+        type=str,
+        help="use standard python the .conf file the specify python logging file configuration format, this will "
+        "bypass --logging-path",
+    )
+    parser.add_argument("monitor_address", nargs="?", type=str, help="scheduler monitor address to connect to")
+    return parser.parse_args()
+
+
+def main():
+    args = get_args()
+
+    webui_config = load_config(WebUIConfig, args.config, args, section_name="webui")
+
+    assert webui_config.monitor_address is not None, "scheduler monitor address has to be set"
+
+    start_webui(
+        webui_config.monitor_address.to_address(),
+        webui_config.web_host,
+        webui_config.web_port,
+        logging_paths=webui_config.logging_paths,
+        logging_config_file=webui_config.logging_config_file,
+        logging_level=webui_config.logging_level,
+    )

scaler/entry_points/worker_adapter_ecs.py

@@ -0,0 +1,191 @@
+import argparse
+import os
+
+from aiohttp import web
+
+from scaler.config import defaults
+from scaler.config.loader import load_config
+from scaler.config.section.ecs_worker_adapter import ECSWorkerAdapterConfig
+from scaler.utility.event_loop import EventLoopType, register_event_loop
+from scaler.utility.logging.utility import setup_logger
+from scaler.worker_adapter.ecs import ECSWorkerAdapter
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        "scaler ECS worker adapter", formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument("--config", "-c", type=str, default=None, help="Path to the TOML configuration file.")
+
+    # Server configuration (match dataclass field names)
+    parser.add_argument("--adapter-web-host", type=str, help="host address for the ecs worker adapter HTTP server")
+    parser.add_argument("--adapter-web-port", "-p", type=int, help="port for the ecs worker adapter HTTP server")
+
+    # AWS / ECS configuration
+    parser.add_argument(
+        "--aws-access-key-id",
+        type=str,
+        default=os.environ.get("AWS_ACCESS_KEY_ID"),
+        help="AWS access key id (or set AWS_ACCESS_KEY_ID env)",
+    )
+    parser.add_argument(
+        "--aws-secret-access-key",
+        type=str,
+        default=os.environ.get("AWS_SECRET_ACCESS_KEY"),
+        help="AWS secret access key (or set AWS_SECRET_ACCESS_KEY env)",
+    )
+    parser.add_argument("--aws-region", type=str, default="us-east-1", help="AWS region for ECS cluster")
+    parser.add_argument("--ecs-cluster", type=str, help="ECS cluster name")
+    parser.add_argument("--ecs-task-image", type=str, help="Container image used for ECS tasks")
+    parser.add_argument("--ecs-python-requirements", type=str, help="Python requirements string passed to the ECS task")
+    parser.add_argument("--ecs-python-version", type=str, help="Python version for ECS task")
+    parser.add_argument("--ecs-task-definition", type=str, help="ECS task definition")
+    parser.add_argument("--ecs-task-cpu", type=int, help="Number of vCPUs for task (used to derive worker count)")
+    parser.add_argument("--ecs-task-memory", type=int, help="Task memory in GB for Fargate")
+    parser.add_argument("--ecs-subnets", type=str, help="Comma-separated list of AWS subnet IDs for ECS tasks")
+
+    # Worker configuration
+    parser.add_argument(
+        "--io-threads", "-it", type=int, default=defaults.DEFAULT_IO_THREADS, help="number of io threads for zmq"
+    )
+    parser.add_argument(
+        "--per-worker-capabilities",
+        "-pwc",
+        type=str,
+        help='comma-separated capabilities provided by the workers (e.g. "-pwc linux,cpu=4")',
+    )
+    parser.add_argument("--per-worker-task-queue-size", "-wtqs", type=int, help="specify worker queue size")
+    parser.add_argument(
+        "--max-instances",
+        "-mi",
+        type=int,
+        help="maximum number of ECS task instances that can be started, required to avoid unexpected surprise bills, "
+        "-1 means no limit",
+    )
+    parser.add_argument(
+        "--heartbeat-interval-seconds",
+        "-hi",
+        type=int,
+        default=defaults.DEFAULT_HEARTBEAT_INTERVAL_SECONDS,
+        help="number of seconds that worker agent send heartbeat to scheduler",
+    )
+    parser.add_argument(
+        "--task-timeout-seconds",
+        "-tt",
+        type=int,
+        default=defaults.DEFAULT_TASK_TIMEOUT_SECONDS,
+        help="default task timeout seconds, 0 means never timeout",
+    )
+    parser.add_argument(
+        "--death-timeout-seconds",
+        "-dt",
+        type=int,
+        default=defaults.DEFAULT_WORKER_DEATH_TIMEOUT,
+        help="number of seconds without scheduler contact before worker shuts down",
+    )
+    parser.add_argument(
+        "--garbage-collect-interval-seconds",
+        "-gc",
+        type=int,
+        default=defaults.DEFAULT_GARBAGE_COLLECT_INTERVAL_SECONDS,
+        help="number of seconds worker doing garbage collection",
+    )
+    parser.add_argument(
+        "--trim-memory-threshold-bytes",
+        "-tm",
+        type=int,
+        default=defaults.DEFAULT_TRIM_MEMORY_THRESHOLD_BYTES,
+        help="number of bytes threshold for worker process that trigger deep garbage collection",
+    )
+    parser.add_argument(
+        "--hard-processor-suspend",
+        "-hps",
+        action="store_true",
+        default=defaults.DEFAULT_HARD_PROCESSOR_SUSPEND,
+        help="if true, suspended worker's processors will be actively suspended with a SIGTSTP signal",
+    )
+    parser.add_argument(
+        "--event-loop", "-e", default="builtin", choices=EventLoopType.allowed_types(), help="select event loop type"
+    )
+    parser.add_argument(
+        "--logging-paths",
+        "-lp",
+        nargs="*",
+        type=str,
+        default=("/dev/stdout",),
+        help="specify where worker logs should be logged to, it can accept multiple files, default is /dev/stdout",
+    )
+    parser.add_argument(
+        "--logging-level",
+        "-ll",
+        type=str,
+        choices=("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"),
+        default="INFO",
+        help="specify the logging level",
+    )
+    parser.add_argument(
+        "--logging-config-file",
+        "-lc",
+        type=str,
+        default=None,
+        help="use standard python .conf file to specify python logging file configuration format",
+    )
+    parser.add_argument(
+        "--object-storage-address",
+        "-osa",
+        type=str,
+        default=None,
+        help="specify the object storage server address, e.g.: tcp://localhost:2346",
+    )
+    parser.add_argument("scheduler_address", nargs="?", type=str, help="scheduler address to connect workers to")
+
+    return parser.parse_args()
+
+
+def main():
+    args = get_args()
+
+    ecs_config = load_config(ECSWorkerAdapterConfig, args.config, args, section_name="ecs_worker_adapter")
+
+    # If ecs_subnets was provided as a comma-separated string on CLI, convert to list
+    if isinstance(ecs_config.ecs_subnets, str):
+        ecs_config.ecs_subnets = [s for s in ecs_config.ecs_subnets.split(",") if s]
+
+    register_event_loop(ecs_config.event_loop)
+
+    setup_logger(ecs_config.logging_paths, ecs_config.logging_config_file, ecs_config.logging_level)
+
+    ecs_worker_adapter = ECSWorkerAdapter(
+        address=ecs_config.scheduler_address,
+        object_storage_address=ecs_config.object_storage_address,
+        capabilities=ecs_config.per_worker_capabilities.capabilities,
+        io_threads=ecs_config.io_threads,
+        per_worker_task_queue_size=ecs_config.per_worker_task_queue_size,
+        max_instances=ecs_config.max_instances,
+        heartbeat_interval_seconds=ecs_config.heartbeat_interval_seconds,
+        task_timeout_seconds=ecs_config.task_timeout_seconds,
+        death_timeout_seconds=ecs_config.death_timeout_seconds,
+        garbage_collect_interval_seconds=ecs_config.garbage_collect_interval_seconds,
+        trim_memory_threshold_bytes=ecs_config.trim_memory_threshold_bytes,
+        hard_processor_suspend=ecs_config.hard_processor_suspend,
+        event_loop=ecs_config.event_loop,
+        aws_access_key_id=ecs_config.aws_access_key_id,
+        aws_secret_access_key=ecs_config.aws_secret_access_key,
+        aws_region=ecs_config.aws_region,
+        ecs_subnets=ecs_config.ecs_subnets,
+        ecs_cluster=ecs_config.ecs_cluster,
+        ecs_task_image=ecs_config.ecs_task_image,
+        ecs_python_requirements=ecs_config.ecs_python_requirements,
+        ecs_python_version=ecs_config.ecs_python_version,
+        ecs_task_definition=ecs_config.ecs_task_definition,
+        ecs_task_cpu=ecs_config.ecs_task_cpu,
+        ecs_task_memory=ecs_config.ecs_task_memory,
+    )
+
+    app = ecs_worker_adapter.create_app()
+    web.run_app(app, host=ecs_config.adapter_web_host, port=ecs_config.adapter_web_port)
+
+
+if __name__ == "__main__":
+    main()