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,
)
