Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Schlüssel importieren und exportieren

In diesem Dokument wird beschrieben, wie Sie KMS-Schlüssel (Key Management System) importieren und exportieren. Für diese Vorgänge wird die kubectl-Befehlszeile verwendet und es wird mit den folgenden Kubernetes-Ressourcen interagiert:

Weitere Informationen zu diesen Ressourcen finden Sie in der KMS API-Übersicht.

Eine vollständige Liste und Details der von KMS unterstützten Schlüssel finden Sie im Abschnitt Unterstützte Schlüssel im Dokument zum Schlüsselverwaltungssystem.

Dieses Dokument richtet sich an Nutzer in der Gruppe der Anwendungsoperatoren, die Schlüsselverwaltungsoperationen in Google Distributed Cloud (GDC) mit Air Gap ausführen. Weitere Informationen finden Sie unter Dokumentation zu Zielgruppen für GDC mit Air Gap.

Hinweis

Bevor Sie Schlüssel importieren oder exportieren können, müssen Sie die erforderlichen Berechtigungen haben und Ihre Umgebung vorbereiten.

IAM-Rollen anfordern

Wenden Sie sich an den IAM-Administrator Ihrer Organisation und bitten Sie ihn, Ihnen die folgenden Rollen in Ihrem Projekt zuzuweisen:

KMS Key Import Admin (kms-keyimport-admin): Erstellen, Aktualisieren und Löschen von KeyImport-Ressourcen.
KMS Key Export Admin (kms-keyexport-admin): KeyExport-Ressourcen erstellen, aktualisieren und löschen.

Umgebung vorbereiten

Laden Sie die gcloud CLI herunter und installieren Sie sie, falls noch nicht geschehen.
Installieren Sie die kubectl-Befehlszeile, wie unter Komponenten installieren beschrieben.
kubeconfig-Datei generieren, um den kubectl-Zugriff zu konfigurieren.

Exportierten Schlüssel importieren

Führen Sie die folgenden Schritte aus, um einen exportierten Schlüssel zu importieren:

Erstellen Sie eine YAML-Datei und fügen Sie die KeyImport-Ressource als Wert des kind-Objekts hinzu:
```
apiVersion: "kms.gdc.goog/v1"
kind: KeyImport
metadata:
  name: KEY_IMPORT_NAME
  namespace: PROJECT
spec:
  context:
    mechanism: MECHANISM
```
Ersetzen Sie die folgenden Variablen:
- KEY_IMPORT_NAME: der Name der KeyImport-Ressource, z. B. key-import-test.
- PROJECT: der Name des Projekt-Namespace, z. B. kms-test1.
- MECHANISM: Der Mechanismus zur Schlüsselweitergabe des Schlüssels, z. B. `EDCH_P521_AES256` .
Wenden Sie den Inhalt der YAML-Datei auf den KMS an und erstellen Sie die Ressource KeyImport:
```
kubectl apply -f FILENAME.yaml
```
Ersetzen Sie FILENAME durch den Namen der YAML-Datei.

Mit dem öffentlichen Schlüssel eines intern generierten Schlüsselpaars aktualisiert KMS den Status der KeyImport-Ressource auf AwaitingKeyToImport. Um fortzufahren, müssen Sie den Status der Ressource aufrufen und den von KMS generierten öffentlichen Schlüssel abrufen.
So rufen Sie den Status der KeyImport-Ressource auf und erhalten den von KMS generierten öffentlichen Schlüssel:
```
kubectl describe keyimport KEY_IMPORT_NAME --namespace PROJECT
```
Ersetzen Sie die folgenden Variablen:
- KEY_IMPORT_NAME: Der KeyImport-Ressourcenname, z. B. key-import-test.
- PROJECT: Der Name des Projekt-Namespace, z. B. kms-test1.
Nach der Ausführung des Befehls wird eine Ausgabe angezeigt, die in etwa so aussieht:
```
...
Status:
  Conditions:
    Last Transition Time:  2022-12-14T20:43:50Z
    Message:               waiting for user to provide KeyToImport
    Observed Generation:   1
    Reason:                AwaitingKeyToImport
    Status:                False
    Type:                  Ready
  Imported Key Ref:
    Kind: KeyImport
    Name: key-import-test
  Peer Context:
    Private Key:
    Public Key: PUBLIC_KEY
Events:           <none>
```
Der Wert PUBLIC_KEY steht für den von KMS generierten öffentlichen Schlüssel. Kopieren Sie den öffentlichen Schlüssel und fügen Sie ihn im nächsten Schritt der KeyExport-Ressource hinzu.
Erstellen Sie eine weitere YAML-Datei, fügen Sie die KeyExport-Ressource als Wert des kind-Objekts und den folgenden Inhalt hinzu:
```
apiVersion: "kms.gdc.goog/v1"
kind: KeyExport
metadata:
  name: KEY_EXPORT_NAME
  namespace: PROJECT
spec:
  context:
    mechanism: MECHANISM
    publicKey: PUBLIC_KEY
  keyToExport:
    kind: KEY_PRIMITIVE
    name: KEY_NAME
```
Ersetzen Sie die folgenden Variablen:
- KEY_EXPORT_NAME: der Name der KeyExport-Ressource, z. B. key-export-test.
- PROJECT: Der Name des Projekt-Namespace, z. B. kms-test1.
  
  Wichtig :Die benutzerdefinierte Ressourcendefinition (Custom Resource Definition, CRD) KeyExport muss sich im selben Projekt-Namespace wie der importierte Schlüssel befinden. Wenn sich der importierte Schlüssel im Projekt-Namespace kms-test1 befindet, muss sich die KeyExport-CRD ebenfalls im selben Projekt-Namespace befinden.
