DefaultAsyncClient (alibabacloud-kms20160120 1.0.4 API)

java.lang.Object
- com.aliyun.sdk.service.kms20160120.DefaultAsyncClient

所有已实现的接口:

com.aliyun.core.utils.SdkAutoCloseable, AsyncClient, AutoCloseable
```
public final class DefaultAsyncClient
extends Object
implements AsyncClient
```
Main client.

字段概要

字段
限定符和类型	字段和说明
`protected Map<String,String>`	`endpointMap`
`protected String`	`endpointRule`
`protected darabonba.core.TeaAsyncHandler`	`handler`
`protected String`	`product`
`protected darabonba.core.TeaRequest`	`REQUEST`
`protected String`	`version`

构造器概要

构造器
限定符构造器和说明

protected DefaultAsyncClient(darabonba.core.client.ClientConfiguration configuration)

构造器
限定符	构造器和说明
`protected`	`DefaultAsyncClient(darabonba.core.client.ClientConfiguration configuration)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`CompletableFuture<AsymmetricDecryptResponse>`	`asymmetricDecrypt(AsymmetricDecryptRequest request)` This operation supports only asymmetric keys for which the Usage parameter is set to ENCRYPT/DECRYPT.
`CompletableFuture<AsymmetricEncryptResponse>`	`asymmetricEncrypt(AsymmetricEncryptRequest request)` This operation is supported only for asymmetric keys for which the Usage parameter is set to ENCRYPT/DECRYPT.
`CompletableFuture<AsymmetricSignResponse>`	`asymmetricSign(AsymmetricSignRequest request)` Generates a signature by using an asymmetric key.
`CompletableFuture<AsymmetricVerifyResponse>`	`asymmetricVerify(AsymmetricVerifyRequest request)` This operation supports only asymmetric keys for which the Usage parameter is set to SIGN/VERIFY.
`CompletableFuture<CancelKeyDeletionResponse>`	`cancelKeyDeletion(CancelKeyDeletionRequest request)` If the deletion task of a CMK is canceled, the CMK returns to the Enabled state.
`CompletableFuture<CertificatePrivateKeyDecryptResponse>`	`certificatePrivateKeyDecrypt(CertificatePrivateKeyDecryptRequest request)` Limit: The encryption algorithm in the request parameters must match the key type.
`CompletableFuture<CertificatePrivateKeySignResponse>`	`certificatePrivateKeySign(CertificatePrivateKeySignRequest request)` The signature algorithm in the request parameters must match the key type.
`CompletableFuture<CertificatePublicKeyEncryptResponse>`	`certificatePublicKeyEncrypt(CertificatePublicKeyEncryptRequest request)` Limit: The encryption algorithm in the request parameters must match the key type.
`CompletableFuture<CertificatePublicKeyVerifyResponse>`	`certificatePublicKeyVerify(CertificatePublicKeyVerifyRequest request)` The signature algorithm in the request parameters must match the key type.
`void`	`close()`
`CompletableFuture<ConnectKmsInstanceResponse>`	`connectKmsInstance(ConnectKmsInstanceRequest request)`
`CompletableFuture<CreateAliasResponse>`	`createAlias(CreateAliasRequest request)` * Each alias can be bound to only one CMK at a time
`CompletableFuture<CreateApplicationAccessPointResponse>`	`createApplicationAccessPoint(CreateApplicationAccessPointRequest request)`
`CompletableFuture<CreateCertificateResponse>`	`createCertificate(CreateCertificateRequest request)` To create a certificate, you must specify the type of the asymmetric key.
`CompletableFuture<CreateClientKeyResponse>`	`createClientKey(CreateClientKeyRequest request)`
`CompletableFuture<CreateKeyResponse>`	`createKey(CreateKeyRequest request)` Creates a customer master key (CMK).
`CompletableFuture<CreateKeyVersionResponse>`	`createKeyVersion(CreateKeyVersionRequest request)` * You can create a version only for an asymmetric CMK that is in the Enabled state.
`CompletableFuture<CreateNetworkRuleResponse>`	`createNetworkRule(CreateNetworkRuleRequest request)`
`CompletableFuture<CreatePolicyResponse>`	`createPolicy(CreatePolicyRequest request)`
`CompletableFuture<CreateSecretResponse>`	`createSecret(CreateSecretRequest request)` The name of the secret.
`CompletableFuture<DecryptResponse>`	`decrypt(DecryptRequest request)`
`CompletableFuture<DeleteAliasResponse>`	`deleteAlias(DeleteAliasRequest request)`
`CompletableFuture<DeleteApplicationAccessPointResponse>`	`deleteApplicationAccessPoint(DeleteApplicationAccessPointRequest request)`
`CompletableFuture<DeleteCertificateResponse>`	`deleteCertificate(DeleteCertificateRequest request)` After the certificate and its private key and certificate chain are deleted, they cannot be restored.
`CompletableFuture<DeleteClientKeyResponse>`	`deleteClientKey(DeleteClientKeyRequest request)`
`CompletableFuture<DeleteKeyMaterialResponse>`	`deleteKeyMaterial(DeleteKeyMaterialRequest request)` This operation does not delete the CMK that is created by using the key material.
`CompletableFuture<DeleteNetworkRuleResponse>`	`deleteNetworkRule(DeleteNetworkRuleRequest request)`
`CompletableFuture<DeletePolicyResponse>`	`deletePolicy(DeletePolicyRequest request)`
`CompletableFuture<DeleteSecretResponse>`	`deleteSecret(DeleteSecretRequest request)` If you call this operation without specifying a recovery period, the deleted secret can be recovered within 30 days.
`CompletableFuture<DescribeAccountKmsStatusResponse>`	`describeAccountKmsStatus(DescribeAccountKmsStatusRequest request)`
`CompletableFuture<DescribeApplicationAccessPointResponse>`	`describeApplicationAccessPoint(DescribeApplicationAccessPointRequest request)`
`CompletableFuture<DescribeCertificateResponse>`	`describeCertificate(DescribeCertificateRequest request)` In this example, the information about the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` is queried.
`CompletableFuture<DescribeKeyResponse>`	`describeKey(DescribeKeyRequest request)` You can query the information about the CMK `05754286-3ba2-4fa6-8d41-4323aca6****` by using parameter settings provided in this topic.
`CompletableFuture<DescribeKeyVersionResponse>`	`describeKeyVersion(DescribeKeyVersionRequest request)` This topic provides an example on how to query the information about a version of the CMK `1234abcd-12ab-34cd-56ef-12345678****`.
`CompletableFuture<DescribeNetworkRuleResponse>`	`describeNetworkRule(DescribeNetworkRuleRequest request)`
`CompletableFuture<DescribePolicyResponse>`	`describePolicy(DescribePolicyRequest request)`
`CompletableFuture<DescribeRegionsResponse>`	`describeRegions(DescribeRegionsRequest request)`
`CompletableFuture<DescribeSecretResponse>`	`describeSecret(DescribeSecretRequest request)` This operation returns the metadata of a secret.
`CompletableFuture<DisableKeyResponse>`	`disableKey(DisableKeyRequest request)` If a customer master key (CMK) is disabled, the ciphertext encrypted by using this CMK cannot be decrypted until you re-enable it.
`CompletableFuture<EnableKeyResponse>`	`enableKey(EnableKeyRequest request)`
`CompletableFuture<EncryptResponse>`	`encrypt(EncryptRequest request)` * KMS uses the primary version of a specified CMK to encrypt data
`CompletableFuture<ExportDataKeyResponse>`	`exportDataKey(ExportDataKeyRequest request)` You can call the [GenerateDataKeyWithoutPlaintext](~~134043~~) operation to generate a data key, which is encrypted by a CMK.
`CompletableFuture<GenerateAndExportDataKeyResponse>`	`generateAndExportDataKey(GenerateAndExportDataKeyRequest request)` We recommend that you perform the following steps to import your data key to a cryptographic module: * Call the GenerateAndExportDataKey operation to generate a data key and obtain both the ciphertext of the data key encrypted by using the CMK and that encrypted by using the public key
`CompletableFuture<GenerateDataKeyResponse>`	`generateDataKey(GenerateDataKeyRequest request)` This operation creates a random data key, encrypts the data key by using the specified customer master key (CMK), and returns the plaintext and ciphertext of the data key.
`CompletableFuture<GenerateDataKeyWithoutPlaintextResponse>`	`generateDataKeyWithoutPlaintext(GenerateDataKeyWithoutPlaintextRequest request)` This operation creates a random data key, encrypts the data key by using a specific symmetric CMK, and returns the ciphertext of the data key.
`CompletableFuture<GetCertificateResponse>`	`getCertificate(GetCertificateRequest request)` In this example, the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` is queried.
`CompletableFuture<GetClientKeyResponse>`	`getClientKey(GetClientKeyRequest request)`
`CompletableFuture<GetKmsInstanceResponse>`	`getKmsInstance(GetKmsInstanceRequest request)`
`CompletableFuture<GetParametersForImportResponse>`	`getParametersForImport(GetParametersForImportRequest request)` The returned parameters can be used to call the [ImportKeyMaterial](https://www.alibabacloud.com/help/en/key-management-service/latest/importkeymaterial) operation
`CompletableFuture<GetPublicKeyResponse>`	`getPublicKey(GetPublicKeyRequest request)`
`CompletableFuture<GetRandomPasswordResponse>`	`getRandomPassword(GetRandomPasswordRequest request)`
`CompletableFuture<GetSecretValueResponse>`	`getSecretValue(GetSecretValueRequest request)` If you do not specify a version number or stage label, Secrets Manager returns the secret value of the version marked with ACSCurrent.
`CompletableFuture<ImportKeyMaterialResponse>`	`importKeyMaterial(ImportKeyMaterialRequest request)` Call [CreateKey](~~28947~~) when creating a CMK, you can select its key material source as external.
`CompletableFuture<ListAliasesResponse>`	`listAliases(ListAliasesRequest request)`
`CompletableFuture<ListAliasesByKeyIdResponse>`	`listAliasesByKeyId(ListAliasesByKeyIdRequest request)`
`CompletableFuture<ListApplicationAccessPointsResponse>`	`listApplicationAccessPoints(ListApplicationAccessPointsRequest request)`
`CompletableFuture<ListClientKeysResponse>`	`listClientKeys(ListClientKeysRequest request)`
`CompletableFuture<ListKeysResponse>`	`listKeys(ListKeysRequest request)`
`CompletableFuture<ListKeyVersionsResponse>`	`listKeyVersions(ListKeyVersionsRequest request)`
`CompletableFuture<ListKmsInstancesResponse>`	`listKmsInstances(ListKmsInstancesRequest request)`
`CompletableFuture<ListNetworkRulesResponse>`	`listNetworkRules(ListNetworkRulesRequest request)`
`CompletableFuture<ListPoliciesResponse>`	`listPolicies(ListPoliciesRequest request)`
`CompletableFuture<ListResourceTagsResponse>`	`listResourceTags(ListResourceTagsRequest request)` Request format: KeyId="string"
`CompletableFuture<ListSecretsResponse>`	`listSecrets(ListSecretsRequest request)` Specifies whether to return the resource tags of the secret.
`CompletableFuture<ListSecretVersionIdsResponse>`	`listSecretVersionIds(ListSecretVersionIdsRequest request)` The secret value is not included in the returned version information.
`CompletableFuture<ListTagResourcesResponse>`	`listTagResources(ListTagResourcesRequest request)`
`CompletableFuture<OpenKmsServiceResponse>`	`openKmsService(OpenKmsServiceRequest request)` When you call this operation, note that: - KMS is a paid service.
`CompletableFuture<PutSecretValueResponse>`	`putSecretValue(PutSecretValueRequest request)` This operation is used to store the secret values of new versions.
`CompletableFuture<ReEncryptResponse>`	`reEncrypt(ReEncryptRequest request)` You can call this operation in the following scenarios: * After the CMK that was used to encrypt your data is rotated, you can call this operation to use the latest CMK version to re-encrypt the data.
`CompletableFuture<RestoreSecretResponse>`	`restoreSecret(RestoreSecretRequest request)` You can only use this operation to restore a deleted secret that is within its recovery period.
`CompletableFuture<RotateSecretResponse>`	`rotateSecret(RotateSecretRequest request)` Limits: • A secret of each Alibaba Cloud account can be rotated for a maximum of 50 times per hour
`CompletableFuture<ScheduleKeyDeletionResponse>`	`scheduleKeyDeletion(ScheduleKeyDeletionRequest request)` During the scheduled period, the CMK is in the PendingDeletion state and cannot be used to encrypt data, decrypt data, or generate data keys.
`CompletableFuture<SetDeletionProtectionResponse>`	`setDeletionProtection(SetDeletionProtectionRequest request)` * After you enable deletion protection for a CMK, you cannot delete the CMK.
`CompletableFuture<TagResourceResponse>`	`tagResource(TagResourceRequest request)` You can add up to 10 tags to a CMK, secret, or certificate.
`CompletableFuture<TagResourcesResponse>`	`tagResources(TagResourcesRequest request)`
`CompletableFuture<UntagResourceResponse>`	`untagResource(UntagResourceRequest request)` One or more tag keys.
`CompletableFuture<UntagResourcesResponse>`	`untagResources(UntagResourcesRequest request)`
`CompletableFuture<UpdateAliasResponse>`	`updateAlias(UpdateAliasRequest request)`
`CompletableFuture<UpdateApplicationAccessPointResponse>`	`updateApplicationAccessPoint(UpdateApplicationAccessPointRequest request)`
`CompletableFuture<UpdateCertificateStatusResponse>`	`updateCertificateStatus(UpdateCertificateStatusRequest request)` In this example, the status of the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` is updated to INACTIVE.
`CompletableFuture<UpdateKeyDescriptionResponse>`	`updateKeyDescription(UpdateKeyDescriptionRequest request)` This operation replaces the description of a customer master key (CMK) with the description that you specify.
`CompletableFuture<UpdateKmsInstanceBindVpcResponse>`	`updateKmsInstanceBindVpc(UpdateKmsInstanceBindVpcRequest request)`
`CompletableFuture<UpdateNetworkRuleResponse>`	`updateNetworkRule(UpdateNetworkRuleRequest request)`
`CompletableFuture<UpdatePolicyResponse>`	`updatePolicy(UpdatePolicyRequest request)`
`CompletableFuture<UpdateRotationPolicyResponse>`	`updateRotationPolicy(UpdateRotationPolicyRequest request)` When automatic key rotation is enabled, KMS automatically creates a key version after the preset rotation period arrives.
`CompletableFuture<UpdateSecretResponse>`	`updateSecret(UpdateSecretRequest request)` In this example, the metadata of the `secret001` secret is updated.
`CompletableFuture<UpdateSecretRotationPolicyResponse>`	`updateSecretRotationPolicy(UpdateSecretRotationPolicyRequest request)` After automatic rotation is enabled, Secrets Manager schedules the first automatic rotation by adding the preset rotation interval to the timestamp of the last rotation.
`CompletableFuture<UpdateSecretVersionStageResponse>`	`updateSecretVersionStage(UpdateSecretVersionStageRequest request)` Updates the stage label that marks a secret version.
`CompletableFuture<UploadCertificateResponse>`	`uploadCertificate(UploadCertificateRequest request)` In this example, a certificate issued by a CA is imported into Certificates Manager.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 com.aliyun.sdk.service.kms20160120.AsyncClient
builder, create

