Si has estado usando Kubernetes por un tiempo y desea aprender cómo utilizar de forma segura sus secretos de Kubernetes mientras organiza, ha venido al lugar correcto.

Este tutorial es diferente a otros tutoriales de Kubernetes que ignoran el aspecto de seguridad. Te sumergirás en el aprendizaje sobre cómo utilizar tus secretos de forma segura. Todo mientras trabaja en un entorno de Kubernetes.

¡Prepárate para mantener tus secretos lejos de miradas indiscretas!

Requisitos previos

Este tutorial será una demostración práctica. Si desea seguirnos, asegúrese de tener lo siguiente:

• Minikubo nodo creado y ejecutándose en VirtualBox – Este tutorial utiliza Minikube v1.25.2 y VirtualBox 6.1.

• Una máquina Linux: este tutorial utiliza Ubuntu 20.04.3 LTS.

• Docker está instalado en su máquina Linux.

Crear y cargar secretos de Kubernetes

Al trabajar con Kubernetes, es posible que encuentre una imagen que necesite utilizar variables de entorno confidenciales, como claves API y contraseñas.

Por ejemplo, cuando utilice una imagen de MongoDB, necesitará credenciales para autenticarse. Esas credenciales deben almacenarse como misterios. Un secreto es un objeto de Kubernetes que se utiliza para manejar datos como TLS, claves API, tokens y contraseñas.

Para crear y cargar secretos de Kubernetes:

1. Cree un nuevo directorio (mkdir) llamado secrets para su proyecto (el nombre del directorio es arbitrario) y cambie (cd) a ese directorio.

2. A continuación, ejecute lo siguiente kubectl crea secreto comando para crear un secreto donde:

• generic sub-command - Indicates the default secret type.

• mongo-secret - The secret’s name to be referenced.

• --from-literal flag - Takes in the secrets as key/value pairs.

kubectl create secret generic mongo-secret --from-literal=MONGO_INITDB_ROOT_USERNAME=username --from-literal=MONGO_INITDB_ROOT_PASSWORD='hidden-password'

3. A continuación, ejecute lo siguiente kubectl describe comando para confirmar que ha creado correctamente el secreto (mongo-secret).

kubectl describe secret mongo-secret

Después de ejecutar el comando, notará que los valores están ocultos ya que Kubernetes codifica los valores en base64.

4. Cree un archivo YAML en el directorio del proyecto (misterios) con su editor de texto preferido y pegue el código siguiente en el archivo YAML. Nombra el archivo YAML como quieras, pero la elección de este tutorial es mongo_deployment.yaml.

El siguiente código crea un contenedor MongoDB en un pod y utiliza variables de entorno de secretos.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongo-deployment
  labels:
    app: mongodb
spec:
  replicas: 1  # State the number of replicas of the application you need.
  selector:
    matchLabels:
      app: mongodb
  template:
    metadata:
      labels:
        app: mongodb
    spec:
      containers:
			  # State the image's name on Docker Hub to build the container from.
      - name: mongodb
        image: mongo
        ports:
				# State container port for Solr server
        - containerPort: 27017
        env:
        - name: MONGO_INITDB_ROOT_USERNAME # required by mongodb image
          valueFrom:
            secretKeyRef:
              name: mongo-secret # name of secret
              key: MONGO_INITDB_ROOT_USERNAME
        - name: MONGO_INITDB_ROOT_PASSWORD 
          valueFrom:
            secretKeyRef:
              name: mongo-secret
              key: MONGO_INITDB_ROOT_PASSWORD 

5. Ahora, ejecuta el aplicar kubectly comando a continuación para aplicar las configuraciones que estableció en el mongo_deployment.yaml archivo.

kubectl apply -f mongo_deployment.yaml

6. Finalmente, ejecute el siguiente comando para obtener la lista de todos los pods.

A continuación, puede verificar que el pod recién creado existe y se está ejecutando.

Dependiendo de la velocidad de su Internet y de su máquina local, la activación de los contenedores en los pods puede tardar de cinco a 10 minutos en completarse.

Extrayendo imágenes de Docker usando secretos

Cuando trabaje con una imagen de Docker en un registro privado, debe autenticarse antes de poder extraer la imagen. La autenticación puede ser manejada por Kubernetes usando Docker. config.json.

Kubernetes convierte Docker configuración.json en un secreto y, desde allí, puede usarlo en su archivo de implementación. El registro privado que utilizará en este tutorial es Docker Hub.

Extraiga imágenes de Docker de un registro privado utilizando secretos con los siguientes pasos:

1. Ejecute el siguiente comando de inicio de sesión de Docker para iniciar sesión en su cuenta de Docker Hub. Asegúrese de reemplazar el nombre de usuario y la contraseña con sus credenciales de Docker Hub.

Este comando genera un configuración.json archivo que contiene su token de autorización.

docker login -u username -p password

