code: def start_http_server(
      bento_identifier: str,
      runner_map: dict[str, str],
      working_dir: str,
      port: int = Provide[BentoMLContainer.api_server_config.port],
      host: str = Provide[BentoMLContainer.api_server_config.host],
      backlog: int = Provide[
          BentoMLContainer.api_server_config.backlog
      ],
      api_workers: int = Provide[BentoMLContainer.api_server_workers],
      timeout: int | None = None,
      ssl_certfile: str | None = Provide[BentoMLContainer.ssl.certfile],
      ssl_keyfile: str | None = Provide[BentoMLContainer.ssl.keyfile],
      ssl_keyfile_password: str
      | None = Provide[BentoMLContainer.ssl.keyfile_password],
      ssl_version: int | None = Provide[BentoMLContainer.ssl.version],
      ssl_cert_reqs: int
      | None = Provide[BentoMLContainer.ssl.cert_reqs],
      ssl_ca_certs: str | None = Provide[BentoMLContainer.ssl.ca_certs],
      ssl_ciphers: str | None = Provide[BentoMLContainer.ssl.ciphers],
  ) -> None:
      from .serve import ensure_prometheus_dir
  
      prometheus_dir = ensure_prometheus_dir()
  
      from circus.sockets import CircusSocket
      from circus.watcher import Watcher
  
      from . import load
      from ._internal.utils.analytics import track_serve
      from ._internal.utils.circus import create_standalone_arbiter
      from .serve import API_SERVER_NAME
      from .serve import PROMETHEUS_MESSAGE
      from .serve import construct_ssl_args
      from .serve import create_watcher
  
      working_dir = os.path.realpath(os.path.expanduser(working_dir))
      svc = load(
          bento_identifier,
          working_dir=working_dir,
          standalone_load=True,
      )
      timeout_args = ["--timeout", str(timeout)] if timeout else []
      runner_requirements = {runner.name for runner in svc.runners}
      if not runner_requirements.issubset(set(runner_map)):
          raise ValueError(
              f"{bento_identifier} requires runners {runner_requirements}, but only {set(runner_map)} are provided."
          )
      watchers: list[Watcher] = []
      circus_socket_map: dict[str, CircusSocket] = {}
      logger.debug("Runner map: %s", runner_map)
      circus_socket_map[API_SERVER_NAME] = CircusSocket(
          name=API_SERVER_NAME,
          host=host,
          port=port,
          backlog=backlog,
      )
      ssl_args = construct_ssl_args(
          ssl_certfile=ssl_certfile,
          ssl_keyfile=ssl_keyfile,
          ssl_keyfile_password=ssl_keyfile_password,
          ssl_version=ssl_version,
          ssl_cert_reqs=ssl_cert_reqs,
          ssl_ca_certs=ssl_ca_certs,
          ssl_ciphers=ssl_ciphers,
      )
      scheme = "https" if BentoMLContainer.ssl.enabled.get() else "http"
      watchers.append(
          create_watcher(
              name="api_server",
              args=[
                  "-m",
                  SCRIPT_API_SERVER,
                  bento_identifier,
                  "--fd",
                  f"$(circus.sockets.{API_SERVER_NAME})",
                  "--runner-map",
                  json.dumps(runner_map),
                  "--working-dir",
                  working_dir,
                  "--backlog",
                  f"{backlog}",
                  "--worker-id",
                  "$(CIRCUS.WID)",
                  "--prometheus-dir",
                  prometheus_dir,
                  *ssl_args,
                  *timeout_args,
              ],
              working_dir=working_dir,
              numprocesses=api_workers,
          )
      )
      if BentoMLContainer.api_server_config.metrics.enabled.get():
          logger.info(
              PROMETHEUS_MESSAGE,
              scheme.upper(),
              bento_identifier,
              f"{scheme}://{host}:{port}/metrics",
          )
  
      arbiter = create_standalone_arbiter(
          watchers=watchers,
          sockets=list(circus_socket_map.values()),
      )
      with track_serve(svc, production=True, component=API_SERVER):
          arbiter.start(
              cb=lambda _: logger.info(  # type: ignore
                  'Starting bare %s BentoServer from "%s" running on %s://%s:%d (Press CTRL+C to quit)',
                  scheme.upper(),
                  bento_identifier,
                  scheme,
                  host,
                  port,
              ),
          )
  
file_path: BentoML/src/bentoml/start.py
imports: from __future__ import annotations
  import contextlib
  import json
  import logging
  import os
  from simple_di import Provide
  from simple_di import inject
  from ._internal.configuration.containers import BentoMLContainer
  from ._internal.runner.runner import Runner
  from .grpc.utils import LATEST_PROTOCOL_VERSION
label_desc: Use image node_id 2 for calling a global function with example usage: start_http_server(bento_identifier, runner_map, working_dir, port, host, backlog, api_workers, timeout, ssl_certfile, ssl_keyfile, ssl_keyfile_password, ssl_version, ssl_cert_reqs, ssl_ca_certs, ssl_ciphers) without return types