register_certificate async ¶

async def register_certificate(
    self,
    certificate_pem: "capo_iot.types.certificate_pem.CertificatePem",
    *,
    config_overrides: Optional[AsyncIoTClientConfig] = None,
    ca_certificate_pem: Optional[
        "capo_iot.types.certificate_pem.CertificatePem"
    ] = None,
    set_as_active: Optional[
        "capo_iot.types.set_as_active_flag.SetAsActiveFlag"
    ] = None,
    status: Optional["capo_iot.types.certificate_status.CertificateStatus"] = None,
) -> "capo_iot.types.register_certificate_response.RegisterCertificateResponse":
    """<p>Registers a device certificate with IoT in the same <a href="https://docs.aws.amazon.com/iot/latest/apireference/API_CertificateDescription.html#iot-Type-CertificateDescription-certificateMode">certificate mode</a> as the signing CA. If you have more than one CA certificate that has the same subject field, you must specify the CA certificate that was used to sign the device certificate being registered.</p> <p>Requires permission to access the <a href="https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions">RegisterCertificate</a> action.</p>

    Args:
        certificate_pem: <p>The certificate data, in PEM format.</p>
        ca_certificate_pem: <p>The CA certificate used to sign the device certificate being registered.</p>
        set_as_active: <p>A boolean value that specifies if the certificate is set to active.</p> <p>Valid values: <code>ACTIVE | INACTIVE</code> </p>
        status: <p>The status of the register certificate request. Valid values that you can use include <code>ACTIVE</code>, <code>INACTIVE</code>, and <code>REVOKED</code>.</p>

    Raises:
        capo_iot.errors.certificate_conflict_exception.CertificateConflictException: <p>Unable to verify the CA certificate used to sign the device certificate you are attempting to register. This is happens when you have registered more than one CA certificate that has the same subject field and public key.</p>
        capo_iot.errors.certificate_state_exception.CertificateStateException: <p>The certificate operation is not allowed.</p>
        capo_iot.errors.certificate_validation_exception.CertificateValidationException: <p>The certificate is invalid.</p>
        capo_iot.errors.internal_failure_exception.InternalFailureException: <p>An unexpected error has occurred.</p>
        capo_iot.errors.invalid_request_exception.InvalidRequestException: <p>The request is not valid.</p>
        capo_iot.errors.resource_already_exists_exception.ResourceAlreadyExistsException: <p>The resource already exists.</p>
        capo_iot.errors.service_unavailable_exception.ServiceUnavailableException: <p>The service is temporarily unavailable.</p>
        capo_iot.errors.throttling_exception.ThrottlingException: <p>The rate exceeds the limit.</p>
        capo_iot.errors.unauthorized_exception.UnauthorizedException: <p>You are not authorized to perform this operation.</p>
        capo_iot.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_iot.types.register_certificate_request.RegisterCertificateRequest]",
    ) -> AsyncOperationResponse[
        "capo_iot.types.register_certificate_response.RegisterCertificateResponse"
    ]:
        import capo_iot._operations.aws_iot_service.register_certificate

        (
            output,
            http_response,
        ) = await capo_iot._operations.aws_iot_service.register_certificate.async_register_certificate(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("RegisterCertificate")
    )
    input_: capo_iot.types.register_certificate_request.RegisterCertificateRequest = {
        "certificate_pem": certificate_pem
    }
    if ca_certificate_pem is not None:
        input_["ca_certificate_pem"] = ca_certificate_pem
    if set_as_active is not None:
        input_["set_as_active"] = set_as_active
    if status is not None:
        input_["status"] = status

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