コード例 #1
0
    def _add(self, deployment_pb, bento_pb, bento_path):
        if loader._is_remote_path(bento_path):
            with loader._resolve_remote_bundle_path(bento_path) as local_path:
                return self._add(deployment_pb, bento_pb, local_path)

        deployment_spec = deployment_pb.spec
        lambda_deployment_config = deployment_spec.aws_lambda_operator_config
        bento_service_metadata = bento_pb.bento.bento_service_metadata
        lambda_s3_bucket = generate_aws_compatible_string(
            'btml-{namespace}-{name}-{random_string}'.format(
                namespace=deployment_pb.namespace,
                name=deployment_pb.name,
                random_string=uuid.uuid4().hex[:6].lower(),
            )
        )
        try:
            create_s3_bucket_if_not_exists(
                lambda_s3_bucket, lambda_deployment_config.region
            )
            _deploy_lambda_function(
                deployment_pb=deployment_pb,
                bento_service_metadata=bento_service_metadata,
                deployment_spec=deployment_spec,
                lambda_s3_bucket=lambda_s3_bucket,
                lambda_deployment_config=lambda_deployment_config,
                bento_path=bento_path,
            )
            return ApplyDeploymentResponse(status=Status.OK(), deployment=deployment_pb)
        except BentoMLException as error:
            if lambda_s3_bucket and lambda_deployment_config:
                _cleanup_s3_bucket_if_exist(
                    lambda_s3_bucket, lambda_deployment_config.region
                )
            raise error
コード例 #2
0
    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)
