Note :

Ce tutoriel est disponible dans un environnement de laboratoire gratuit fourni par Oracle.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments d'Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles qui sont propres à votre environnement en nuage.

Utiliser des clés secrètes avec Oracle Cloud Native Environment

Présentation

De nombreuses applications disposent d'informations, telles que des mots de passe, auxquelles seuls les utilisateurs autorisés doivent accéder. C'est dans cette situation que les clés secrètes Kubernetes peuvent vous aider. Ils fournissent un moyen de gérer en toute sécurité les données sensibles telles que les mots de passe, SSH et les clés d'API. L'utilisation de secrets permet de séparer les données confidentielles du code de l'application, ce qui réduit le risque d'exposition ou de modification des données sensibles pendant le flux de travail de vos pods.

Avant de commencer, il est utile de connaître quelques détails de base sur les clés secrètes Kubernetes :

Ils doivent être présents avant d'être utilisés par un Pod.
Défini à l'aide d'une paire KEY et VALUE.
Limité à une taille maximale de 1 Mo pour les empêcher d'utiliser toute la mémoire kube-apiserver et kubelet.
Définissez-les comme immuables pour les protéger contre les modifications accidentelles ou indésirables.

Important : Les clés secrètes Kubernetes ne sont pas chiffrées par défaut, car elles ne sont encodées que par Base64 et sont stockées non chiffrées dans etcd. Ainsi, toute personne ayant accès à etcd peut voir ou modifier un secret. L'utilisation des clés secrètes Kubernetes peut être sécurisée à l'aide de l'une des méthodes suivantes :

Activez le chiffrement au repos pour les clés secrètes.

Configurez l'accès avec privilège minimal à l'aide de l'autorisation RAC.

Restreindre l'accès aux clés secrètes à des conteneurs spécifiques.

Utilisation d'un service de gestion des clés secrètes externe.

Ce tutoriel présente les bases des clés secrètes Kubernetes et présente un cas d'utilisation simple.

Pour plus d'informations sur Oracle Cloud Native Environment 2, veuillez consulter la documentation de version actuelle.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Créer une clé secrète
Voir une clé secrète
Décoder une clé secrète
Utiliser une clé secrète pour définir une variable d'environnement dans un déploiement

Préalables

Installation d'Oracle Cloud Native Environment (Oracle CNE)
Un noeud de contrôle unique et un noeud de travail

Configurer Oracle Cloud Native Environment

Note : Si vous exécutez votre propre location, lisez les préalables du projet linux-virt-labs GitHub README.md et remplissez les conditions requises avant de déployer l'environnement de laboratoire.

Ouvrez un terminal sur le Luna Desktop.

Clonez le projet linux-virt-labs GitHub.

git clone https://github.com/oracle-devrel/linux-virt-labs.git

Accédez au répertoire de travail.
```
cd linux-virt-labs/ocne2
```

Installez les collections requises.

ansible-galaxy collection install -r requirements.yml

Déployez l'environnement de l'exercice.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e install_ocne_rpm=true -e create_ocne_cluster=true -e "ocne_cluster_node_options='-n 1 -w 1'"
```
L'environnement de laboratoire gratuit nécessite la variable supplémentaire local_python_interpreter, qui définit ansible_python_interpreter pour les lectures exécutées sur localhost. Cette variable est nécessaire car l'environnement installe l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python, située sous les modules python3.6.

La forme de déploiement par défaut utilise le processeur AMD et Oracle Linux 8. Pour utiliser une unité centrale Intel ou Oracle Linux 9, ajoutez -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" à la commande de déploiement.

Important : Attendez que le livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. À ce stade du livre de jeux, l'installation du CNE Oracle est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'il déploie et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Accéder à la grappe Kubernetes

Ouvrez un terminal et connectez-vous au moyen de SSH à l'instance ocne.
```
ssh oracle@<ip_address_of_instance>
```
Attendez que la grappe se stabilise et que tous les pods soient en cours d'exécution.
```
watch kubectl get pods -A
```
Une fois que tous les pods affichent le statut STATUS En cours d'exécution, entrez ctrl-c pour quitter la commande watch.
Vérifiez le nombre de noeuds présents.
```
kubectl get nodes
```

Création de clés secrètes

Il existe trois façons de créer des clés secrètes Kubernetes :

Utilisation de l'outil de ligne de commande kubectl pour gérer les clés secrètes directement à partir de la ligne de commande.
Utilisation de l'outil de ligne de commande kubectl avec un fichier de configuration de ressource.
Utilisation de l'outil de gestion des objets personnalisé avec un fichier kustomization.yaml.

Utiliser Kubectl directement à partir de la ligne de commande

Kubectl crée des secrets de deux façons :

Passer directement via la ligne de commande.
Les stocker en tant que données d'identification dans des fichiers.

Créez une clé secrète à l'aide de valeurs littérales transmises directement à partir de la ligne de commande.
```
kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password
```
Note : Utilisez des guillemets simples '' pour échapper aux caractères spéciaux tels que $, \, $, &, = et ! inclus dans les valeurs de chaîne. Sinon, l'interpréteur de commandes les interprétera.
Exemple de sortie :
```
[oracle@ocne ~]$ kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password
secret/my-literal-secret created
```

Utilisation de Kubectl avec des fichiers de données d'identification stockés

Le contenu du fichier devient la VALUE et le nom du fichier devient la KEY.

Créez les fichiers de données d'identification.

echo -n 'admin' > ./username.txt
echo -n 'S!B\*d$zDsb=' > ./password.txt

Créer une clé secrète à l'aide des fichiers enregistrés.
```
kubectl create secret generic my-file-secret \
 --from-file=username=./username.txt \
 --from-file=password=./password.txt
