def deploy( name, bento, namespace, region, min_size, desired_capacity, max_size, instance_type, ami_id, output, wait, ): yatai_client = get_default_yatai_client() bento_name, bento_version = bento.split(":") with Spinner(f"Deploying {bento} to AWS EC2"): result = yatai_client.deployment.create_ec2_deployment( name=name, namespace=namespace, bento_name=bento_name, bento_version=bento_version, region=region, min_size=min_size, desired_capacity=desired_capacity, max_size=max_size, instance_type=instance_type, ami_id=ami_id, wait=wait, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _print_deployment_info(result.deployment, output) _echo("Successfully created AWS EC2 deployment", CLI_COLOR_SUCCESS)
def create(deployment_yaml, output, wait): yatai_client = YataiClient() platform_name = deployment_yaml.get('spec', {}).get('operator') deployment_name = deployment_yaml.get('name') track_cli('deploy-create', platform_name) try: with Spinner('Creating deployment '): result = yatai_client.deployment.create(deployment_yaml, wait) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status ) track_cli( 'deploy-create-failure', platform_name, {'error_code': error_code, 'error_message': error_message}, ) _echo( f'Failed to create deployment {deployment_name} ' f'{error_code}:{error_message}', CLI_COLOR_ERROR, ) return track_cli('deploy-create-success', platform_name) _echo( f'Successfully created deployment {deployment_name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: _echo( f'Failed to create deployment {deployment_name} {str(e)}', CLI_COLOR_ERROR, )
def update(name, namespace, bento, memory_size, timeout, output, wait): _echo( message= 'AWS Lambda deployment functionalities are being migrated to a ' 'separate tool and related CLI commands will be deprecated in BentoML ' 'itself, please use https://github.com/bentoml/aws-lambda-deploy ' 'going forward.', color='yellow', ) yatai_client = get_default_yatai_client() if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None with Spinner('Updating Lambda deployment '): result = yatai_client.deployment.update_lambda_deployment( bento_name=bento_name, bento_version=bento_version, deployment_name=name, namespace=namespace, memory_size=memory_size, timeout=timeout, wait=wait, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully updated AWS Lambda deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def update(name, namespace, bento, memory_size, timeout, output, wait): yatai_client = YataiClient() if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None with Spinner('Updating Lambda deployment '): result = yatai_client.deployment.update_lambda_deployment( bento_name=bento_name, bento_version=bento_version, deployment_name=name, namespace=namespace, memory_size=memory_size, timeout=timeout, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully updated AWS Lambda deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def update(name, namespace, bento, min_instances, max_burst, premium_plan_sku, output, wait): yatai_client = get_default_yatai_client() if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None with Spinner(f'Updating Azure Functions deployment {name}'): result = yatai_client.deployment.update_azure_functions_deployment( namespace=namespace, deployment_name=name, bento_name=bento_name, bento_version=bento_version, min_instances=min_instances, max_burst=max_burst, premium_plan_sku=premium_plan_sku, wait=wait, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully updated Azure Functions deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def deploy( name, namespace, bento, labels, region, api_name, memory_size, timeout, output, wait, ): yatai_client = YataiClient() bento_name, bento_version = bento.split(':') with Spinner(f'Deploying "{bento}" to AWS Lambda '): result = yatai_client.deployment.create_lambda_deployment( name=name, namespace=namespace, bento_name=bento_name, bento_version=bento_version, api_name=api_name, region=region, memory_size=memory_size, timeout=timeout, labels=labels, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo(f'Successfully created AWS Lambda deployment {name}', CLI_COLOR_SUCCESS) _print_deployment_info(result.deployment, output)
def deploy( name, namespace, bento, labels, region, api_name, memory_size, timeout, output, wait, ): track_cli('deploy-create', PLATFORM_NAME) yatai_client = YataiClient() bento_name, bento_version = bento.split(':') try: with Spinner(f'Deploying "{bento}" to AWS Lambda '): result = yatai_client.deployment.create_lambda_deployment( name=name, namespace=namespace, bento_name=bento_name, bento_version=bento_version, api_name=api_name, region=region, memory_size=memory_size, timeout=timeout, labels=labels, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) track_cli( 'deploy-create-failure', PLATFORM_NAME, { 'error_code': error_code, 'error_message': error_message }, ) _echo( f'Failed to create AWS Lambda deployment {name} ' f'{error_code}:{error_message}', CLI_COLOR_ERROR, ) return track_cli('deploy-create-success', PLATFORM_NAME) _echo(f'Successfully created AWS Lambda deployment {name}', CLI_COLOR_SUCCESS) _print_deployment_info(result.deployment, output) except BentoMLException as e: track_cli('deploy-create-failure', PLATFORM_NAME, {'error_message': str(e)}) _echo( f'Failed to create AWS Lambda deployment {name} {str(e)}', CLI_COLOR_ERROR, )
def deploy( name, bento, namespace, labels, region, instance_type, instance_count, num_of_gunicorn_workers_per_instance, api_name, timeout, output, wait, ): # use the DeploymentOperator name in proto to be consistent with amplitude track_cli('deploy-create', PLATFORM_NAME) bento_name, bento_version = bento.split(':') yatai_client = YataiClient() try: with Spinner('Deploying Sagemaker deployment '): result = yatai_client.deployment.create_sagemaker_deployment( name=name, namespace=namespace, labels=labels, bento_name=bento_name, bento_version=bento_version, instance_count=instance_count, instance_type=instance_type, num_of_gunicorn_workers_per_instance= num_of_gunicorn_workers_per_instance, # noqa E501 api_name=api_name, timeout=timeout, region=region, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) _echo( f'Failed to create AWS Sagemaker deployment {name} ' f'{error_code}:{error_message}', CLI_COLOR_ERROR, ) return track_cli('deploy-create-success', PLATFORM_NAME) _echo( f'Successfully created AWS Sagemaker deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: _echo( 'Failed to create AWS Sagemaker deployment {}.: {}'.format( name, str(e)), CLI_COLOR_ERROR, )
def containerize(bento, push, tag, build_arg, yatai_url): """Containerize specified BentoService. BENTO is the target BentoService to be containerized, referenced by its name and version in format of name:version. For example: "iris_classifier:v1.2.0" `bentoml containerize` command also supports the use of the `latest` tag which will automatically use the last built version of your Bento. You can provide a tag for the image built by Bento using the `--tag` flag. Additionally, you can provide a `--push` flag, which will push the built image to the Docker repository specified by the image tag. You can also prefixing the tag with a hostname for the repository you wish to push to. e.g. `bentoml containerize IrisClassifier:latest --push --tag repo-address.com:username/iris` would build a Docker image called `username/iris:latest` and push that to docker repository at repo-address.com. By default, the `containerize` command will use the current credentials provided by Docker daemon. """ saved_bundle_path = resolve_bundle_path(bento, pip_installed_bundle_path, yatai_url) _echo(f"Found Bento: {saved_bundle_path}") # fmt: off bento_metadata: "BentoServiceMetadata" = load_bento_service_metadata( saved_bundle_path) # noqa: E501 # fmt: on bento_tag = f'{bento_metadata.name}:{bento_metadata.version}' yatai_client: "YataiClient" = get_yatai_client(yatai_url) docker_build_args = {} if build_arg: for arg in build_arg: key, value = arg.split("=", 1) docker_build_args[key] = value if yatai_url is not None: spinner_message = f'Sending containerize RPC to YataiService at {yatai_url}' else: spinner_message = ( f'Containerizing {bento_tag} with local YataiService and docker ' f'daemon from local environment') with Spinner(spinner_message): tag: str = yatai_client.repository.containerize( bento=bento_tag, tag=tag, build_args=docker_build_args, push=push, ) _echo(f'\nBuild container image: {tag}', CLI_COLOR_SUCCESS)
def deploy( name, bento, namespace, labels, region, instance_type, instance_count, num_of_gunicorn_workers_per_instance, api_name, timeout, output, wait, data_capture_s3_prefix, data_capture_sample_percent, ): _echo( message= 'AWS Sagemaker deployment functionalities are being migrated to a ' 'separate tool and related CLI commands will be deprecated in BentoML ' 'itself, please use https://github.com/bentoml/aws-sagemaker-deploy ' 'going forward.', color='yellow', ) # use the DeploymentOperator name in proto to be consistent with amplitude bento_name, bento_version = bento.split(':') yatai_client = get_default_yatai_client() with Spinner('Deploying Sagemaker deployment '): result = yatai_client.deployment.create_sagemaker_deployment( name=name, namespace=namespace, labels=labels, bento_name=bento_name, bento_version=bento_version, instance_count=instance_count, instance_type=instance_type, num_of_gunicorn_workers_per_instance= num_of_gunicorn_workers_per_instance, # noqa E501 api_name=api_name, timeout=timeout, region=region, wait=wait, data_capture_s3_prefix=data_capture_s3_prefix, data_capture_sample_percent=data_capture_sample_percent, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully created AWS Sagemaker deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def deploy( namespace, name, bento, location, min_instances, max_burst, premium_plan_sku, labels, function_auth_level, output, wait, ): track_cli('deploy-create', PLATFORM_NAME) bento_name, bento_version = bento.split(':') yatai_client = YataiClient() try: with Spinner(f'Deploying {bento} to Azure Functions'): result = yatai_client.deployment.create_azure_functions_deployment( name=name, namespace=namespace, labels=labels, bento_name=bento_name, bento_version=bento_version, location=location, min_instances=min_instances, max_burst=max_burst, premium_plan_sku=premium_plan_sku, function_auth_level=function_auth_level, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status ) _echo( f'Failed to create Azure Functions deployment {name} ' f'{error_code}:{error_message}', CLI_COLOR_ERROR, ) return track_cli('deploy-create-success', PLATFORM_NAME) _echo( f'Successfully created Azure Functions deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: _echo( f'Failed to create Azure Functions deployment {name}. {str(e)}', CLI_COLOR_ERROR, )
def update( name, namespace, bento, api_name, instance_type, instance_count, num_of_gunicorn_workers_per_instance, timeout, output, wait, ): yatai_client = YataiClient() track_cli('deploy-update', PLATFORM_NAME) if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None try: with Spinner('Updating Sagemaker deployment '): result = yatai_client.deployment.update_sagemaker_deployment( namespace=namespace, deployment_name=name, bento_name=bento_name, bento_version=bento_version, instance_count=instance_count, instance_type=instance_type, num_of_gunicorn_workers_per_instance= num_of_gunicorn_workers_per_instance, # noqa E501 timeout=timeout, api_name=api_name, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) _echo(f'Failed to update AWS Sagemaker deployment {name}.' f'{error_code}:{error_message}') track_cli('deploy-update-success', PLATFORM_NAME) _echo( f'Successfully updated AWS Sagemaker deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: _echo( f'Failed to update AWS Sagemaker deployment {name}: {str(e)}', CLI_COLOR_ERROR, )
def apply(deployment_yaml, output, wait): deployment_name = deployment_yaml.get('name') yatai_client = YataiClient() with Spinner('Applying deployment'): result = yatai_client.deployment.apply(deployment_yaml, wait) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully applied deployment {deployment_name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def create(deployment_yaml, output, wait): yatai_client = get_default_yatai_client() deployment_name = deployment_yaml.get('name') with Spinner('Creating deployment '): result = yatai_client.deployment.create(deployment_yaml, wait) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully created deployment {deployment_name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def update(name, namespace, bento, memory_size, timeout, output, wait): yatai_client = YataiClient() if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None try: with Spinner('Updating Lambda deployment '): result = yatai_client.deployment.update_lambda_deployment( bento_name=bento_name, bento_version=bento_version, deployment_name=name, namespace=namespace, memory_size=memory_size, timeout=timeout, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) track_cli( 'deploy-update-failure', PLATFORM_NAME, { 'error_code': error_code, 'error_message': error_message }, ) _echo( f'Failed to update AWS Lambda deployment {name} ' f'{error_code}:{error_message}', CLI_COLOR_ERROR, ) return track_cli('deploy-update-success', PLATFORM_NAME) _echo( f'Successfully updated AWS Lambda deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: track_cli('deploy-update-failure', PLATFORM_NAME, {'error_message': str(e)}) _echo( f'Failed to updated AWS Lambda deployment {name}: {str(e)}', CLI_COLOR_ERROR, )
def update( name, bento, namespace, min_size, desired_capacity, max_size, instance_type, ami_id, output, wait, ): _echo( message='AWS EC2 deployment functionalities are being migrated to a ' 'separate tool and related CLI commands will be deprecated in BentoML ' 'itself, please use https://github.com/bentoml/aws-ec2-deploy ' 'going forward.', color='yellow', ) yatai_client = get_default_yatai_client() if bento: bento_name, bento_version = bento.split(":") else: bento_name = None bento_version = None with Spinner("Updating EC2 deployment"): update_result = yatai_client.deployment.update_ec2_deployment( deployment_name=name, bento_name=bento_name, bento_version=bento_version, namespace=namespace, min_size=min_size, desired_capacity=desired_capacity, max_size=max_size, instance_type=instance_type, ami_id=ami_id, wait=wait, ) if update_result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( update_result.status) raise CLIException(f"{error_code}:{error_message}") _print_deployment_info(update_result.deployment, output) _echo(f"Successfiully updated AWS EC2 deployment '{name}'", CLI_COLOR_SUCCESS)
def deploy( name, bento, namespace, labels, region, instance_type, instance_count, num_of_gunicorn_workers_per_instance, api_name, timeout, output, wait, data_capture_s3_prefix, data_capture_sample_percent, ): # use the DeploymentOperator name in proto to be consistent with amplitude bento_name, bento_version = bento.split(':') yatai_client = get_default_yatai_client() with Spinner('Deploying Sagemaker deployment '): result = yatai_client.deployment.create_sagemaker_deployment( name=name, namespace=namespace, labels=labels, bento_name=bento_name, bento_version=bento_version, instance_count=instance_count, instance_type=instance_type, num_of_gunicorn_workers_per_instance= num_of_gunicorn_workers_per_instance, # noqa E501 api_name=api_name, timeout=timeout, region=region, wait=wait, data_capture_s3_prefix=data_capture_s3_prefix, data_capture_sample_percent=data_capture_sample_percent, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully created AWS Sagemaker deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def deploy( namespace, name, bento, location, min_instances, max_burst, premium_plan_sku, labels, function_auth_level, output, wait, ): _echo( message= 'Azure Functions deployment functionalities are being migrated to ' 'a separate tool and related CLI commands will be deprecated in BentoML ' 'itself, please use https://github.com/bentoml/azure-functions-deploy ' 'going forward.', color='yellow', ) bento_name, bento_version = bento.split(':') yatai_client = get_default_yatai_client() with Spinner(f'Deploying {bento} to Azure Functions'): result = yatai_client.deployment.create_azure_functions_deployment( name=name, namespace=namespace, labels=labels, bento_name=bento_name, bento_version=bento_version, location=location, min_instances=min_instances, max_burst=max_burst, premium_plan_sku=premium_plan_sku, function_auth_level=function_auth_level, wait=wait, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully created Azure Functions deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def update( name, namespace, bento, api_name, instance_type, instance_count, num_of_gunicorn_workers_per_instance, timeout, output, wait, data_capture_s3_prefix, data_capture_sample_percent, ): yatai_client = get_default_yatai_client() if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None with Spinner('Updating Sagemaker deployment '): result = yatai_client.deployment.update_sagemaker_deployment( namespace=namespace, deployment_name=name, bento_name=bento_name, bento_version=bento_version, instance_count=instance_count, instance_type=instance_type, num_of_gunicorn_workers_per_instance= num_of_gunicorn_workers_per_instance, # noqa E501 timeout=timeout, api_name=api_name, wait=wait, data_capture_s3_prefix=data_capture_s3_prefix, data_capture_sample_percent=data_capture_sample_percent, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully updated AWS Sagemaker deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def get_state_after_await_action_complete(yatai_service, name, namespace, message, timeout_limit=600, wait_time=5): start_time = time.time() with Spinner(message): while (time.time() - start_time) < timeout_limit: result = describe_deployment(namespace, name, yatai_service) if (result.status.status_code == status_pb2.Status.OK and result.state.state is DeploymentState.PENDING): time.sleep(wait_time) continue else: break return result
def get_state_after_await_action_complete(yatai_service, name, namespace, message, timeout_limit=600, wait_time=5): start_time = time.time() with Spinner(message): while (time.time() - start_time) < timeout_limit: result = yatai_service.DescribeDeployment( DescribeDeploymentRequest(deployment_name=name, namespace=namespace)) if result.state.state is DeploymentState.PENDING: time.sleep(wait_time) continue else: break return result
def deploy( name, bento, namespace, region, min_size, desired_capacity, max_size, instance_type, ami_id, output, wait, ): _echo( message='AWS EC2 deployment functionalities are being migrated to a ' 'separate tool and related CLI commands will be deprecated in BentoML ' 'itself, please use https://github.com/bentoml/aws-ec2-deploy ' 'going forward.', color='yellow', ) yatai_client = get_default_yatai_client() bento_name, bento_version = bento.split(":") with Spinner(f"Deploying {bento} to AWS EC2"): result = yatai_client.deployment.create_ec2_deployment( name=name, namespace=namespace, bento_name=bento_name, bento_version=bento_version, region=region, min_size=min_size, desired_capacity=desired_capacity, max_size=max_size, instance_type=instance_type, ami_id=ami_id, wait=wait, ) if result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) raise CLIException(f'{error_code}:{error_message}') _print_deployment_info(result.deployment, output) _echo("Successfully created AWS EC2 deployment", CLI_COLOR_SUCCESS)
def apply(deployment_yaml, output, wait): track_cli('deploy-apply', deployment_yaml.get('spec', {}).get('operator')) platform_name = deployment_yaml.get('spec', {}).get('operator') deployment_name = deployment_yaml.get('name') try: yatai_client = YataiClient() with Spinner('Applying deployment'): result = yatai_client.deployment.apply(deployment_yaml, wait) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status) track_cli( 'deploy-apply-failure', platform_name, { 'error_code': error_code, 'error_message': error_message }, ) _echo( f'Failed to apply deployment {deployment_name} ' f'{error_code}:{error_message}', CLI_COLOR_ERROR, ) return track_cli('deploy-create-success', platform_name) _echo( f'Successfully applied deployment {deployment_name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: track_cli( 'deploy-apply-failure', platform_name, {'error_message': str(e)}, ) _echo( 'Failed to apply deployment {name}. Error message: {message}'. format(name=deployment_yaml.get('name'), message=e))
def update( name, namespace, bento, min_instances, max_burst, premium_plan_sku, output, wait ): yatai_client = YataiClient() track_cli('deploy-update', PLATFORM_NAME) if bento: bento_name, bento_version = bento.split(':') else: bento_name = None bento_version = None try: with Spinner(f'Updating Azure Functions deployment {name}'): result = yatai_client.deployment.update_azure_functions_deployment( namespace=namespace, deployment_name=name, bento_name=bento_name, bento_version=bento_version, min_instances=min_instances, max_burst=max_burst, premium_plan_sku=premium_plan_sku, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status ) _echo( f'Failed to update Azure Functions deployment {name}. ' f'{error_code}:{error_message}' ) track_cli('deploy-update-success', PLATFORM_NAME) _echo( f'Successfully update Azure Functions deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output) except BentoMLException as e: _echo( f'Failed to update Azure Functions deployment {name}: {str(e)}', CLI_COLOR_ERROR, )
def update( name, bento, namespace, min_size, desired_capacity, max_size, instance_type, ami_id, output, wait, ): yatai_client = get_default_yatai_client() if bento: bento_name, bento_version = bento.split(":") else: bento_name = None bento_version = None with Spinner("Updating EC2 deployment"): update_result = yatai_client.deployment.update_ec2_deployment( deployment_name=name, bento_name=bento_name, bento_version=bento_version, namespace=namespace, min_size=min_size, desired_capacity=desired_capacity, max_size=max_size, instance_type=instance_type, ami_id=ami_id, wait=wait, ) if update_result.status.status_code != yatai_proto.status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( update_result.status) raise CLIException(f"{error_code}:{error_message}") _print_deployment_info(update_result.deployment, output) _echo(f"Successfiully updated AWS EC2 deployment '{name}'", CLI_COLOR_SUCCESS)
def deploy( namespace, name, bento, location, min_instances, max_burst, premium_plan_sku, labels, function_auth_level, output, wait, ): bento_name, bento_version = bento.split(':') yatai_client = YataiClient() with Spinner(f'Deploying {bento} to Azure Functions'): result = yatai_client.deployment.create_azure_functions_deployment( name=name, namespace=namespace, labels=labels, bento_name=bento_name, bento_version=bento_version, location=location, min_instances=min_instances, max_burst=max_burst, premium_plan_sku=premium_plan_sku, function_auth_level=function_auth_level, wait=wait, ) if result.status.status_code != status_pb2.Status.OK: error_code, error_message = status_pb_to_error_code_and_message( result.status ) raise CLIException(f'{error_code}:{error_message}') _echo( f'Successfully created Azure Functions deployment {name}', CLI_COLOR_SUCCESS, ) _print_deployment_info(result.deployment, output)
def containerize(bento, push, tag, username, password): """Containerize specified BentoService. BENTO is the target BentoService to be containerized, referenced by its name and version in format of name:version. For example: "iris_classifier:v1.2.0" `bentoml containerize` command also supports the use of the `latest` tag which will automatically use the last built version of your Bento. You can provide a tag for the image built by Bento using the `--docker-image-tag` flag. Additionally, you can provide a `--push` flag, which will push the built image to the Docker repository specified by the image tag. You can also prefixing the tag with a hostname for the repository you wish to push to. e.g. `bentoml containerize IrisClassifier:latest --push --tag username/iris` would build a Docker image called `username/iris:latest` and push that to Docker Hub. By default, the `containerize` command will use the credentials provided by Docker. You may provide your own through `--username` and `--password`. """ bento_service_bundle_path = resolve_bundle_path( bento, pip_installed_bundle_path ) _echo(f"Found Bento: {bento_service_bundle_path}") name, version = get_name_version_from_tag(bento) # use tag name and version where applicable if tag is not None: name, v = get_name_version_from_tag(tag) if v is not None: version = v name, version = make_bento_name_docker_compatible(name, version) full_tag = f"{name}:{version}" if full_tag != bento: _echo( f'Bento tag was changed to be Docker compatible. \n' f'"{bento}" -> "{full_tag}"', CLI_COLOR_WARNING, ) import docker docker_api = docker.APIClient() try: with Spinner(f"Building Docker image: {name}\n"): for line in _echo_docker_api_result( docker_api.build( path=bento_service_bundle_path, tag=full_tag, decode=True, ) ): _echo(line) except docker.errors.APIError as error: raise CLIException(f'Could not build Docker image: {error}') _echo( f'Finished building {full_tag} from {bento}', CLI_COLOR_SUCCESS, ) if push: auth_config_payload = ( {"username": username, "password": password} if username or password else None ) try: with Spinner(f"Pushing docker image to {full_tag}\n"): for line in _echo_docker_api_result( docker_api.push( repository=name, tag=version, stream=True, decode=True, auth_config=auth_config_payload, ) ): _echo(line) _echo( f'Pushed {full_tag} to {name}', CLI_COLOR_SUCCESS, ) except (docker.errors.APIError, BentoMLException) as error: raise CLIException(f'Could not push Docker image: {error}')
def containerize(bento, push, tag, build_arg, username, password): """Containerize specified BentoService. BENTO is the target BentoService to be containerized, referenced by its name and version in format of name:version. For example: "iris_classifier:v1.2.0" `bentoml containerize` command also supports the use of the `latest` tag which will automatically use the last built version of your Bento. You can provide a tag for the image built by Bento using the `--docker-image-tag` flag. Additionally, you can provide a `--push` flag, which will push the built image to the Docker repository specified by the image tag. You can also prefixing the tag with a hostname for the repository you wish to push to. e.g. `bentoml containerize IrisClassifier:latest --push --tag username/iris` would build a Docker image called `username/iris:latest` and push that to Docker Hub. By default, the `containerize` command will use the credentials provided by Docker. You may provide your own through `--username` and `--password`. """ saved_bundle_path = resolve_bundle_path(bento, pip_installed_bundle_path) _echo(f"Found Bento: {saved_bundle_path}") bento_metadata = load_bento_service_metadata(saved_bundle_path) name = to_valid_docker_image_name(bento_metadata.name) version = to_valid_docker_image_version(bento_metadata.version) if not tag: _echo("Tag not specified, using tag parsed from " f"BentoService: '{name}:{version}'") tag = f"{name}:{version}" if ":" not in tag: _echo( "Image version not specified, using version parsed " f"from BentoService: '{version}'", CLI_COLOR_WARNING, ) tag = f"{tag}:{version}" docker_build_args = {} if build_arg: for arg in build_arg: key, value = arg.split("=") docker_build_args[key] = value import docker docker_api = docker.APIClient() try: with Spinner(f"Building Docker image {tag} from {bento} \n"): for line in echo_docker_api_result( docker_api.build( path=saved_bundle_path, tag=tag, decode=True, buildargs=docker_build_args, )): _echo(line) except docker.errors.APIError as error: raise CLIException(f'Could not build Docker image: {error}') _echo( f'Finished building {tag} from {bento}', CLI_COLOR_SUCCESS, ) if push: auth_config_payload = ({ "username": username, "password": password } if username or password else None) try: with Spinner(f"Pushing docker image to {tag}\n"): for line in echo_docker_api_result( docker_api.push( repository=tag, stream=True, decode=True, auth_config=auth_config_payload, )): _echo(line) _echo( f'Pushed {tag} to {name}', CLI_COLOR_SUCCESS, ) except (docker.errors.APIError, BentoMLException) as error: raise CLIException(f'Could not push Docker image: {error}')