- 字段详细资料
  - product
```
protected final String product
```
  - version
```
protected final String version
```
  - endpointRule
```
protected final String endpointRule
```
  - endpointMap
```
protected final Map<String,String> endpointMap
```
  - REQUEST
```
protected final darabonba.core.TeaRequest REQUEST
```
  - handler
```
protected final darabonba.core.TeaAsyncHandler handler
```
- 构造器详细资料
  - DefaultAsyncClient
```
protected DefaultAsyncClient(darabonba.core.client.ClientConfiguration configuration)
```
- 方法详细资料
  - close
```
public void close()
```
    指定者:
    
    close 在接口中 com.aliyun.core.utils.SdkAutoCloseable
    
    指定者:
    
    close 在接口中 AutoCloseable
  - asymmetricDecrypt
```
public CompletableFuture<AsymmetricDecryptResponse> asymmetricDecrypt(AsymmetricDecryptRequest request)
```
    This operation supports only asymmetric keys for which the **Usage** parameter is set to **ENCRYPT/DECRYPT**. The following table lists supported encryption algorithms. | KeySpec | Algorithm | Description | Maximum length in bytes | | ------- | --------- | ----------- | ----------------------- | | RSA_2048 | RSAES_OAEP_SHA_256 | RSAES-OAEP using SHA-256 and MGF1 with SHA-256 | 256 | | RSA_2048 | RSAES_OAEP_SHA_1 | RSAES-OAEP using SHA1 and MGF1 with SHA1 | 256 | | RSA_3072 | RSAES_OAEP_SHA_256 | RSAES-OAEP using SHA-256 and MGF1 with SHA-256 | 384 | | RSA_3072 | RSAES_OAEP_SHA_1 | RSAES-OAEP using SHA1 and MGF1 with SHA1 | 384 | | EC_SM2 | SM2PKE | SM2 public key encryption algorithm based on elliptic curves | 6144 | In this example, the asymmetric key whose ID is `5c438b18-05be-40ad-b6c2-3be6752c****` and version ID is `2ab1a983-7072-4bbc-a582-584b5bd8****` and the decryption algorithm `RSAES_OAEP_SHA_1` are used to decrypt the ciphertext `BQKP+1zK6+ZEMxTP5qaVzcsgXtWplYBKm0NXdSnB5FzliFxE1bSiu4dnEIlca2JpeH7yz1/S6fed630H+hIH6DoM25fTLNcKj+mFB0Xnh9m2+HN59Mn4qyTfcUeadnfCXSWcGBouhXFwcdd2rJ3n337bzTf4jm659gZu3L0i6PLuxM9p7mqdwO0cKJPfGVfhnfMz+f4alMg79WB/NNyE2lyX7/qxvV49ObNrrJbKSFiz8Djocaf0IESNLMbfYI5bXjWkJlX92DQbKhibtQW8ZOJ//ZC6t0AWcUoKL6QDm/dg5koQalcleRinpB+QadFm894sLbVZ9+N4GVsv1W****==`.
    
    指定者:
    
    asymmetricDecrypt 在接口中 AsyncClient
  - asymmetricEncrypt
