Note:

• Este tutorial está disponible en un entorno de laboratorio gratuito proporcionado por Oracle.
• Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar el laboratorio, sustituya estos valores por otros específicos de su entorno en la nube.

Uso de secretos con Oracle Cloud Native Environment

Introducción

Muchas aplicaciones tienen información, como contraseñas, a la que solo deben acceder los usuarios autorizados. En esta situación, los secretos de Kubernetes pueden ayudar. Proporcionan una forma de gestionar de forma segura datos confidenciales como contraseñas, SSH y claves de API. El uso de secretos permite separar los datos confidenciales del código de la aplicación, lo que reduce el riesgo de que los datos confidenciales se expongan o modifiquen durante el flujo de trabajo de los pods.

Antes de empezar, es útil conocer algunos detalles básicos sobre los secretos de Kubernetes:

• Deben estar presentes antes de ser utilizados por un pod.
• Se define mediante un par KEY y VALUE.
• Limitado a un tamaño máximo de 1 MB para evitar que utilicen toda la memoria kube-apiserver y kubelet.
• Definirlos como inmutables para protegerlos de modificaciones accidentales o no deseadas.

Importante: los secretos de Kubernetes no se cifran por defecto porque solo están codificados con Base64 y se almacenan sin cifrar en etcd. Así que cualquier persona con acceso a etcd puede ver o alterar un secreto. El uso de secretos de Kubernetes se puede hacer seguro mediante cualquiera de estos métodos:

• Active Cifrado estático para secretos.
• Configure el acceso con el mínimo de privilegios mediante la autorización RBAC.
• Restrinja el acceso a secretos en contenedores específicos.
• Uso de un servicio de gestión de secretos externo.

En este tutorial se tratan los conceptos básicos de los secretos de Kubernetes y se muestra un caso de uso sencillo.

Para obtener más información sobre Oracle Cloud Native Environment 2, consulte el sitio de documentación de la versión actual.

Objetivos

En este tutorial, aprenderá a:

• Crear un secreto
• Ver un secreto
• Decodificar un secreto
• Utilizar un secreto para definir una variable de entorno en un despliegue

Requisitos

• Instalación de Oracle Cloud Native Environment (Oracle CNE)
• Un único nodo de control y un nodo de trabajador

Configurar Oracle Cloud Native Environment

Nota: Si se ejecuta en su propio arrendamiento, lea el proyecto linux-virt-labs GitHub README.md y complete los requisitos antes de desplegar el entorno de prácticas.

1. Abra un terminal en Luna Desktop.

2. Clone el proyecto linux-virt-labs GitHub.

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

3. Cambie al directorio de trabajo.

   cd linux-virt-labs/ocne2
   

4. Instale las recopilaciones necesarias.

   ansible-galaxy collection install -r requirements.yml
   

5. Despliegue el entorno de prácticas.

   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'"
   

   El entorno de prácticas libres necesita la variable adicional local_python_interpreter, que define ansible_python_interpreter para las reproducciones que se ejecutan en localhost. Esta variable es necesaria porque el entorno instala el paquete RPM para el SDK para Python de Oracle Cloud Infrastructure, que se encuentra en los módulos python3.6.

   La unidad de despliegue por defecto utiliza la CPU AMD y Oracle Linux 8. Para utilizar una CPU Intel u Oracle Linux 9, agregue -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando de despliegue.

   Importante: Espere a que el cuaderno de estrategias se ejecute correctamente y alcance la tarea de pausa. En esta etapa del manual, se ha completado la instalación del CNE de Oracle y las instancias están listas. Tome nota de la reproducción anterior, que imprime las direcciones IP públicas y privadas de los nodos que despliega y cualquier otra información de despliegue necesaria al ejecutar el ejercicio práctico.

Acceso al cluster de Kubernetes

1. Abra un terminal y conéctese mediante SSH a la instancia de ocne.

   ssh oracle@<ip_address_of_instance>
   

2. Espere a que el cluster se estabilice y a que todos los pods se informen en estado de ejecución.

   watch kubectl get pods -A
   

   Una vez que todos los pods muestren un STATUS de Running, escriba ctrl-c para salir del comando watch.

3. Confirme cuántos nodos están presentes.

   kubectl get nodes
   

