    def start_http_server(  # type: ignore (unused warning)
        bento: str,
        service_name: str,
        depends: list[str] | None,
        runner_map: str | None,
        bind: str | None,
        port: int | None,
        host: str | None,
        backlog: int | None,
        working_dir: str | None,
        api_workers: int | None,
        timeout: int | None,
        ssl_certfile: str | None,
        ssl_keyfile: str | None,
        ssl_keyfile_password: str | None,
        ssl_version: int | None,
        ssl_cert_reqs: int | None,
        ssl_ca_certs: str | None,
        ssl_ciphers: str | None,
        timeout_keep_alive: int | None,
        timeout_graceful_shutdown: int | None,
        reload: bool = False,
    ) -> None:
        """
        Start a HTTP API server standalone. This will be used inside Yatai.
        """
        from bentoml import Service
        from bentoml._internal.service.loader import load

        if working_dir is None:
            if os.path.isdir(os.path.expanduser(bento)):
                working_dir = os.path.expanduser(bento)
            else:
                working_dir = "."
        if sys.path[0] != working_dir:
            sys.path.insert(0, working_dir)
        if depends:
            runner_map_dict = dict([s.split("=", maxsplit=2) for s in depends or []])
        elif runner_map:
            runner_map_dict = json.loads(runner_map)
        else:
            runner_map_dict = {}

        if bind is not None:
            parsed = urlparse(bind)
            assert parsed.scheme == "tcp"
            host = parsed.hostname or host
            port = parsed.port or port

        svc = load(bento, working_dir=working_dir)
        if isinstance(svc, Service):
            if reload:
                logger.warning("--reload does not work with legacy style services")
            # for <1.2 bentos
            if not service_name or service_name == svc.name:
                from bentoml.start import start_http_server

                for dep in depends or []:
                    rich.print(f"Using remote: {dep}")
                start_http_server(
                    bento,
                    runner_map=runner_map_dict,
                    working_dir=working_dir,
                    port=port,
                    host=host,
                    backlog=backlog,
                    api_workers=api_workers or 1,
                    timeout=timeout,
                    ssl_keyfile=ssl_keyfile,
                    ssl_certfile=ssl_certfile,
                    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,
                    timeout_keep_alive=timeout_keep_alive,
                    timeout_graceful_shutdown=timeout_graceful_shutdown,
                )
            else:
                from bentoml.start import start_runner_server

                if bind is not None:
                    parsed = urlparse(bind)
                    assert parsed.scheme == "tcp"
                    host = parsed.hostname or host
                    port = parsed.port or port

                start_runner_server(
                    bento,
                    runner_name=service_name,
                    working_dir=working_dir,
                    timeout=timeout,
                    port=port,
                    host=host,
                    backlog=backlog,
                )
        else:
            # for >=1.2 bentos
            from _bentoml_impl.server import serve_http

            svc.inject_config()
            serve_http(
                bento,
                working_dir=working_dir,
                port=port,
                host=host,
                backlog=backlog,
                timeout=timeout,
                ssl_keyfile=ssl_keyfile,
                ssl_certfile=ssl_certfile,
                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,
                timeout_keep_alive=timeout_keep_alive,
                timeout_graceful_shutdown=timeout_graceful_shutdown,
                dependency_map=runner_map_dict,
                service_name=service_name,
                reload=reload,
            )
Start a HTTP API server standalone. This will be used inside Yatai.
src/bentoml_cli/start.py