Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

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 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 Key Management System.

Dieses Dokument richtet sich an Zielgruppen in der Gruppe der Anwendungsoperatoren, wenn sie Schlüsselverwaltungsvorgänge 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, müssen Sie die erforderlichen Berechtigungen haben und Ihre Umgebung vorbereiten.

IAM-Rollen anfordern

Wenden Sie sich an Ihren IAM-Administrator der Organisation, um die folgenden Rollen in Ihrem Projekt anzufordern:

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

Umgebung vorbereiten

Laden Sie die gdcloud CLI herunter und installieren Sie sie, falls noch nicht geschehen.
Installieren Sie die kubectl CLI.
Generieren Sie eine kubeconfig-Datei 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 das KMS an und erstellen Sie die KeyImport-Ressource:
```
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 das KMS den Status der KeyImport-Ressource auf AwaitingKeyToImport. Um fortzufahren, müssen Sie den Status der Ressource aufrufen und den vom KMS generierten öffentlichen Schlüssel abrufen.
Führen Sie Folgendes aus, um den Status der KeyImport-Ressource aufzurufen und den vom KMS generierten öffentlichen Schlüssel abzurufen:
```
kubectl describe keyimport KEY_IMPORT_NAME --namespace PROJECT
```
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.
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 vom 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 auch 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 das KMS an und erstellen Sie die KeyExport-Ressource:
```
kubectl apply -f FILENAME.yaml
```
Ersetzen Sie FILENAME durch den Namen der YAML-Datei.

Nach der Ausführung des Befehls aktualisiert das KMS den Status der KeyExport-Ressource und generiert einen exportierten Schlüssel. Rufen Sie den Status der Ressource auf, um den exportierten Schlüssel zu erhalten.
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 in 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

Wenden Sie nach der Bearbeitung der YAML-Datei den Inhalt auf das KMS an:
```
kubectl apply -f FILENAME.yaml
```
Nach der Ausführung des Befehls importiert das KMS den von Ihnen angegebenen 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, zwischen AEAD- und Signaturschlüsseln.