コード例 #3
0
ファイル: __init__.py プロジェクト: seo-inyoung/BentoML
    def _add(self, deployment_pb, bento_pb, bento_path):
        if loader._is_remote_path(bento_path):
            with loader._resolve_remote_bundle_path(bento_path) as local_path:
                return self._add(deployment_pb, bento_pb, local_path)

        deployment_spec = deployment_pb.spec
        sagemaker_config = deployment_spec.sagemaker_operator_config

        raise_if_api_names_not_found_in_bento_service_metadata(
            bento_pb.bento.bento_service_metadata, [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,
                bento_pb.bento.bento_service_metadata.env.docker_base_image,
            )
            ecr_image_path = create_and_push_docker_image_to_ecr(
                sagemaker_config.region,
                deployment_spec.bento_name,
                deployment_spec.bento_version,
                sagemaker_project_dir,
            )

        try:
            (
                sagemaker_model_name,
                sagemaker_endpoint_config_name,
                sagemaker_endpoint_name,
            ) = _get_sagemaker_resource_names(deployment_pb)

            _create_sagemaker_model(sagemaker_client, sagemaker_model_name,
                                    ecr_image_path, sagemaker_config)
            _create_sagemaker_endpoint_config(
                sagemaker_client,
                sagemaker_model_name,
                sagemaker_endpoint_config_name,
                sagemaker_config,
            )
            _create_sagemaker_endpoint(
                sagemaker_client,
                sagemaker_endpoint_name,
                sagemaker_endpoint_config_name,
            )
        except AWSServiceError as e:
            delete_sagemaker_deployment_resources_if_exist(deployment_pb)
            raise e

        return ApplyDeploymentResponse(status=Status.OK(),
                                       deployment=deployment_pb)
コード例 #4
0
    def _update(self, deployment_pb, current_deployment, bento_pb, bento_path):
        if loader._is_remote_path(bento_path):
            with loader._resolve_remote_bundle_path(bento_path) as local_path:
                return self._update(
                    deployment_pb, current_deployment, bento_pb, local_path
                )
        updated_deployment_spec = deployment_pb.spec
        updated_lambda_deployment_config = (
            updated_deployment_spec.aws_lambda_operator_config
        )
        updated_bento_service_metadata = bento_pb.bento.bento_service_metadata
        describe_result = self.describe(deployment_pb)
        if describe_result.status.status_code != status_pb2.Status.OK:
            error_code, error_message = status_pb_to_error_code_and_message(
                describe_result.status
            )
            raise YataiDeploymentException(
                f'Failed fetching Lambda deployment current status - '
                f'{error_code}:{error_message}'
            )
        latest_deployment_state = json.loads(describe_result.state.info_json)
        if 's3_bucket' in latest_deployment_state:
            lambda_s3_bucket = latest_deployment_state['s3_bucket']
        else:
            raise BentoMLException(
                'S3 Bucket is missing in the AWS Lambda deployment, please make sure '
                'it exists and try again'
            )

        _deploy_lambda_function(
            deployment_pb=deployment_pb,
            bento_service_metadata=updated_bento_service_metadata,
            deployment_spec=updated_deployment_spec,
            lambda_s3_bucket=lambda_s3_bucket,
            lambda_deployment_config=updated_lambda_deployment_config,
            bento_path=bento_path,
        )

        return ApplyDeploymentResponse(deployment=deployment_pb, status=Status.OK())
コード例 #5
0
ファイル: __init__.py プロジェクト: yoavz/BentoML
    def _add(self, deployment_pb, bento_pb, bento_path):
        if loader._is_remote_path(bento_path):
            with loader._resolve_remote_bundle_path(bento_path) as local_path:
                return self._add(deployment_pb, bento_pb, local_path)

        deployment_spec = deployment_pb.spec
        lambda_deployment_config = deployment_spec.aws_lambda_operator_config
        bento_service_metadata = bento_pb.bento.bento_service_metadata
        lambda_s3_bucket = generate_aws_compatible_string(
            'btml-{namespace}-{name}-{random_string}'.format(
                namespace=deployment_pb.namespace,
                name=deployment_pb.name,
                random_string=uuid.uuid4().hex[:6].lower(),
            ))

        try:
            py_major, py_minor, _ = bento_service_metadata.env.python_version.split(
                '.')
            if py_major != '3':
                raise BentoMLException(
                    'Python 2 is not supported for Lambda Deployment')
            python_runtime = 'python{}.{}'.format(py_major, py_minor)

            artifact_types = [
                item.artifact_type for item in bento_service_metadata.artifacts
            ]
            if any(i in ['TensorflowSavedModelArtifact', 'KerasModelArtifact']
                   for i in artifact_types) and (py_major, py_minor) != ('3',
                                                                         '6'):
                raise BentoMLException(
                    'For Tensorflow and Keras model, only python3.6 is '
                    'supported for AWS Lambda deployment')

            api_names = ([lambda_deployment_config.api_name]
                         if lambda_deployment_config.api_name else
                         [api.name for api in bento_service_metadata.apis])

            raise_if_api_names_not_found_in_bento_service_metadata(
                bento_service_metadata, api_names)

            create_s3_bucket_if_not_exists(lambda_s3_bucket,
                                           lambda_deployment_config.region)
            deployment_path_prefix = os.path.join(deployment_pb.namespace,
                                                  deployment_pb.name)
            with TempDirectory() as lambda_project_dir:
                logger.debug(
                    'Generating cloudformation template.yaml for lambda project at %s',
                    lambda_project_dir,
                )
                template_file_path = _create_aws_lambda_cloudformation_template_file(
                    project_dir=lambda_project_dir,
                    namespace=deployment_pb.namespace,
                    deployment_name=deployment_pb.name,
                    deployment_path_prefix=deployment_path_prefix,
                    api_names=api_names,
                    bento_service_name=deployment_spec.bento_name,
                    s3_bucket_name=lambda_s3_bucket,
                    py_runtime=python_runtime,
                    memory_size=lambda_deployment_config.memory_size,
                    timeout=lambda_deployment_config.timeout,
                )
                logger.debug('Validating generated template.yaml')
                validate_lambda_template(
                    template_file_path,
                    lambda_deployment_config.region,
                    lambda_project_dir,
                )
                logger.debug(
                    'Initializing lambda project in directory: %s ...',
                    lambda_project_dir,
                )
                init_sam_project(
                    lambda_project_dir,
                    bento_path,
                    deployment_pb.name,
                    deployment_spec.bento_name,
                    api_names,
                    aws_region=lambda_deployment_config.region,
                )
                for api_name in api_names:
                    build_directory = os.path.join(lambda_project_dir,
                                                   '.aws-sam', 'build',
                                                   api_name)
                    logger.debug(
                        'Checking is function "%s" bundle under lambda size '
                        'limit',
                        api_name,
                    )
                    # Since we only use s3 get object in lambda function, and
                    # lambda function pack their own boto3/botocore modules,
                    # we will just delete those modules from function bundle
                    # directory
                    delete_list = ['boto3', 'botocore']
                    for name in delete_list:
                        logger.debug('Remove module "%s" from build directory',
                                     name)
                        shutil.rmtree(os.path.join(build_directory, name))
                    total_build_dir_size = total_file_or_directory_size(
                        build_directory)
                    if total_build_dir_size > LAMBDA_FUNCTION_MAX_LIMIT:
                        raise BentoMLException(
                            'Build function size is over 700MB, max size '
                            'capable for AWS Lambda function')
                    if total_build_dir_size >= LAMBDA_FUNCTION_LIMIT:
                        logger.debug(
                            'Function %s is over lambda size limit, attempting '
                            'reduce it',
                            api_name,
                        )
                        reduce_bundle_size_and_upload_extra_resources_to_s3(
                            build_directory=build_directory,
                            region=lambda_deployment_config.region,
                            s3_bucket=lambda_s3_bucket,
                            deployment_prefix=deployment_path_prefix,
                            function_name=api_name,
                            lambda_project_dir=lambda_project_dir,
                        )
                    else:
                        logger.debug(
                            'Function bundle is within Lambda limit, removing '
                            'download_extra_resources.py file from function bundle'
                        )
                        os.remove(
                            os.path.join(build_directory,
                                         'download_extra_resources.py'))
                logger.info('Packaging AWS Lambda project at %s ...',
                            lambda_project_dir)
                lambda_package(
                    lambda_project_dir,
                    lambda_deployment_config.region,
                    lambda_s3_bucket,
                    deployment_path_prefix,
                )
                logger.info('Deploying lambda project')
                stack_name = generate_aws_compatible_string(
                    deployment_pb.namespace + '-' + deployment_pb.name)
                lambda_deploy(
                    lambda_project_dir,
                    lambda_deployment_config.region,
                    stack_name=stack_name,
                )

            deployment_pb.state.state = DeploymentState.PENDING
            return ApplyDeploymentResponse(status=Status.OK(),
                                           deployment=deployment_pb)
        except BentoMLException as error:
            if lambda_s3_bucket and lambda_deployment_config:
                _cleanup_s3_bucket_if_exist(lambda_s3_bucket,
                                            lambda_deployment_config.region)
            raise error
コード例 #6
0
ファイル: __init__.py プロジェクト: seo-inyoung/BentoML
    def _update(self, deployment_pb, current_deployment, bento_pb, bento_path):
        if loader._is_remote_path(bento_path):
            with loader._resolve_remote_bundle_path(bento_path) as local_path:
                return self._update(deployment_pb, current_deployment,
                                    bento_pb, local_path)
        updated_deployment_spec = deployment_pb.spec
        updated_sagemaker_config = updated_deployment_spec.sagemaker_operator_config
        sagemaker_client = boto3.client('sagemaker',
                                        updated_sagemaker_config.region)

        try:
            raise_if_api_names_not_found_in_bento_service_metadata(
                bento_pb.bento.bento_service_metadata,
                [updated_sagemaker_config.api_name],
            )
            describe_latest_deployment_state = self.describe(deployment_pb)
            current_deployment_spec = current_deployment.spec
            current_sagemaker_config = current_deployment_spec.sagemaker_operator_config
            latest_deployment_state = json.loads(
                describe_latest_deployment_state.state.info_json)

            current_ecr_image_tag = latest_deployment_state[
                'ProductionVariants'][0]['DeployedImages'][0]['SpecifiedImage']
            if (updated_deployment_spec.bento_name !=
                    current_deployment_spec.bento_name
                    or updated_deployment_spec.bento_version !=
                    current_deployment_spec.bento_version):
                logger.debug(
                    'BentoService tag is different from current deployment, '
                    'creating new docker image and push to ECR')
                with TempDirectory() as temp_dir:
                    sagemaker_project_dir = os.path.join(
                        temp_dir, updated_deployment_spec.bento_name)
                    _init_sagemaker_project(
                        sagemaker_project_dir,
                        bento_path,
                        bento_pb.bento.bento_service_metadata.env.
                        docker_base_image,
                    )
                    ecr_image_path = create_and_push_docker_image_to_ecr(
                        updated_sagemaker_config.region,
                        updated_deployment_spec.bento_name,
                        updated_deployment_spec.bento_version,
                        sagemaker_project_dir,
                    )
            else:
                logger.debug('Using existing ECR image for Sagemaker model')
                ecr_image_path = current_ecr_image_tag

            (
                updated_sagemaker_model_name,
                updated_sagemaker_endpoint_config_name,
                sagemaker_endpoint_name,
            ) = _get_sagemaker_resource_names(deployment_pb)
            (
                current_sagemaker_model_name,
                current_sagemaker_endpoint_config_name,
                _,
            ) = _get_sagemaker_resource_names(current_deployment)

            if (updated_sagemaker_config.api_name !=
                    current_sagemaker_config.api_name
                    or updated_sagemaker_config.
                    num_of_gunicorn_workers_per_instance !=
                    current_sagemaker_config.
                    num_of_gunicorn_workers_per_instance
                    or ecr_image_path != current_ecr_image_tag):
                logger.debug(
                    'Sagemaker model requires update. Delete current sagemaker model %s'
                    'and creating new model %s',
                    current_sagemaker_model_name,
                    updated_sagemaker_model_name,
                )
                _delete_sagemaker_model_if_exist(sagemaker_client,
                                                 current_sagemaker_model_name)
                _create_sagemaker_model(
                    sagemaker_client,
                    updated_sagemaker_model_name,
                    ecr_image_path,
                    updated_sagemaker_config,
                )
            # When bento service tag is not changed, we need to delete the current
            # endpoint configuration in order to create new one to avoid name collation
            if (current_sagemaker_endpoint_config_name ==
                    updated_sagemaker_endpoint_config_name):
                logger.debug(
                    'Current sagemaker config name %s is same as updated one, '
                    'delete it before create new endpoint config',
                    current_sagemaker_endpoint_config_name,
                )
                _delete_sagemaker_endpoint_config_if_exist(
                    sagemaker_client, current_sagemaker_endpoint_config_name)
            logger.debug(
                'Create new endpoint configuration %s',
                updated_sagemaker_endpoint_config_name,
            )
            _create_sagemaker_endpoint_config(
                sagemaker_client,
                updated_sagemaker_model_name,
                updated_sagemaker_endpoint_config_name,
                updated_sagemaker_config,
            )
            logger.debug(
                'Updating endpoint to new endpoint configuration %s',
                updated_sagemaker_endpoint_config_name,
            )
            _update_sagemaker_endpoint(
                sagemaker_client,
                sagemaker_endpoint_name,
                updated_sagemaker_endpoint_config_name,
            )
            logger.debug(
                'Delete old sagemaker endpoint config %s',
                current_sagemaker_endpoint_config_name,
            )
            _delete_sagemaker_endpoint_config_if_exist(
                sagemaker_client, current_sagemaker_endpoint_config_name)
        except AWSServiceError as e:
            delete_sagemaker_deployment_resources_if_exist(deployment_pb)
            raise e

        return ApplyDeploymentResponse(status=Status.OK(),
                                       deployment=deployment_pb)
コード例 #7
0
    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)