Utilisation des secrets

Apprenez à utiliser des secrets dans Code Engine. Dans Code Engine, vous pouvez stocker vos informations sous forme de paires clé-valeur dans des secrets qui peuvent être consommés par votre fonction, votre travail ou votre application à l'aide de variables d'environnement.

Qu'est-ce qu'un secret et pourquoi l'utiliser?

Dans Code Engine, les secrets (et les mappes de configuration) sont une collection de paires clé-valeur. Lorsqu'elles sont mappées à des variables d'environnement, les relations NAME=VALUE sont définies de telle sorte que le nom de la variable d'environnement correspond à la "clé" de chaque entrée de ces mappes, et la valeur de la variable d'environnement est la "valeur" de cette clé.

Un secret fournit une méthode permettant d'inclure des informations de configuration sensibles, telles que des mots de passe ou des clés SSH, à votre déploiement. En référençant les valeurs de votre secret, vous pouvez découpler les informations sensibles de votre déploiement pour que votre application, votre fonction ou votre travail reste portable. Quiconque dispose de droits sur votre projet peut également afficher vos secrets : assurez-vous que les informations secrètes peuvent être partagées avec ces utilisateurs. Les secrets contiennent des informations dans des paires clé-valeur.

Les secrets et les cartes de configuration étant des entités similaires (sauf que les secrets sont stockés de manière plus sûre), la manière dont vous interagissez et travaillez avec les secrets et les cartes de configuration est également similaire. Pour en savoir plus sur les mappes de configuration, voir Utilisation des mappes de configuration.

Quel type de secret puis-je créer dans Code Engine?

Code Engine prend en charge divers secrets et fournit des options pour la création et l'utilisation de secrets.

Le tableau suivant récapitule les secrets pris en charge dans Code Engine.

Secrets dans Code Engine
Nom Description
Authentification de base Secret qui contient une clé username et password.
Utilisez les secrets d'authentification de base lorsque vous accédez à un service qui nécessite une authentification de base HTTP.
Générique Un secret qui stocke des paires clé-valeur simples et Code Engine ne fait aucune hypothèse sur les paires clé-valeur définies ni sur l'utilisation prévue du secret.
Utilisez des secrets génériques lorsque vous souhaitez définir vos propres paires clé-valeur pour accéder à un service.
HMAC Un secret qui contient une clé access_key_id et une clé secret_access_key.
Utilisez les informations d'identification HMAC pour utiliser les outils et bibliothèques S3-compatible qui nécessitent une authentification mais ne prennent pas en charge les clés d'API IBM Cloud® Identity and Access Management.
Registry Secret qui stocke les données d'identification permettant d'accéder à un registre de conteneur.
Utilisez des secrets de registre lorsque vous utilisez des applications ou des travaux Code Engine pour accéder à une image de conteneur. Vous pouvez également utiliser Code Engine pour générer une image de conteneur et le secret de registre est utilisé par Code Engine pour accéder au registre afin de stocker l'image de conteneur générée.
Ce secret est également appelé Registry access secret dans l'interface de ligne de commande.
Accès au service Secret qui stocke les données d'identification pour accéder à une instance de service IBM Cloud.
Utilisez les secrets d'accès aux services lorsque vous travaillez avec des liaisons de services dans Code Engine. Code Engine peut générer automatiquement ce secret ou vous pouvez créer votre propre secret d'accès aux services.
SSH Secret qui stocke les données d'identification pour l'authentification auprès d'un service avec une clé SSH, telle que l'authentification auprès d'un référentiel Git, tel que GitHub ou GitLab.
Utilisez des secrets SSH lorsque vous souhaitez que Code Engine génère une image de conteneur pour vous. Code Engine utilise ce secret pour accéder à votre code source dans un référentiel de codes. Par exemple, utilisez ce secret avec des exécutions de génération pour accéder à votre code source dans un référentiel, tel que GitHub ou GitLab.
Ce secret est également utilisé en tant que Git repository access secret dans l'interface de ligne de commande et Code repo access dans la console.
Protocole TLS Secret contenant un certificat TLS signé, y compris tous ses certificats intermédiaires, et sa clé privée correspondante provenant d'une autorité de certification.
Utilisez des secrets TLS lorsque vous utilisez des mappages de domaine personnalisés dans Code Engine.

Création de secrets

Utilisez les secrets pour fournir des informations sensibles à vos applications, tâches ou fonctions. Les secrets sont définis dans des paires clé-valeur et les données qui sont stockées dans les secrets sont codées.

Création d'un secret à partir de la console

Apprenez à créer des secrets à partir de la console Code Engine.

Apprenez à créer les types de secrets suivants à partir de la console.

Création d'un secret générique à partir de la console

Apprenez à créer des secrets génériques à partir de la console Code Engine, qui peuvent être utilisés par des fonctions, des tâches ou des applications en tant que variables d'environnement.

Avant de commencer, créez un projet.

  1. Une fois que votre projet est en statut actif, cliquez sur le nom de votre projet sur la page Code Engine Projects.
  2. Sur la page Composants, cliquez sur Secrets et mappes de configuration.
  3. Sur la page Secrets et mappes de configuration, cliquez sur Créer pour créer votre secret.
  4. Dans la page Créer un secret ou une mappe de configuration, procédez comme suit:
    1. Sélectionnez Secret générique, puis cliquez sur Suivant.
    2. Indiquez un nom; par exemple, mysecret-generic.
    3. Cliquez sur Ajouter une paire clé-valeur. Indiquez une ou plusieurs paires clé-valeur pour ce secret. Par exemple, spécifiez une clé comme secret1 avec la valeur mysecret1 et spécifiez une autre clé comme secret2 avec la valeur target-secret. Il n'est pas nécessaire que le nom choisi pour votre clé soit identique au nom de votre variable d'environnement. Notez que la valeur de la clé est masquée, mais qu'elle peut être affichée si nécessaire.
    4. Cliquez sur Créer pour créer le secret.

Maintenant que votre secret est créé à partir de la console, allez à la page Secrets et cartes de configuration pour voir la liste des secrets et cartes de configuration définis. Vous pouvez appliquer des filtres pour personnaliser la liste en fonction de vos besoins.

Création d'un secret HMAC à partir de la console

Apprenez à créer des secrets HMAC à partir de la console Code Engine qui peuvent être consommés par des fonctions, des tâches ou des applications en tant que variables d'environnement. Ils sont utilisés avec les outils et bibliothèques S3-compatible qui nécessitent une authentification mais ne prennent pas en charge les clés d'API IBM Cloud® Identity and Access Management.

Avant de commencer, créez un projet.

  1. Une fois que votre projet est en statut actif, cliquez sur le nom de votre projet sur la page Code Engine Projects.
  2. Sur la page Composants, cliquez sur Secrets et mappes de configuration.
  3. Sur la page Secrets et mappes de configuration, cliquez sur Créer pour créer votre secret.
  4. Dans la page Créer un secret ou une mappe de configuration, procédez comme suit:
    1. Sélectionnez HMAC secret, puis cliquez sur Suivant.
    2. Indiquez un nom; par exemple, mysecret-hmac.
    3. Indiquez l'ID de la clé d'accès.
    4. Spécifiez la clé d'accès secrète. Notez que la valeur de la clé est masquée, mais qu'elle peut être affichée si nécessaire.
    5. Cliquez sur Créer pour créer le secret.

