Cree y almacene secretos como contraseñas, tokens OAuth y claves SSH en Kubernetes

En Kubernetes, podemos almacenar y administrar información confidencial, como contraseñas, tokens de OAuth y claves ssh usando Kubernetes Secrets. En Kubernetes, los secretos se pueden definir como objetos de Kubernetes. 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. Crear desde un archivo de texto
2. Crear desde un archivo yml

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

1. Variable de entorno
2. Volumen
3. Uso del campo imagePullSecrets

Para obtener más información sobre los secretos de Kubernetes, haga clic aquí.

En este artículo, crearemos secretos utilizando un archivo .yml y accederemos a ellos en el pod como variables de entorno.

Requisitos previos

1. Clúster de Kubernetes con al menos 1 nodo trabajador.
   Si desea aprender a crear un Clúster de Kubernetes, haga clic aquí. Esta guía lo ayudará a crear un clúster de Kubernetes con 1 maestro y 2 nodos en instancias AWS Ubuntu 18l04 EC2.

Lo que haremos

1. Crear secretos

Crear secretos

Para crear nuevos secretos en Kubernetes, primero cífrelos como se muestra a continuación usando el método de codificación base64.

Aquí,

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

echo -n "rahúl" | base64

echo -n "cómoforjar123" | base64

En la captura de pantalla anterior, se puede ver que las credenciales se cifraron.

Cree un archivo de definición de secreto de la siguiente manera, 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==

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

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

vim my-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

Vamos a crear secretos usando el siguiente comando.

kubectl create -f mi-secreto.yml

kubectl obtener secreto | grep misecreto

Ahora, cree un pod usando la siguiente definición de pod para acceder a los secretos creados previamente.

kubectl create -f my-pod.yml

kubectl obtener pods | grep secretos-en-pod

Inicie sesión en el pod con el siguiente comando.

kubectl obtener vainas | grep secretos-en-pod

kubectl exec -it secrets-in-pod /bin/bash

Una vez que inicie sesión en el pod, se puede acceder a los secretos como Variable de entorno mediante el siguiente comando.

echo $SECRET_NOMBRE DE USUARIO

echo $SECRET_PASSWORD

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, ejecute el siguiente comando.

kubectl obtener secreto | grep misecreto

kubectl obtener secreto mysecret -o yaml

Estos secretos también se pueden decodificar desde la línea de comandos usando los siguientes comandos.

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

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

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 comando usando base64.

Conclusión

En este artículo, vimos los pasos para crear y almacenar secretos en Kubernetes desde un archivo .yml. Intentamos acceder a estos secretos en Pod como variables de entorno. También vimos el comando para descifrar los secretos en la línea de comandos.