```
public CompletableFuture<AsymmetricEncryptResponse> asymmetricEncrypt(AsymmetricEncryptRequest request)
```
    This operation is supported only for asymmetric keys for which the **Usage** parameter is set to **ENCRYPT/DECRYPT**. The following table lists the supported encryption algorithms: | KeySpec | Algorithm | Description | Maximum number of bytes that can be encrypted | | ------- | --------- | ----------- | --------------------------------------------- | | RSA_2048 | RSAES_OAEP_SHA_256 | RSAES-OAEP using SHA-256 and MGF1 with SHA-256 | 190 | | RSA_2048 | RSAES_OAEP_SHA_1 | RSAES-OAEP using SHA1 and MGF1 with SHA1 | 214 | | RSA_3072 | RSAES_OAEP_SHA_256 | RSAES-OAEP using SHA-256 and MGF1 with SHA-256 | 318 | | RSA_3072 | RSAES_OAEP_SHA_1 | RSAES-OAEP using SHA1 and MGF1 with SHA1 | 342 | | EC_SM2 | SM2PKE | SM2 public key encryption algorithm based on elliptic curves | 6047 | You can use the asymmetric CMK whose ID is `5c438b18-05be-40ad-b6c2-3be6752c****` and version ID is `2ab1a983-7072-4bbc-a582-584b5bd8****` and the algorithm `RSAES_OAEP_SHA_1` to encrypt the plaintext `SGVsbG8gd29ybGQ=` based on the parameter settings provided in this topic.
    
    指定者:
    
    asymmetricEncrypt 在接口中 AsyncClient
  - asymmetricSign
```
public CompletableFuture<AsymmetricSignResponse> asymmetricSign(AsymmetricSignRequest request)
```
    Generates a signature by using an asymmetric key.
    
    指定者:
    
    asymmetricSign 在接口中 AsyncClient
  - asymmetricVerify
```
public CompletableFuture<AsymmetricVerifyResponse> asymmetricVerify(AsymmetricVerifyRequest request)
```
    This operation supports only asymmetric keys for which the **Usage** parameter is set to **SIGN/VERIFY**. The following table describes the supported signature algorithms. | KeySpec | Algorithm | Description | | ------- | --------- | ----------- | | RSA_2048 | RSA_PSS_SHA_256 | RSASSA-PSS using SHA-256 and MGF1 with SHA-256 | | RSA_2048 | RSA_PKCS1_SHA_256 | RSASSA-PKCS1-v1_5 using SHA-256 | | RSA_3072 | RSA_PSS_SHA_256 | RSASSA-PSS using SHA-256 and MGF1 with SHA-256 | | RSA_3072 | RSA_PKCS1_SHA_256 | RSASSA-PKCS1-v1_5 using SHA-256 | | EC_P256 | ECDSA_SHA_256 | ECDSA on the P-256 Curve(secp256r1) with a SHA-256 digest | | EC_P256K | ECDSA_SHA_256 | ECDSA on the P-256K Curve(secp256k1) with a SHA-256 digest | | EC_SM2 | SM2DSA | SM2 elliptic curve public key encryption algorithm | > When you calculate the SM2 signature based on GB/T 32918, the **Digest** parameter is used to calculate the digest value of the combination of Z(A) and M, rather than the SM3 digest value. M indicates the original message to be signed. Z(A) indicates the hash value for User A. The hash value is defined in GB/T 32918. In this example, the asymmetric key whose ID is `5c438b18-05be-40ad-b6c2-3be6752c****` and version ID is `2ab1a983-7072-4bbc-a582-584b5bd8****` and the signature algorithm RSA_PSS_SHA_256 are used to verify the signature `M2CceNZH00ZgL9ED/ZHFp21YRAvYeZHknJUc207OCZ0N9wNn9As4z2bON3FF3je+1Nu+2+/8Zj50HpMTpzYpMp2R93cYmACCmhaYoKydxylbyGzJR8y9likZRCrkD38lRoS40aBBvv/6iRKzQuo9EGYVcel36cMNg00VmYNBy3pa1rwg3gA4l3cy6kjayZja1WGPkVhrVKsrJMdbpl0ApLjXKuD8rw1n1XLCwCUEL5eLPljTZaAveqdOFQOiZnZEGI27qIiZe7I1fN8tcz6anS/gTM7xRKE++5egEvRWlTQQTJeApnPSiUPA+8ZykNdelQsOQh5SrGoyI4A5pq****==` of the digest `ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=`.
    
    指定者:
    
    asymmetricVerify 在接口中 AsyncClient
  - cancelKeyDeletion
```
public CompletableFuture<CancelKeyDeletionResponse> cancelKeyDeletion(CancelKeyDeletionRequest request)
```
    If the deletion task of a CMK is canceled, the CMK returns to the Enabled state.
    
    指定者:
    
    cancelKeyDeletion 在接口中 AsyncClient
  - certificatePrivateKeyDecrypt