Maintenant que votre secret est créé à partir de la console, allez à la page Secrets et cartes de configuration pour voir la liste des secrets et cartes de configuration définis. Vous pouvez appliquer des filtres pour personnaliser la liste en fonction de vos besoins.

Pour plus d'informations sur les secrets HMAC, voir IBM Cloud Object Storage- API Key vs HMAC.

Création d'un secret de registre à partir de la console

Apprenez à créer des secrets de registre à partir de la console Code Engine qui peut être utilisée par des fonctions, des travaux, des applications ou des générations pour l'accès à une image de conteneur.

Avant de commencer, créez un projet.

  1. Une fois que votre projet est en statut actif, cliquez sur le nom de votre projet sur la page Code Engine Projects.
  2. Sur la page Composants, cliquez sur Secrets et mappes de configuration.
  3. Sur la page Secrets et mappes de configuration, cliquez sur Créer pour créer votre secret.
  4. Dans la page Créer un secret ou une mappe de configuration, procédez comme suit:
    1. Sélectionnez Registry secret et cliquez sur Next.
    2. Indiquez un nom; par exemple, mysecret-registry.
    3. Indiquez le registre cible de ce secret, tel que IBM Cloud Container Registry ou Docker Hub.
    4. Indiquez l'emplacement du registre.
    5. Indiquez un nom d'utilisateur. Si ce secret concerne IBM Cloud Container Registry, le nom d'utilisateur est iamapikey. Si ce secret est destiné à Docker Hub, il s'agit de votre ID Docker.
    6. Entrez les données d'identification pour le nom d'utilisateur. Pour IBM Cloud Container Registry, utilisez votre clé d'API IAM. Pour Docker Hub, vous pouvez utiliser votre mot de passe Docker Hub ou un jeton d'accès. Pour les autres registres cible, indiquez le mot de passe ou la clé d'API pour le nom d'utilisateur.
    7. Cliquez sur Créer pour créer le secret.

Maintenant que votre secret est créé à partir de la console, allez à la page Secrets et cartes de configuration pour voir la liste des secrets et cartes de configuration définis. Vous pouvez appliquer des filtres pour personnaliser la liste en fonction de vos besoins.

Pour plus d'informations sur l'utilisation des registres d'images, voir Accès aux registres de conteneurs.

Création d'un secret SSH à partir de la console

Découvrez comment créer un secret SSH à partir de la console qui peut être consommé par les générations pour accéder à des référentiels de code source privés. Un secret SSH stocke les données d'identification permettant de s'authentifier auprès d'un service avec une clé SSH, telle que l'authentification auprès d'un référentiel Git, tel que GitHub ou GitLab.

Avant de commencer, créez un projet.

  1. Une fois que votre projet est en statut actif, cliquez sur le nom de votre projet sur la page Code Engine Projects.
  2. Sur la page Composants, cliquez sur Secrets et mappes de configuration.
  3. Sur la page Secrets et mappes de configuration, cliquez sur Créer pour créer votre secret.
  4. Dans la page Créer un secret ou une mappe de configuration, procédez comme suit:
    1. Sélectionnez SSH secret et cliquez sur Suivant.
    2. Indiquez un nom; par exemple, mysecret-ssh.
    3. Ajoutez la clé privée SSH pour ce secret.
    4. Cliquez sur Créer pour créer le secret.

Maintenant que votre secret est créé à partir de la console, allez à la page Secrets et cartes de configuration pour voir la liste des secrets et cartes de configuration définis. Vous pouvez appliquer des filtres pour personnaliser la liste en fonction de vos besoins.

Utilisez votre secret SSH lorsque vous utilisez des référentiels de code privé, tels que des référentiels Git. Voir Accès aux référentiels de code privés.

Création d'un secret TLS à partir de la console

Apprenez à créer un secret TLS à partir de la console qui peut être consommé par les applications lorsque vous utilisez des mappages de domaine personnalisés dans Code Engine. Un secret TLS (Transport Layer Security) contient un certificat TLS signé, y compris tous ses certificats intermédiaires, et sa clé privée correspondante provenant d'une autorité de certification.

Avant de commencer, créez un projet.

  1. Une fois que votre projet est en statut actif, cliquez sur le nom de votre projet sur la page Code Engine Projects.
  2. Sur la page Composants, cliquez sur Secrets et mappes de configuration.
  3. Sur la page Secrets et mappes de configuration, cliquez sur Créer pour créer votre secret.
  4. Dans la page Créer un secret ou une mappe de configuration, procédez comme suit:
    1. Sélectionnez Secret TLS, puis cliquez sur Suivant.
    2. Indiquez un nom; par exemple, mysecret-tls.
    3. Ajoutez la chaîne de certificats et sa clé privée. Notez que vous pouvez concaténer les certificats en commençant chacun d'eux par une nouvelle ligne. Vous pouvez fournir ces informations dans un fichier.
    4. Cliquez sur Créer pour créer le secret.

Maintenant que votre secret est créé à partir de la console, allez à la page Secrets et cartes de configuration pour voir la liste des secrets et cartes de configuration définis. Vous pouvez appliquer des filtres pour personnaliser la liste en fonction de vos besoins.

Utilisez votre secret TLS lorsque vous utilisez des mappages de domaine personnalisés dans Code Engine.

Création de secrets à l'aide de l'interface de programmation

Apprenez à créer des secrets avec l'interface CLI de Code Engine qui peuvent être utilisés par des applications, des tâches ou des fonctions en tant que variables d'environnement.

Avant de commencer

À partir de la version de l'interface de programmation 1.42.0, la définition et l'utilisation des secrets dans l'interface de programmation sont unifiées sous le groupe de commandes secret sous le groupe de commandes Voir les commandes ibmcloud ce secret. Utilisez l'option --format pour spécifier la catégorie du secret, par exemple basic_auth, generic, hmac, ssh, tls, ou registry. La valeur par défaut de l'option --format est generic.

A l'aide de la commande secret create, vous pouvez créer et gérer divers formats de secret. Pour la description des différents formats de secret, voir Quel type de secret puis-je créer dans Code Engine?

Apprenez à créer les types de secrets suivants à l'aide de l'interface de ligne de commande:

Création d'un secret d'authentification de base à l'aide de l'interface de programmation

Un secret d'authentification de base contient un nom d'utilisateur et un mot de passe et est utilisé pour accéder à un service qui nécessite une authentification de base HTTP. L'exemple suivant crée un secret d'authentification de base avec des données d'identification pour myusername et le mot de passe associé est fourni dans un fichier sur le poste de travail local

ibmcloud ce secret create --name mysecret-basicauth --format basic_auth --username myusername --password-from-file ./password.txt

Pour afficher les détails de ce secret,

ibmcloud ce secret get --name mysecret-basicauth

Exemple de sortie

Getting secret 'mysecret-basicauth'...
OK