Creación de secretos

Hay tres formas de crear secretos de Kubernetes, que son:

• Uso de la herramienta de línea de comandos de kubectl para gestionar secretos directamente desde la línea de comandos.
• Uso de la herramienta de línea de comandos de kubectl con un archivo de configuración de recursos.
• Uso de la herramienta de gestión de objetos personalizada con un archivo kustomization.yaml.

Uso de Kubectl directamente desde la línea de comandos

Kubectl crea secretos de una de estas dos maneras:

• Pasarlos directamente a través de la línea de comandos.
• Almacenándolos como credenciales en los archivos.

1. Crear un secreto mediante valores literales transferidos directamente desde la línea de comandos.

   kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password
   

   Nota: Utilice comillas simples '' para introducir caracteres especiales como $, \, $, &, = y ! incluidos en los valores de cadena. De lo contrario, el shell de comandos los interpretará.

   Salida de ejemplo:

   [oracle@ocne ~]$ kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password
   secret/my-literal-secret created
   

Uso de Kubectl con archivos de credenciales almacenados

El contenido del archivo se convierte en el VALUE y el nombre de archivo se convierte en el KEY.

1. Cree los archivos de credenciales.

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

2. Cree un secreto mediante archivos guardados.

   kubectl create secret generic my-file-secret \
    --from-file=username=./username.txt \
    --from-file=password=./password.txt
   

   Nota: El comportamiento por defecto utiliza el nombre de archivo como valor KEY para mostrar cómo sustituir el comportamiento por defecto y declarar el valor de nombre KEY directamente desde la línea de comandos mediante el método --from-file=[key]=[path to file].

   Información Adicional:

   También puede crear un secreto a partir de varios archivos almacenados en un subdirectorio.

   1. Cree un subdirectorio.

      mkdir secrets
      

   2. Cree los archivos de credenciales.

      echo -n 'user1' > ./secrets/username.txt
      echo -n 'my-super-secret-password' > ./secrets/password.txt
      

   3. Crear un secreto mediante archivos de credenciales en un subdirectorio.

      kubectl create secret generic my-secret --from-file=./secrets/
      

      Nota: Este método utiliza cada nombre de archivo como el valor KEY y el contenido del archivo como el VALUE.

Uso de Kubectl para Aplicar un Archivo de Configuración YAML

1. Cree el archivo de definición YAML Secrets.

   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
   

   Nota: Los valores secretos del archivo YAML deben estar codificados en BASE64.

2. Aplicar el secreto.

   kubectl apply -f db-credentials.yaml
   

Uso de Kustomize con un archivo kustomization.yaml

La creación de secretos con Kustomize requiere un archivo kustomization.yaml. Ese archivo debe definir un secretGenerator mediante uno de los siguientes métodos:

• Los archivos que almacenan los valores data secretos y los nombres de archivo se convierten en los valores KEY.
• Versión literal sin cifrar del valor data en un archivo.
• Archivos de variables de entorno (.env).

Todo lo anterior no necesita que los valores secretos estén codificados en Base64 al utilizar Kustomize. El nombre del archivo YAML utilizado por Kustomize must debe ser kustomization.yaml o kustomization.yml.

En este ejemplo se muestra cómo utilizar literales para crear un secreto.

1. Cree el archivo secretGenerator.

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

2. Genere el secreto con Kustomize.

   kubectl -n default apply -k .
   

   Salida de ejemplo:

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

Gestión de secretos de Kubernetes

Puede almacenar secretos de Kubernetes en diferentes espacios de nombres. Por tanto, debe utilizar la opción -n para recuperar secretos de un espacio de nombres específico, o bien utilizar --all-namespaces o -A para recuperar secretos de todos los espacios de nombres. El comando kubectl utiliza el espacio de nombres default si no especifica un espacio de nombres. Se aplica el mismo comportamiento al crear un secreto de Kubernetes.

Lista de secretos de Kubernetes existentes

1. Enumere los secretos recién creados.

   kubectl get secrets
   

   Salida de ejemplo:

   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
   