```
public CompletableFuture<CertificatePrivateKeyDecryptResponse> certificatePrivateKeyDecrypt(CertificatePrivateKeyDecryptRequest request)
```
    Limit: The encryption algorithm in the request parameters must match the key type. The following table describes the mapping between encryption algorithms and key types. | Algorithm | Key Spec | | --------- | -------- | | RSAES_OAEP_SHA_1 | RSA_2048 | | RSAES_OAEP_SHA_256 | RSA_2048 | | SM2PKE | EC_SM2 | In this example, the certificate whose ID is `12345678-1234-1234-1234-12345678****` and the encryption algorithm `RSAES_OAEP_SHA_256` are used to decrypt the data `ZOyIygCyaOW6Gj****MlNKiuyjfzw=`.
    
    指定者:
    
    certificatePrivateKeyDecrypt 在接口中 AsyncClient
  - certificatePrivateKeySign
```
public CompletableFuture<CertificatePrivateKeySignResponse> certificatePrivateKeySign(CertificatePrivateKeySignRequest request)
```
    The signature algorithm in the request parameters must match the key type. The following table describes the mapping between signature algorithms and key types. | Algorithm | Key Spec | | --------- | -------- | | RSA_PKCS1_SHA_256 | RSA_2048 | | RSA_PSS_SHA_256 | RSA_2048 | | ECDSA_SHA_256 | EC_P256 | | SM2DSA | EC_SM2 | In this example, the certificate whose ID is `12345678-1234-1234-1234-12345678****` and the signature algorithm `ECDSA_SHA_256` are used to generate a signature for the raw data `VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4=`.
    
    指定者:
    
    certificatePrivateKeySign 在接口中 AsyncClient
  - certificatePublicKeyEncrypt
```
public CompletableFuture<CertificatePublicKeyEncryptResponse> certificatePublicKeyEncrypt(CertificatePublicKeyEncryptRequest request)
```
    Limit: The encryption algorithm in the request parameters must match the key type. The following table describes the mapping between encryption algorithms and key types. | Algorithm | Key Spec | | --------- | -------- | | RSAES_OAEP_SHA_1 | RSA_2048 | | RSAES_OAEP_SHA_256 | RSA_2048 | | SM2PKE | EC_SM2 | In this example, the certificate whose ID is `12345678-1234-1234-1234-12345678****` and the encryption algorithm `RSAES_OAEP_SHA_256` are used to encrypt the data `VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4=`.
    
    指定者:
    
    certificatePublicKeyEncrypt 在接口中 AsyncClient
  - certificatePublicKeyVerify
```
public CompletableFuture<CertificatePublicKeyVerifyResponse> certificatePublicKeyVerify(CertificatePublicKeyVerifyRequest request)
```
    The signature algorithm in the request parameters must match the key type. The following table describes the mapping between signature algorithms and key types. | Algorithm | Key Spec | | --------- | -------- | | RSA_PKCS1_SHA_256 | RSA_2048 | | RSA_PSS_SHA_256 | RSA_2048 | | ECDSA_SHA_256 | EC_P256 | | SM2DSA | EC_SM2 | In this example, the certificate whose ID is `12345678-1234-1234-1234-12345678****` and the signature algorithm `ECDSA_SHA_256` are used to verify the digital signature `ZOyIygCyaOW6Gj****MlNKiuyjfzw=` of the raw data `VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4=`.
    
    指定者:
    
    certificatePublicKeyVerify 在接口中 AsyncClient
  - connectKmsInstance
```
public CompletableFuture<ConnectKmsInstanceResponse> connectKmsInstance(ConnectKmsInstanceRequest request)
```
    指定者:
    
    connectKmsInstance 在接口中 AsyncClient
  - createAlias
```
public CompletableFuture<CreateAliasResponse> createAlias(CreateAliasRequest request)
```
    * Each alias can be bound to only one CMK at a time. * The aliases of CMKs in the same region must be unique. In this topic, an alias named `alias/example` is created for a CMK named `7906979c-8e06-46a2-be2d-68e3ccbc****`.
    
    指定者:
    
    createAlias 在接口中 AsyncClient
  - createApplicationAccessPoint
```
public CompletableFuture<CreateApplicationAccessPointResponse> createApplicationAccessPoint(CreateApplicationAccessPointRequest request)
```
    指定者:
    
    createApplicationAccessPoint 在接口中 AsyncClient
  - createCertificate
```
public CompletableFuture<CreateCertificateResponse> createCertificate(CreateCertificateRequest request)
```
    To create a certificate, you must specify the type of the asymmetric key. Certificates Manager generates a private key and returns a certificate signing request (CSR). Submit the CSR in the Privacy Enhanced Mail (PEM) format to a certificate authority (CA) to obtain the formal certificate and certificate chain. Then, call the [UploadCertificate](~~212136~~) operation to import the certificate into Certificates Manager. In this example, a certificate is created and the CSR is obtained.
    
    指定者:
    
    createCertificate 在接口中 AsyncClient
  - createClientKey
```
public CompletableFuture<CreateClientKeyResponse> createClientKey(CreateClientKeyRequest request)
```
    指定者:
    
    createClientKey 在接口中 AsyncClient
  - createKey
```
public CompletableFuture<CreateKeyResponse> createKey(CreateKeyRequest request)
```
    Creates a customer master key (CMK).
    
    指定者:
    
    createKey 在接口中 AsyncClient
  - createKeyVersion
```
public CompletableFuture<CreateKeyVersionResponse> createKeyVersion(CreateKeyVersionRequest request)
```
    * You can create a version only for an asymmetric CMK that is in the Enabled state. You can call the [CreateKey](~~28947~~) operation to create an asymmetric CMK and the [DescribeKey](~~28952~~) operation to query the status of the CMK. The status is specified by the KeyState parameter. * The minimum interval for creating a version of the same CMK is seven days. You can call the [DescribeKey](~~28952~~) operation to query the time when the last version of a CMK was created. The time is specified by the LastRotationDate parameter. * If a CMK is in a private key store, you cannot create a version for the CMK. * You can create a maximum of 50 versions for a CMK in the same region. You can create a version for the CMK whose ID is `0b30658a-ed1a-4922-b8f7-a673ca9c****` by using the parameter settings provided in this topic.
    
    指定者:
    
    createKeyVersion 在接口中 AsyncClient
  - createNetworkRule
```
public CompletableFuture<CreateNetworkRuleResponse> createNetworkRule(CreateNetworkRuleRequest request)
```
    指定者:
    
    createNetworkRule 在接口中 AsyncClient
  - createPolicy
```
public CompletableFuture<CreatePolicyResponse> createPolicy(CreatePolicyRequest request)
```
    指定者:
    
    createPolicy 在接口中 AsyncClient
  - createSecret
```
public CompletableFuture<CreateSecretResponse> createSecret(CreateSecretRequest request)
```
    The name of the secret. The value must be 1 to 64 characters in length and can contain letters, digits, underscores (\\_), forward slashes (/), plus signs (+), equal signs (=), periods (.), hyphens (-), and at signs (@). The following list describes the name requirements for different types of secrets: * If the SecretType parameter is set to Generic or Rds, the name cannot start with `acs/`. * If the SecretType parameter is set to RAMCredentials, set the SecretName parameter to `$Auto`. In this case, KMS automatically generates a secret name that starts with `acs/ram/user/`. The name includes the display name of RAM user. * If the SecretType parameter is set to ECS, the name must start with `acs/ecs/`.
    
    指定者:
    
    createSecret 在接口中 AsyncClient
  - decrypt
```
public CompletableFuture<DecryptResponse> decrypt(DecryptRequest request)
```
    指定者:
    
    decrypt 在接口中 AsyncClient
  - deleteAlias
```
public CompletableFuture<DeleteAliasResponse> deleteAlias(DeleteAliasRequest request)
```
    指定者:
    
    deleteAlias 在接口中 AsyncClient
  - deleteApplicationAccessPoint
```
public CompletableFuture<DeleteApplicationAccessPointResponse> deleteApplicationAccessPoint(DeleteApplicationAccessPointRequest request)
```
    指定者:
    
    deleteApplicationAccessPoint 在接口中 AsyncClient
  - deleteCertificate