Name:          mysecret-basicauth
ID:            abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Format:        basic_auth
Project Name:  myproject
Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
Age:           66s
Created:       2021-03-10T18:44:18-05:00

Data:    
---
password: REDACTED
username: bXl1c2VybmFtZQ==

Notez que la valeur de la clé username pour ce secret d'authentification de base est codée et que la valeur de password est occultée. Pour afficher les données confidentielles sous une forme décodée, utilisez l'option --decode avec la commande secret get.

Création d'un secret générique à l'aide de l'interface de programmation

Un secret générique stocke des paires clé-valeur simples et Code Engine ne fait aucune hypothèse sur les paires clé-valeur définies ni sur l'utilisation prévue du secret.

Vous pouvez créer un secret générique avec la commande secret create de l'une des manières suivantes. Par défaut, un secret générique est créé lorsque l'option --format n'est pas spécifiée.

  • Créez un secret directement dans la ligne de commande en utilisant l'option --from-literal au format KEY=VALUE. Par exemple :

    ibmcloud ce secret create --name myliteralsecret --from-literal "TARGET=My literal secret"
    
  • Créez un secret à l'aide de l'option --from-file pour pointer vers un fichier. En utilisant cette option, tout le contenu du fichier devient la valeur pour la paire valeur-clé. Pour cet exemple, utilisez un fichier nommé secrets.txt qui contient my little secret1.

    • L'exemple suivant utilise le format --from-file KEY=FILE avec la commande secret create :

      ibmcloud ce secret create --name mysecretmsg1 --from-file TARGET=secrets.txt
      
    • L'exemple ci-après utilise le format --from-file FILE avec la commande secret create. Dans cet exemple, TARGET (sans extension) est le nom du fichier, qui est identique au nom de la variable d'environnement connue de votre travail.

      ibmcloud ce secret create --name mysecretmsg2  --from-file TARGET
      
  • Créez un secret à l'aide de l'option --from-env-file pour pointer vers un fichier contenant une ou plusieurs lignes correspondant au format KEY=VALUE. Chaque ligne du fichier spécifié est ajoutée en tant que paire clé-valeur. Toutes les lignes du fichier indiqué qui sont vides ou commencent par #sont ignorées. Pour cet exemple, utilisez un fichier nommé secrets_multi.txt qui contient les paires clé-valeur sec1=mysec1, sec2=mysec2 et sec3=mysec3.

    ibmcloud ce secret create --name mysecretmulti --from-env-file secrets_multi.txt
    

Si vous souhaitez créer (ou mettre à jour) un secret générique à partir d'un fichier, utilisez l'option --from-file avec l'un des formats suivants: --from-file FILE ou --from-file KEY=FILE Dans Code Engine, lorsque vous utilisez l'option --from-file pour spécifier des valeurs de secret, tout le contenu du fichier est la valeur de la paire clé-valeur. Lorsque vous utilisez le format d'option --from-file KEY=FILE, KEY est le nom de la variable d'environnement connue de votre travail, fonction ou application. Lorsque vous utilisez le format d'option --from-file FILE, FILE est le nom de la variable d'environnement connue de votre travail, fonction ou application. Si votre fichier contient une ou plusieurs paires clé-valeur, utilisez l'option --from-env-file afin d'ajouter une variable d'environnement pour chaque paire clé-valeur dans le fichier spécifié. Toutes les lignes du fichier spécifié qui sont vides ou qui commencent par # sont ignorées.

Pour afficher les détails du secret générique, myliteralsecret,

ibmcloud ce secret get --name myliteralsecret

Exemple de sortie

Getting secret 'myliteralsecret'...
OK

Name:          myliteralsecret
ID:            abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Format:        generic
Project Name:  myproject
Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
Age:           66s
Created:       2023-03-07 21:06:34 +0000 UTC  

Data:    
---
TARGET: TXkgbGl0ZXJhbCBzZWNyZXQ=

Remarquez que la valeur de la clé TARGET pour ce secret générique est codée. Pour afficher les données confidentielles sous une forme décodée, utilisez l'option --decode avec la commande secret get.

Création d'un secret HMAC à l'aide de l'interface de programmation

Un secret HMAC contient une clé access_key_id et une clé secret_access_key et est utilisé avec des outils et des bibliothèques S3-compatible qui nécessitent une authentification mais ne prennent pas en charge les clés API IBM Cloud® Identity and Access Management. Voir IBM Cloud Object Storage- API Key vs HMAC lorsqu'il s'agit d'utiliser des clés d'API IBM Cloud® Identity and Access Management ou des informations d'identification HMAC. L'exemple suivant crée un secret HMAC avec des informations d'identification types, à fournir lorsque l'on vous le demande.

ibmcloud ce secret create --name mysecret-hmac --format hmac --access-key-id-prompt --secret-access-key-prompt

Pour afficher les détails de ce secret,

ibmcloud ce secret get --name mysecret-hmac

Exemple de sortie

Getting secret 'mysecret-hmac'...
OK

Name:          mysecret-hmac
ID:            abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Format:        hmac_auth
Project Name:  myproject
Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
Age:           86s
Created:       2025-05-15T12:41:15-05:00

Data:
---
access_key_id: MWEyYjNjNGQ1ZTZmMWEyYjNjNGQ1ZTZmMWEyYjNjNGQK
secret_access_key: REDACTED

Remarquez que la valeur de la clé access_key_id pour ce secret HMAC est codée et que la valeur de secret_access_key est expurgée. Pour afficher les données confidentielles sous une forme décodée, utilisez l'option --decode avec la commande secret get.

Création d'un secret de registre à l'aide de l'interface de programmation

Un secret de registre stocke les données d'identification permettant d'accéder à un registre de conteneur.

L'exemple suivant crée un secret de registre nommé mysecret-registry pour accéder à une instance IBM Cloud Container Registry qui se trouve sur le serveur de registre us.icr.io et spécifie les données d'identification pour username et password.

ibmcloud ce secret create --name mysecret-registry --format registry --server us.icr.io --username iamapikey --password API_KEY

Pour afficher les détails de ce secret,

ibmcloud ce secret get --name mysecret-registry

Exemple de sortie

Getting secret 'mysecret-registry'...
OK

Name:          mysecret-registry
ID:            abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Format:        registry
Project Name:  myproject
Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
Age:           66s
Created:       2023-03-07 20:00:45 +0000 UTC  

Data:    
---
email: ""
password: REDACTED
server: dXMuaWNyLmlv
username: aWFtYXBpa2V5

Notez que la valeur des clés username et server de ce secret de registre est codée et que la valeur de password est occultée. Pour afficher les données confidentielles sous une forme décodée, utilisez l'option --decode avec la commande secret get.

Création d'un secret SSH à l'aide de l'interface de ligne de commande

Un secret SSH stocke les données d'identification pour l'authentification auprès d'un service avec une clé SSH ; par exemple, l'authentification auprès d'un référentiel Git, tel que GitHub ou GitLab.

