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. Diese Vorgänge verwenden die kubectl-Befehlszeile und interagieren mit den folgenden Kubernetes-Ressourcen:

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

Eine vollständige Liste und Details zu den vom KMS unterstützten Schlüsseln finden Sie im Abschnitt Unterstützte Schlüssel im Dokument „Schlüsselverwaltungssystem“.

Dieses Dokument richtet sich an Zielgruppen innerhalb der Gruppe der Anwendungsoperatoren, die 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 können, müssen Sie die erforderlichen Berechtigungen haben und Ihre Umgebung vorbereiten.

IAM-Rollen anfordern

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

KMS-Schlüsselimport-Administrator (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 gdcloud CLI herunter und installieren Sie sie, falls noch nicht geschehen.
Installieren Sie die kubectl-Befehlszeile.
Generieren Sie eine kubeconfig-Datei, um den Zugriff auf kubectl zu konfigurieren.

Exportierten Schlüssel importieren

So importieren Sie einen exportierten Schlüssel:

Erstellen Sie eine YAML-Datei und fügen Sie die Ressource KeyImport als Wert des Objekts kind 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, 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 der 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.
Führen Sie den folgenden Befehl aus, um den Status der KeyImport-Ressource aufzurufen und den von KMS generierten öffentlichen Schlüssel abzurufen:
```
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 stellt den von KMS generierten öffentlichen Schlüssel dar. Kopieren Sie den öffentlichen Schlüssel und fügen Sie ihn im nächsten Schritt der Ressource KeyExport hinzu.
Erstellen Sie eine weitere YAML-Datei und fügen Sie die Ressource KeyExport als Wert des Objekts kind 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 (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, 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 das KMS den Status der Ressource KeyExport und generiert einen exportierten Schlüssel. Rufen Sie den Status der Ressource auf, um den exportierten Schlüssel zu erhalten.
Führen Sie den folgenden Befehl 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 stellt die Metadaten des exportierten Schlüssels dar. Kopieren Sie den Inhalt in EXPORTED_KEY, um mit dem nächsten Schritt fortzufahren.

Bearbeiten Sie die YAML-Datei, die die Ressource KeyImport enthält, und fügen Sie den Inhalt hinzu, 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
```
Nachdem Sie den Befehl ausgeführt haben, importiert KMS den von Ihnen bereitgestellten exportierten Schlüssel.
Führen Sie den folgenden Befehl 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, also AEAD- oder Signaturschlüssel.