```
public CompletableFuture<DeleteCertificateResponse> deleteCertificate(DeleteCertificateRequest request)
```
    After the certificate and its private key and certificate chain are deleted, they cannot be restored. Proceed with caution. In this example, the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` and its private key and certificate chain are deleted.
    
    指定者:
    
    deleteCertificate 在接口中 AsyncClient
  - deleteClientKey
```
public CompletableFuture<DeleteClientKeyResponse> deleteClientKey(DeleteClientKeyRequest request)
```
    指定者:
    
    deleteClientKey 在接口中 AsyncClient
  - deleteKeyMaterial
```
public CompletableFuture<DeleteKeyMaterialResponse> deleteKeyMaterial(DeleteKeyMaterialRequest request)
```
    This operation does not delete the CMK that is created by using the key material. If the CMK is in the PendingDeletion state, the state of the CMK and the scheduled deletion time do not change after you call this operation. If the CMK is not in the PendingDeletion state, the state of the CMK changes to PendingImport after you call this operation. After you delete the key material, you can upload only the same key material into the CMK.
    
    指定者:
    
    deleteKeyMaterial 在接口中 AsyncClient
  - deleteNetworkRule
```
public CompletableFuture<DeleteNetworkRuleResponse> deleteNetworkRule(DeleteNetworkRuleRequest request)
```
    指定者:
    
    deleteNetworkRule 在接口中 AsyncClient
  - deletePolicy
```
public CompletableFuture<DeletePolicyResponse> deletePolicy(DeletePolicyRequest request)
```
    指定者:
    
    deletePolicy 在接口中 AsyncClient
  - deleteSecret
```
public CompletableFuture<DeleteSecretResponse> deleteSecret(DeleteSecretRequest request)
```
    If you call this operation without specifying a recovery period, the deleted secret can be recovered within 30 days. If you specify a recovery period, the deleted secret can be recovered within the recovery period. You can also forcibly delete a secret. A forcibly deleted secret cannot be recovered.
    
    指定者:
    
    deleteSecret 在接口中 AsyncClient
  - describeAccountKmsStatus
```
public CompletableFuture<DescribeAccountKmsStatusResponse> describeAccountKmsStatus(DescribeAccountKmsStatusRequest request)
```
    指定者:
    
    describeAccountKmsStatus 在接口中 AsyncClient
  - describeApplicationAccessPoint
```
public CompletableFuture<DescribeApplicationAccessPointResponse> describeApplicationAccessPoint(DescribeApplicationAccessPointRequest request)
```
    指定者:
    
    describeApplicationAccessPoint 在接口中 AsyncClient
  - describeCertificate
```
public CompletableFuture<DescribeCertificateResponse> describeCertificate(DescribeCertificateRequest request)
```
    In this example, the information about the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` is queried. The certificate information includes the certificate ID, creation time, certificate issuer, validity period, serial number, and signature algorithm.
    
    指定者:
    
    describeCertificate 在接口中 AsyncClient
  - describeKey
```
public CompletableFuture<DescribeKeyResponse> describeKey(DescribeKeyRequest request)
```
    You can query the information about the CMK `05754286-3ba2-4fa6-8d41-4323aca6****` by using parameter settings provided in this topic. The information includes the creator, creation time, status, and deletion protection status of the CMK.
    
    指定者:
    
    describeKey 在接口中 AsyncClient
  - describeKeyVersion
```
public CompletableFuture<DescribeKeyVersionResponse> describeKeyVersion(DescribeKeyVersionRequest request)
```
    This topic provides an example on how to query the information about a version of the CMK `1234abcd-12ab-34cd-56ef-12345678****`. The ID of the CMK version is `2ab1a983-7072-4bbc-a582-584b5bd8****`. The response shows that the creation time of the CMK version is `2016-03-25T10:42:40Z`.
    
    指定者:
    
    describeKeyVersion 在接口中 AsyncClient
  - describeNetworkRule
```
public CompletableFuture<DescribeNetworkRuleResponse> describeNetworkRule(DescribeNetworkRuleRequest request)
```
    指定者:
    
    describeNetworkRule 在接口中 AsyncClient
  - describePolicy
```
public CompletableFuture<DescribePolicyResponse> describePolicy(DescribePolicyRequest request)
```
    指定者:
    
    describePolicy 在接口中 AsyncClient
  - describeRegions
```
public CompletableFuture<DescribeRegionsResponse> describeRegions(DescribeRegionsRequest request)
```
    指定者:
    
    describeRegions 在接口中 AsyncClient
  - describeSecret
```
public CompletableFuture<DescribeSecretResponse> describeSecret(DescribeSecretRequest request)
```
    This operation returns the metadata of a secret. This operation does not return the secret value. In this example, the metadata of the secret named `secret001` is queried.
    
    指定者:
    
    describeSecret 在接口中 AsyncClient
  - disableKey
```
public CompletableFuture<DisableKeyResponse> disableKey(DisableKeyRequest request)
```
    If a customer master key (CMK) is disabled, the ciphertext encrypted by using this CMK cannot be decrypted until you re-enable it. You can call the [EnableKey](~~35150~~) operation to enable the CMK. In this example, the CMK whose ID is `1234abcd-12ab-34cd-56ef-12345678****` is disabled.
    
    指定者:
    
    disableKey 在接口中 AsyncClient
  - enableKey
```
public CompletableFuture<EnableKeyResponse> enableKey(EnableKeyRequest request)
```
    指定者:
    
    enableKey 在接口中 AsyncClient
  - encrypt
```
public CompletableFuture<EncryptResponse> encrypt(EncryptRequest request)
```
    * KMS uses the primary version of a specified CMK to encrypt data. * Only data of 6 KB or less can be encrypted. For example, you can call this operation to encrypt RSA keys, database access passwords, or other sensitive information. * When you migrate encrypted data across regions, you can call this operation in the destination region to encrypt the plaintext of the data key that is used to encrypt the migrated data in the source region. This way, the ciphertext of the data key is generated in the destination region. You can also call the [Decrypt](~~28950~~) operation to decrypt the data key.
    
    指定者:
    
    encrypt 在接口中 AsyncClient
  - exportDataKey
```
public CompletableFuture<ExportDataKeyResponse> exportDataKey(ExportDataKeyRequest request)
```
    You can call the [GenerateDataKeyWithoutPlaintext](~~134043~~) operation to generate a data key, which is encrypted by a CMK. If you want to distribute the data key to other regions or cryptographic modules, you can call the ExportDataKey operation to use a public key to encrypt the data key. Then, you can import the ciphertext of the data key to the cryptographic module where the private key is stored. This way, the data key is securely distributed from KMS to the cryptographic module. After the data key is imported to the cryptographic module, you can use it to encrypt or decrypt data.
    
    指定者:
    
    exportDataKey 在接口中 AsyncClient
  - generateAndExportDataKey
```
public CompletableFuture<GenerateAndExportDataKeyResponse> generateAndExportDataKey(GenerateAndExportDataKeyRequest request)
```
    We recommend that you perform the following steps to import your data key to a cryptographic module: * Call the GenerateAndExportDataKey operation to generate a data key and obtain both the ciphertext of the data key encrypted by using the CMK and that encrypted by using the public key. * Store the ciphertext of the data key encrypted by using the CMK in KMS Secrets Manager or in a storage service such as ApsaraDB. This ciphertext is used for backup and restoration. * Import the ciphertext of the data key encrypted by using the public key to the cryptographic module where the private key is stored. Then, you can use the data key to encrypt or decrypt data. > The CMK that you specify in the request of this operation is only used to encrypt the data key and is not involved in the generation of the data key. KMS does not record or store the data keys randomly generated by calling this operation. You must take note of the data keys and the returned ciphertext.
    
    指定者:
    
    generateAndExportDataKey 在接口中 AsyncClient
  - generateDataKey