2. Obtenga más detalles sobre los secretos recién creados.

   kubectl describe secrets
   

   Salida de ejemplo:

   [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
   

   Tenga en cuenta que los comandos kubectl get y kubectl describe no muestran el contenido de un archivo secret para evitar la exposición o inclusión accidental en un archivo log.

3. Consulta de la información de uno de los secretos.

   kubectl -n default describe secret db-credentials
   

   Salida de ejemplo:

   [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
   

Decodificación de un secreto de Kubernetes

1. Consulta de los datos almacenados de uno de los secretos.

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

   Salida de ejemplo:

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

   La salida muestra los pares de clave:valor codificados para los datos secretos. Los datos de valor están codificados en base64.

2. Decodifique los datos de clave:valor codificados.

   echo <BASE64-VALUE-FOR-PASSWORD> | base64 --decode
   

   Salida de ejemplo:

   [oracle@ocne ~]$ echo bXktc3VwZXItc2VjcmV0LXBhc3Nvd3Jk | base64 --decode
   my-password[oracle@ocne ~]$ 
   

   ADVERTENCIA: estos pasos pueden dar como resultado un registro de los datos secretos en el historial del shell. Evite esto combinando ambos pasos, como se muestra en el siguiente paso.

3. Un método más seguro para descodificar los datos codificados de clave: valor.

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

   Salida de ejemplo:

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

Editar un secreto

Al igual que muchos objetos de Kubernetes, puede editar un secreto de Kubernetes. La única excepción es cuando un secreto se declara inmutable.

1. Editar un secreto.

   kubectl edit secrets my-literal-secret
   

   El editor por defecto se abre (vi por defecto) para permitirle actualizar los valores secretos codificados en Base64 en el campo data:.

   Salida de ejemplo:

   # 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
   

2. Salga del editor sin guardar pulsando la tecla Esc, seguida de las teclas :q!.

   Salida de ejemplo:

   [oracle@ocne ~]$ kubectl edit secrets my-literal-secret
   Edit cancelled, no changes made.
   

Suprimir un secreto

Puede eliminar un secreto mediante el comando kubectl -n <NAMESPACE> delete.

1. Elimine los secretos.

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

   Salida de ejemplo:

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

   Nota: Puede suprimir varios secretos delimitándolos por espacios.

Uso de secretos con un despliegue

A continuación, creará un despliegue con los datos secretos de Kubernetes que ha creado.

1. Muestre todos los secretos en el espacio de nombres default.

   kubectl get secrets -n default
   

   Salida de ejemplo:

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

2. Cree un archivo YAML de despliegue.

   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
   

3. Crear el despliegue

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

4. Confirme que se despliega.

   kubectl get deployments
   

   Es posible que tenga que volver a consultar algunas veces mientras se despliega.

   Salida de ejemplo:

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

5. Obtenga el nombre del pod desplegado.

   kubectl get pods
   

   Salida de ejemplo:

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

   Nota: El nombre del pod será diferente.

6. Verifique que el pod desplegado ha utilizado el secreto.

   kubectl -n default describe pod <POD-NAME>
   

   Dónde:

   • <POD-NAME>: nombre del pod en el despliegue.

   Salida de ejemplo:

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

   Nota: Compruebe que la sección Environment: confirma que las variables $USER y $PASSWORD están presentes.

7. Confirme que las variables de entorno están presentes en el pod desplegado.

   kubectl exec -it <POD-NAME> -- printenv USER PASSWORD
   

   Dónde:

   • <POD-NAME>: nombre del pod en el despliegue.

   Salida de ejemplo:

   [oracle@ocne ~]$ kubectl exec -it echo-deployment-59bff74847-9nnkq -- printenv USER PASSWORD
   my-user
   my-password
   

   La salida confirma que ha utilizado correctamente los secretos de Kubernetes como variable de entorno en el pod desplegado.

Pasos siguientes

En este tutorial se muestra cómo crear y utilizar secretos de Kubernetes para restringir el acceso no autorizado a información confidencial. Sin embargo, esto es solo el comienzo. Consulte la estación de formación de Oracle Linux para obtener tutoriales y contenido adicionales.

Enlaces relacionados

• Documentación de Oracle Cloud Native Environment
• Circuito de Oracle Cloud Native Environment
• Oracle Linux Training Station

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.

---

Título e Información de Copyright

Use Secrets with Oracle Cloud Native Environment

G39900-01

Copyright ©2025, Oracle and/or its affiliates.