L'exemple suivant crée un secret SSH nommé mysecret-ssh pour accéder à un hôte inclus dans le fichier known_hosts en s'authentifiant avec un fichier de clé privée SSH non chiffré qui se trouve dans /<filepath>/.ssh/<key_name>, où <filepath> est le chemin d'accès sur votre poste de travail local. Cette commande requiert un nom et un chemin de clé et autorise également d'autres arguments facultatifs, tels que le chemin d'accès au fichier hosts connu.

ibmcloud ce secret create --name mysecret-ssh --format ssh --key-path ~/.ssh/<key_name> --known-hosts-path  ~/.ssh/known_hosts

Pour afficher les détails de ce secret,

ibmcloud ce secret get --name mysecret-ssh

Exemple de sortie

Getting secret 'mysecret-ssh'...
OK

Name:          mysecret-ssh'
ID:            abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Format:        ssh
Project Name:  myproject
Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
Age:           66s
Created:       2023-03-07 19:19:59 +0000 UTC  

Data:    
---
known_hosts: fDF8bGh0ekpiSFVXdXRxZWg1NUlrWTk4RjdOdjJZPXxsUmhZd0txVmIwd3dSV2xzcjEySFdoWURUTG89IHNzaC1yc2EgQUFBQUIzTnphQzF5YzJFQUFBQUJJd0FBQVFFQXEyQTdoUkdtZG5tOXRVRGJPOUlEU3dCSzZUYlFhK1BYWVBDUHk2cmJUclR0dzdQSGtjY0tycHAweVZocDVIZEVJY0tyNnBMbFZEQmZPTFg5UVVzeUNPVjB3emZqSUpObEdFWXNkbExKaXpIaGJuMm1VanZTQUhRcVpFVFlQODFlRnpMUU5uUEh0NEVWVlVoN1ZmREVTVTg0S2V6bUQ1UWxXcFhMbXZVMzEveU1mK1NlOHhoSFR2S1NDWklGSW1Xd29HNm1iVW9XZjluenBJb2FTakIrd2VxcVVVbXBhYWFzWFZhbDcySitVWDJCKzJSUFczUmNUMGVPelFncWxKTDNSS3JUSnZkc2pFM0pFQXZHcTNsR0hTWlh5MjhHM3NrdWEyU21WaS93NHlDRTZnYk9EcW5UV2xnNyt3QzYwNHlkR1hBOFZKaVM1YXA0M0pYaVVGRkFhUT09CnwxfEpUSjI4MCt0RkFSMGcxZ3VrZW56U3ZBYm5sQT18RDlSUWppenZlR3UxS0FnNjhNeisrUHM3RmZrPSBlY2RzYS1zaGEyLW5pc3RwMjU2IEFBQUFFMlZqWkhOaExYTm9ZVEl0Ym1semRIQXlOVFlBQUFBSWJtbHpkSEF5TlRZQUFBQkJCRW1LU0VOalFFZXpPbXhrWk15N29wS2d3RkI5bmt0NVlScllNak51RzVOODd1UmdnNkNMcmJvNXdBZFQveTZ2MG1LVjBVMncwV1oyWUIvKytUcG9ja2c9CnwxfDhIOXpNb0VORklZVDNPeVZYWlQrY25wb0srND18dVdhVThFV1FPc0ttSDMzREVVd0xnNUtiUk44PSBzc2gtZWQyNTUxOSBBQUFBQzNOemFDMWxaREkxTlRFNUFBQUFJT01xcW5rVnpybTBTZEc2VU9vcUtMc2FiZ0g1Qzlva1dpMGRoMmw5R0tKbAo=
ssh-privatekey: REDACTED

Notez que la valeur de la clé known_hosts pour ce secret SSH est codée et que la valeur de ssh-privatekey est occultée. Pour afficher les données confidentielles sous une forme décodée, utilisez l'option --decode avec la commande secret get.

Création d'un secret TLS à l'aide de l'interface de programmation

Un secret TLS (Transport Layer Security) contient un certificat TLS signé, y compris tous ses certificats intermédiaires, et sa clé privée correspondante provenant d'une autorité de certification. Utilisez des secrets TLS lorsque vous utilisez des mappages de domaine personnalisés.

L'exemple suivant crée un secret TLS nommé mysecret-tls. La chaîne de certificats qui correspond au domaine personnalisé est contenue dans le fichier certificate.txt et le fichier de clé privée correspondant est contenu dans le fichier privatekey.txt. Dans cet exemple, ces deux fichiers se trouvent dans le répertoire racine du poste de travail local.

ibmcloud ce secret create --name mysecret-tls  --format tls  --cert-chain-file certificate.txt --private-key-file privatekey.txt

Pour afficher les détails de ce secret,

ibmcloud ce secret get --name mysecret-tls

Exemple de sortie

Getting secret 'mysecret-tls'...
OK

Name:          mysecret-tls'
ID:            abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Format:        tls
Project Name:  myproject
Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
Age:           66s
Created:       2023-03-07 16:14:46 +0000 UTC  

Data:    
---
tls.crt: REDACTED
tls.key: REDACTED

Affichage de la liste des secrets à l'aide de l'interface de ligne de commande

Une fois les secrets créés, utilisez la commande secret list pour répertorier tous les secrets de votre projet. Par exemple :

ibmcloud ce secret list

Exemple de sortie

Listing secrets...
OK

Name                          Format          Data  Age  
ce-auto-icr-private-us-south  registry        4     333d  
ce-auto-private-icr-us-south  registry        4     335d  
myregistry-seccmd             registry        4     3h31m  
mysecret-basicauth            basic_auth      2     7m37s  
mysecret-generic              generic         1     7m7s  
mysecret-genericfromfile      generic         2     2m29s  
mysecret-hmac                 hmac_auth       2     21m
mysecret-registry             registry        4     111s  
mysecret-ssh                  ssh_auth        2     42m  
mysecret-tls                  tls             2     3h47m

Mise à jour des secrets

Vous pouvez modifier les paires clé-valeur des secrets existants.

Mise à jour des secrets à partir de la console

Vous pouvez mettre à jour les paires clé-valeur de vos secrets définis à partir de la console.

  1. Vous pouvez mettre à jour les paires clé-valeur de vos secrets définis à partir de la console de l'une des manières suivantes.

    • Accédez à la page Secrets et mappes de configuration de votre projet et recherchez le secret que vous souhaitez mettre à jour. Cliquez sur le nom du secret à mettre à jour pour l'ouvrir.
    • Si votre secret est référencé par une application, un travail ou une fonction, utilisez les liens du tableau des variables d'environnement dans l'onglet Variables d'environnement de votre application, travail ou fonction. Ces liens vous permettent d'accéder directement à votre secret. Vous pouvez également accéder à la page Secrets et mappes de configuration de votre projet et rechercher le secret que vous souhaitez mettre à jour. Cliquez sur le nom du secret à mettre à jour pour l'ouvrir.
  2. Cliquez sur Editer et apportez les mises à jour à votre secret.

  3. Cliquez sur Sauvegarder pour enregistrer les modifications apportées à votre secret.

