def load(cls, filepath): conf = cls() with open(filepath, "rb") as config_file: yml_content = config_file.read() conf.config = conf._yaml.load(yml_content) ver = str(conf["version"]) py_ver = conf.config["env"]["python_version"] if ver != BENTOML_VERSION: msg = ( "Saved BentoService bundle version mismatch: loading BentoService " "bundle create with BentoML version {}, but loading from BentoML " "version {}".format(conf["version"], BENTOML_VERSION)) # If major version is different, then there could be incompatible API # changes. Raise error in this case. if ver.split(".")[0] != BENTOML_VERSION.split(".")[0]: if not BENTOML_VERSION.startswith('0+untagged'): raise BentoMLConfigException(msg) else: logger.warning(msg) else: # Otherwise just show a warning. logger.warning(msg) if py_ver != PYTHON_VERSION: logger.warning( f"Saved BentoService Python version mismatch: loading " f"BentoService bundle created with Python version {py_ver}, " f"but current environment version is {PYTHON_VERSION}.") return conf
def load(cls, filepath): conf = cls() with open(filepath, "rb") as config_file: yml_content = config_file.read() conf.config = conf._yaml.load(yml_content) if conf["version"] != BENTOML_VERSION: msg = ( "BentoArchive version mismatch: loading archive bundled in version " "{}, but loading from version {}".format( conf["version"], BENTOML_VERSION ) ) # If major version is different, then there could be incompatible API # changes. Raise error in this case. if conf["version"].split(".")[0] != BENTOML_VERSION.split(".")[0]: if not BENTOML_VERSION.startswith('0+untagged'): raise ValueError(msg) else: LOG.warning(msg) else: # Otherwise just show a warning. LOG.warning(msg) return conf
def load(cls, filepath): conf = cls() with open(filepath, "rb") as config_file: yml_content = config_file.read() conf.config = conf._yaml.load(yml_content) if conf["version"] != BENTOML_VERSION: msg = ( "Saved BentoService bundle version mismatch: loading BentoServie " "bundle create with BentoML version {}, but loading from BentoML " "version {}".format(conf["version"], BENTOML_VERSION)) # If major version is different, then there could be incompatible API # changes. Raise error in this case. if conf["version"].split(".")[0] != BENTOML_VERSION.split(".")[0]: if not BENTOML_VERSION.startswith('0+untagged'): raise BentoMLConfigException(msg) else: logger.warning(msg) else: # Otherwise just show a warning. logger.warning(msg) return conf
class BentoMLContainer(containers.DeclarativeContainer): config = providers.Configuration(strict=True) api_server_workers = providers.Callable( lambda workers: workers or (multiprocessing.cpu_count() // 2) + 1, config.bento_server.workers, ) bentoml_home = providers.Callable( lambda: expand_env_var( os.environ.get("BENTOML_HOME", os.path.join("~", "bentoml")) ) ) prometheus_multiproc_dir = providers.Callable( os.path.join, bentoml_home, "prometheus_multiproc_dir", ) bento_bundle_deployment_version = providers.Callable( get_bentoml_deploy_version, providers.Callable( lambda default, customized: customized or default, __version__.split('+')[0], config.bento_bundle.deployment_version, ), ) yatai_database_url = providers.Callable( lambda default, customized: customized or default, providers.Callable( "sqlite:///{}".format, providers.Callable(os.path.join, bentoml_home, "storage.db"), ), config.yatai.database.url, ) yatai_file_system_directory = providers.Callable( lambda default, customized: customized or default, providers.Callable(os.path.join, bentoml_home, "repository"), config.yatai.repository.file_system.directory, ) yatai_tls_root_ca_cert = providers.Callable( lambda current, deprecated: current or deprecated, config.yatai.remote.tls.root_ca_cert, config.yatai.remote.tls.client_certificate_file, ) logging_file_directory = providers.Callable( lambda default, customized: customized or default, providers.Callable(os.path.join, bentoml_home, "logs",), config.logging.file.directory, ) yatai_logging_path = providers.Callable( lambda default, customized: customized or default, providers.Callable( os.path.join, logging_file_directory, "yatai_web_server.log" ), config.yatai.logging.path, )
return template.format(**all_vars) DEFAULT_BENTOML_HOME = expand_env_var( os.environ.get("BENTOML_HOME", "~/bentoml")) BENTOML_HOME = DEFAULT_BENTOML_HOME BENTOML_CONFIG = os.path.join(BENTOML_HOME, "bentoml.yml") # This is used as default for config('core', 'bentoml_deploy_version') - which is used # for getting the BentoML PyPI version string or the URL to a BentoML sdist, indicating # the BentoML module to be used when loading and using a saved BentoService bundle. # This is useful when using customized BentoML fork/branch or when working with # development branches of BentoML BENTOML_VERSION = __version__ # e.g. from '0.4.2+5.g6cac97f.dirty' to '0.4.2' LAST_PYPI_RELEASE_VERSION = __version__.split('+')[0] def _is_pip_installed_bentoml(): is_installed_package = hasattr(version_mod, 'version_json') is_tagged = not __version__.startswith('0+untagged') is_clean = not version_mod.get_versions()['dirty'] return is_installed_package and is_tagged and is_clean def get_local_config_file(): if "BENTOML_CONFIG" in os.environ: # User local config file for customizing bentoml return expand_env_var(os.environ.get("BENTOML_CONFIG")) else: return os.path.join(BENTOML_HOME, "bentoml.cfg")
class BentoMLContainerClass: config = providers.Configuration() @providers.SingletonFactory @staticmethod def tracer( tracer_type: str = Provide[config.tracing.type], zipkin_server_url: str = Provide[config.tracing.zipkin.url], jaeger_server_address: str = Provide[config.tracing.jaeger.address], jaeger_server_port: int = Provide[config.tracing.jaeger.port], ): if tracer_type and tracer_type.lower( ) == 'zipkin' and zipkin_server_url: from bentoml.tracing.zipkin import get_zipkin_tracer return get_zipkin_tracer(zipkin_server_url) elif (tracer_type and tracer_type.lower() == 'jaeger' and jaeger_server_address and jaeger_server_port): from bentoml.tracing.jaeger import get_jaeger_tracer return get_jaeger_tracer(jaeger_server_address, jaeger_server_port) else: from bentoml.tracing.noop import NoopTracer return NoopTracer() @providers.SingletonFactory @staticmethod def access_control_options( allow_credentials=config.bento_server.cors. access_control_allow_credentials, expose_headers=config.bento_server.cors.access_control_expose_headers, allow_methods=config.bento_server.cors.access_control_allow_methods, allow_headers=config.bento_server.cors.access_control_allow_headers, max_age=config.bento_server.cors.access_control_max_age, ): import aiohttp_cors kwargs = dict( allow_credentials=allow_credentials, expose_headers=expose_headers, allow_methods=allow_methods, allow_headers=allow_headers, max_age=max_age, ) filtered_kwargs = {k: v for k, v in kwargs.items() if v is not None} return aiohttp_cors.ResourceOptions(**filtered_kwargs) api_server_workers = providers.Factory( lambda workers: workers or (multiprocessing.cpu_count() // 2) + 1, config.bento_server.workers, ) bentoml_home = providers.Factory(lambda: expand_env_var( os.environ.get("BENTOML_HOME", os.path.join("~", "bentoml")))) bundle_path: Provider[str] = providers.Static("") service_host: Provider[str] = providers.Static("0.0.0.0") service_port: Provider[int] = config.bento_server.port forward_host: Provider[str] = providers.Static("localhost") forward_port: Provider[int] = providers.SingletonFactory(get_free_port) @providers.Factory @staticmethod def model_server(): from bentoml.server.gunicorn_model_server import GunicornModelServer return GunicornModelServer() @providers.Factory @staticmethod def proxy_server(): from bentoml.server.gunicorn_marshal_server import GunicornMarshalServer return GunicornMarshalServer() @providers.Factory @staticmethod def proxy_app() -> "MarshalApp": from bentoml.marshal.marshal import MarshalApp return MarshalApp() @providers.Factory @staticmethod def model_app(): from bentoml.server.model_app import ModelApp return ModelApp() prometheus_lock = providers.SingletonFactory(multiprocessing.Lock) prometheus_multiproc_dir = providers.Factory( os.path.join, bentoml_home, "prometheus_multiproc_dir", ) @providers.SingletonFactory @staticmethod def metrics_client( multiproc_lock=prometheus_lock, multiproc_dir=prometheus_multiproc_dir, namespace=config.bento_server.metrics.namespace, ): from bentoml.metrics.prometheus import PrometheusClient return PrometheusClient( multiproc_lock=multiproc_lock, multiproc_dir=multiproc_dir, namespace=namespace, ) @providers.SingletonFactory @staticmethod def yatai_metrics_client(): from bentoml.metrics.prometheus import PrometheusClient return PrometheusClient(multiproc=False, namespace="YATAI") bento_bundle_deployment_version = providers.Factory( get_bentoml_deploy_version, providers.Factory( lambda default, customized: customized or default, __version__.split('+')[0], config.bento_bundle.deployment_version, ), ) yatai_database_url = providers.Factory( lambda default, customized: customized or default, providers.Factory( "sqlite:///{}".format, providers.Factory(os.path.join, bentoml_home, "storage.db"), ), config.yatai.database.url, ) yatai_file_system_directory = providers.Factory( lambda default, customized: customized or default, providers.Factory(os.path.join, bentoml_home, "repository"), config.yatai.repository.file_system.directory, ) yatai_tls_root_ca_cert = providers.Factory( lambda current, deprecated: current or deprecated, config.yatai.remote.tls.root_ca_cert, config.yatai.remote.tls.client_certificate_file, ) logging_file_directory = providers.Factory( lambda default, customized: customized or default, providers.Factory( os.path.join, bentoml_home, "logs", ), config.logging.file.directory, ) yatai_logging_path = providers.Factory( lambda default, customized: customized or default, providers.Factory(os.path.join, logging_file_directory, "yatai_web_server.log"), config.yatai.logging.path, )