create_tiering_configuration async ¶

async def create_tiering_configuration(
    self,
    tiering_configuration: "capo_backup.types.tiering_configuration_input_for_create.TieringConfigurationInputForCreate",
    *,
    config_overrides: Optional[AsyncBackupClientConfig] = None,
    tiering_configuration_tags: Optional["capo_backup.types.tags.Tags"] = None,
    creator_request_id: Optional[
        "capo_backup.types.creator_request_id.CreatorRequestId"
    ] = None,
) -> "capo_backup.types.create_tiering_configuration_output.CreateTieringConfigurationOutput":
    """<p>Creates a tiering configuration.</p> <p>A tiering configuration enables automatic movement of backup data to a lower-cost storage tier based on the age of backed-up objects in the backup vault.</p> <p>Each vault can only have one vault-specific tiering configuration, in addition to any global configuration that applies to all vaults.</p>

    Args:
        tiering_configuration: <p>A tiering configuration must contain a unique <code>TieringConfigurationName</code> string you create and must contain a <code>BackupVaultName</code> and <code>ResourceSelection</code>. You may optionally include a <code>CreatorRequestId</code> string.</p> <p>The <code>TieringConfigurationName</code> is a unique string that is the name of the tiering configuration. This cannot be changed after creation, and it must consist of only alphanumeric characters and underscores.</p>
        tiering_configuration_tags: <p>The tags to assign to the tiering configuration.</p>
        creator_request_id: <p>This is a unique string that identifies the request and allows failed requests to be retried without the risk of running the operation twice. This parameter is optional. If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.</p>

    Raises:
        capo_backup.errors.already_exists_exception.AlreadyExistsException: <p>The required resource already exists.</p>
        capo_backup.errors.conflict_exception.ConflictException: <p>Backup can't perform the action that you requested until it finishes performing a previous action. Try again later.</p>
        capo_backup.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>Indicates that something is wrong with a parameter's value. For example, the value is out of range.</p>
        capo_backup.errors.limit_exceeded_exception.LimitExceededException: <p>A limit in the request has been exceeded; for example, a maximum number of items allowed in a request.</p>
        capo_backup.errors.missing_parameter_value_exception.MissingParameterValueException: <p>Indicates that a required parameter is missing.</p>
        capo_backup.errors.service_unavailable_exception.ServiceUnavailableException: <p>The request failed due to a temporary failure of the server.</p>
        capo_backup.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_backup.types.create_tiering_configuration_input.CreateTieringConfigurationInput]",
    ) -> AsyncOperationResponse[
        "capo_backup.types.create_tiering_configuration_output.CreateTieringConfigurationOutput"
    ]:
        import capo_backup._operations.cryo_controller_user_manager.create_tiering_configuration

        (
            output,
            http_response,
        ) = await capo_backup._operations.cryo_controller_user_manager.create_tiering_configuration.async_create_tiering_configuration(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_backup.types.create_tiering_configuration_input.CreateTieringConfigurationInput",
    ) -> dict[str, Any]:
        import capo_backup.types.create_tiering_configuration_input

        return (
            capo_backup.types.create_tiering_configuration_input.redact_sensitive(
                input_
            )
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging("CreateTieringConfiguration", redact_input=_redact_input),
    )
    input_: capo_backup.types.create_tiering_configuration_input.CreateTieringConfigurationInput = {
        "tiering_configuration": tiering_configuration
    }
    if tiering_configuration_tags is not None:
        input_["tiering_configuration_tags"] = tiering_configuration_tags
    if creator_request_id is None:
        creator_request_id = str(uuid.uuid4())
    input_["creator_request_id"] = creator_request_id

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output