Crea e archivia segreti come password, token OAuth e chiavi SSH in Kubernetes

In Kubernetes, possiamo archiviare e gestire informazioni sensibili, come password, token OAuth e chiavi ssh utilizzando Kubernetes Secrets. In Kubernetes, i segreti possono essere definiti come oggetti Kubernetes. È più sicuro archiviare le credenziali in Kubernetes Secrets che nei Pod o nelle Docker Images.

Ci sono diversi modi per generare segreti in Kubernetes:

1. Creazione da un file di testo
2. Creazione da un file yml

Una volta che i segreti sono disponibili, possono essere utilizzati nei seguenti modi:

1. Variabile d'ambiente
2. Volume
3. Utilizzo del campo imagePullSecrets

Per saperne di più su Kubernetes Secrets, fai clic qui.

In questo articolo creeremo segreti utilizzando il file .yml e accederemo ad essi nel Pod come variabili d'ambiente.

Prerequisiti

1. Cluster Kubernetes con almeno 1 nodo di lavoro.
   Se vuoi imparare a creare un Cluster Kubernetes, fai clic qui. Questa guida ti aiuterà a creare un cluster Kubernetes con 1 master e 2 nodi su istanze AWS Ubuntu 18l04 EC2.

Cosa faremo

1. Crea segreti

Crea segreti

Per creare nuovi segreti in Kubernetes, prima crittografali come mostrato di seguito usando il metodo di codifica base64.

Qui,

nomeutente=rahul e password=howtoforge123.

echo -n "rahul" | base64

echo -n "howtoforge123" | base64

Nello screenshot sopra, si può vedere che le credenziali sono state crittografate.

Crea un file di definizione del segreto come segue, questo file contiene il valore base64 delle credenziali generate nel passaggio precedente.

vim mio-segreto.yml

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  username: cmFodWw=
  password: aG93dG9mb3JnZTEyMw==

Ora creiamo un pod in cui è possibile accedere a questi segreti.

Crea un nuovo file che conterrà la definizione del pod come segue.

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

Creiamo i segreti usando il seguente comando.

kubectl create -f my-secret.yml

kubectl diventa segreto | grep mysecret

Ora, crea un pod utilizzando la seguente definizione di pod per accedere ai segreti precedentemente creati.

kubectl create -f mio-pod.yml

kubectl get pods | grep secrets-in-pod

Accedi al pod usando il comando seguente.

kubectl ottenere pod | grep secrets-in-pod

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

Una volta effettuato l'accesso al pod, è possibile accedere ai segreti come variabile d'ambiente utilizzando il comando seguente.

echo $SECRET_USERNAME

eco $PASSWORD_SEGRETA

Nello screenshot sopra, puoi vedere che i segreti sono disponibili come variabili d'ambiente.

Per vedere i dettagli dell'oggetto segreto, esegui il comando seguente.

kubectl diventa segreto | grep mysecret

kubectl get secret mysecret -o yaml

Questi secret possono anche essere decodificati dalla riga di comando usando i seguenti comandi.

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

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

Nello screenshot sopra, si può vedere che le credenziali vengono estratte dai Segreti e decifrate sulla riga di comando utilizzando base64.

Conclusione

In questo articolo, abbiamo visto i passaggi per creare e archiviare i segreti in Kubernetes da un file .yml. Abbiamo provato ad accedere a questi segreti in Pod come variabili di ambiente. Abbiamo anche visto il comando per decrittografare i segreti sulla riga di comando.