Si votre secret mis à jour est référencé par un travail, une fonction ou une application, ce travail, cette fonction ou cette application doit être redémarré(e) pour que les nouvelles données prennent effet.

  • Applications : dans la page de votre application, cliquez sur Nouvelle révision, puis sur Sauvegarder et déployer. Vous pouvez également attendre que votre application soit mise à l'échelle par diminution jusqu'à zéro, après quoi elle utilise la mappe de configuration mise à jour lorsqu'elle est mise à l'échelle par augmentation.
  • Travaux : dans la page de votre travail, cliquez sur Soumettre un travail pour exécuter votre travail. Vous pouvez aussi réexécuter un travail. Cette nouvelle exécution de travail utilise le secret mis à jour.
  • Fonctions-Dans la page correspondant à votre fonction, cliquez sur Tester la fonction. Si votre navigateur est ouvert sur la fonction URL, actualisez le navigateur.

Mise à jour des secrets via l'interface de ligne de commande

Vous pouvez mettre à jour un secret existant et ses paires clé-valeur via l'interface de ligne de commande.

  1. Pour modifier la valeur d'une paire clé-valeur dans un secret défini, utilisez la commande secret update. Mettons à jour le secret mysecret-registry pour utiliser un autre serveur.

    ibmcloud ce secret update --name mysecret-registry --format registry --server <new_server> --username <new_username> --password <password>
    
  2. Maintenant que votre secret est mis à jour, utilisez la commande secret get pour afficher les détails relatifs à un secret spécifique. Si nécessaire, utilisez l'option --decode pour afficher les données secrètes en tant que données décodées. Par exemple :

    ibmcloud ce secret get --name mysecret-registry --decode
    

    Exemple de sortie

    Getting generic secret 'mysecret-registry'...
    OK
    
    Name:          mysecret-registry
    ID:            abcdefgh-abcd-abcd-abcd-c88e2775388e
    Project Name:  myproject
    Project ID:    01234567-abcd-abcd-abcd-abcdabcd1111
    Age:           21m
    Created:       2023-03-07 20:00:45 +0000 UTC  
    
    Data:    
    ---
    email: ""
    password: REDACTED
    server: newserver
    username: newuser
    

Référencement de secrets

Votre travail, votre fonction ou votre application peut consommer et utiliser les informations stockées dans un secret en utilisant des variables d'environnement.

Référencement de secrets à partir de la console

Vous pouvez utiliser la console pour créer des variables d'environnement pour vos applications, tâches et fonctions qui font entièrement référence à un secret ou à des clés individuelles dans un secret.

Avant de pouvoir référencer un secret, celui-ci doit exister. Voir Création d'un secret. Pour cet exemple, créez un secret appelé target-secretavec la paire clé-valeur deTARGET=Sunshine.

  1. Pour référencer un secret défini à partir de vos applications, travaux et fonctions, créez une variable d'environnement. La variable d'environnement peut référencer un secret existant intégral ou une clé individuelle dans un secret existant. Lorsque vous référencez complètement un secret (ou une mappe de configuration), vous pouvez éventuellement spécifier unprefix. Par exemple, si vous référencez intégralement le secret mysecretà partir de l'applicationmyapp et que vous utilisez le préfixemysecret_, chaque clé du secret est préfixée avecmysecret_.

  2. Après avoir créé des variables d'environnement, vous devez redémarrer vos applications, travaux et fonctions pour que les modifications soient prises en compte. Pour les applications, sauvegardez et déployez l'application concernée pour la mettre à jour avec les variables d'environnement que vous avez définies. Pour les travaux, soumettez le travail concerné pour le mettre à jour avec les variables d'environnement que vous avez définies.

  3. Une fois que le statut des applications, des travaux et des fonctions est passé à Prêt, vous pouvez tester l'application ou la fonction ou exécuter le travail. Pour une application, cliquez sur Application de test, puis sur Envoyer la demande dans le panneau Application de test. Pour ouvrir l'application dans une page Web, cliquez sur URL de l'application. Dans l'exemple myapp, comme un préfixe a été spécifié pour le secret mysecret entièrement référencé, toutes les clés de ce secret sont référencées en tant que variables d'environnement et sont préfixées par mysecret_. Par exemple, ces variables d'environnement s'affichent sous la formemysecret_secret1=mysecret1 etmysecret_secret2=mysecret2.

Pour mettre à jour une variable d'environnement référençant un secret, voir Mise à jour des variables d'environnement et Points à prendre en compte pour la mise à jour des variables d'environnement.

Pour supprimer une variable d'environnement référençant un secret, voir Suppression de variables d'environnement.

Par exemple, utilisez le secret mysecret que vous avez précédemment défini à partir de la console avec un travail et référencez entièrement ce secret à l'aide d'une variable d'environnement.

  1. Créez et exécutez un travail. Pour cet exemple, créez un travail Code Engine qui utilise l'image icr.io/codeengine/codeengine, puis exécutez le travail. Lorsqu'une demande est envoyée à cet exemple de travail, le travail lit la variable d'environnement TARGET, imprime Hello ${TARGET} from Code Engine et imprime une liste de variables d'environnement. Si la variable d'environnement TARGETest vide, Hello World from Code Engine est renvoyé.

    Sur la page Travaux,

    1. Créez un travail, par exemple myjob.
    2. Indiquez icr.io/codeengine/codeengine comme référence d'image.
    3. Cliquez sur Créer pour créer le travail.

    Si la charge de travail que vous souhaitez utiliser avec le secret est déjà définie sur Code Engine, allez sur la page Applications, Jobs ou Fonctions, puis cliquez sur le nom de votre application, job ou fonction pour ouvrir le composant.

  2. Lorsque le travail est créé, sur la page Travaux, cliquez sur le nom de votre travail pour l'ouvrir.

  3. Mettez à jour le travail pour ajouter un secret en tant que variable d'environnement. Cliquez sur Variables d'environnement pour ouvrir l'onglet et cliquez sur Ajouter pour ajouter votre variable d'environnement.

  4. Sur la page Ajouter une variable d'environnement,

    1. Pour utiliser le secret précédemment défini, sélectionnez Référencer un secret intégral.
    2. Dans le menu, sélectionnez le nom du secret que vous souhaitez ; par exemple,target-secret.
    3. Cliquez sur Ajouter pour ajouter la variable d'environnement.
    4. Cliquez sur Sauvegarder pour enregistrer les modifications apportées à votre travail.
  5. Pour exécuter le travail avec la variable d'environnement référençant un secret, cliquez sur Soumettre le travail. Pour cet exemple, les journaux de l'exécution du travail myjob affichent Hello Sunshine from Code Engine et impriment les variables d'environnement, y compris les valeurs des secrets référencés avec des variables d'environnement.

Référencement de secrets via l'interface de ligne de commande

Pour utiliser des secrets avec des applications, des tâches et des fonctions, vous pouvez définir des variables d'environnement qui font entièrement référence à un secret ou qui font référence à des clés individuelles dans un secret avec l'interface de ligne de commande.

Référencement de secrets existants via l'interface de ligne de commande

Les exemples suivants font référence à un secret générique, qui est le secret par défaut lorsque l'option --format n'est pas spécifiée. Utilisez l'option --format pour spécifier la catégorie de secret, telle que basic_auth, generic, ssh, tls ou registry.

