create_replication_configuration_template async ¶

async def create_replication_configuration_template(
    self,
    staging_area_subnet_id: "capo_drs.types.subnet_id.SubnetID",
    replication_servers_security_groups_i_ds: "capo_drs.types.replication_servers_security_groups_i_ds.ReplicationServersSecurityGroupsIDs",
    ebs_encryption: "capo_drs.types.replication_configuration_ebs_encryption.ReplicationConfigurationEbsEncryption",
    bandwidth_throttling: "capo_drs.types.positive_integer.PositiveInteger",
    staging_area_tags: "capo_drs.types.tags_map.TagsMap",
    pit_policy: "capo_drs.types.pit_policy.PITPolicy",
    *,
    config_overrides: Optional[AsyncdrsClientConfig] = None,
    associate_default_security_group: Optional[bool] = None,
    replication_server_instance_type: Optional[
        "capo_drs.types.ec2_instance_type.EC2InstanceType"
    ] = None,
    use_dedicated_replication_server: Optional[bool] = None,
    default_large_staging_disk_type: Optional[
        "capo_drs.types.replication_configuration_default_large_staging_disk_type.ReplicationConfigurationDefaultLargeStagingDiskType"
    ] = None,
    ebs_encryption_key_arn: Optional["capo_drs.types.arn.ARN"] = None,
    data_plane_routing: Optional[
        "capo_drs.types.replication_configuration_data_plane_routing.ReplicationConfigurationDataPlaneRouting"
    ] = None,
    create_public_ip: Optional[bool] = None,
    tags: Optional["capo_drs.types.tags_map.TagsMap"] = None,
    auto_replicate_new_disks: Optional[bool] = None,
    internet_protocol: Optional[
        "capo_drs.types.internet_protocol.InternetProtocol"
    ] = None,
) -> "capo_drs.types.replication_configuration_template.ReplicationConfigurationTemplate":
    """<p>Creates a new ReplicationConfigurationTemplate.</p>

    Args:
        staging_area_subnet_id: <p>The subnet to be used by the replication staging area.</p>
        associate_default_security_group: <p>Whether to associate the default Elastic Disaster Recovery Security group with the Replication Configuration Template.</p>
        replication_servers_security_groups_i_ds: <p>The security group IDs that will be used by the replication server.</p>
        replication_server_instance_type: <p>The instance type to be used for the replication server.</p>
        use_dedicated_replication_server: <p>Whether to use a dedicated Replication Server in the replication staging area.</p>
        default_large_staging_disk_type: <p>The Staging Disk EBS volume type to be used during replication.</p>
        ebs_encryption: <p>The type of EBS encryption to be used during replication.</p>
        ebs_encryption_key_arn: <p>The ARN of the EBS encryption key to be used during replication.</p>
        bandwidth_throttling: <p>Configure bandwidth throttling for the outbound data transfer rate of the Source Server in Mbps.</p>
        data_plane_routing: <p>The data plane routing mechanism that will be used for replication.</p>
        create_public_ip: <p>Whether to create a Public IP for the Recovery Instance by default.</p>
        staging_area_tags: <p>A set of tags to be associated with all resources created in the replication staging area: EC2 replication server, EBS volumes, EBS snapshots, etc.</p>
        pit_policy: <p>The Point in time (PIT) policy to manage snapshots taken during replication.</p>
        tags: <p>A set of tags to be associated with the Replication Configuration Template resource.</p>
        auto_replicate_new_disks: <p>Whether to allow the AWS replication agent to automatically replicate newly added disks.</p>
        internet_protocol: <p>Which version of the Internet Protocol to use for replication of data. (IPv4 or IPv6)</p>

    Raises:
        capo_drs.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_drs.errors.internal_server_exception.InternalServerException: <p>The request processing has failed because of an unknown error, exception or failure.</p>
        capo_drs.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request could not be completed because its exceeded the service quota.</p>
        capo_drs.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_drs.errors.uninitialized_account_exception.UninitializedAccountException: <p>The account performing the request has not been initialized.</p>
        capo_drs.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by the AWS service.</p>
        capo_drs.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_drs.types.create_replication_configuration_template_request.CreateReplicationConfigurationTemplateRequest]",
    ) -> AsyncOperationResponse[
        "capo_drs.types.replication_configuration_template.ReplicationConfigurationTemplate"
    ]:
        import capo_drs._operations.elastic_disaster_recovery_service.create_replication_configuration_template

        (
            output,
            http_response,
        ) = await capo_drs._operations.elastic_disaster_recovery_service.create_replication_configuration_template.async_create_replication_configuration_template(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_drs.types.create_replication_configuration_template_request.CreateReplicationConfigurationTemplateRequest",
    ) -> dict[str, Any]:
        import capo_drs.types.create_replication_configuration_template_request

        return capo_drs.types.create_replication_configuration_template_request.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_drs.types.replication_configuration_template.ReplicationConfigurationTemplate",
    ) -> dict[str, Any]:
        import capo_drs.types.replication_configuration_template

        return capo_drs.types.replication_configuration_template.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "CreateReplicationConfigurationTemplate",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_drs.types.create_replication_configuration_template_request.CreateReplicationConfigurationTemplateRequest = {
        "staging_area_subnet_id": staging_area_subnet_id,
        "replication_servers_security_groups_i_ds": replication_servers_security_groups_i_ds,
        "ebs_encryption": ebs_encryption,
        "bandwidth_throttling": bandwidth_throttling,
        "staging_area_tags": staging_area_tags,
        "pit_policy": pit_policy,
    }
    if associate_default_security_group is not None:
        input_["associate_default_security_group"] = (
            associate_default_security_group
        )
    if replication_server_instance_type is not None:
        input_["replication_server_instance_type"] = (
            replication_server_instance_type
        )
    if use_dedicated_replication_server is not None:
        input_["use_dedicated_replication_server"] = (
            use_dedicated_replication_server
        )
    if default_large_staging_disk_type is not None:
        input_["default_large_staging_disk_type"] = default_large_staging_disk_type
    if ebs_encryption_key_arn is not None:
        input_["ebs_encryption_key_arn"] = ebs_encryption_key_arn
    if data_plane_routing is not None:
        input_["data_plane_routing"] = data_plane_routing
    if create_public_ip is not None:
        input_["create_public_ip"] = create_public_ip
    if tags is not None:
        input_["tags"] = tags
    if auto_replicate_new_disks is not None:
        input_["auto_replicate_new_disks"] = auto_replicate_new_disks
    if internet_protocol is not None:
        input_["internet_protocol"] = internet_protocol

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