2. A continuación, ejecute el siguiente comando cat para verificar si se ha generado su token de autorización.

cat ~/.docker/config.json

3. Ejecute el siguiente comando para registrar su token de autenticación de Docker (~/.docker/config.json) en Kubernetes en formato JSON serializado como un secreto con lo siguiente:

• Establezca el nombre del elemento de datos en .dockerconfigjson

• SEstablezca el tipo en kubernetes.io/dockerconfigjson

• Establezca auth-token como el nombre que se utilizará para hacer referencia al secreto.

Pero asegúrese de cambiar /home/muhammed/.docker/config.json con la ruta a su propio Docker configuración.json archivo.

kubectl create secret generic auth-token \
    --from-file=.dockerconfigjson=/home/muhammed/.docker/config.json \
    --type=kubernetes.io/dockerconfigjson

4. Cree un nuevo archivo YAML en el directorio de su proyecto (misterios) y complete el siguiente código en el archivo YAML. Nombra el archivo YAML como quieras, pero el archivo YAML tiene el nombre implementación_privada.yaml para este tutorial.

El siguiente código crea un pod con una imagen de Docker privada especificada. Así que asegúrese de reemplazar khabdrick/sample:v1 con su propia imagen privada de Docker.

apiVersion: v1
kind: Pod
metadata:
  name: private-deployment # name of the pod
spec:
  containers:
  - name: example-container
    image: khabdrick/sample:v1 # a private image in Docker Hub
    ports:
      - containerPort: 5000
  imagePullSecrets:
  - name: auth-token

5. Ahora, ejecute el siguiente comando para aplicar las configuraciones que estableció en el archivo private_deployment.yaml.

kubectl apply -f private_deployment.yaml

6. Finalmente, ejecute el siguiente comando para ver si el pod se creó y se ejecutó como se esperaba.

Limitar el uso secreto

Ahora tienes un secreto y estás un paso más cerca de mantenerlo a salvo. Como sabes, el concepto de secreto es mantenerlo, bueno, en secreto. Así que limite el uso del secreto a usted mismo. ¿Cómo? Establece tus secretos dentro de un espacio de nombres. Cuando un usuario está en un espacio de nombres particular, ese usuario no puede acceder a secretos de otro espacio de nombres.

Si no se configuran espacios de nombres, Kubernetes crea uno con el nombre predeterminado, por lo que todos los secretos que creó están en el espacio de nombres predeterminado.

Para crear secretos a los que solo pueden acceder usuarios específicos, cree un nuevo espacio de nombres antes de crear los secretos:

1. Cree un nuevo archivo YAML llamado new-namespace.yaml y agregue el siguiente código al archivo YAML.

El siguiente código crea un espacio de nombres llamado nuevo-espacio de nombres, pero usted cambia el nombre como desee.

apiVersion: v1
kind: Namespace
metadata:
  name: new-namespace # this could be any name of your choice

2. A continuación, ejecute el comando kubectl create para crear el espacio de nombres según la configuración que estableció en el archivo new-namespace.yml.

kubectl create -f new-namespace.yaml

3. Ejecute el siguiente comando para enumerar todos los espacios de nombres disponibles.

A continuación, puede verificar que el espacio de nombres (nuevo espacio de nombres) se creó correctamente.

4. Ahora, ejecute el siguiente comando para crear un nuevo secreto para el nombre de usuario y la contraseña. Pero esta vez, adjuntará una etiqueta –namespace y definirá el espacio de nombres (nuevo-espacio de nombres) donde desea almacenar el nuevo secreto.

kubectl create secret generic new-secret --from-literal=USERNAME=username --from-literal=PASSWORD='password' --namespace=new-namespace

5. Ejecute el comando kubectl get secrets a continuación para intentar ver todos los secretos.

Notarás a continuación que el secreto recién creado no está en la lista ya que no estás en el espacio de nombres correcto para acceder a él.

6. Finalmente, ejecute el mismo comando kubectl get secrets. Pero esta vez, agregue la etiqueta –namespace junto con el nombre del espacio de nombres (nuevo espacio de nombres).

kubectl get secrets --namespace=new-namespace

Como puede ver a continuación, el secreto recién creado (nuevo secreto) ahora se muestra en la lista ya que se encuentra en el espacio de nombres correcto (nuevo espacio de nombres).

Conclusión

En este tutorial, ha aprendido las mejores prácticas para mantener seguros los secretos mientras trabaja en un entorno de Kubernetes utilizando una imagen de MongoDB como caso de uso. Continuó utilizando Kubernetes para autenticar su registro de Docker y obtener una imagen privada.

Ahora, en cualquier momento, puede limitar el uso de secretos a usuarios específicos que utilizan espacios de nombres. Así que evita preocuparte por tus secretos y mantenlos a salvo.

¿Tiene curiosidad por saber cómo aplicar los conocimientos recién adquiridos? Quizás almacenar sus claves API como secretos en lugar de env archivos?