AWS KMS 鍵環

若要識別 AWS KMS key 中加密金鑰環中的 適用於 C 的 AWS Encryption SDK，請指定金鑰ARN或別名 ARN。在解密鍵控中，您必須使用金鑰 ARN。如需詳細資訊，請參閱 在鍵環 AWS KMS keys 中 AWS KMS 識別。

如需完整範例，請參閱 string.cpp。

const char * generator_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"

const char * additional_key = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"    

struct aws_cryptosdk_keyring *kms_encrypt_keyring = 
       Aws::Cryptosdk::KmsKeyring::Builder().Build(generator_key,{additional_key});

若要在 for 中建立具有一或多個 AWS KMS 金鑰 AWS Encryption SDK 的 AWS KMS 鍵環NET，請建立多鍵環。 AWS Encryption SDK 適用於 的 。NET 包含 金鑰專用的多金鑰。 AWS KMS

當您 AWS KMS key 在 中為 AWS Encryption SDK 的加密鍵環指定 時NET，您可以使用任何有效的金鑰識別符：金鑰 ID 、金鑰 ARN、別名名稱 或別名 ARN。如需在 AWS KMS 金鑰環 AWS KMS keys 中識別 的說明，請參閱 在鍵環 AWS KMS keys 中 AWS KMS 識別。

下列範例使用 的 4.x 版 AWS Encryption SDK for 。NET 建立具有產生器金鑰和其他金鑰的 AWS KMS 金鑰環。如需完整範例，請參閱 AwsKmsMultiKeyringExample.cs。

// Instantiate the AWS Encryption SDK and material provider
var mpl = new MaterialProviders(new MaterialProvidersConfig());
var esdk =  new ESDK(new AwsEncryptionSdkConfig());

string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<string> additionalKey = new List<string> { "alias/exampleAlias" };

// Instantiate the keyring input object
var kmsEncryptKeyringInput = new CreateAwsKmsMultiKeyringInput
{
    Generator = generatorKey,
    KmsKeyIds = additionalKey
};

var kmsEncryptKeyring = materialProviders.CreateAwsKmsMultiKeyring(kmsEncryptKeyringInput);

當您 AWS KMS key 在 中指定加密金鑰環的 時 適用於 JavaScript 的 AWS Encryption SDK，您可以使用任何有效的金鑰識別符：金鑰 ID 、金鑰 ARN、別名名稱 或別名 ARN。如需識別 AWS KMS 金鑰環 AWS KMS keys 中的 的說明，請參閱 在鍵環 AWS KMS keys 中 AWS KMS 識別。

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數目。如需詳細資訊，請參閱限制加密的資料金鑰。

如需完整範例，請參閱 中 適用於 JavaScript 的 AWS Encryption SDK 儲存庫中的 kms_simple.ts GitHub。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'

const keyring = new KmsKeyringBrowser({
  clientProvider, 
  generatorKeyId, 
  keyIds: [additionalKey] 
})

當您 AWS KMS key 在 中指定加密金鑰的 時 適用於 JavaScript 的 AWS Encryption SDK，您可以使用任何有效的金鑰識別符：金鑰 ID 、金鑰 ARN、別名名稱 或別名 ARN。如需識別 AWS KMS 金鑰環 AWS KMS keys 中的 的說明，請參閱 在鍵環 AWS KMS keys 中 AWS KMS 識別。

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數目。如需詳細資訊，請參閱限制加密的資料金鑰。

如需完整範例，請參閱 中 適用於 JavaScript 的 AWS Encryption SDK 儲存庫中的 kms_simple.ts GitHub。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
                            
const additionalKey = 'alias/exampleAlias'

const keyring = new KmsKeyringNode({
  generatorKeyId,
  keyIds: [additionalKey]
})

若要在 中建立具有一或多個 AWS KMS 金鑰的 AWS KMS 鍵環 適用於 JAVA 的 AWS Encryption SDK，請建立多重鍵環。 適用於 JAVA 的 AWS Encryption SDK 包含僅適用於金鑰的多 AWS KMS 金鑰。

當您 AWS KMS key 在 中指定加密金鑰環的 時 適用於 JAVA 的 AWS Encryption SDK，您可以使用任何有效的金鑰識別符：金鑰 ID 、金鑰 ARN、別名名稱 或別名 ARN。如需識別 AWS KMS 金鑰環 AWS KMS keys 中的 的說明，請參閱 在鍵環 AWS KMS keys 中 AWS KMS 識別。

如需完整範例，請參閱 中 適用於 JAVA 的 AWS Encryption SDK 儲存庫中的 BasicEncryptionKeyringExample.java GitHub。

 // Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
            .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
            .build();

String generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<String> additionalKey = Collections.singletonList("alias/exampleAlias");

// Create the AWS KMS keyring
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
        .generator(generatorKey)
        .kmsKeyIds(additionalKey)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMultiKeyring(keyringInput);

若要在 中建立具有一或多個 AWS KMS 金鑰的 AWS KMS 鍵環 適用於 Python 的 AWS Encryption SDK，請建立多重鍵環。 適用於 Python 的 AWS Encryption SDK 包含僅適用於金鑰的多重 AWS KMS 金鑰。如需範例，請參閱 中 適用於 Python 的 AWS Encryption SDK 儲存庫中的 aws_kms_multi_keyring_example.py GitHub。

