Remarques :

Ce tutoriel est disponible dans un environnement d'atelier gratuit fourni par Oracle.
Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

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

Introduction

De nombreuses applications disposent d'informations, telles que des mots de passe, auxquelles seuls les utilisateurs autorisés doivent accéder. C'est là que les clés secrètes Kubernetes peuvent vous aider. Ils permettent 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 que des données sensibles soient exposées ou modifiées 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 la totalité de la mémoire kube-apiserver et kubelet.
Définissez-les comme immuables pour les protéger contre toute modification accidentelle ou indésirable.

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

Activez Cryptage inactif pour les clés secrètes.

Configurez l'accès avec le moins de privilèges à l'aide de l'autorisation RBAC.

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

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

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

Pour plus d'informations sur Oracle Cloud Native Environment 2, reportez-vous au site actuel de la documentation sur les versions.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

Créer une clé secrète
Afficher 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érequis

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

Configuration d'Oracle Cloud Native Environment

Remarque : si vous êtes en cours d'exécution dans votre propre location, lisez le projet linux-virt-labs GitHub README.md et complétez les prérequis avant de déployer l'environnement d'exercice.

Ouvrez un terminal sur le bureau Luna.

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 ensembles requis.

ansible-galaxy collection install -r requirements.yml

Déployez l'environnement d'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 d'exercice libre requiert 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 le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python, situé sous les modules python3.6.

La forme de déploiement par défaut utilise l'UC AMD et Oracle Linux 8. Pour utiliser une CPU 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 guide de lecture s'exécute correctement et atteignez la tâche de pause. A ce stade du manuel, l'installation du CNE Oracle est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui affiche les adresses IP publiques et privées des noeuds qu'elle déploie et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Accéder au cluster Kubernetes

Ouvrez un terminal et connectez-vous via SSH à l'instance ocne.
```
ssh oracle@<ip_address_of_instance>
```
Attendez que le cluster se stabilise et que tous les pods présentent un état d'exécution.
```
watch kubectl get pods -A
```
Une fois que tous les pods affichent le STATUS de Running, saisissez 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 :

Utiliser 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 des ressources.
Utilisation de l'outil de gestion des objets Kustomize avec un fichier kustomization.yaml.

Utiliser Kubectl directement à partir de la ligne de commande

Kubectl crée des secrets de l'une des deux façons suivantes :

Les transmettre directement via la ligne de commande.
Les stocker en tant qu'informations d'identification dans des fichiers.

Créez une clé secrète à l'aide des 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
```
Remarque : utilisez des apostrophes '' pour faire échapper les caractères spéciaux tels que $, \, $, &, = et ! inclus dans les valeurs de chaîne. Sinon, le shell de commande les interprétera.
Exemple de résultat :
```
[oracle@ocne ~]$ kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password
secret/my-literal-secret created
```

Utiliser Kubectl avec des fichiers d'informations d'identification stockés

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

Créez les fichiers d'informations d'identification.

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

Créez 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
```
Remarque : le comportement par défaut utilise le nom de fichier comme valeur KEY pour indiquer 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 complé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 d'informations 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 d'informations d'identification dans un sous-répertoire.
  kubectl create secret generic my-secret --from-file=./secrets/
  Remarque : cette méthode utilise chaque nom de fichier comme valeur KEY et le contenu du fichier comme valeur VALUE.

Utilisation de Kubectl pour appliquer un fichier de configuration YAML

Créez le fichier de définition Secrets YAML.

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

Remarque : les valeurs de clé secrète du fichier YAML doivent être encodées par BASE64.

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

Utiliser Kustomize avec un fichier `kustomization.yaml`

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

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

Toutes les réponses ci-dessus ne nécessitent pas que les valeurs de clé secrète soient codées par 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érer le secret avec Kustomize.

kubectl -n default apply -k .

Exemple de résultat :

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

Gestion des clés secrètes Kubernetes

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

Répertorier les clés secrètes Kubernetes existantes

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

kubectl get secrets

Exemple de résultat :

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 résultat :

[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 élément secret afin d'éviter toute exposition ou inclusion accidentelle dans un fichier journal.

Afficher des informations sur l'un des secrets.

kubectl -n default describe secret db-credentials

Exemple de résultat :

[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écodage d'une clé secrète Kubernetes

Affichez 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 résultat :

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

La sortie affiche les paires clé:valeur encodées pour les données secrètes. Les données de valeur sont encodées en base64.

Décodez les données Key:Value encodées.
```
echo <BASE64-VALUE-FOR-PASSWORD> | base64 --decode
```
Exemple de résultat :
```
[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 shell. Pour éviter cela, combinez les deux étapes, comme indiqué à l'étape suivante.

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

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

Exemple de résultat :

[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 comme immutable.

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 résultat :

# 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, puis sur les touches :q!.
Exemple de résultat :
```
[oracle@ocne ~]$ kubectl edit secrets my-literal-secret
Edit cancelled, no changes made.
```

Suppression d'une clé privée

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

Supprimez les clés secrètes.

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

Exemple de résultat :

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

Remarque : 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.

Répertoriez toutes les clés secrètes dans l'espace de noms default.

kubectl get secrets -n default

Exemple de résultat :

[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

Confirmez le déploiement.

kubectl get deployments

Vous devrez peut-être réinterroger plusieurs fois pendant son déploiement.

Exemple de résultat :

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

Obtenez le nom du pod déployé.

kubectl get pods

Exemple de résultat :

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

Remarque : 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 résultat :

[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 ~]$ 

Remarque : 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 résultat :
```
[oracle@ocne ~]$ kubectl exec -it echo-deployment-59bff74847-9nnkq -- printenv USER PASSWORD
my-user
my-password
```
La sortie confirme que vous avez utilisé les clés secrètes Kubernetes en tant que variable d'environnement dans le pod déployé.

Etapes suivantes

Ce tutoriel a démontré 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 le module de formation Oracle Linux pour obtenir des tutoriels et du contenu supplémentaires.

Ressources de formation supplémentaires

Explorez d'autres ateliers sur le site docs.oracle.com/learn ou accédez à d'autres contenus d'apprentissage gratuits sur le canal Oracle Learning YouTube. En outre, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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

Informations relatives au titre et au copyright

Use Secrets with Oracle Cloud Native Environment

G39902-01

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

Introduction

Objectifs

Prérequis

Configuration d'Oracle Cloud Native Environment

Accéder au cluster Kubernetes

Création de clés secrètes

Utiliser Kubectl directement à partir de la ligne de commande

Utiliser Kubectl avec des fichiers d'informations d'identification stockés

Utilisation de Kubectl pour appliquer un fichier de configuration YAML

Utiliser Kustomize avec un fichier kustomization.yaml

Gestion des clés secrètes Kubernetes

Répertorier les clés secrètes Kubernetes existantes

Décodage d'une clé secrète Kubernetes

Modifier une clé secrète

Suppression d'une clé privée

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

Etapes suivantes

Liens connexes

Ressources de formation supplémentaires

Utiliser Kustomize avec un fichier `kustomization.yaml`