def get(self, namespace, name):
namespace = (
namespace if namespace else config().get('deployment', 'default_namespace')
)
return self.yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=name, namespace=namespace)
)
def get_deployment(namespace, name, yatai_service=None):
if yatai_service is None:
from bentoml.yatai import get_yatai_service
yatai_service = get_yatai_service()
return yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=name, namespace=namespace))
def get(name, output):
track_cli('deploy-get')
result = get_yatai_service().GetDeployment(
GetDeploymentRequest(deployment_name=name))
if result.status.status_code != Status.OK:
_echo(
'Failed to get deployment {name}. code: {error_code}, message: {error_message}'
.format(
name=name,
error_code=Status.Code.Name(result.status.status_code),
error_message=result.status.error_message,
),
CLI_COLOR_ERROR,
)
else:
display_deployment_info(result.deployment, output)
def create(self, deployment_info, wait):
if isinstance(deployment_info, dict):
deployment_pb = deployment_dict_to_pb(deployment_info)
elif isinstance(deployment_info, str):
deployment_pb = deployment_yaml_string_to_pb(deployment_info)
elif isinstance(deployment_info, Deployment):
deployment_pb = deployment_info
else:
raise YataiDeploymentException(
'Unexpected argument type, expect deployment info to be str in yaml '
'format or a dict or a deployment protobuf obj, instead got: {}'.format(
str(type(deployment_info))
)
)
validation_errors = validate_deployment_pb_schema(deployment_pb)
if validation_errors:
raise YataiDeploymentException(
f'Failed to validate deployment {deployment_pb.name}: '
f'{validation_errors}'
)
# Make sure there is no active deployment with the same deployment name
get_deployment_pb = self.yatai_service.GetDeployment(
GetDeploymentRequest(
deployment_name=deployment_pb.name, namespace=deployment_pb.namespace
)
)
if get_deployment_pb.status.status_code != status_pb2.Status.NOT_FOUND:
raise BentoMLException(
f'Deployment "{deployment_pb.name}" already existed, use Update or '
f'Apply for updating existing deployment, delete the deployment, '
f'or use a different deployment name'
)
apply_result = self.yatai_service.ApplyDeployment(
ApplyDeploymentRequest(deployment=deployment_pb)
)
if apply_result.status.status_code != status_pb2.Status.OK:
error_code, error_message = status_pb_to_error_code_and_message(
apply_result.status
)
raise YataiDeploymentException(f'{error_code}:{error_message}')
if wait:
self._wait_deployment_action_complete(
deployment_pb.name, deployment_pb.namespace
)
return self.get(namespace=deployment_pb.namespace, name=deployment_pb.name)
def describe(name, output, namespace):
track_cli('deploy-describe')
yatai_service = get_yatai_service()
result = yatai_service.DescribeDeployment(
DescribeDeploymentRequest(deployment_name=name,
namespace=namespace))
if result.status.status_code != Status.OK:
_echo(
'Failed to describe deployment {name}. code: {error_code}, message: '
'{error_message}'.format(
name=name,
error_code=Status.Code.Name(result.status.status_code),
error_message=result.status.error_message,
),
CLI_COLOR_ERROR,
)
else:
get_response = yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=name,
namespace=namespace))
deployment_pb = get_response.deployment
deployment_pb.state.CopyFrom(result.state)
display_deployment_info(deployment_pb, output)
def create_deployment(
deployment_name,
namespace,
bento_name,
bento_version,
platform,
operator_spec,
labels=None,
annotations=None,
yatai_service=None,
):
if yatai_service is None:
from bentoml.yatai import get_yatai_service
yatai_service = get_yatai_service()
# Make sure there is no active deployment with the same deployment name
get_deployment_pb = yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=deployment_name,
namespace=namespace))
if get_deployment_pb.status.status_code == status_pb2.Status.OK:
raise YataiDeploymentException(
'Deployment "{name}" already existed, use Update or Apply for updating '
'existing deployment, delete the deployment, or use a different deployment '
'name'.format(name=deployment_name))
if get_deployment_pb.status.status_code != status_pb2.Status.NOT_FOUND:
raise YataiDeploymentException(
'Failed accesing YataiService deployment store. {error_code}:'
'{error_message}'.format(
error_code=Status.Name(get_deployment_pb.status.status_code),
error_message=get_deployment_pb.status.error_message,
))
deployment_dict = {
"name": deployment_name,
"namespace": namespace
or config().get('deployment', 'default_namespace'),
"labels": labels,
"annotations": annotations,
"spec": {
"bento_name": bento_name,
"bento_version": bento_version,
"operator": platform,
},
}
operator = platform.replace('-', '_').upper()
try:
operator_value = DeploymentSpec.DeploymentOperator.Value(operator)
except ValueError:
return ApplyDeploymentResponse(status=Status.INVALID_ARGUMENT(
'Invalid platform "{}"'.format(platform)))
if operator_value == DeploymentSpec.AWS_SAGEMAKER:
deployment_dict['spec']['sagemaker_operator_config'] = {
'region':
operator_spec.get('region')
or config().get('aws', 'default_region'),
'instance_count':
operator_spec.get('instance_count'),
'instance_type':
operator_spec.get('instance_type'),
'api_name':
operator_spec.get('api_name', ''),
}
if operator_spec.get('num_of_gunicorn_workers_per_instance'):
deployment_dict['spec']['sagemaker_operator_config'][
'num_of_gunicorn_workers_per_instance'] = operator_spec.get(
'num_of_gunicorn_workers_per_instance')
elif operator_value == DeploymentSpec.AWS_LAMBDA:
deployment_dict['spec']['aws_lambda_operator_config'] = {
'region':
operator_spec.get('region')
or config().get('aws', 'default_region')
}
for field in ['api_name', 'memory_size', 'timeout']:
if operator_spec.get(field):
deployment_dict['spec']['aws_lambda_operator_config'][
field] = operator_spec[field]
elif operator_value == DeploymentSpec.KUBERNETES:
deployment_dict['spec']['kubernetes_operator_config'] = {
'kube_namespace': operator_spec.get('kube_namespace', ''),
'replicas': operator_spec.get('replicas', 0),
'service_name': operator_spec.get('service_name', ''),
'service_type': operator_spec.get('service_type', ''),
}
else:
raise YataiDeploymentException(
'Platform "{}" is not supported in the current version of '
'BentoML'.format(platform))
apply_response = apply_deployment(deployment_dict, yatai_service)
if apply_response.status.status_code == status_pb2.Status.OK:
describe_response = describe_deployment(deployment_name, namespace,
yatai_service)
if describe_response.status.status_code == status_pb2.Status.OK:
deployment_state = describe_response.state
apply_response.deployment.state.CopyFrom(deployment_state)
return apply_response
return apply_response
def get(self, namespace, name):
return self.yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=name, namespace=namespace)
)
def create_deployment(
deployment_name,
namespace,
bento_name,
bento_version,
platform,
operator_spec,
labels=None,
annotations=None,
yatai_service=None,
):
if yatai_service is None:
from bentoml.yatai import get_yatai_service
yatai_service = get_yatai_service()
try:
# Make sure there is no active deployment with the same deployment name
get_deployment_pb = yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=deployment_name, namespace=namespace)
)
if get_deployment_pb.status.status_code == status_pb2.Status.OK:
raise BentoMLDeploymentException(
'Deployment "{name}" already existed, use Update or Apply for updating'
'existing deployment, or create the deployment with a different name or'
'under a different deployment namespace'.format(name=deployment_name)
)
if get_deployment_pb.status.status_code != status_pb2.Status.NOT_FOUND:
raise BentoMLDeploymentException(
'Failed accesing YataiService deployment store. {error_code}:'
'{error_message}'.format(
error_code=Status.Name(get_deployment_pb.status.status_code),
error_message=get_deployment_pb.status.error_message,
)
)
deployment_dict = {
"name": deployment_name,
"namespace": namespace or config().get('deployment', 'default_namespace'),
"labels": labels,
"annotations": annotations,
"spec": {
"bento_name": bento_name,
"bento_version": bento_version,
"operator": platform,
},
}
operator = platform.replace('-', '_').upper()
try:
operator_value = DeploymentSpec.DeploymentOperator.Value(operator)
except ValueError:
return ApplyDeploymentResponse(
status=Status.INVALID_ARGUMENT('Invalid platform "{}"'.format(platform))
)
if operator_value == DeploymentSpec.AWS_SAGEMAKER:
deployment_dict['spec']['sagemaker_operator_config'] = {
'region': operator_spec.get('region')
or config().get('aws', 'default_region'),
'instance_count': operator_spec.get('instance_count')
or config().getint('sagemaker', 'default_instance_count'),
'instance_type': operator_spec.get('instance_type')
or config().get('sagemaker', 'default_instance_type'),
'api_name': operator_spec.get('api_name', ''),
}
elif operator_value == DeploymentSpec.AWS_LAMBDA:
deployment_dict['spec']['aws_lambda_operator_config'] = {
'region': operator_spec.get('region')
or config().get('aws', 'default_region')
}
if operator_spec.get('api_name'):
deployment_dict['spec']['aws_lambda_operator_config'][
'api_name'
] = operator_spec['api_name']
elif operator_value == DeploymentSpec.GCP_FCUNTION:
deployment_dict['spec']['gcp_function_operatorConfig'] = {
'region': operator_spec.get('region')
or config().get('google-cloud', 'default_region')
}
if operator_spec.get('api_name'):
deployment_dict['spec']['gcp_function_operator_config'][
'api_name'
] = operator_spec['api_name']
elif operator_value == DeploymentSpec.KUBERNETES:
deployment_dict['spec']['kubernetes_operator_config'] = {
'kube_namespace': operator_spec.get('kube_namespace', ''),
'replicas': operator_spec.get('replicas', 0),
'service_name': operator_spec.get('service_name', ''),
'service_type': operator_spec.get('service_type', ''),
}
else:
raise BentoMLDeploymentException(
'Platform "{}" is not supported in the current version of '
'BentoML'.format(platform)
)
return apply_deployment(deployment_dict, yatai_service)
except BentoMLException as error:
return ApplyDeploymentResponse(status=Status.INTERNAL(str(error)))
def create(
name,
bento,
platform,
output,
namespace,
labels,
annotations,
region,
instance_type,
instance_count,
api_name,
kube_namespace,
replicas,
service_name,
service_type,
wait,
):
# converting platform parameter to DeploymentOperator name in proto
# e.g. 'aws-lambda' to 'AWS_LAMBDA'
platform = platform.replace('-', '_').upper()
operator = DeploymentSpec.DeploymentOperator.Value(platform)
track_cli('deploy-create', platform)
yatai_service = get_yatai_service()
# Make sure there is no active deployment with the same deployment name
get_deployment = yatai_service.GetDeployment(
GetDeploymentRequest(deployment_name=name, namespace=namespace))
if get_deployment.status.status_code != Status.NOT_FOUND:
raise BentoMLDeploymentException(
'Deployment {name} already existed, please use update or apply command'
' instead'.format(name=name))
if operator == DeploymentSpec.AWS_SAGEMAKER:
if not api_name:
raise click.BadParameter(
'api-name is required for Sagemaker deployment')
sagemaker_operator_config = DeploymentSpec.SageMakerOperatorConfig(
region=region or config().get('aws', 'default_region'),
instance_count=instance_count
or config().getint('sagemaker', 'instance_count'),
instance_type=instance_type
or config().get('sagemaker', 'instance_type'),
api_name=api_name,
)
spec = DeploymentSpec(
sagemaker_operator_config=sagemaker_operator_config)
elif operator == DeploymentSpec.AWS_LAMBDA:
aws_lambda_operator_config = DeploymentSpec.AwsLambdaOperatorConfig(
region=region or config().get('aws', 'default_region'))
if api_name:
aws_lambda_operator_config.api_name = api_name
spec = DeploymentSpec(
aws_lambda_operator_config=aws_lambda_operator_config)
elif operator == DeploymentSpec.GCP_FUNCTION:
gcp_function_operator_config = DeploymentSpec.GcpFunctionOperatorConfig(
region=region
or config().get('google-cloud', 'default_region'))
if api_name:
gcp_function_operator_config.api_name = api_name
spec = DeploymentSpec(
gcp_function_operator_config=gcp_function_operator_config)
elif operator == DeploymentSpec.KUBERNETES:
kubernetes_operator_config = DeploymentSpec.KubernetesOperatorConfig(
kube_namespace=kube_namespace,
replicas=replicas,
service_name=service_name,
service_type=service_type,
)
spec = DeploymentSpec(
kubernetes_operator_config=kubernetes_operator_config)
else:
raise BentoMLDeploymentException(
'Custom deployment is not supported in the current version of BentoML'
)
bento_name, bento_version = bento.split(':')
spec.bento_name = bento_name
spec.bento_version = bento_version
spec.operator = operator
result = yatai_service.ApplyDeployment(
ApplyDeploymentRequest(deployment=Deployment(
namespace=namespace,
name=name,
annotations=parse_key_value_pairs(annotations),
labels=parse_key_value_pairs(labels),
spec=spec,
)))
if result.status.status_code != Status.OK:
_echo(
'Failed to create deployment {name}. {error_code}: '
'{error_message}'.format(
name=name,
error_code=Status.Code.Name(result.status.status_code),
error_message=result.status.error_message,
),
CLI_COLOR_ERROR,
)
else:
if wait:
result_state = get_state_after_await_action_complete(
yatai_service=yatai_service,
name=name,
namespace=namespace,
message='Creating deployment ',
)
result.deployment.state.CopyFrom(result_state.state)
_echo('Successfully created deployment {}'.format(name),
CLI_COLOR_SUCCESS)
display_deployment_info(result.deployment, output)