當您 AWS KMS key 在 中指定加密金鑰環的 時 適用於 Python 的 AWS Encryption SDK，您可以使用任何有效的金鑰識別符：金鑰 ID 、金鑰 ARN、別名名稱 或別名 ARN。如需識別 AWS KMS 金鑰環 AWS KMS keys 中的 的說明，請參閱 在鍵環 AWS KMS keys 中 AWS KMS 識別。

下列範例會使用預設承諾政策 、 來實例化 AWS Encryption SDK 用戶端REQUIRE_ENCRYPT_REQUIRE_DECRYPT。如需完整範例，請參閱 中 適用於 Python 的 AWS Encryption SDK 儲存庫中的 aws_kms_keyring_example.py GitHub。

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name="us-west-2")
        
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring 
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
    generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    kms_key_ids=additionalKey
)

kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
    input=keyring_input
)

const char * additional_key = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"    

struct aws_cryptosdk_keyring *kms_decrypt_keyring = 
       Aws::Cryptosdk::KmsKeyring::Builder().Build(additional_key);

因為此解密鍵控僅包含一個 AWS KMS 金鑰，所以範例會使用 CreateAwsKmsKeyring()方法搭配其CreateAwsKmsKeyringInput物件的執行個體。若要使用一個 AWS KMS 金鑰建立鍵環 AWS KMS ，您可以使用單一金鑰或多金鑰鍵環。如需詳細資訊，請參閱 加密 中 AWS Encryption SDK 適用於 的資料。NET。下列範例使用 的 4.NETx 版 AWS Encryption SDK 。 建立用於解密的 AWS KMS 金鑰環。

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

string additionalKey = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321";

// Instantiate a KMS keyring for one AWS KMS key.
var kmsDecryptKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = additionalKey
};

var kmsDecryptKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數目。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })
const additionalKey = 'arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321'

const keyring = new KmsKeyringBrowser({ clientProvider, keyIds: [additionalKey] })

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數目。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const additionalKey = 'arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321'

const keyring = new KmsKeyringNode({ keyIds: [additionalKey] })

因為此解密鍵控僅包含一個 AWS KMS 金鑰，所以範例會使用 CreateAwsKmsKeyring()方法搭配其CreateAwsKmsKeyringInput物件的執行個體。若要使用一個 AWS KMS 金鑰建立鍵環 AWS KMS ，您可以使用單一金鑰或多金鑰鍵環。

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
        
String additionalKey = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321";

// Create a AwsKmsKeyring
CreateAwsKmsKeyringInput kmsDecryptKeyringInput = CreateAwsKmsKeyringInput.builder()
        .generator(additionalKey)
        .kmsClient(KmsClient.create())
        .build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

下列範例會使用預設承諾政策 、 來實例化 AWS Encryption SDK 用戶端REQUIRE_ENCRYPT_REQUIRE_DECRYPT。如需完整範例，請參閱 中 適用於 Python 的 AWS Encryption SDK 儲存庫中的 aws_kms_keyring_example.py GitHub。

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name="us-west-2")
        
# Instantiate the material providers   
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
    generator=additionalKey,
    kms_client=kms_client
)

kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
    input=keyring_input
)

struct aws_cryptosdk_keyring *kms_decrypt_keyring = 
       Aws::Cryptosdk::KmsKeyring::Builder().Build(generator_key, {additional_key, other_key});

下列範例使用適用於 的 4.x AWS Encryption SDK 版NET。

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

// Instantiate a KMS keyring for one AWS KMS key.
var kmsDecryptKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = generatorKey
};

var kmsDecryptKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數目。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const keyring = new KmsKeyringBrowser({
  clientProvider, 
  generatorKeyId, 
  keyIds: [additionalKey, otherKey]
})

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數量。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const keyring = new KmsKeyringNode({
  generatorKeyId,
  keyIds: [additionalKey, otherKey]
})

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
        
String generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

// Create a AwsKmsKeyring
CreateAwsKmsKeyringInput kmsDecryptKeyringInput = CreateAwsKmsKeyringInput.builder()
        .generator(generatorKey)
        .kmsClient(KmsClient.create())
        .build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

下列範例會使用預設承諾政策 、 來實例化 AWS Encryption SDK 用戶端REQUIRE_ENCRYPT_REQUIRE_DECRYPT。如需完整範例，請參閱 中 適用於 Python 的 AWS Encryption SDK 儲存庫中的 aws_kms_keyring_example.py GitHub。

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name="us-west-2")
        
# Instantiate the material providers library  
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
    generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    kms_client=kms_client
)

kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
    input=keyring_input
)

如需完整範例，請參閱：kms_discovery.cpp。

std::shared_ptr<KmsKeyring::> discovery_filter(
    KmsKeyring::DiscoveryFilter::Builder("aws")
        .AddAccount("111122223333")
        .Build());

struct aws_cryptosdk_keyring *kms_discovery_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
       .BuildDiscovery(discovery_filter));