- MECHANISM: Der Mechanismus zur Schlüsselweitergabe des Schlüssels, z. B. `EDCH_P521_AES256` .
- PUBLIC_KEY: Der öffentliche Schlüssel aus keyImport.Status.PeerContext.PublicKey.
- KEY_PRIMITIVE: die CRD des Schlüssels, z. B. „aeadkey“ und „signingkey“.
- KEY_NAME: der Name des Schlüssels, z. B. key-1.
Wenden Sie den Inhalt der YAML-Datei auf den KMS an und erstellen Sie die Ressource KeyExport:
```
kubectl apply -f FILENAME.yaml
```
Ersetzen Sie FILENAME durch den Namen der YAML-Datei.

Nachdem Sie den Befehl ausgeführt haben, aktualisiert KMS den Status der KeyExport-Ressource und generiert einen exportierten Schlüssel. Um den exportierten Schlüssel zu erhalten, sehen Sie sich den Status der Ressource an.
Führen Sie Folgendes aus, um den Status der Ressource aufzurufen:
```
kubectl describe keyexport KEY_EXPORT_NAME --namespace PROJECT
```
Ersetzen Sie die folgenden Variablen:
- KEY_EXPORT_NAME: Der Name der KeyExport-Ressource, z. B. key-export-test.
- PROJECT: der Name des Projekt-Namespace, z. B. kms-test1.
Nach der Ausführung des Befehls wird eine Ausgabe angezeigt, die in etwa so aussieht:
```
...
Status:
Conditions:
Last Transition Time:  2022-12-14T20:45:57Z
Message:               key successfully exported
Observed Generation:   1
Reason:                KeyExportCompleted
Status:                True
Type:                  Ready
Exported Key: EXPORTED_KEY
```
EXPORTED_KEY steht für die Metadaten des exportierten Schlüssels. Kopieren Sie den Inhalt von EXPORTED_KEY, um mit dem nächsten Schritt fortzufahren.

Bearbeiten Sie die YAML-Datei, die die KeyImport-Ressource enthält, und fügen Sie den Inhalt ein, den Sie aus der Ausgabe in keyexport.status.exportedkey kopiert haben.

apiVersion: "kms.gdc.goog/v1"
kind: KeyImport
metadata:
  name: key-import-test
  namespace: kms-test1
spec:
  context:
    mechanism: EDCH_P521_AES256
  keyToImport: EXPORTED_KEY

Nachdem Sie die YAML-Datei bearbeitet haben, wenden Sie den Inhalt auf den KMS an:
```
kubectl apply -f FILENAME.yaml
```
Nach der Ausführung des Befehls importiert der KMS den von Ihnen bereitgestellten exportierten Schlüssel.
Führen Sie Folgendes aus, um Details zum importierten Schlüssel aufzurufen:
```
kubectl get keyimport KEY_IMPORT_NAME
```
Die Ausgabe sollte in etwa so aussehen:
```
NAMESPACE   NAME             AGE    READY   REASON              KEY KIND
kms-test1  KEY_IMPORT_NAME   60s    True    KeyImportCompleted  KEY_PRIMITIVE
```
KEY_PRIMITIVE steht für die Art des importierten Schlüssels, entweder AEAD- oder Signaturschlüssel.