Pour utiliser un secret avec une charge de travail avec l'interface de ligne de commande, spécifiez l'option --env-from-secret dans les commandes suivantes.

L'exemple suivant décrit comment référencer un secret générique existant avec un travail en utilisant la CLI.

  1. Utilisez la commande secret create pour créer les deux secrets génériques suivants pour ce scénario. Par défaut, un secret générique est créé lorsque l'option --format n'est pas spécifiée.

    ibmcloud ce secret create --name myliteralsecret --from-literal "TARGET=My big literal secret"
    
    ibmcloud ce secret create --name myliteralsecret2 --from-literal "TARGET=My little literal secret"
    
  2. Créez un travail et référencez le secret myliteralsecret. Pour cet exemple, créez un travail Code Engine qui utilise l'image icr.io/codeengine/codeengine, puis exécutez le travail. Lorsqu'une demande est envoyée à cet exemple de travail, le travail lit la variable d'environnement TARGET, imprime Hello ${TARGET} from Code Engine et imprime une liste de variables d'environnement. Si la variable d'environnement TARGETest vide, Hello World from Code Engine est renvoyé.

    ibmcloud ce job create --name myjob --image icr.io/codeengine/codeengine --array-indices 2-3 --env-from-secret myliteralsecret
    
  3. Exécutez le travail myjob.

    ibmcloud ce jobrun submit --name myjobrun --job myjob
    
  4. Utilisez la commande jobrun get pour afficher les détails de l'exécution de travail, y compris les instances de celle-ci.

    ibmcloud ce jobrun get --name myjobrun
    

    Exemple de sortie

    Getting jobrun 'myjobrun'...
    Getting instances of jobrun 'myjobrun'...
    Getting events of jobrun 'myjobrun'...
    Run 'ibmcloud ce jobrun events -n myjobrun' to get the system events of the job run instances.
    Run 'ibmcloud ce jobrun logs -f -n myjobrun' to follow the logs of the job run instances.
    OK
    
    Name:               myjobrun
    [...]
    Job Ref:                myjob
    Environment Variables:
        Type                   Name          Value
        Secret full reference  myliteralsecret
    Image:                  icr.io/codeengine/codeengine
    Resource Allocation:
        CPU:                1
        Ephemeral Storage:  4G
        Memory:             4G
    
    Runtime:
        Mode:                  task
        Array Indices:         2-3
        Array Size:            2
        JOP_ARRAY_SIZE Value:  2
        Max Execution Time:    7200
        Retry Limit:           3
    
    Status:
        Completed:          9s
        Instance Statuses:
            Succeeded:  2
        Conditions:
            Type      Status  Last Probe  Last Transition
            Pending   True    13s         13s
            Running   True    9s          9s
            Complete  True    9s          9s
    
    Events:
        Type    Reason     Age                Source                Messages
        Normal  Updated    10s (x4 over 14s)  batch-job-controller  Updated JobRun "myjobrun"
        Normal  Completed  10s                batch-job-controller  JobRun completed successfully
    
    Instances:
        Name          Running  Status     Restarts  Age
        myjobrun-2-0  0/1      Succeeded  0         14s
        myjobrun-3-0  0/1      Succeeded  0         14s
    
  5. Affichez les journaux de l'exécution de travail myjobrun. Vous pouvez afficher les journaux de toutes les instances d'un travail exécuté ou afficher les journaux d'une instance spécifique d'une exécution de travail. Cette fois, affichez les journaux de toutes les instances de l'exécution du travail. Le journal affiche Hello my big literal secret!, qui a été spécifié en utilisant une variable d'environnement avec un secret. Remarque: pour ce travail défini avec l'image icr.io/codeengine/codeengine, la sortie de l'exécution du travail imprime les variables d'environnement, y compris les valeurs de secrets référencés avec des variables d'environnement.

    ibmcloud ce jobrun logs --jobrun myjobrun
    

    Exemple de sortie

    Getting logs for all instances of job run 'myjobrun'...
    Getting jobrun 'myjobrun'...
    Getting instances of jobrun 'myjobrun'...
    OK
    
    myjobrun-2-0/myjob:
    Hello from helloworld! I'm a batch job! Index: 2
    
    Hello My big literal secret from:
    . ___  __  ____  ____
    ./ __)/  \(    \(  __)
    ( (__(  O )) D ( ) _)
    .\___)\__/(____/(____)
    .____  __ _   ___  __  __ _  ____
    (  __)(  ( \ / __)(  )(  ( \(  __)
    .) _) /    /( (_ \ )( /    / ) _)
    (____)\_)__) \___/(__)\_)__)(____)
    
    Some Env Vars:
    --------------
    HOME=/root
    HOSTNAME=myjobrun-2-0
    JOB_INDEX=2
    KUBERNETES_PORT=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP_ADDR=172.21.0.1
    KUBERNETES_PORT_443_TCP_PORT=443
    KUBERNETES_PORT_443_TCP_PROTO=tcp
    KUBERNETES_SERVICE_HOST=172.21.0.1
    KUBERNETES_SERVICE_PORT=443
    KUBERNETES_SERVICE_PORT_HTTPS=443
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    PWD=/
    SHLVL=1
    TARGET=My big literal secret
    
    myjobrun-3-0/myjob:
    Hello from helloworld! I'm a batch job! Index: 3
    
    Hello My big literal secret from:
    . ___  __  ____  ____
    ./ __)/  \(    \(  __)
    ( (__(  O )) D ( ) _)
    .\___)\__/(____/(____)
    .____  __ _   ___  __  __ _  ____
    (  __)(  ( \ / __)(  )(  ( \(  __)
    .) _) /    /( (_ \ )( /    / ) _)
    (____)\_)__) \___/(__)\_)__)(____)
    
    Some Env Vars:
    --------------
    HOME=/root
    HOSTNAME=myjobrun-3-0
    JOB_INDEX=3
    KUBERNETES_PORT=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP_ADDR=172.21.0.1
    KUBERNETES_PORT_443_TCP_PORT=443
    KUBERNETES_PORT_443_TCP_PROTO=tcp
    KUBERNETES_SERVICE_HOST=172.21.0.1
    KUBERNETES_SERVICE_PORT=443
    KUBERNETES_SERVICE_PORT_HTTPS=443
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    PWD=/
    SHLVL=1
    TARGET=My big literal secret
    
  6. Soumettez à nouveau l'exécution de travail et indiquez que le secret myliteralsecret2 doit être utilisé pour cette exécution de travail.

    ibmcloud ce jobrun resubmit  --jobrun myjobrun  --name myjobrunresubmit  --env-from-secret myliteralsecret2
    

    Lorsque vous mettez à jour un travail, une application ou une fonction avec une variable d'environnement qui fait entièrement référence à un secret pour faire entièrement référence à un secret différent, les références complètes remplacent les autres références complètes dans l'ordre dans lequel elles sont définies (le dernier ensemble référencé remplace le premier ensemble).

  7. Utilisez la commande jobrun get pour afficher les détails de l'exécution de travail, y compris les instances de celle-ci. Notez que l'exécution de travail fait référence à la fois au secret myliteralsecret et au secret myliteralsecret2.

    ibmcloud ce jobrun get --name myjobrunresubmit
    

    Exemple de sortie

    Getting jobrun 'myjobrunresubmit'...
    Getting instances of jobrun 'myjobrunresubmit'...
    Getting events of jobrun 'myjobrunresubmit'...
    [...]
    
    Name:          myjobrunresubmit
    ID:            79f01367-932b-4a76-be18-b1e68790a85b
    Project Name:  myproject
    Project ID:    841f0f38-420d-4388-b5d8-f230657d7dc6
    Age:           14s
    Created:       2021-06-15T21:15:37-04:00
    
    Job Ref:                myjob
        Environment Variables:
        Type                   Name              Value
        Secret full reference  myliteralsecret
        Secret full reference  myliteralsecret2
    Image:                  icr.io/codeengine/codeengine
        Resource Allocation:
        CPU:                1
        Ephemeral Storage:  4G
        Memory:             4G
    
    Runtime:
        Mode:                  task
        Array Indices:         2-3
        Array Size:            2
        JOP_ARRAY_SIZE Value:  2
        Max Execution Time:    7200
        Retry Limit:           3
    
    Status:
        Completed:          11s
        Instance Statuses:
            Succeeded:  2
        Conditions:
            Type      Status  Last Probe  Last Transition
            Pending   True    14s         14s
            Running   True    12s         12s
            Complete  True    11s         11s
    
    Events:
        Type    Reason     Age                Source                Messages
        Normal  Updated    13s (x4 over 16s)  batch-job-controller  Updated JobRun "myjobrunresubmit"
        Normal  Completed  13s                batch-job-controller  JobRun completed successfully
    
    Instances:
        Name                  Running  Status     Restarts  Age
        myjobrunresubmit-2-0  0/1      Succeeded  0         16s
        myjobrunresubmit-3-0  0/1      Succeeded  0         16s
    
  8. Affichez les journaux d'exécution de travail d'une instance de l'exécution de travail myjobrunresubmit. Cette fois, affichez les journaux de l'instance myjobrunresubmit-3-0. Le journal affiche Hello My little literal secret!, qui est la valeur spécifiée dans le secret myliteralsecret2. Utilisez la commande jobrun get pour afficher les détails de l'exécution de travail, y compris les instances en cours de celle-ci.

    ibmcloud ce jobrun logs --instance myjobrunresubmit-3-0
    

    Exemple de sortie

    Getting logs for job run instance 'myjobrunresubmit-3-0'...
    OK
    
    myjobrunresubmit-3-0/myjob:
    Hello from helloworld! I'm a batch job! Index: 3
    
    Hello My little literal secret from:
    . ___  __  ____  ____
    ./ __)/  \(    \(  __)
    ( (__(  O )) D ( ) _)
    .\___)\__/(____/(____)
    .____  __ _   ___  __  __ _  ____
    (  __)(  ( \ / __)(  )(  ( \(  __)
    .) _) /    /( (_ \ )( /    / ) _)
    (____)\_)__) \___/(__)\_)__)(____)
    
    Some Env Vars:
    --------------
    HOME=/root
    HOSTNAME=myjobrunresubmit-3-0
    JOB_INDEX=3
    KUBERNETES_PORT=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP_ADDR=172.21.0.1
    KUBERNETES_PORT_443_TCP_PORT=443
    KUBERNETES_PORT_443_TCP_PROTO=tcp
    KUBERNETES_SERVICE_HOST=172.21.0.1
    KUBERNETES_SERVICE_PORT=443
    KUBERNETES_SERVICE_PORT_HTTPS=443
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    PWD=/
    SHLVL=1
    TARGET=My little literal secret
    
  9. Pour modifier la valeur d'une paire clé-valeur dans un secret, utilisez la commande secret update. Mettez à jour le secret myliteralsecret pour remplacer la valeur de la clé TARGET, My big literal secret, par My new big literal secret.

    ibmcloud ce secret update --name myliteralsecret --from-literal "TARGET=My new big literal secret"
    
  10. Pour que les nouvelles données soient appliquées, exécutez à nouveau votre travail. Soumettez à nouveau l'exécution de travail et indiquez que le secret myliteralsecret doit être utilisé pour cette exécution de travail.