```
public CompletableFuture<GenerateDataKeyResponse> generateDataKey(GenerateDataKeyRequest request)
```
    This operation creates a random data key, encrypts the data key by using the specified customer master key (CMK), and returns the plaintext and ciphertext of the data key. You can use the plaintext of the data key to locally encrypt your data without using KMS and store the encrypted data together with the ciphertext of the data key. You can obtain the plaintext of the data key from the Plaintext parameter in the response and the ciphertext of the data key from the CiphertextBlob parameter in the response. The CMK that you specify in the request of this operation is only used to encrypt the data key and is not involved in the generation of the data key. KMS does not record or store the generated data key. Therefore, you need to store the ciphertext of the data key in persistent storage. We recommend that you locally encrypt data by performing the following steps: 1\\. Call the GenerateDataKey operation. 2\\. Use the plaintext of the data key that you obtain to locally encrypt data without using KMS. Then, delete the plaintext of the data key from the memory. 3\\. Store the encrypted data together with the ciphertext of the data key that you obtain. We recommend that you locally decrypt data by performing the following steps: * Call the [Decrypt](~~28950~~) operation to decrypt the locally stored ciphertext of the data key. The plaintext of data key is then returned. * Use the plaintext of the data key to locally decrypt data and then delete the plaintext of the data key from the memory. In this example, a random data key is generated for the CMK whose ID is `7906979c-8e06-46a2-be2d-68e3ccbc****`.
    
    指定者:
    
    generateDataKey 在接口中 AsyncClient
  - generateDataKeyWithoutPlaintext
```
public CompletableFuture<GenerateDataKeyWithoutPlaintextResponse> generateDataKeyWithoutPlaintext(GenerateDataKeyWithoutPlaintextRequest request)
```
    This operation creates a random data key, encrypts the data key by using a specific symmetric CMK, and returns the ciphertext of the data key. This operation serves the same purpose as the [GenerateDataKey](~~28948~~) operation. The only difference is that this operation does not return the plaintext of the data key. The CMK that you specify in the request of this operation is only used to encrypt the data key and is not involved in the generation of the data key. KMS does not record or store the generated data key. > * This operation applies to the scenario when you do not need to use the data key to immediately encrypt data. Before you can use the data key to encrypt data, you must call the [Decrypt](~~28950~~) operation to decrypt the ciphertext of the data key. > * This operation is also suitable for a distributed system with different trust levels. For example, a system stores data in different partitions based on a preset trust policy. A module creates different partitions and generates different data keys for each partition in advance. This module is not involved in data production and consumption after it completes initialization of the control plane. This module is the key provider. When producing and consuming data, modules on the control plane obtain the ciphertext of the data key for a partition first. After decrypting the ciphertext of the data key, modules on the control plane use the plaintext of the data key to encrypt or decrypt data and then clear the plaintext of the data key from the memory. In such a system, the key provider does not need to obtain the plaintext of the data key. It only needs to have the permissions to call the GenerateDataKeyWithoutPlaintext operation. The data producers or consumers do not need to generate new data keys. They only need to have the permissions to call the Decrypt operation.
    
    指定者:
    
    generateDataKeyWithoutPlaintext 在接口中 AsyncClient
  - getCertificate
