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

Importer et exporter des clés

Ce document vous explique comment importer et exporter des clés Key Management System (KMS). Ces opérations utilisent l'interface de ligne de commande kubectl et interagissent avec les ressources Kubernetes suivantes :

Pour en savoir plus sur ces ressources, consultez la présentation de l'API KMS.

Consultez la section Clés compatibles du document Système de gestion des clés pour obtenir la liste complète et les détails des clés compatibles avec KMS.

Ce document est destiné aux audiences du groupe d'opérateurs d'applications lors de l'exécution d'opérations de gestion des clés dans Google Distributed Cloud (GDC) sous air gap. Pour en savoir plus, consultez la documentation sur les audiences pour GDC sous air gap.

Avant de commencer

Avant d'importer ou d'exporter des clés, vous devez disposer des autorisations nécessaires et préparer votre environnement.

Demander des rôles IAM

Contactez l'administrateur IAM de votre organisation pour demander les rôles suivants dans votre projet :

Administrateur d'importation de clés KMS (kms-keyimport-admin) : créez, mettez à jour et supprimez des ressources KeyImport.
Administrateur d'exportation de clés KMS (kms-keyexport-admin) : créez, mettez à jour et supprimez des ressources KeyExport.

Préparer votre environnement

Téléchargez et installez la CLI gdcloud, si ce n'est pas déjà fait.
Installez la CLI kubectl, comme décrit dans Installer des composants.
Générez un fichier kubeconfig pour configurer l'accès kubectl.

Importer une clé exportée

Pour importer une clé exportée, procédez comme suit :

Créez un fichier YAML et ajoutez la ressource KeyImport en tant que valeur de l'objet kind :
```
apiVersion: "kms.gdc.goog/v1"
kind: KeyImport
metadata:
  name: KEY_IMPORT_NAME
  namespace: PROJECT
spec:
  context:
    mechanism: MECHANISM
```
Remplacez les variables suivantes :
- KEY_IMPORT_NAME : nom de la ressource KeyImport , par exemple key-import-test.
- PROJECT : nom de l'espace de noms du projet, par exemple kms-test1.
- MECHANISM : mécanisme de partage de clés de la clé , par exemple `EDCH_P521_AES256` .
Appliquez le contenu du fichier YAML à KMS et créez la ressource KeyImport :
```
kubectl apply -f FILENAME.yaml
```
Remplacez FILENAME par le nom du fichier YAML.

Avec la clé publique d'une paire de clés générée en interne, KMS met à jour l'état de la ressource KeyImport sur AwaitingKeyToImport. Pour continuer, vous devez afficher l'état de la ressource et obtenir la clé publique générée par KMS.
Pour afficher l'état de la ressource KeyImport et obtenir la clé publique générée par KMS, exécutez la commande suivante :
```
kubectl describe keyimport KEY_IMPORT_NAME --namespace PROJECT
```
Remplacez les variables suivantes :
- KEY_IMPORT_NAME : nom de la ressource KeyImport — par exemple key-import-test.
- PROJECT : nom de l'espace de noms du projet, par exemple : kms-test1.
Une fois la commande exécutée, un résultat semblable aux lignes suivantes s'affiche :
```
...
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>
```
La valeur PUBLIC_KEY représente la clé publique générée par KMS. Copiez la clé publique et ajoutez-la à la ressource KeyExport à l'étape suivante.
Créez un autre fichier YAML, ajoutez la ressource KeyExport en tant que valeur de l'objet kind, ainsi que le contenu suivant :
```
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
```
Remplacez les variables suivantes :
- KEY_EXPORT_NAME : nom de la ressource KeyExport , par exemple key-export-test.
- PROJECT : nom de l'espace de noms du projet, par exemple : kms-test1.
  
  Important : La définition de ressource personnalisée (CRD) KeyExport doit résider dans le même espace de noms de projet que la clé importée. Si la clé importée réside dans l'espace de noms du projet kms-test1, la CRD KeyExport doit également résider dans le même espace de noms de projet.
- MECHANISM : mécanisme de partage de clés de la clé , par exemple `EDCH_P521_AES256` .
- PUBLIC_KEY : clé publique de keyImport.Status.PeerContext.PublicKey.
- KEY_PRIMITIVE : CRD de la clé, par exemple aeadkey et signingkey.
- KEY_NAME : nom de la clé, par exemple key-1.
Appliquez le contenu du fichier YAML à KMS et créez la ressource KeyExport :
```
kubectl apply -f FILENAME.yaml
```
Remplacez FILENAME par le nom du fichier YAML.

Une fois la commande exécutée, KMS met à jour l'état de la ressource KeyExport et génère une clé exportée. Pour obtenir la clé exportée, affichez l'état de la ressource.
Pour afficher l'état de la ressource, exécutez la commande suivante :
```
kubectl describe keyexport KEY_EXPORT_NAME --namespace PROJECT
```
Remplacez les variables suivantes :
- KEY_EXPORT_NAME : nom de la ressource KeyExport, par exemple key-export-test.
- PROJECT : nom de l'espace de noms du projet, par exemple : kms-test1.
Une fois la commande exécutée, un résultat semblable aux lignes suivantes s'affiche :
```
...
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 représente les métadonnées de la clé exportée. Copiez le contenu dans EXPORTED_KEY pour passer à l' étape suivante.

Modifiez le fichier YAML contenant la ressource KeyImport et ajoutez le contenu que vous avez copié à partir du résultat dans keyexport.status.exportedkey.

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

Après avoir modifié le fichier YAML, appliquez le contenu à KMS :
```
kubectl apply -f FILENAME.yaml
```
Une fois la commande exécutée, KMS importe la clé exportée que vous avez fournie.
Pour afficher les détails de la clé importée, exécutez la commande suivante :
```
kubectl get keyimport KEY_IMPORT_NAME
```
Vous obtenez un résultat semblable à celui-ci :
```
NAMESPACE   NAME             AGE    READY   REASON              KEY KIND
kms-test1  KEY_IMPORT_NAME   60s    True    KeyImportCompleted  KEY_PRIMITIVE
```
KEY_PRIMITIVE représente le type de clé que vous avez importé, entre les clés AEAD et de signature.