ibmcloud ce jobrun resubmit  --jobrun myjobrun  --name myjobrunresubmit2 --env-from-secret myliteralsecret
  1. Affichez les journaux de l'exécution de travail myjobrunresubmit2. Cette fois, le journal affiche Hello My new big literal secret!, qui est la valeur spécifiée dans le secret myliteralsecret mis à jour. Vous pouvez utiliser la commande jobrun get pour afficher les détails de l'exécution de travail, y compris les instances en cours de celle-ci. Affichez les journaux pour n'importe quelle instance en cours de l'exécution de travail.
ibmcloud ce jobrun logs --instance myjobrunresubmit2-2-0

Exemple de sortie

Getting logs for job run instance 'myjobrunresubmit2-2-0'...
OK

myjobrunresubmit2-2-0/myjob:
Hello from helloworld! I'm a batch job! Index: 2

Hello My new big literal secret from:
. ___  __  ____  ____
./ __)/  \(    \(  __)
( (__(  O )) D ( ) _)
.\___)\__/(____/(____)
.____  __ _   ___  __  __ _  ____
(  __)(  ( \ / __)(  )(  ( \(  __)
.) _) /    /( (_ \ )( /    / ) _)
(____)\_)__) \___/(__)\_)__)(____)

Some Env Vars:
--------------
HOME=/root
HOSTNAME=myjobrunresubmit2-2-0
JOB_INDEX=2
KUBERNETES_PORT=tcp://172.21.0.1:443
KUBERNETES_PORT_443_TCP=tcp://172.21.0.1:443
KUBERNETES_PORT_443_TCP_ADDR=172.21.0.1
KUBERNETES_PORT_443_TCP_PORT=443
KUBERNETES_PORT_443_TCP_PROTO=tcp
KUBERNETES_SERVICE_HOST=172.21.0.1
KUBERNETES_SERVICE_PORT=443
KUBERNETES_SERVICE_PORT_HTTPS=443
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PWD=/
SHLVL=1
TARGET=My new big literal secret

En résumé, vous avez exécuté des scénarios de base destinés à illustrer la façon d'utiliser les secrets avec un travail en référençant un secret intégral existant et en mettant à jour des clés dans un secret.

Référencement de secrets qui ne sont pas encore définis via l'interface de ligne de commande

Si un secret n'existe pas avant d'être référencé, une application ne sera pas déployée avec succès, et un travail ou une fonction ne sera pas exécuté avec succès tant que le secret référencé n'aura pas été créé.

Si vous travaillez avec une application, un travail ou une fonction et que le secret référencé n'est pas encore défini, utilisez l'option --force pour éviter la vérification de l'existence du secret référencé. L'option --force peut être utilisée avec les commandes suivantes.

