Weitere AWS SDK-Beispiele sind im GitHub Repo [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) verfügbar.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwendung `CreateKey` mit einem AWS SDK oder CLI
Die folgenden Code-Beispiele zeigen, wie `CreateKey` verwendet wird.
Aktionsbeispiele sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Sie können diese Aktion in den folgenden Codebeispielen im Kontext sehen:
+ [Kennenlernen der Grundlagen](kms_example_kms_Scenario_Basics_section.md)
+ [Arbeiten mit der Tabellenverschlüsselung](kms_example_dynamodb_Scenario_EncryptionExamples_section.md)
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/KMS#code-examples) einrichten und ausführen.
```
using System;
using System.Threading.Tasks;
using Amazon.KeyManagementService;
using Amazon.KeyManagementService.Model;
///
/// Shows how to create a new AWS Key Management Service (AWS KMS)
/// key.
///
public class CreateKey
{
public static async Task Main()
{
// Note that if you need to create a Key in an AWS Region
// other than the Region defined for the default user, you need to
// pass the Region to the client constructor.
var client = new AmazonKeyManagementServiceClient();
// The call to CreateKeyAsync will create a symmetrical AWS KMS
// key. For more information about symmetrical and asymmetrical
// keys, see:
//
// https://docs.aws.amazon.com/kms/latest/developerguide/symm-asymm-choose.html
var response = await client.CreateKeyAsync(new CreateKeyRequest());
// The KeyMetadata object contains information about the new AWS KMS key.
KeyMetadata keyMetadata = response.KeyMetadata;
if (keyMetadata is not null)
{
Console.WriteLine($"KMS Key: {keyMetadata.KeyId} was successfully created.");
}
else
{
Console.WriteLine("Could not create KMS Key.");
}
}
}
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/kms-2014-11-01/CreateKey)in der *AWS SDK für .NET API-Referenz*.
------
#### [ CLI ]
**AWS CLI**
**Beispiel 1: So erstellen Sie einen vom Kunden verwalteten KMS-Schlüssel in AWS KMS**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel für die symmetrische Verschlüsselung erstellt.
Zum Erstellen des grundlegenden KMS-Schlüssels, einem symmetrischen Verschlüsselungsschlüssel, müssen Sie keine Parameter angeben. Die Standardwerte für diese Parameter erstellen einen symmetrischen Verschlüsselungsschlüssel.
Da dieser Befehl keine Schlüsselrichtlinie angibt, erhält der KMS-Schlüssel die [Standardschlüsselrichtlinie](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default) für KMS-Schlüssel, die programmgesteuert erstellt werden. Verwenden Sie den Befehl `get-key-policy`, um die Schlüsselrichtlinie anzuzeigen. Verwenden Sie den Befehl `put-key-policy`, um die Schlüsselrichtlinie zu ändern.
```
aws kms create-key
```
Der Befehl `create-key` gibt die wichtigsten Metadaten zurück, einschließlich der Schlüssel-ID und des ARN des neuen KMS-Schlüssels. Sie können diese Werte verwenden, um den KMS-Schlüssel in anderen AWS KMS-Vorgängen zu identifizieren. Die Ausgabe enthält keine Tags. Verwenden Sie den `list-resource-tags command`, um die Tags für einen KMS-Schlüssel anzuzeigen.
Ausgabe:
```
{
"KeyMetadata": {
"AWSAccountId": "111122223333",
"Arn": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"CreationDate": "2017-07-05T14:04:55-07:00",
"CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "AWS_KMS"
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
]
}
}
```
Hinweis: Mit dem Befehl `create-key` können Sie keinen Alias angeben. Verwenden Sie den Befehl `create-alias`, um einen Alias für den neuen KMS-Schlüssel zu erstellen.
Weitere Informationen finden Sie unter [Erstellen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 2: So erstellen Sie einen asymmetrischen RSA-KMS-Schlüssel für die Verschlüsselung und Entschlüsselung**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel erstellt, der ein asymmetrisches RSA-Schlüsselpaar für die Verschlüsselung und Entschlüsselung enthält. Die Schlüsselspezifikation und -verwendung können nach dem Erstellen des Schlüssels nicht geändert werden.
```
aws kms create-key \
--key-spec RSA_4096 \
--key-usage ENCRYPT_DECRYPT
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2021-04-05T14:04:55-07:00",
"CustomerMasterKeySpec": "RSA_4096",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"RSAES_OAEP_SHA_1",
"RSAES_OAEP_SHA_256"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "RSA_4096",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "AWS_KMS"
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 3: So erstellen Sie einen KMS-Schlüssel mit asymmetrischer Elliptic-Curve für die Signatur und Verifizierung**
Um einen asymmetrischen KMS-Schlüssel zu erstellen, der ein asymmetrisches Schlüsselpaar mit elliptischer Kurve (ECC) für Signatur und Verifizierung enthält. Der Parameter `--key-usage` ist erforderlich, obwohl `SIGN_VERIFY` der einzig gültige Wert für ECC-KMS-Schlüssel ist. Die Schlüsselspezifikation und -verwendung können nach dem Erstellen des Schlüssels nicht geändert werden.
```
aws kms create-key \
--key-spec ECC_NIST_P521 \
--key-usage SIGN_VERIFY
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2019-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "ECC_NIST_P521",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "ECC_NIST_P521",
"KeyState": "Enabled",
"KeyUsage": "SIGN_VERIFY",
"MultiRegion": false,
"Origin": "AWS_KMS",
"SigningAlgorithms": [
"ECDSA_SHA_512"
]
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 4: So erstellen Sie einen asymmetrischen ML-DSA-KMS-Schlüssel für Signatur und Verifizierung**
In diesem Beispiel wird ein ML-DSA-Schlüssel (Module-Lattice Digital Signature Algorithm) für Signatur und Verifizierung erstellt. Der Schlüsselnutzungsparameter ist erforderlich, obwohl `SIGN_VERIFY` der einzig gültige Wert für ML-DSA-Schlüssel ist.
```
aws kms create-key \
--key-spec ML_DSA_65 \
--key-usage SIGN_VERIFY
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2019-12-02T07:48:55-07:00",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "ML_DSA_65",
"KeyState": "Enabled",
"KeyUsage": "SIGN_VERIFY",
"MultiRegion": false,
"Origin": "AWS_KMS",
"SigningAlgorithms": [
"ML_DSA_SHAKE_256"
]
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 5: So erstellen Sie einen HMAC-KMS-Schlüssel**
Im folgenden Beispiel für `create-key` wird ein HMAC-KMS-Schlüssel von 384 Bit erstellt. Der Wert `GENERATE_VERIFY_MAC` für den Parameter `--key-usage` ist erforderlich, obwohl er der einzig gültige Wert für HMAC-KMS-Schlüssel ist.
```
aws kms create-key \
--key-spec HMAC_384 \
--key-usage GENERATE_VERIFY_MAC
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2022-04-05T14:04:55-07:00",
"CustomerMasterKeySpec": "HMAC_384",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "HMAC_384",
"KeyState": "Enabled",
"KeyUsage": "GENERATE_VERIFY_MAC",
"MacAlgorithms": [
"HMAC_SHA_384"
],
"MultiRegion": false,
"Origin": "AWS_KMS"
}
}
```
Weitere Informationen finden Sie unter [HMAC-Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 6: So erstellen Sie einen multiregionalen KMS-Schlüssel**
Im folgenden Beispiel für `create-key` wird ein multiregionaler Primärschlüssel erstellt. Da die Standardwerte für alle Parameter einen symmetrischen Verschlüsselungsschlüssel erzeugen, ist nur der Parameter `--multi-region` für diesen KMS-Schlüssel erforderlich. Um in der AWS CLI anzugeben, dass ein boolescher Parameter wahr ist, geben Sie einfach den Parameternamen an.
```
aws kms create-key \
--multi-region
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
"AWSAccountId": "111122223333",
"CreationDate": "2021-09-02T016:15:21-09:00",
"CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "mrk-1234abcd12ab34cd56ef12345678990ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": true,
"MultiRegionConfiguration": {
"MultiRegionKeyType": "PRIMARY",
"PrimaryKey": {
"Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
"Region": "us-west-2"
},
"ReplicaKeys": []
},
"Origin": "AWS_KMS"
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS im AWS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) *Key Management Service* Developer Guide.
**Beispiel 7: So erstellen Sie einen KMS-Schlüssel für importiertes Schlüsselmaterial**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel ohne Schlüsselmaterial erstellt. Wenn der Vorgang abgeschlossen ist, können Sie Ihr eigenes Schlüsselmaterial in den KMS-Schlüssel importieren. Um diesen KMS-Schlüssel zu erstellen, legen Sie den Parameter `--origin` auf `EXTERNAL` fest.
```
aws kms create-key \
--origin EXTERNAL
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2019-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"Description": "",
"Enabled": false,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "PendingImport",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "EXTERNAL"
}
}
```
Weitere Informationen finden Sie unter [Importieren von Schlüsselmaterial in AWS KMS-Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 6: So erstellen Sie einen KMS-Schlüssel in einem AWS CloudHSM-Schlüsselspeicher**
Das folgende `create-key` Beispiel erstellt einen KMS-Schlüssel im angegebenen AWS CloudHSM-Schlüsselspeicher. Der Vorgang erstellt den KMS-Schlüssel und seine Metadaten in AWS KMS und erstellt das Schlüsselmaterial im AWS CloudHSM-Cluster, der dem benutzerdefinierten Schlüsselspeicher zugeordnet ist. Die Parameter `--custom-key-store-id` und `--origin` müssen angegeben werden.
```
aws kms create-key \
--origin AWS_CLOUDHSM \
--custom-key-store-id cks-1234567890abcdef0
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CloudHsmClusterId": "cluster-1a23b4cdefg",
"CreationDate": "2019-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"CustomKeyStoreId": "cks-1234567890abcdef0",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "AWS_CLOUDHSM"
}
}
```
Weitere Informationen finden Sie unter [AWS -CloudHSM-Schlüsselspeicher](https://docs.aws.amazon.com/kms/latest/developerguide/keystore-cloudhsm.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 8: So erstellen Sie einen KMS-Schlüssel in einem externen Schlüsselspeicher**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel im angegebenen externen Schlüsselspeicher erstellt. Die Parameter `--custom-key-store-id`, `--origin` und `--xks-key-id` sind in diesem Befehl erforderlich.
Der Parameter `--xks-key-id` gibt die ID eines vorhandenen symmetrischen Verschlüsselungsschlüssels in Ihrem externen Schlüsselmanager an. Dieser Schlüssel dient als externes Schlüsselmaterial für den KMS-Schlüssel. Der Wert des Parameters `--origin` muss `EXTERNAL_KEY_STORE` lauten. Der Parameter `custom-key-store-id` muss einen externen Schlüsselspeicher identifizieren, der mit dem Proxy seines externen Schlüsselspeichers verbunden ist.
```
aws kms create-key \
--origin EXTERNAL_KEY_STORE \
--custom-key-store-id cks-9876543210fedcba9 \
--xks-key-id bb8562717f809024
```
Ausgabe:
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2022-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"CustomKeyStoreId": "cks-9876543210fedcba9",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "EXTERNAL_KEY_STORE",
"XksKeyConfiguration": {
"Id": "bb8562717f809024"
}
}
}
```
Weitere Informationen finden Sie unter [Externe Schlüsselspeicher](https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [CreateKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-key.html)in der *AWS CLI Befehlsreferenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/kms#code-examples) einrichten und ausführen.
```
/**
* Creates a new symmetric encryption key asynchronously.
*
* @param keyDesc the description of the key to be created
* @return a {@link CompletableFuture} that completes with the ID of the newly created key
* @throws RuntimeException if an error occurs while creating the key
*/
public CompletableFuture createKeyAsync(String keyDesc) {
CreateKeyRequest keyRequest = CreateKeyRequest.builder()
.description(keyDesc)
.keySpec(KeySpec.SYMMETRIC_DEFAULT)
.keyUsage(KeyUsageType.ENCRYPT_DECRYPT)
.build();
return getAsyncClient().createKey(keyRequest)
.thenApply(resp -> resp.keyMetadata().keyId())
.exceptionally(ex -> {
throw new RuntimeException("An error occurred while creating the key: " + ex.getMessage(), ex);
});
}
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/kms-2014-11-01/CreateKey)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ Kotlin ]
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/kms#code-examples) einrichten und ausführen.
```
suspend fun createKey(keyDesc: String?): String? {
val request =
CreateKeyRequest {
description = keyDesc
customerMasterKeySpec = CustomerMasterKeySpec.SymmetricDefault
keyUsage = KeyUsageType.fromValue("ENCRYPT_DECRYPT")
}
KmsClient.fromEnvironment { region = "us-west-2" }.use { kmsClient ->
val result = kmsClient.createKey(request)
println("Created a customer key with id " + result.keyMetadata?.arn)
return result.keyMetadata?.keyId
}
}
```
+ API-Details finden Sie [CreateKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/kms#code-examples) einrichten und ausführen.
```
/***
* @param string $keySpec
* @param string $keyUsage
* @param string $description
* @return array
*/
public function createKey(string $keySpec = "", string $keyUsage = "", string $description = "Created by the SDK for PHP")
{
$parameters = ['Description' => $description];
if($keySpec && $keyUsage){
$parameters['KeySpec'] = $keySpec;
$parameters['KeyUsage'] = $keyUsage;
}
try {
$result = $this->client->createKey($parameters);
return $result['KeyMetadata'];
}catch(KmsException $caught){
// Check for error specific to createKey operations
if ($caught->getAwsErrorMessage() == "LimitExceededException"){
echo "The request was rejected because a quota was exceeded. For more information, see Quotas in the Key Management Service Developer Guide.";
}
throw $caught;
}
}
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateKey)in der *AWS SDK für PHP API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/kms#code-examples) einrichten und ausführen.
```
class KeyManager:
def __init__(self, kms_client):
self.kms_client = kms_client
self.created_keys = []
@classmethod
def from_client(cls) -> "KeyManager":
"""
Creates a KeyManager instance with a default KMS client.
:return: An instance of KeyManager initialized with the default KMS client.
"""
kms_client = boto3.client("kms")
return cls(kms_client)
def create_key(self, key_description: str) -> dict[str, any]:
"""
Creates a key with a user-provided description.
:param key_description: A description for the key.
:return: The key ID.
"""
try:
key = self.kms_client.create_key(Description=key_description)["KeyMetadata"]
self.created_keys.append(key)
return key
except ClientError as err:
logging.error(
"Couldn't create your key. Here's why: %s",
err.response["Error"]["Message"],
)
raise
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.aws.amazon.com/goto/boto3/kms-2014-11-01/CreateKey)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Ruby ]
**SDK für Ruby**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/kms#code-examples) einrichten und ausführen.
```
require 'aws-sdk-kms' # v2: require 'aws-sdk'
# Create a AWS KMS key.
# As long we are only encrypting small amounts of data (4 KiB or less) directly,
# a KMS key is fine for our purposes.
# For larger amounts of data,
# use the KMS key to encrypt a data encryption key (DEK).
client = Aws::KMS::Client.new
resp = client.create_key({
tags: [
{
tag_key: 'CreatedBy',
tag_value: 'ExampleUser'
}
]
})
puts resp.key_metadata.key_id
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/kms-2014-11-01/CreateKey)in der *AWS SDK für Ruby API-Referenz*.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/kms#code-examples) einrichten und ausführen.
```
async fn make_key(client: &Client) -> Result<(), Error> {
let resp = client.create_key().send().await?;
let id = resp.key_metadata.as_ref().unwrap().key_id();
println!("Key: {}", id);
Ok(())
}
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.rs/aws-sdk-kms/latest/aws_sdk_kms/client/struct.Client.html#method.create_key)in der *API-Referenz zum AWS SDK für Rust*.
------
#### [ SAP ABAP ]
**SDK für SAP ABAP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/kms#code-examples) einrichten und ausführen.
```
TRY.
" iv_description = 'Created by the AWS SDK for SAP ABAP'
oo_result = lo_kms->createkey( iv_description = iv_description ).
MESSAGE 'KMS key created successfully.' TYPE 'I'.
CATCH /aws1/cx_kmskmsinternalex.
MESSAGE 'An internal error occurred.' TYPE 'E'.
CATCH /aws1/cx_kmslimitexceededex.
MESSAGE 'Limit exceeded for KMS resources.' TYPE 'E'.
ENDTRY.
```
+ Einzelheiten zur API finden Sie [CreateKey](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)in der *API-Referenz zum AWS SDK für SAP ABAP*.
------