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 múltiples formas de generar secretos en Kubernetes:

1. Creación a partir de 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 ambiental
2. Volumen
3. Usando el campo imagePullSecrets

Para saber más sobre los secretos de Kubernetes, haga clic en 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 quieres aprender a crear un Cluster de Kubernetes, haz 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 utilizando 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 han cifrado.

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 mi secreto

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

kubectl create -f mi-pod.yml

kubectl obtener vainas | grep secrets-in-podPublicidad

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 $CONTRASEÑA_SECRETO

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 mi secreto

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 comandos 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.