Implementing Exponential Backoff to Deal with Service Frequency

Product Overview

Features

Product Strengths

Use Cases

Concepts

Product Introduction

Billing Overview

Purchase Method

Payment Overdue

Purchase Guide

Getting Started

Creating a Key

Viewing keys

Editing Key

Enabling/Disabling Key

Key Rotation

Encryption and Decryption

Deleting Key

Key Management

Overview

Managing Sub-account

Creating Access Control Policy

Access Control

Operations Logged by CloudAudit

Viewing Audit Logs

Audit

Console Guide

Operation Overview

Creating Key

Viewing Key

Asymmetric key decryption

 TCCLI Management Guide 

Encrypting/Decrypting Sensitive Data

 Envelope Encryption/Decryption

Symmetrical Encryption and Decryption

Asymmetric Data Encryption and Decryption

Asymmetric Signature Verification

Asymmetric Encryption and Decryption

Post-Quantum Cryptography Practice In KMS

Operation Guide

 Importing External Key

Practical Tutorial

History

Introduction

API Category

Request Structure

Common Params

Signature v3

Signature

Responses

Making API Requests

UpdateKeyDescription

UpdateAlias

ReEncrypt

ListKeys

ListKeyDetail

GetServiceStatus

GetKeyRotationStatus

GenerateDataKey

Encrypt

EnableKeys

EnableKeyRotation

EnableKey

DisableKeys

DisableKeyRotation

DisableKey

DescribeKeys

DescribeKey

Decrypt

CreateKey

ScheduleKeyDeletion

ImportKeyMaterial

GetParametersForImport

GenerateRandom

DeleteImportedKeyMaterial

CancelKeyDeletion

ListAlgorithms

UnbindCloudResource

BindCloudResource

GetRegions

CancelKeyArchive

ArchiveKey

PostQuantumCryptoEncrypt

PostQuantumCryptoDecrypt

Key APIs

GetPublicKey

AsymmetricSm2Decrypt

AsymmetricRsaDecrypt

VerifyByAsymmetricKey

SignByAsymmetricKey

PostQuantumCryptoVerify

PostQuantumCryptoSign

Asymmetric Key APIs

Data Types

Error Codes

API documentation

Service Level Agreement

FAQs

General

FAQS

Privacy Policy

Data Processing And Security Agreement

KMS Policy

Contact Us

Glossary

Key Management Service

If exceptional errors occur when you call KMS APIs to send requests from your application to the remote KMS server, you can deal with the errors as suggested below:

: if an error shows that the failure is not temporary and persists after several re-executions, you need to terminate or cancel the application call and report the error.

: if an uncommon error is returned, for example, network packets are damaged during transfer but still sent, in this case, you can try again immediately.

: if an error is generally caused by connections, it indicates that the server is busy and needs to clear the loads first. You can try again in a while in such cases.

The following paragraphs introduce how to increase delays between re-executions. The delay can be gradually increased or scheduled (by implementing exponential backoff). As the frequency of KMS API calls is limited, you can increase delays between re-executions to avoid errors caused by high frequency.

// Gradually increase re-execution delays

For(Retries = 0; Retries < MAX_RETRIES; Retries = Retries+1)

        wait for (2^Retries * InitDelayValue) milliseconds

            BREAK // Succeeded, stop calling the API again.

        ELSE IF Status = THROTTLED || Status == SERVER_NOT_READY

            CONTINUE // Failed due to throttling or server busy, try again.

            BREAK // another error occurs, stop calling the API again.

Python: implement exponential backoff for frequency errors in KMS API calls to 

from tencentcloud.common import credential

from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException

from tencentcloud.common.profile.client_profile import ClientProfile

from tencentcloud.common.profile.http_profile import HttpProfile

from tencentcloud.kms.v20190118 import kms_client, models

def KmsInit(region="ap-guangzhou", secretId="", secretKey=""):

                credProfile = credential.Credential(secretId, secretKey)

                client = kms_client.KmsClient(credProfile, region)

          except TencentCloudSDKException as err:

            DelayTime = math.pow(2, RetryCount) * InitDelayValue

            secretId = "replace-with-real-secretId"

            secretKey = "replace-with-real-secretKey"

            keyId = "replace-with-realkeyid"

            plaintext = "abcdefg123456789abcdefg123456789abcdefg"

            client = KmsInit(region, secretId, secretKey)

            req = models.EncryptRequest()

            req.Plaintext = base64.b64encode(plaintext)

                    rsp = client.Encrypt(req)  # Call the API `Encrypt`

                    print 'plaintext: ',plaintext,'CiphertextBlob: ',rsp.CiphertextBlob

                except TencentCloudSDKException as err:

                    if err.code == 'InternalError' or err.code == 'RequestLimitExceeded':

                        if Retries == MaxRetries: 

                        time.sleep(BackoffFunction(Retries + 1))

To deal with other specific errors, you can directly modify the content of the statement 

You can customize the schedule policy based on your code logic and business policy to set the optimal initial delay value (InitDelayValue) and the number of retries (Retries), preventing your business from being affected by a too-low or too-high threshold.

tencent cloud