下列範例使用 的 4.x 版 AWS Encryption SDK 。NET

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };
        
// In a discovery keyring, you specify an AWS KMS client and a discovery filter,
// but not a AWS KMS key
var kmsDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    DiscoveryFilter = new DiscoveryFilter()
    {
        AccountIds = account,
        Partition = "aws"
    }
};
        
var kmsDiscoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(kmsDiscoveryKeyringInput);

在 中 JavaScript，您必須明確指定探索屬性。

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數量。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const discovery = true
const keyring = new KmsKeyringBrowser(clientProvider, {
    discovery,
    discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})

在 中 JavaScript，您必須明確指定探索屬性。

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數量。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const discovery = true

const keyring = new KmsKeyringNode({
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})

// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
        .discoveryFilter(discoveryFilter)
        .build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);

# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)

# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS discovery keyring
discovery_keyring_input: CreateAwsKmsDiscoveryKeyringInput = CreateAwsKmsDiscoveryKeyringInput(
    kms_client=kms_client,
    discovery_filter=DiscoveryFilter(
        account_ids=[aws_account_id],
        partition="aws"
    )
)

discovery_keyring: IKeyring = mat_prov.create_aws_kms_discovery_keyring(
    input=discovery_keyring_input
)
                            

若要檢視此 keyring 和 create_kms_client 方法的工作實例，請參閱 kms_discovery.cpp。

std::shared_ptr<KmsKeyring::DiscoveryFilter> discovery_filter(
    KmsKeyring::DiscoveryFilter::Builder("aws")
        .AddAccount("111122223333")
        .Build());

struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
       .WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery(discovery_filter));

AWS Encryption SDK for .NET 沒有專用的區域探索金鑰環。不過，您可以使用數種技術來限制解密至特定區域時使用的KMS金鑰。

限制探索金鑰環中區域最有效的方法是使用 multi-Region-aware探索金鑰環，即使您僅使用單一區域金鑰加密資料。當遇到單一區域金鑰時 multi-Region-aware，金鑰環不會使用任何多區域功能。

CreateAwsKmsMrkDiscoveryKeyring() 方法傳回的鍵環會依區域篩選KMS金鑰，然後再呼叫 AWS KMS。 AWS KMS 只有當加密的資料金鑰由CreateAwsKmsMrkDiscoveryKeyringInput物件中 Region 參數指定的區域中的KMS金鑰加密時，才會傳送解密請求至 。

下列範例使用適用於 的 4.x AWS Encryption SDK 版NET。

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };

// Create the discovery filter
var filter = DiscoveryFilter = new DiscoveryFilter
{
    AccountIds = account,
    Partition = "aws"
};
                                
var regionalDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    Region = RegionEndpoint.USWest2,
    DiscoveryFilter = filter
};                                

var kmsRegionalDiscoveryKeyring = materialProviders.CreateAwsKmsMrkDiscoveryKeyring(regionalDiscoveryKeyringInput);

您也可以 AWS 區域 在 AWS KMS 用戶端執行個體 （） 中指定區域，將KMS金鑰限制為特定 AmazonKeyManagementServiceClient。不過，相較於使用探索金鑰環， multi-Region-aware此組態效率較低，而且可能成本更高。 AWS Encryption SDK 的 不會在呼叫 之前依區域篩選KMS金鑰 AWS KMS，而是 AWS KMS 針對每個加密的資料金鑰呼叫 （NET直到其解密一個），並依賴 AWS KMS 將其使用的KMS金鑰限制到指定的區域。

下列範例使用 AWS Encryption SDK 的 4.x 版NET。

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };
        
// Create the discovery filter,
// but not a AWS KMS key
var createRegionalDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    DiscoveryFilter = new DiscoveryFilter()
    {
        AccountIds = account,
        Partition = "aws"
    }
};
        
var kmsRegionalDiscoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(createRegionalDiscoveryKeyringInput);

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數量。如需詳細資訊，請參閱限制加密的資料金鑰。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser(clientProvider, {
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})

下列範例使用 buildClient函數來指定預設承諾政策 、 REQUIRE_ENCRYPT_REQUIRE_DECRYPT。您也可以使用 buildClient來限制加密訊息中的加密資料金鑰數量。如需詳細資訊，請參閱限制加密的資料金鑰。

若要檢視此鍵環和limitRegions函數，請參閱工作範例中的 kms_regional_discovery.ts。

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({
    clientProvider,
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})

// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
        .discoveryFilter(discoveryFilter)
        .regions("us-west-2")
        .build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);

# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)

# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS regional discovery keyring
regional_discovery_keyring_input: CreateAwsKmsMrkDiscoveryKeyringInput = \
    CreateAwsKmsMrkDiscoveryKeyringInput(
        kms_client=kms_client,
        region=mrk_replica_decrypt_region,
        discovery_filter=DiscoveryFilter(
            account_ids=[111122223333],
            partition="aws"
        )
)

    regional_discovery_keyring: IKeyring = mat_prov.create_aws_kms_mrk_discovery_keyring(
        input=regional_discovery_keyring_input
    )