def apply(self, deployment_pb, repo, prev_deployment=None):
deployment_spec = deployment_pb.spec
gcp_config = deployment_spec.gcp_function_operator_config
bento_path = repo.get(deployment_spec.bento_name,
deployment_spec.bento_version)
bento_config = load_bentoml_config(bento_path)
with TemporaryServerlessContent(
archive_path=bento_path,
deployment_name=deployment_pb.name,
bento_name=deployment_spec.bento_name,
template_type='google-python',
) as output_path:
generate_main_py(bento_config['name'], bento_config['apis'],
output_path)
generate_serverless_configuration_for_gcp_function(
service_name=bento_config['name'],
apis=bento_config['apis'],
output_path=output_path,
region=gcp_config.region,
stage=deployment_pb.namespace,
)
call_serverless_command(["deploy"], output_path)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
state = self.describe(res_deployment_pb, repo).state
res_deployment_pb.state.CopyFrom(state)
return ApplyDeploymentResponse(status=Status.OK(),
deployment=res_deployment_pb)
def _apply(self, deployment_pb, bento_pb, yatai_service, bento_path):
if loader._is_remote_path(bento_path):
with loader._resolve_remote_bundle_path(bento_path) as local_path:
return self._apply(deployment_pb, bento_pb, yatai_service,
local_path)
deployment_spec = deployment_pb.spec
aws_config = deployment_spec.aws_lambda_operator_config
bento_service_metadata = bento_pb.bento.bento_service_metadata
template = 'aws-python3'
if version.parse(bento_service_metadata.env.python_version
) < version.parse('3.0.0'):
template = 'aws-python'
api_names = ([aws_config.api_name] if aws_config.api_name else
[api.name for api in bento_service_metadata.apis])
ensure_deploy_api_name_exists_in_bento(
[api.name for api in bento_service_metadata.apis], api_names)
with TempDirectory() as serverless_project_dir:
init_serverless_project_dir(
serverless_project_dir,
bento_path,
deployment_pb.name,
deployment_spec.bento_name,
template,
)
generate_aws_lambda_handler_py(deployment_spec.bento_name,
api_names, serverless_project_dir)
generate_aws_lambda_serverless_config(
bento_service_metadata.env.python_version,
deployment_pb.name,
api_names,
serverless_project_dir,
aws_config.region,
# BentoML deployment namespace is mapping to serverless `stage`
# concept
stage=deployment_pb.namespace,
)
logger.info(
'Installing additional packages: serverless-python-requirements'
)
install_serverless_plugin("serverless-python-requirements",
serverless_project_dir)
logger.info('Deploying to AWS Lambda')
call_serverless_command(["deploy"], serverless_project_dir)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
state = self.describe(res_deployment_pb, yatai_service).state
res_deployment_pb.state.CopyFrom(state)
return ApplyDeploymentResponse(status=Status.OK(),
deployment=res_deployment_pb)
def apply(self, deployment_pb, repo):
# deploy code.....
spec = deployment_pb.spec
bento_path = repo.get(spec.bento_name, spec.bento_version)
# config = load_bentoml_config(bento_path)...
res_deployment_pb = Deployment()
res_deployment_pb.CopyFrom(deployment_pb)
# res_deployment_pb.state = ...
return ApplyDeploymentResponse(status=Status.OK(), deployment=res_deployment_pb)
def apply(self, deployment_pb, yatai_service, prev_deployment=None):
try:
deployment_spec = deployment_pb.spec
gcp_config = deployment_spec.gcp_function_operator_config
bento_pb = yatai_service.GetBento(
GetBentoRequest(
bento_name=deployment_spec.bento_name,
bento_version=deployment_spec.bento_version,
))
if bento_pb.bento.uri.type != BentoUri.LOCAL:
raise BentoMLException(
'BentoML currently only support local repository')
else:
bento_path = bento_pb.bento.uri.uri
bento_service_metadata = bento_pb.bento.bento_service_metadata
api_names = ([gcp_config.api_name] if gcp_config.api_name else
[api.name for api in bento_service_metadata.apis])
ensure_deploy_api_name_exists_in_bento(
[api.name for api in bento_service_metadata.apis], api_names)
with TempDirectory() as serverless_project_dir:
init_serverless_project_dir(
serverless_project_dir,
bento_path,
deployment_pb.name,
deployment_spec.bento_name,
'google-python',
)
generate_gcp_function_main_py(deployment_spec.bento_name,
api_names,
serverless_project_dir)
generate_gcp_function_serverless_config(
deployment_pb.name,
api_names,
serverless_project_dir,
gcp_config.region,
# BentoML namespace is mapping to serverless stage.
stage=deployment_pb.namespace,
)
call_serverless_command(["deploy"], serverless_project_dir)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
state = self.describe(res_deployment_pb, yatai_service).state
res_deployment_pb.state.CopyFrom(state)
return ApplyDeploymentResponse(status=Status.OK(),
deployment=res_deployment_pb)
except BentoMLException as error:
return ApplyDeploymentResponse(
status=exception_to_return_status(error))
def apply(self, deployment_pb, repo, prev_deployment=None):
ensure_docker_available_or_raise()
deployment_spec = deployment_pb.spec
aws_config = deployment_spec.aws_lambda_operator_config
bento_path = repo.get(deployment_spec.bento_name,
deployment_spec.bento_version)
bento_config = load_bentoml_config(bento_path)
template = 'aws-python3'
minimum_python_version = version.parse('3.0.0')
bento_python_version = version.parse(
bento_config['env']['python_version'])
if bento_python_version < minimum_python_version:
template = 'aws-python'
with TemporaryServerlessContent(
archive_path=bento_path,
deployment_name=deployment_pb.name,
bento_name=deployment_spec.bento_name,
template_type=template,
) as output_path:
generate_handler_py(deployment_spec.bento_name,
bento_config['apis'], output_path)
generate_serverless_configuration_for_aws_lambda(
service_name=deployment_pb.name,
apis=bento_config['apis'],
output_path=output_path,
region=aws_config.region,
stage=deployment_pb.namespace,
)
logger.info(
'Installing additional packages: serverless-python-requirements, '
'serverless-apigw-binary')
install_serverless_plugin("serverless-python-requirements",
output_path)
install_serverless_plugin("serverless-apigw-binary", output_path)
logger.info('Deploying to AWS Lambda')
call_serverless_command(["deploy"], output_path)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
state = self.describe(res_deployment_pb, repo).state
res_deployment_pb.state.CopyFrom(state)
return ApplyDeploymentResponse(status=Status.OK(),
deployment=res_deployment_pb)
def apply(self, deployment_pb, repo, prev_deployment=None):
deployment_spec = deployment_pb.spec
sagemaker_config = deployment_spec.sagemaker_operator_config
if sagemaker_config is None:
raise BentoMLDeploymentException('Sagemaker configuration is missing.')
archive_path = repo.get(
deployment_spec.bento_name, deployment_spec.bento_version
)
# config = load_bentoml_config(bento_path)...
sagemaker_client = boto3.client('sagemaker', sagemaker_config.region)
with TemporarySageMakerContent(
archive_path, deployment_spec.bento_name, deployment_spec.bento_version
) as temp_path:
ecr_image_path = create_push_image_to_ecr(
deployment_spec.bento_name, deployment_spec.bento_version, temp_path
)
execution_role_arn = get_arn_role_from_current_user()
model_name = create_sagemaker_model_name(
deployment_spec.bento_name, deployment_spec.bento_version
)
sagemaker_model_info = {
"ModelName": model_name,
"PrimaryContainer": {
"ContainerHostname": model_name,
"Image": ecr_image_path,
"Environment": {
"API_NAME": sagemaker_config.api_name,
"BENTO_SERVER_TIMEOUT": config().get(
'apiserver', 'default_timeout'
),
"BENTO_SERVER_WORKERS": config().get(
'apiserver', 'default_gunicorn_workers_count'
),
},
},
"ExecutionRoleArn": execution_role_arn,
}
logger.info("Creating sagemaker model %s", model_name)
create_model_response = sagemaker_client.create_model(**sagemaker_model_info)
logger.debug("AWS create model response: %s", create_model_response)
production_variants = [
{
"VariantName": generate_aws_compatible_string(
deployment_spec.bento_name
),
"ModelName": model_name,
"InitialInstanceCount": sagemaker_config.instance_count,
"InstanceType": sagemaker_config.instance_type,
}
]
endpoint_config_name = create_sagemaker_endpoint_config_name(
deployment_spec.bento_name, deployment_spec.bento_version
)
logger.info(
"Creating Sagemaker endpoint %s configuration", endpoint_config_name
)
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=production_variants,
)
logger.debug(
"AWS create endpoint config response: %s", create_endpoint_config_response
)
endpoint_name = generate_aws_compatible_string(
deployment_pb.namespace + '-' + deployment_spec.bento_name
)
if prev_deployment:
logger.info("Updating sagemaker endpoint %s", endpoint_name)
update_endpoint_response = sagemaker_client.update_endpoint(
EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name
)
logger.debug("AWS update endpoint response: %s", update_endpoint_response)
else:
logger.info("Creating sagemaker endpoint %s", endpoint_name)
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name
)
logger.debug("AWS create endpoint response: %s", create_endpoint_response)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
return ApplyDeploymentResponse(status=Status.OK(), deployment=res_deployment_pb)
def apply(self, deployment_pb, yatai_service, prev_deployment=None):
try:
ensure_docker_available_or_raise()
deployment_spec = deployment_pb.spec
sagemaker_config = deployment_spec.sagemaker_operator_config
if sagemaker_config is None:
raise BentoMLDeploymentException('Sagemaker configuration is missing.')
bento_pb = yatai_service.GetBento(
GetBentoRequest(
bento_name=deployment_spec.bento_name,
bento_version=deployment_spec.bento_version,
)
)
if bento_pb.bento.uri.type != BentoUri.LOCAL:
raise BentoMLException(
'BentoML currently only support local repository'
)
else:
bento_path = bento_pb.bento.uri.uri
ensure_deploy_api_name_exists_in_bento(
[api.name for api in bento_pb.bento.bento_service_metadata.apis],
[sagemaker_config.api_name],
)
sagemaker_client = boto3.client('sagemaker', sagemaker_config.region)
with TempDirectory() as temp_dir:
sagemaker_project_dir = os.path.jon(
temp_dir, deployment_spec.bento_name
)
init_sagemaker_project(sagemaker_project_dir, bento_path)
ecr_image_path = create_push_docker_image_to_ecr(
deployment_spec.bento_name,
deployment_spec.bento_version,
sagemaker_project_dir,
)
execution_role_arn = get_arn_role_from_current_aws_user()
model_name = create_sagemaker_model_name(
deployment_spec.bento_name, deployment_spec.bento_version
)
sagemaker_model_info = {
"ModelName": model_name,
"PrimaryContainer": {
"ContainerHostname": model_name,
"Image": ecr_image_path,
"Environment": {
"API_NAME": sagemaker_config.api_name,
"BENTO_SERVER_TIMEOUT": config().get(
'apiserver', 'default_timeout'
),
"BENTO_SERVER_WORKERS": config().get(
'apiserver', 'default_gunicorn_workers_count'
),
},
},
"ExecutionRoleArn": execution_role_arn,
}
logger.info("Creating sagemaker model %s", model_name)
try:
create_model_response = sagemaker_client.create_model(
**sagemaker_model_info
)
logger.debug("AWS create model response: %s", create_model_response)
except ClientError as e:
status = _parse_aws_client_exception_or_raise(e)
status.error_message = (
'Failed to create model for SageMaker Deployment: %s',
status.error_message,
)
return ApplyDeploymentResponse(status=status, deployment=deployment_pb)
production_variants = [
{
"VariantName": generate_aws_compatible_string(
deployment_spec.bento_name
),
"ModelName": model_name,
"InitialInstanceCount": sagemaker_config.instance_count,
"InstanceType": sagemaker_config.instance_type,
}
]
endpoint_config_name = create_sagemaker_endpoint_config_name(
deployment_spec.bento_name, deployment_spec.bento_version
)
logger.info(
"Creating Sagemaker endpoint %s configuration", endpoint_config_name
)
try:
create_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=production_variants,
)
logger.debug(
"AWS create endpoint config response: %s", create_config_response
)
except ClientError as e:
# create endpoint failed, will remove previously created model
cleanup_model_error = _cleanup_sagemaker_model(
sagemaker_client,
deployment_spec.bento_name,
deployment_spec.bento_version,
)
if cleanup_model_error:
cleanup_model_error.error_message = (
'Failed to clean up model after unsuccessfully '
'create endpoint config: %s',
cleanup_model_error.error_message,
)
return ApplyDeploymentResponse(
status=cleanup_model_error, deployment=deployment_pb
)
status = _parse_aws_client_exception_or_raise(e)
status.error_message = (
'Failed to create endpoint config for SageMaker deployment: %s',
status.error_message,
)
return ApplyDeploymentResponse(status=status, deployment=deployment_pb)
endpoint_name = generate_aws_compatible_string(
deployment_pb.namespace + '-' + deployment_spec.bento_name
)
try:
if prev_deployment:
logger.debug("Updating sagemaker endpoint %s", endpoint_name)
update_endpoint_response = sagemaker_client.update_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
logger.debug(
"AWS update endpoint response: %s", update_endpoint_response
)
else:
logger.debug("Creating sagemaker endpoint %s", endpoint_name)
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
logger.debug(
"AWS create endpoint response: %s", create_endpoint_response
)
except ClientError as e:
# create/update endpoint failed, will remove previously created config
# and then remove the model
cleanup_endpoint_config_error = _cleanup_sagemaker_endpoint_config(
client=sagemaker_client,
name=deployment_spec.bento_name,
version=deployment_spec.bento_version,
)
if cleanup_endpoint_config_error:
cleanup_endpoint_config_error.error_message = (
'Failed to clean up endpoint config after unsuccessfully '
'apply SageMaker deployment: %s',
cleanup_endpoint_config_error.error_message,
)
return ApplyDeploymentResponse(
status=cleanup_endpoint_config_error, deployment=deployment_pb
)
cleanup_model_error = _cleanup_sagemaker_model(
client=sagemaker_client,
name=deployment_spec.bento_name,
version=deployment_spec.bento_version,
)
if cleanup_model_error:
cleanup_model_error.error_message = (
'Failed to clean up model after unsuccessfully '
'apply SageMaker deployment: %s',
cleanup_model_error.error_message,
)
return ApplyDeploymentResponse(
status=cleanup_model_error, deployment=deployment_pb
)
status = _parse_aws_client_exception_or_raise(e)
status.error_message = (
'Failed to apply SageMaker deployment: %s',
status.error_message,
)
return ApplyDeploymentResponse(status=status, deployment=deployment_pb)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
return ApplyDeploymentResponse(
status=Status.OK(), deployment=res_deployment_pb
)
except BentoMLException as error:
return ApplyDeploymentResponse(status=exception_to_return_status(error))
def _apply(
self, deployment_pb, bento_pb, yatai_service, bento_path, prev_deployment=None
):
if loader._is_remote_path(bento_path):
with loader._resolve_remote_bundle_path(bento_path) as local_path:
return self._apply(
deployment_pb, bento_pb, yatai_service, local_path, prev_deployment
)
deployment_spec = deployment_pb.spec
sagemaker_config = deployment_spec.sagemaker_operator_config
ensure_deploy_api_name_exists_in_bento(
[api.name for api in bento_pb.bento.bento_service_metadata.apis],
[sagemaker_config.api_name],
)
sagemaker_client = boto3.client('sagemaker', sagemaker_config.region)
with TempDirectory() as temp_dir:
sagemaker_project_dir = os.path.join(temp_dir, deployment_spec.bento_name)
init_sagemaker_project(sagemaker_project_dir, bento_path)
ecr_image_path = create_push_docker_image_to_ecr(
sagemaker_config.region,
deployment_spec.bento_name,
deployment_spec.bento_version,
sagemaker_project_dir,
)
try:
model_name = _create_sagemaker_model(
sagemaker_client,
deployment_spec.bento_name,
deployment_spec.bento_version,
ecr_image_path,
sagemaker_config.api_name,
)
except ClientError as e:
status = _parse_aws_client_exception(e)
status.error_message = (
'Failed to create model for SageMaker'
' Deployment: {}'.format(status.error_message)
)
return ApplyDeploymentResponse(status=status, deployment=deployment_pb)
try:
endpoint_config_name = _create_sagemaker_endpoint_config(
sagemaker_client,
model_name,
deployment_spec.bento_name,
deployment_spec.bento_version,
sagemaker_config,
)
except ClientError as e:
# create endpoint failed, will remove previously created model
cleanup_model_error = _cleanup_sagemaker_model(
sagemaker_client,
deployment_spec.bento_name,
deployment_spec.bento_version,
)
if cleanup_model_error:
cleanup_model_error.error_message = (
'Failed to clean up model after unsuccessfully '
'create endpoint config: %s',
cleanup_model_error.error_message,
)
return ApplyDeploymentResponse(
status=cleanup_model_error, deployment=deployment_pb
)
status = _parse_aws_client_exception(e)
status.error_message = (
'Failed to create endpoint config for SageMaker deployment: %s',
status.error_message,
)
return ApplyDeploymentResponse(status=status, deployment=deployment_pb)
endpoint_name = generate_aws_compatible_string(
deployment_pb.namespace + '-' + deployment_spec.bento_name
)
try:
if prev_deployment:
logger.debug("Updating sagemaker endpoint %s", endpoint_name)
update_endpoint_response = sagemaker_client.update_endpoint(
EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name
)
logger.debug(
"AWS update endpoint response: %s", update_endpoint_response
)
else:
logger.debug("Creating sagemaker endpoint %s", endpoint_name)
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name
)
logger.debug(
"AWS create endpoint response: %s", create_endpoint_response
)
except ClientError as e:
# create/update endpoint failed, will remove previously created config
# and then remove the model
cleanup_endpoint_config_error = _cleanup_sagemaker_endpoint_config(
client=sagemaker_client,
name=deployment_spec.bento_name,
version=deployment_spec.bento_version,
)
if cleanup_endpoint_config_error:
cleanup_endpoint_config_error.error_message = (
'Failed to clean up endpoint config after unsuccessfully '
'apply SageMaker deployment: %s',
cleanup_endpoint_config_error.error_message,
)
return ApplyDeploymentResponse(
status=cleanup_endpoint_config_error, deployment=deployment_pb
)
cleanup_model_error = _cleanup_sagemaker_model(
client=sagemaker_client,
name=deployment_spec.bento_name,
version=deployment_spec.bento_version,
)
if cleanup_model_error:
cleanup_model_error.error_message = (
'Failed to clean up model after unsuccessfully apply '
'SageMaker deployment: {}'.format(cleanup_model_error.error_message)
)
return ApplyDeploymentResponse(
status=cleanup_model_error, deployment=deployment_pb
)
status = _parse_aws_client_exception(e)
status.error_message = 'Failed to apply SageMaker ' 'deployment: {}'.format(
status.error_message
)
return ApplyDeploymentResponse(status=status, deployment=deployment_pb)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
return ApplyDeploymentResponse(status=Status.OK(), deployment=res_deployment_pb)
def apply(self, deployment_pb, yatai_service, prev_deployment=None):
try:
ensure_docker_available_or_raise()
deployment_spec = deployment_pb.spec
aws_config = deployment_spec.aws_lambda_operator_config
bento_pb = yatai_service.GetBento(
GetBentoRequest(
bento_name=deployment_spec.bento_name,
bento_version=deployment_spec.bento_version,
)
)
if bento_pb.bento.uri.type != BentoUri.LOCAL:
raise BentoMLException(
'BentoML currently only support local repository'
)
else:
bento_path = bento_pb.bento.uri.uri
bento_service_metadata = bento_pb.bento.bento_service_metadata
template = 'aws-python3'
if version.parse(bento_service_metadata.env.python_version) < version.parse(
'3.0.0'
):
template = 'aws-python'
api_names = (
[aws_config.api_name]
if aws_config.api_name
else [api.name for api in bento_service_metadata.apis]
)
ensure_deploy_api_name_exists_in_bento(
[api.name for api in bento_service_metadata.apis], api_names
)
with TempDirectory() as serverless_project_dir:
init_serverless_project_dir(
serverless_project_dir,
bento_path,
deployment_pb.name,
deployment_spec.bento_name,
template,
)
generate_aws_lambda_handler_py(
deployment_spec.bento_name, api_names, serverless_project_dir
)
generate_aws_lambda_serverless_config(
bento_service_metadata.env.python_version,
deployment_pb.name,
api_names,
serverless_project_dir,
aws_config.region,
# BentoML deployment namespace is mapping to serverless `stage`
# concept
stage=deployment_pb.namespace,
)
logger.info(
'Installing additional packages: serverless-python-requirements'
)
install_serverless_plugin(
"serverless-python-requirements", serverless_project_dir
)
logger.info('Deploying to AWS Lambda')
call_serverless_command(["deploy"], serverless_project_dir)
res_deployment_pb = Deployment(state=DeploymentState())
res_deployment_pb.CopyFrom(deployment_pb)
state = self.describe(res_deployment_pb, yatai_service).state
res_deployment_pb.state.CopyFrom(state)
return ApplyDeploymentResponse(
status=Status.OK(), deployment=res_deployment_pb
)
except BentoMLException as error:
return ApplyDeploymentResponse(status=exception_to_return_status(error))