```
public CompletableFuture<GetCertificateResponse> getCertificate(GetCertificateRequest request)
```
    In this example, the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` is queried. The certificate, certificate chain, certificate ID, and certificate signing request (CSR) are returned.
    
    指定者:
    
    getCertificate 在接口中 AsyncClient
  - getClientKey
```
public CompletableFuture<GetClientKeyResponse> getClientKey(GetClientKeyRequest request)
```
    指定者:
    
    getClientKey 在接口中 AsyncClient
  - getKmsInstance
```
public CompletableFuture<GetKmsInstanceResponse> getKmsInstance(GetKmsInstanceRequest request)
```
    指定者:
    
    getKmsInstance 在接口中 AsyncClient
  - getParametersForImport
```
public CompletableFuture<GetParametersForImportResponse> getParametersForImport(GetParametersForImportRequest request)
```
    The returned parameters can be used to call the [ImportKeyMaterial](https://www.alibabacloud.com/help/en/key-management-service/latest/importkeymaterial) operation. - You can import key material only for CMKs whose Origin parameter is set to EXTERNAL. - The public key and token that are returned by the GetParametersForImport operation must be used together. The public key and token can be used to import key material only for the CMK that is specified when you call the operation. - The public key and token that are returned vary each time you call the GetParametersForImport operation. - You must specify the type of the public key and the encryption algorithm that are used to encrypt key material. The following table lists the types of public keys and the encryption algorithms allowed for each type. | Public key type | Encryption algorithm | Description | | --------------- | -------------------- | ----------- | | RSA_2048 | RSAES_PKCS1_V1_5 RSAES_OAEP_SHA_1 RSAES_OAEP_SHA_256 | CMKs of all regions and all protection levels are supported. Dedicated Key Management Service (KMS) does not support RSAES_OAEP_SHA_1. | | EC_SM2 | SM2PKE | CMKs whose ProtectionLevel is set to HSM are supported. The SM2 algorithm is developed and approved by the State Cryptography Administration of China. The SM2 algorithm can be used only to import key material for a CMK whose ProtectionLevel is set to HSM. You can use the SM2 algorithm only when you enable the Managed HSM feature for KMS in the Chinese mainland. For more information, see [Overview of Managed HSM](https://www.alibabacloud.com/help/en/key-management-service/latest/managed-hsm-overview). | For more information, see [Import key material](https://www.alibabacloud.com/help/en/key-management-service/latest/import-key-material). This topic provides an example on how to query the parameters that are used to import key material for a CMK. The ID of the CMK is `1234abcd-12ab-34cd-56ef-12345678****`, the encryption algorithm is `RSAES_PKCS1_V1_5`, and the public key is of the `RSA_2048` type. The parameters that are returned include the ID of the CMK, the public key that is used to encrypt the key material, the token that is used to import the key material, and the time when the token expires.
    
    指定者:
    
    getParametersForImport 在接口中 AsyncClient
  - getPublicKey
```
public CompletableFuture<GetPublicKeyResponse> getPublicKey(GetPublicKeyRequest request)
```
    指定者:
    
    getPublicKey 在接口中 AsyncClient
  - getRandomPassword
```
public CompletableFuture<GetRandomPasswordResponse> getRandomPassword(GetRandomPasswordRequest request)
```
    指定者:
    
    getRandomPassword 在接口中 AsyncClient
  - getSecretValue
```
public CompletableFuture<GetSecretValueResponse> getSecretValue(GetSecretValueRequest request)
```
    If you do not specify a version number or stage label, Secrets Manager returns the secret value of the version marked with ACSCurrent. If a customer master key (CMK) is specified to encrypt the secret value, you must also have the `kms:Decrypt` permission on the CMK to call the GetSecretValue operation. In this example, the value of the secret named `secret001` is obtained. The secret value is returned in the `SecretData` parameter. The secret value is `testdata1`.
    
    指定者:
    
    getSecretValue 在接口中 AsyncClient
  - importKeyMaterial
```
public CompletableFuture<ImportKeyMaterialResponse> importKeyMaterial(ImportKeyMaterialRequest request)
```
    Call [CreateKey](~~28947~~) when creating a CMK, you can select its key material source as external. **Origin** set to **EXTERNAL**. This API is used to import the key material into the CMK. * To view the CMK **Origin**, see [DescribeKey](~~28952~~). * Before importing key material, you need to call the [GetParametersForImport](~~68621~~) obtain the parameters required to import the key material, including the public key and import token. > * The key type of the pair is **Aliyun\\_AES\\_256** the key material must be 256 bits. The key type must be **Aliyun\\_SM4** the CMK and key material must be 128 bits. > * You can set the expiration time for the key material, or you can set it to never expire. > * You can reimport the key material and reset the expiration time for the specified CMK at any time, but the same key material must be imported. > * After the imported key material expires or is deleted, the specified CMK is unavailable until the same key material are imported again. > * A Key material can be imported to multiple cmks, but any Data or Data Key encrypted by one CMK cannot be decrypted by another CMK.
    
    指定者:
    
    importKeyMaterial 在接口中 AsyncClient
  - listAliases
```
public CompletableFuture<ListAliasesResponse> listAliases(ListAliasesRequest request)
```
    指定者:
    
    listAliases 在接口中 AsyncClient
  - listAliasesByKeyId
```
public CompletableFuture<ListAliasesByKeyIdResponse> listAliasesByKeyId(ListAliasesByKeyIdRequest request)
```
    指定者:
    
    listAliasesByKeyId 在接口中 AsyncClient
  - listApplicationAccessPoints
```
public CompletableFuture<ListApplicationAccessPointsResponse> listApplicationAccessPoints(ListApplicationAccessPointsRequest request)
```
    指定者:
    
    listApplicationAccessPoints 在接口中 AsyncClient
  - listClientKeys
```
public CompletableFuture<ListClientKeysResponse> listClientKeys(ListClientKeysRequest request)
```
    指定者:
    
    listClientKeys 在接口中 AsyncClient
  - listKeyVersions
```
public CompletableFuture<ListKeyVersionsResponse> listKeyVersions(ListKeyVersionsRequest request)
```
    指定者:
    
    listKeyVersions 在接口中 AsyncClient
  - listKeys
```
public CompletableFuture<ListKeysResponse> listKeys(ListKeysRequest request)
```
    指定者:
    
    listKeys 在接口中 AsyncClient
  - listKmsInstances
```
public CompletableFuture<ListKmsInstancesResponse> listKmsInstances(ListKmsInstancesRequest request)
```
    指定者:
    
    listKmsInstances 在接口中 AsyncClient
  - listNetworkRules
```
public CompletableFuture<ListNetworkRulesResponse> listNetworkRules(ListNetworkRulesRequest request)
```
    指定者:
    
    listNetworkRules 在接口中 AsyncClient
  - listPolicies
```
public CompletableFuture<ListPoliciesResponse> listPolicies(ListPoliciesRequest request)
```
    指定者:
    
    listPolicies 在接口中 AsyncClient
  - listResourceTags
```
public CompletableFuture<ListResourceTagsResponse> listResourceTags(ListResourceTagsRequest request)
```
    Request format: KeyId="string"
    
    指定者:
    
    listResourceTags 在接口中 AsyncClient
  - listSecretVersionIds
```
public CompletableFuture<ListSecretVersionIdsResponse> listSecretVersionIds(ListSecretVersionIdsRequest request)
```
    The secret value is not included in the returned version information. By default, deprecated secret versions are not returned.
    
    指定者:
    
    listSecretVersionIds 在接口中 AsyncClient
  - listSecrets
```
public CompletableFuture<ListSecretsResponse> listSecrets(ListSecretsRequest request)
```
    Specifies whether to return the resource tags of the secret. Valid values: * true: returns the resource tags. * false: does not return the resource tags. This is the default value.
    
    指定者:
    
    listSecrets 在接口中 AsyncClient
  - listTagResources
```
public CompletableFuture<ListTagResourcesResponse> listTagResources(ListTagResourcesRequest request)
```
    指定者:
    
    listTagResources 在接口中 AsyncClient
  - openKmsService
```
public CompletableFuture<OpenKmsServiceResponse> openKmsService(OpenKmsServiceRequest request)
```
    When you call this operation, note that: - KMS is a paid service. For more information about the billing method, see [Billing description](https://www.alibabacloud.com/help/en/key-management-service/latest/billing-billing). - An Alibaba Cloud account can activate KMS only once. - Make sure that your Alibaba Cloud account has passed real-name authentication.
    
    指定者:
    
    openKmsService 在接口中 AsyncClient
  - putSecretValue
```
public CompletableFuture<PutSecretValueResponse> putSecretValue(PutSecretValueRequest request)
```
    This operation is used to store the secret values of new versions. It cannot be used to modify the secret value of an existing version. By default, the newly stored secret value is marked with ACSCurrent, and the mark for the previous version of the secret value is changed from ACSCurrent to ACSPrevious. If you specify the VersionStage parameter, the newly stored secret value is marked with the stage label that you specify. You must specify a version number when you call the operation. Secrets Manager performs operations based on the following rules: * If the specified version number does not exist in the secret, Secrets Manager creates the version and stores the secret value. * If the specified version number already exists in the secret and the secret value of the existing version is the same as the secret value that you specify, Secrets Manager ignores the request and returns a success message. The request is idempotent. * If the specified version number already exists in the secret but the secret value of the existing version is different from the secret value that you specify, Secrets Manager rejects the request and returns a failure message. Limits: This operation is available only for standard secrets. In this example, the secret value of a new version is stored into the `secret001` secret. The `VersionId` parameter is set to `00000000000000000000000000000000203` as the new version, and the `SecretData` parameter is set to `importantdata`.
    
    指定者:
    
    putSecretValue 在接口中 AsyncClient
  - reEncrypt
```
public CompletableFuture<ReEncryptResponse> reEncrypt(ReEncryptRequest request)
```
    You can call this operation in the following scenarios: * After the CMK that was used to encrypt your data is rotated, you can call this operation to use the latest CMK version to re-encrypt the data. For more information about automatic key rotation, see [Configure automatic key rotation](~~134270~~). * The CMK that was used to encrypt your data remains unchanged, but EncryptionContext is changed. In this scenario, you can call this operation to re-encrypt the data. * You can call this operation to use a CMK in KMS to re-encrypt data or a data key that was previously encrypted by a different CMK. To use the ReEncrypt operation, you must have two permissions: * kms:ReEncryptFrom on the source CMK * kms:ReEncryptTo on the destination CMK * For simplicity, you can specify kms:ReEncrypt\\* to allow both of the preceding permissions.
    
    指定者:
    
    reEncrypt 在接口中 AsyncClient
  - restoreSecret
```
public CompletableFuture<RestoreSecretResponse> restoreSecret(RestoreSecretRequest request)
```
    You can only use this operation to restore a deleted secret that is within its recovery period. If you set **ForceDeleteWithoutRecovery** to **true** when you delete the secret, you cannot restore it.
    
    指定者:
    
    restoreSecret 在接口中 AsyncClient
  - rotateSecret
```
public CompletableFuture<RotateSecretResponse> rotateSecret(RotateSecretRequest request)
```
    Limits: • A secret of each Alibaba Cloud account can be rotated for a maximum of 50 times per hour. • The RotateSecret operation is unavailable for standard secrets. In this example, the `RdsSecret/Mysql5.4/MyCred` secret is manually rotated, and the version number of the secret is set to `000000123` after the secret is rotated.
    
    指定者:
    
    rotateSecret 在接口中 AsyncClient
  - scheduleKeyDeletion
```
public CompletableFuture<ScheduleKeyDeletionResponse> scheduleKeyDeletion(ScheduleKeyDeletionRequest request)
```
    During the scheduled period, the CMK is in the PendingDeletion state and cannot be used to encrypt data, decrypt data, or generate data keys. After a CMK is deleted, it cannot be recovered. Data that is encrypted and data keys that are generated by using the CMK cannot be decrypted. To prevent accidental deletion of CMKs, Key Management Service (KMS) allows you to only schedule key deletion tasks. You cannot directly delete CMKs. If you want to delete a CMK, call the [DisableKey](~~35151~~) operation to disable the CMK. When you call this operation, you must specify a scheduled period between 7 days to 366 days. The scheduled period starts from the time when you submit the request. You can call the [CancelKeyDeletion](~~44197~~) operation to cancel the key deletion task before the scheduled period ends.
    
    指定者:
    
    scheduleKeyDeletion 在接口中 AsyncClient
  - setDeletionProtection
```
public CompletableFuture<SetDeletionProtectionResponse> setDeletionProtection(SetDeletionProtectionRequest request)
```
    * After you enable deletion protection for a CMK, you cannot delete the CMK. If you want to delete the CMK, you must first disable deletion protection for the CMK. * Before you can call the SetDeletionProtection operation, make sure that the required CMK is not in the Pending Deletion state. You can call the [DescribeKey](~~28952~~) operation to query the CMK status, which is specified by the KeyState parameter. You can enable deletion protection for the CMK whose Alibaba Cloud Resource Name (ARN) is `acs:kms:cn-hangzhou:123213123****:key/0225f411-b21d-46d1-be5b-93931c82****` by using parameter settings provided in this topic. The CMK ARN is specified by the ProtectedResourceArn parameter.
    
    指定者:
    
    setDeletionProtection 在接口中 AsyncClient
  - tagResource
```
public CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest request)
```
    You can add up to 10 tags to a CMK, secret, or certificate. In this example, the tags `[{"TagKey":"S1key1","TagValue":"S1val1"},{"TagKey":"S1key2","TagValue":"S2val2"}]` are added to the CMK whose ID is `08c33a6f-4e0a-4a1b-a3fa-7ddf****`.
    
    指定者:
    
    tagResource 在接口中 AsyncClient
  - tagResources
```
public CompletableFuture<TagResourcesResponse> tagResources(TagResourcesRequest request)
```
    指定者:
    
    tagResources 在接口中 AsyncClient
  - untagResource
```
public CompletableFuture<UntagResourceResponse> untagResource(UntagResourceRequest request)
```
    One or more tag keys. Separate multiple tag keys with commas (,). You need to specify only the tag keys, not the tag values. Each tag key must be 1 to 128 bytes in length.
    
    指定者:
    
    untagResource 在接口中 AsyncClient
  - untagResources
```
public CompletableFuture<UntagResourcesResponse> untagResources(UntagResourcesRequest request)
```
    指定者:
    
    untagResources 在接口中 AsyncClient
  - updateAlias
```
public CompletableFuture<UpdateAliasResponse> updateAlias(UpdateAliasRequest request)
```
    指定者:
    
    updateAlias 在接口中 AsyncClient
  - updateApplicationAccessPoint
```
public CompletableFuture<UpdateApplicationAccessPointResponse> updateApplicationAccessPoint(UpdateApplicationAccessPointRequest request)
```
    指定者:
    
    updateApplicationAccessPoint 在接口中 AsyncClient
  - updateCertificateStatus
```
public CompletableFuture<UpdateCertificateStatusResponse> updateCertificateStatus(UpdateCertificateStatusRequest request)
```
    In this example, the status of the certificate whose ID is `9a28de48-8d8b-484d-a766-dec4****` is updated to INACTIVE.
    
    指定者:
    
    updateCertificateStatus 在接口中 AsyncClient
  - updateKeyDescription
```
public CompletableFuture<UpdateKeyDescriptionResponse> updateKeyDescription(UpdateKeyDescriptionRequest request)
```
    This operation replaces the description of a customer master key (CMK) with the description that you specify. The original description of the CMK is specified by the Description parameter when you call the [DescribeKey](~~28952~~) operation. You can call this operation to add, modify, or delete the description of a CMK.
    
    指定者:
    
    updateKeyDescription 在接口中 AsyncClient
  - updateKmsInstanceBindVpc
```
public CompletableFuture<UpdateKmsInstanceBindVpcResponse> updateKmsInstanceBindVpc(UpdateKmsInstanceBindVpcRequest request)
```
    指定者:
    
    updateKmsInstanceBindVpc 在接口中 AsyncClient
  - updateNetworkRule
```
public CompletableFuture<UpdateNetworkRuleResponse> updateNetworkRule(UpdateNetworkRuleRequest request)
```
    指定者:
    
    updateNetworkRule 在接口中 AsyncClient
  - updatePolicy
```
public CompletableFuture<UpdatePolicyResponse> updatePolicy(UpdatePolicyRequest request)
```
    指定者:
    
    updatePolicy 在接口中 AsyncClient
  - updateRotationPolicy
```
public CompletableFuture<UpdateRotationPolicyResponse> updateRotationPolicy(UpdateRotationPolicyRequest request)
```
    When automatic key rotation is enabled, KMS automatically creates a key version after the preset rotation period arrives. In addition, KMS sets the new key version as the primary key version. An automatic key rotation policy cannot be configured for the following keys: * Asymmetric key * Service-managed key * Bring your own key (BYOK) that is imported into KMS * Key that is not in the **Enabled** state In this example, automatic key rotation is enabled for a CMK whose ID is `1234abcd-12ab-34cd-56ef-12345678****`. The automatic rotation period is 30 days.
    
    指定者:
    
    updateRotationPolicy 在接口中 AsyncClient
  - updateSecret
```
public CompletableFuture<UpdateSecretResponse> updateSecret(UpdateSecretRequest request)
```
    In this example, the metadata of the `secret001` secret is updated. The `Description` parameter is set to `datainfo`.
    
    指定者:
    
    updateSecret 在接口中 AsyncClient
  - updateSecretRotationPolicy
```
public CompletableFuture<UpdateSecretRotationPolicyResponse> updateSecretRotationPolicy(UpdateSecretRotationPolicyRequest request)
```
    After automatic rotation is enabled, Secrets Manager schedules the first automatic rotation by adding the preset rotation interval to the timestamp of the last rotation. Limits: The UpdateSecretRotationPolicy operation cannot be used to update the rotation policy of generic secrets. In this example, the rotation policy of the `RdsSecret/Mysql5.4/MyCred` secret is updated. The following settings are modified: * The `EnableAutomaticRotation` parameter is set to `true`, which indicates that automatic rotation is enabled. * The `RotationInterval` parameter is set to `30d`, which indicates that the interval for automatic rotation is 30 days.
    
    指定者:
    
    updateSecretRotationPolicy 在接口中 AsyncClient
  - updateSecretVersionStage
```
public CompletableFuture<UpdateSecretVersionStageResponse> updateSecretVersionStage(UpdateSecretVersionStageRequest request)
```
    Updates the stage label that marks a secret version.
    
    指定者:
    
    updateSecretVersionStage 在接口中 AsyncClient
  - uploadCertificate
```
public CompletableFuture<UploadCertificateResponse> uploadCertificate(UploadCertificateRequest request)
```
    In this example, a certificate issued by a CA is imported into Certificates Manager. The ID of the certificate in Certificates Manager is `12345678-1234-1234-1234-12345678****`.
    
    指定者:
    
    uploadCertificate 在接口中 AsyncClient

类 DefaultAsyncClient

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 com.aliyun.sdk.service.kms20160120.AsyncClient

字段详细资料

product

version

endpointRule

endpointMap

REQUEST

handler

构造器详细资料

DefaultAsyncClient

方法详细资料

close

asymmetricDecrypt

asymmetricEncrypt

asymmetricSign

asymmetricVerify

cancelKeyDeletion

certificatePrivateKeyDecrypt

certificatePrivateKeySign

certificatePublicKeyEncrypt

certificatePublicKeyVerify

connectKmsInstance

createAlias

createApplicationAccessPoint

createCertificate

createClientKey

createKey

createKeyVersion

createNetworkRule

createPolicy

createSecret

decrypt

deleteAlias

deleteApplicationAccessPoint

deleteCertificate

deleteClientKey

deleteKeyMaterial

deleteNetworkRule

deletePolicy

deleteSecret

describeAccountKmsStatus

describeApplicationAccessPoint

describeCertificate

describeKey

describeKeyVersion

describeNetworkRule

describePolicy

describeRegions

describeSecret

disableKey

enableKey

encrypt

exportDataKey

generateAndExportDataKey

generateDataKey

generateDataKeyWithoutPlaintext

getCertificate

getClientKey

getKmsInstance

getParametersForImport

getPublicKey

getRandomPassword

getSecretValue

importKeyMaterial

listAliases

listAliasesByKeyId

listApplicationAccessPoints

listClientKeys

listKeyVersions

listKeys

listKmsInstances

listNetworkRules

listPolicies

listResourceTags

listSecretVersionIds