Crear y almacenar secretos como contraseñas, tokens OAuth y claves SSH en Kubernetes

En Kubernetes, podemos almacenar y gestionar información sensible, como contraseñas, tokens OAuth y claves ssh, utilizando Kubernetes Secrets. En Kubernetes, los secretos pueden definirse como Kubernetes Objects. Es más seguro almacenar credenciales en Kubernetes Secrets que en Pods o en Docker Images.

Hay varias formas de generar secretos en Kubernetes:

  1. Creando desde un archivo de texto
  2. Creando desde un archivo yml

Una vez que los secretos están disponibles, se pueden utilizar de las siguientes maneras:

  1. Variable de entorno
  2. Volumen
  3. Utilizando el campo imagePullSecrets

Para saber más sobre los secretos de Kubernetes, haz clic aquí.

En este artículo, crearemos secretos utilizando el archivo .yml y accederemos a ellos en el Pod como Variables de Entorno.

Requisitos previos

  1. Cluster Kubernetes con al menos 1 nodo trabajador.
    Si quieres aprender a crear un Cluster de Kubernetes. Esta guía te ayudará a crear un clúster Kubernetes con 1 Maestro y 2 Nodos en Instancias EC2 de AWS Ubuntu.

Qué haremos

  1. Crear secretos

Crear secretos

Para crear nuevos secretos en Kubernetes, primero hay que encriptarlos como se muestra a continuación utilizando el método de codificación base64.

Aquí,

nombre de usuario=rahul y contraseña=howtoforge123.

echo -n "rahul" | base64
echo -n "howtoforge123" | base64

codificar-credenciales

En la captura de pantalla anterior, se puede ver que las credenciales han sido encriptadas.

Crea un archivo de definición secreta como el siguiente, este archivo contiene el valor base64 de las credenciales generadas en el paso anterior,.

vim mi-secreto.yml
apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  username: cmFodWw=
  password: aG93dG9mb3JnZTEyMw==

mis-secretos

Ahora, vamos a crear un pod en el que se pueda acceder a estos secretos.

Crea un nuevo archivo que contendrá la definición del pod de la siguiente manera

vim mi-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: secrets-in-pod
spec:
  containers:
    - name: my-container
      image: redis
      env:
        - name: SECRET_USERNAME
          valueFrom:
            secretKeyRef:
              name: mysecret
              key: username
        - name: SECRET_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysecret
              key: password
  restartPolicy: Never

mi-pod

Vamos a crear los secretos utilizando el siguiente comando

kubectl create -f mi-secreto.yml
kubectl get secret | grep mysecret

crear-secretoAhora, crea un pod con la siguiente definición de pod para acceder a los secretos creados anteriormente.

kubectl create -f mi-pod.yml
kubectl get pods | grep secretos-en-pod

mi-pod

Accede al pod utilizando el siguiente comando.

kubectl get pods | grep secretos-en-pod
kubectl exec -it secretos-en-pod /bin/bash

login-into-pod

Una vez que entres en el pod, se puede acceder a los secretos como Variable de Entorno utilizando el siguiente comando.

echo $SECRET_USERNAME
echo $SECRET_PASSWORD

acceso-credenciales-en-pod

En la captura de pantalla anterior, se puede ver que los secretos están disponibles como variables de entorno.

Para ver los detalles del objeto secreto, ejecuta el siguiente comando.

kubectl get secret | grep mysecret
kubectl get secret mysecret -o yaml

get-secret-details

Estos secretos también pueden descodificarse desde la línea de comandos utilizando los siguientes comandos.

kubectl get secrets/mysecret --template={{.data.username}} | base64 -d
kubectl get secrets/mysecret --template={.data.password}} | base64 -d

decodificar-secretos

En la captura de pantalla anterior, se puede ver que las credenciales se extraen de los Secretos y se descifran en la línea de comandos utilizando base64.

Scroll al inicio