```
Note : Le comportement par défaut utilise le nom de fichier comme valeur KEY pour montrer comment remplacer le comportement par défaut et déclarer la valeur de nom KEY directement à partir de la ligne de commande à l'aide de la méthode --from-file=[key]=[path to file].
Informations supplémentaires :

Vous pouvez également créer une clé secrète à partir de plusieurs fichiers stockés dans un sous-répertoire.
1. Créez un sous-répertoire.
  mkdir secrets
2. Créez les fichiers de données d'identification.
  echo -n 'user1' > ./secrets/username.txt echo -n 'my-super-secret-password' > ./secrets/password.txt
3. Créez une clé secrète à l'aide de fichiers de données d'identification dans un sous-répertoire.
  kubectl create secret generic my-secret --from-file=./secrets/
  Note : Cette méthode utilise chaque nom de fichier comme valeur KEY et le contenu du fichier comme VALUE.

Utiliser Kubectl pour appliquer un fichier de configuration YAML

Créez le fichier de définition YAML des clés secrètes.

cat << EOF | tee db-credentials.yaml > /dev/null
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
  # immutable: true
type: Opaque
data:
  username: "bXktdXNlcg=="
  password: "bXktcGFzc3dvcmQ="
EOF

Note : Les valeurs de clé secrète du fichier YAML doivent être encodées à BASE64.

Appliquez le secret.
```
kubectl apply -f db-credentials.yaml
```

Utilisation de Kustomize avec un fichier `kustomization.yaml`

La création de clés secrètes avec Personnaliser nécessite un fichier kustomization.yaml. Ce fichier doit définir un fichier secretGenerator à l'aide de l'une des méthodes suivantes :

Les fichiers stockant les valeurs de données de clé secrète et les noms de fichier deviennent les valeurs KEY.
Version littérale non chiffrée de la valeur de données dans un fichier.
Fichiers de variable d'environnement (.env).

Tout ce qui précède ne nécessite pas que les valeurs de clé secrète soient encodées Base64 lors de l'utilisation de Kustomize. Le nom du fichier YAML utilisé par Kustomize doit être kustomization.yaml ou kustomization.yml.

Cet exemple montre comment utiliser des littéraux pour créer une clé secrète.

Créez le fichier secretGenerator.

cat << EOF | tee kustomization.yaml > /dev/null
secretGenerator:
- name: database-credentials
  literals:
  - username=admin
  - password=password
EOF

Générez la clé secrète avec Kustomize.

kubectl -n default apply -k .

Exemple de sortie :

[oracle@ocne ~]$ kubectl -n default apply -k .
secret/database-credentials-fd8288cb7g created

Gestion des clés secrètes Kubernetes

Vous pouvez stocker des clés secrètes Kubernetes dans différents espaces de noms. Vous devez donc utiliser l'option -n pour extraire des clés secrètes d'un espace de noms spécifique, ou utiliser --all-namespaces ou -A pour extraire des clés secrètes de tous les espaces de noms. La commande kubectl utilise l'espace de noms default si vous ne spécifiez pas d'espace de noms. Le même comportement s'applique lors de la création d'une clé secrète Kubernetes.

Lister les clés secrètes Kubernetes existantes

Répertorier les clés secrètes nouvellement créées.

kubectl get secrets

Exemple de sortie :

NAME                              TYPE     DATA   AGE
database-credentials-fd8288cb7g   Opaque   2      34s
db-credentials                    Opaque   2      2m16s
my-file-secret                    Opaque   2      2m40s
my-literal-secret                 Opaque   2      2m51s

Obtenez plus de détails sur les clés secrètes nouvellement créées.

kubectl describe secrets

Exemple de sortie :

[oracle@ocne ~]$ kubectl describe secrets
Name:         database-credentials-fd8288cb7g
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
password:  8 bytes
username:  5 bytes


Name:         db-credentials
Namespace:    default
...
...

Name:         my-literal-secret
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
username:  7 bytes
password:  11 bytes

Notez que les commandes kubectl get et kubectl describe n'affichent pas le contenu d'un fichier secret pour empêcher une exposition accidentelle ou une inclusion dans un fichier journal.

Voir les informations sur l'une des clés secrètes.

kubectl -n default describe secret db-credentials

Exemple de sortie :

[oracle@ocne ~]$ kubectl -n default describe secret db-credentials
Name:         db-credentials
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
password:  11 bytes
username:  7 bytes

Décoder une clé secrète Kubernetes

Voir les données stockées pour l'une des clés secrètes.

kubectl -n default get secret db-credentials -o jsonpath='{.data}'

Exemple de sortie :

[oracle@ocne ~]$ kubectl -n default get secret db-credentials -o jsonpath='{.data}'
{"password":"bXktcGFzc3dvcmQ=","username":"bXktdXNlcg=="}[oracle@ocne ~]$ 

La sortie affiche les paires Key:Value codées pour les données secrètes. Les données de valeur sont encodées à base64.

Décodez les données encodées Key:Value.
```
echo <BASE64-VALUE-FOR-PASSWORD> | base64 --decode
```
Exemple de sortie :
```
[oracle@ocne ~]$ echo bXktc3VwZXItc2VjcmV0LXBhc3Nvd3Jk | base64 --decode
my-password[oracle@ocne ~]$ 
```
AVERTISSEMENT : Ces étapes peuvent entraîner l'enregistrement des données secrètes dans l'historique de votre interpréteur de commandes. Évitez cela en combinant les deux étapes, comme indiqué à l'étape suivante.

Une méthode plus sécurisée pour décoder les données encodées Key:Value.

kubectl -n default get secret db-credentials -o jsonpath='{.data.password}' | base64 --decode

Exemple de sortie :

[oracle@ocne ~]$ kubectl -n default get secret db-credentials -o jsonpath='{.data.password}' | base64 --decode
my-password[oracle@ocne ~]$ 

Modifier une clé secrète

Comme de nombreux objets Kubernetes, vous pouvez modifier une clé secrète Kubernetes. La seule exception est lorsqu'une clé secrète est déclarée immuable.

Modifier une clé secrète.

kubectl edit secrets my-literal-secret

L'éditeur par défaut s'ouvre (vi par défaut) pour vous permettre de mettre à jour les valeurs de clé secrète encodées Base64 dans le champ data:.

Exemple de sortie :

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
data:
  password: bXktcGFzc3dvcmQ=
  username: bXktdXNlcg==
kind: Secret
metadata:
  creationTimestamp: "2025-05-09T10:56:14Z"
  name: my-literal-secret
  namespace: default
  resourceVersion: "1689"
  uid: 394dfda3-025a-417d-bbfe-c4851a6b6cff
type: Opaque
~                                                                                                                                       
~                                                                                                                                             
~                                                                                                                                       
~                                                                                                                                             
"/tmp/kubectl-edit-1267071353.yaml" 16L, 480C

Quittez l'éditeur sans enregistrer en appuyant sur la touche Esc, suivie des clés :q!.
Exemple de sortie :
```
[oracle@ocne ~]$ kubectl edit secrets my-literal-secret
Edit cancelled, no changes made.
```

Supprimer une clé secrète

Vous pouvez supprimer une clé secrète à l'aide de la commande kubectl -n <NAMESPACE> delete.

Supprimer les clés secrètes.

kubectl -n default delete secret my-file-secret my-literal-secret

Exemple de sortie :

[oracle@ocne ~]$ kubectl -n default delete secret my-file-secret  my-literal-secret
secret "my-file-secret" deleted
secret "my-literal-secret" deleted

Note : Vous pouvez supprimer plusieurs clés secrètes en les séparant par des espaces.

Utiliser des clés secrètes avec un déploiement

Vous allez ensuite créer un déploiement à l'aide des données de clé secrète Kubernetes que vous avez créées.

Lister toutes les clés secrètes dans l'espace de noms par défaut.

kubectl get secrets -n default

Exemple de sortie :

[oracle@ocne ~]$ kubectl get secrets -n default
NAME                              TYPE     DATA   AGE
database-credentials-fd8288cb7g   Opaque   2      10m
db-credentials                    Opaque   2      8m

Créez un fichier YAML de déploiement.

cat << EOF | tee echo-deployment.yaml > /dev/null
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echo
        image: ghcr.io/oracle/oraclelinux:9
        command: ["/bin/bash", "-c"]
        args: ["echo 'Username: $USER' 'Password: $PASSWORD'; sleep infinity"]
        env:
        - name: USER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password
      restartPolicy: Always
EOF

Créer le déploiement

kubectl -n default apply -f echo-deployment.yaml

Vérifiez qu'il se déploie.

kubectl get deployments

Vous devrez peut-être effectuer une nouvelle interrogation plusieurs fois pendant son déploiement.

Exemple de sortie :

[oracle@ocne ~]$ kubectl get deployments 
NAME              READY   UP-TO-DATE   AVAILABLE   AGE
echo-deployment   1/1     1            1           4m

Obtenir le nom du pod déployé.

kubectl get pods

Exemple de sortie :

[oracle@ocne ~]$ kubectl get pods
NAME                               READY   STATUS    RESTARTS   AGE
echo-deployment-59bff74847-9nnkq   1/1     Running   0          6m

Note : Le nom de votre pod sera différent.

Vérifiez que le pod déployé a utilisé la clé secrète.

kubectl -n default describe pod <POD-NAME>

Où :

<POD-NAME> - Nom du pod dans votre déploiement.

Exemple de sortie :

[oracle@ocne ~]$ kubectl -n default describe pod echo-deployment-59bff74847-9nnkq
Name:             echo-deployment-59bff74847-9nnkq
Namespace:        default
Priority:         0
Service Account:  default
Node:             ocne-worker-1/192.168.122.77
Start Time:       Mon, 12 May 2025 13:42:25 +0000
...
...
    Ready:          True
    Restart Count:  0
    Environment:
      USER:      <set to the key 'username' in secret 'db-credentials'>  Optional: false
      PASSWORD:  <set to the key 'password' in secret 'db-credentials'>  Optional: false
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-5fp4d (ro)
Conditions:
  Type                        Status
  PodReadyToStartContainers   True 
  Initialized                 True
...
..
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:                      <none>
[oracle@ocne ~]$ 

Note : Vérifiez que la section Environment: confirme la présence des variables $USER et $PASSWORD.

Vérifiez que les variables d'environnement sont présentes dans le pod déployé.
```
kubectl exec -it <POD-NAME> -- printenv USER PASSWORD
```
Où :
- <POD-NAME> - Nom du pod dans votre déploiement.
Exemple de sortie :
```
[oracle@ocne ~]$ kubectl exec -it echo-deployment-59bff74847-9nnkq -- printenv USER PASSWORD
my-user
my-password
```
La sortie confirme que vous avez utilisé avec succès les clés secrètes Kubernetes en tant que variable d'environnement dans le pod déployé.

prochaines étapes

Ce tutoriel explique comment créer et utiliser des clés secrètes Kubernetes pour restreindre l'accès non autorisé aux informations sensibles. Cependant, ce n'est que le début. Consultez la station de formation Oracle Linux pour obtenir des tutoriels et du contenu supplémentaires.

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.

Informations sur le titre et les droits d'auteur

Use Secrets with Oracle Cloud Native Environment

G39901-01

Utiliser des clés secrètes avec Oracle Cloud Native Environment

Présentation

Objectifs

Préalables

Configurer Oracle Cloud Native Environment

Accéder à la grappe Kubernetes

Création de clés secrètes

Utiliser Kubectl directement à partir de la ligne de commande

Utilisation de Kubectl avec des fichiers de données d'identification stockés

Utiliser Kubectl pour appliquer un fichier de configuration YAML

Utilisation de Kustomize avec un fichier kustomization.yaml

Gestion des clés secrètes Kubernetes

Lister les clés secrètes Kubernetes existantes

Décoder une clé secrète Kubernetes

Modifier une clé secrète

Supprimer une clé secrète

Utiliser des clés secrètes avec un déploiement

prochaines étapes

Liens connexes

Autres ressources d'apprentissage

Utilisation de Kustomize avec un fichier `kustomization.yaml`