Lorsque vous utilisez l'option --force avec ces commandes, l'action de création, de mise à jour ou d'exécution de l'application, du travail ou de la fonction s'achève. Cependant, l'application, le travail ou la fonction ne s'exécutera pas correctement tant que le secret référencé n'existera pas. Si vous ajoutez l'option --no-wait en plus de l'option --force à la commande, le système termine l'action et n'attend pas que l'application, le travail ou la fonction s'exécute correctement.

L'exemple suivant montre comment référencer un secret qui n'est pas encore défini avec un travail à l'aide de l'interface de ligne de commande.

  1. Créez un travail. Pour cet exemple, créez un travail Code Engine qui utilise l'image icr.io/codeengine/codeengine, puis exécutez le travail. Lorsqu'une demande est envoyée à cet exemple de travail, le travail lit la variable d'environnement TARGET, imprime Hello ${TARGET} from Code Engine et imprime une liste de variables d'environnement. Si la variable d'environnement TARGETest vide, Hello World from Code Engine est renvoyé.

    ibmcloud ce job create --name myjob --image icr.io/codeengine/codeengine
    
  2. Utilisez la commande jobrun submit pour exécuter le travail myjob. Notez que mynewliteralsecret n'existe pas. Avec l'option --no-wait dans la commande jobrun submit, l'exécution du travail est soumise sans attendre que les instances de ce travail soient terminées.

    ibmcloud ce jobrun submit --name myjobrun1 --job myjob --env-from-secret mynewliteralsecret --force --no-wait
    
  3. Utilisez la commande jobrun get pour afficher les détails de l'exécution de travail, y compris les informations relatives aux variables d'environnement. Notez que l'exécution du travail est à l'état pending (en attente).

    ibmcloud ce jobrun get --name myjobrun1
    

    Exemple de sortie

    Getting jobrun 'myjobrun1'...
    Getting instances of jobrun 'myjobrun1'...
    Getting events of jobrun 'myjobrun1'...
    [...]
    
    Name:          myjobrun1
    [...]
    
    Job Ref:                myjob
    Environment Variables:
        Type                   Name                Value
        Secret full reference  mynewliteralsecret
    Image:                  icr.io/codeengine/codeengine
    Resource Allocation:
        CPU:                1
        Ephemeral Storage:  400M
        Memory:             4G
    
    Runtime:
        Mode:                  task
        Array Indices:         0
        Array Size:            1
        JOP_ARRAY_SIZE Value:  1
        Max Execution Time:    7200
        Retry Limit:           3
    
    Status:
        Instance Statuses:
            Pending:  1
        Conditions:
            Type     Status  Last Probe  Last Transition
            Pending  True    100s        100s
    
    Events:
        Type    Reason   Age                   Source                Messages
        Normal  Updated  108s (x5 over 2m29s)  batch-job-controller  Updated JobRun "myjobrun1"
    
    Instances:
        Name           Running  Status   Restarts  Age
        myjobrun1-0-0  0/1      Pending  0         2m29s
    
  4. Créez le secret.

    ibmcloud ce secret create --name mynewliteralsecret --from-literal "TARGET=Fun secret"
    
  5. Exécutez à nouveau le travail myjobrun1.

    ibmcloud ce jobrun resubmit --jobrun myjobrun1 --name myjobrunresubmit1
    

    Exécutez la commande ibmcloud ce jobrun get -n myjobrunresubmit1 pour vérifier l'état de cette exécution de travail.

  6. Affichez les journaux de l'exécution de travail myjobrunresubmit1. Les journaux affichent Hello Fun secret from Code Engine, ce qui confirme que l'exécution de travail a référencé le secret myliteralsecret.

    ibmcloud ce jobrun logs --jobrun myjobrunresubmit1
    

    Exemple de sortie

    Getting logs for all instances of job run 'myjobrunresubmit1'...
    Getting jobrun 'myjobrunresubmit1'...
    Getting instances of jobrun 'myjobrunresubmit1'...
    OK
    
    myjobrunresubmit1-0-0/myjob:
    Hello from helloworld! I'm a batch job! Index: 0
    
    Hello Fun secret from:
    . ___  __  ____  ____
    ./ __)/  \(    \(  __)
    ( (__(  O )) D ( ) _)
    .\___)\__/(____/(____)
    .____  __ _   ___  __  __ _  ____
    (  __)(  ( \ / __)(  )(  ( \(  __)
    .) _) /    /( (_ \ )( /    / ) _)
    (____)\_)__) \___/(__)\_)__)(____)
    
    Some Env Vars:
    --------------
    HOME=/root
    HOSTNAME=myjobrunresubmit1-0-0
    JOB_INDEX=0
    KUBERNETES_PORT=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP=tcp://172.21.0.1:443
    KUBERNETES_PORT_443_TCP_ADDR=172.21.0.1
    KUBERNETES_PORT_443_TCP_PORT=443
    KUBERNETES_PORT_443_TCP_PROTO=tcp
    KUBERNETES_SERVICE_HOST=172.21.0.1
    KUBERNETES_SERVICE_PORT=443
    KUBERNETES_SERVICE_PORT_HTTPS=443
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    PWD=/
    SHLVL=1
    TARGET=Fun secret
    

Pour obtenir des scénarios plus détaillés sur le référencement de secrets et de mappes de configuration complets en tant que variables d'environnement, sur le remplacement de références et sur le retrait de références dans l'interface de ligne de commande, voir Référencement de secrets et des mappes de configuration.

Suppression de secrets

Lorsque vous n'avez plus besoin d'un secret, vous pouvez le supprimer.

Supprimer des secrets de la console

  1. Pour supprimer un secret de la console,
    1. Allez à la page Secrets and configmaps à partir de votre page Code Engine Projects.
    2. Cliquez sur le secret que vous souhaitez supprimer pour ouvrir sa page.
    3. Dans la page correspondant au secret spécifique, cliquez sur Actions > Supprimer le secret.
  2. Pour supprimer une paire clé-valeur pour un secret spécifique dans la console,
    1. Allez à la page Secrets and configmaps à partir de votre page Code Engine Projects.
    2. Cliquez sur le secret que vous souhaitez modifier pour ouvrir sa page.
    3. Dans la page du secret en question, supprimez la paire clé-valeur que vous souhaitez supprimer.

Vous pouvez également supprimer des variables d'environnement définies qui référencent des secrets et des mappes de configuration. Pour supprimer une variable d'environnement définie, dans l'onglet Variables d'environnement de votre application, job ou fonction, supprimez la variable d'environnement que vous souhaitez supprimer. Après avoir supprimé une variable d'environnement définie, n'oubliez pas de cliquer sur Enregistrer pour sauvegarder les modifications apportées à votre application, tâche ou fonction. Pour plus d'informations, voir Suppression d'une variable d'environnement.

Suppression de secrets à l'aide de l'interface de programmation

Pour supprimer un secret à l'aide de l'interface de ligne de commande, utilisez la commande secret delete. Par exemple :

ibmcloud ce secret delete --name myliteralsecret -f

Exemple de sortie

Deleting secret myliteralsecret...
OK

Vous pouvez également supprimer des variables d'environnement qui référencent des secrets et des mappes de configuration à partir de l'interface de ligne de commande.