Segreti di Kubernetes:come creare, utilizzare e accedere ai segreti

Introduzione

La maggior parte delle applicazioni distribuite tramite Kubernetes richiede l'accesso a database, servizi e altre risorse ubicate esternamente. Il modo più semplice per gestire le informazioni di accesso necessarie per accedere a tali risorse è utilizzare i segreti di Kubernetes. I segreti aiutano a organizzare e distribuire informazioni sensibili in un cluster.

In questo tutorial imparerai cosa sono i segreti di Kubernetes e come crearli e usarli nel tuo cluster.

Prerequisiti

• Un cluster Kubernetes (a scopo di test, puoi crearlo con minikube)
• Lo strumento da riga di comando Kubernetes kubectl

Quali sono i segreti di Kubernetes?

Un segreto Kubernetes è un oggetto che memorizza dati sensibili come nomi utente, password, token e chiavi. I segreti vengono creati dal sistema durante l'installazione di un'app o dagli utenti ogni volta che devono archiviare informazioni riservate e renderle disponibili a un pod.

Se password, token o chiavi facevano semplicemente parte di una definizione di pod o di un'immagine del contenitore, potrebbero essere esposti accidentalmente durante le operazioni di Kubernetes. Pertanto, la funzione più importante del segreto è prevenire l'esposizione accidentale delle informazioni in esso memorizzate e allo stesso tempo renderle disponibili ovunque l'utente ne abbia bisogno.

Tipi segreti di Kubernetes

Kubernetes presenta due categorie di segreti:

• Gli account di servizio del sistema creano automaticamente segreti integrati e associarli ai contenitori insieme alle credenziali API.
• Puoi anche creare segreti personalizzati per le credenziali devi metterle a disposizione dei pod.

I segreti integrati sono disponibili in diversi tipi, corrispondenti agli scenari di utilizzo più diffusi:

Tipo integrato	Descrizione
Opaque	Questo è il tipo predefinito di segreto. I segreti il ​​cui file di configurazione non contiene l'istruzione di tipo sono tutti considerati di questo tipo. I segreti opachi sono progettati per memorizzare dati utente arbitrari.
kubernetes.io/service-account-token	I segreti dei token dell'account di servizio archiviano i token che identificano gli account di servizio. Al momento della creazione di un pod, Kubernetes crea automaticamente questo segreto e lo associa al pod, consentendo l'accesso sicuro all'API. Questo comportamento può essere disabilitato.
kubernetes.io/dockercfg	L'accesso a un registro Docker per le immagini richiede credenziali Docker valide. Questo tipo di segreto viene utilizzato per archiviare un ~/.dockercfg serializzato formato legacy per la configurazione della riga di comando Docker. Contiene il .dockercfg con codifica base64 chiave.
kubernetes.io/dockerconfigjson	Questo tipo di segreto presenta un .dockerconfigjson key, che è una versione con codifica base64 del ~/.docker/config.json file, una nuova versione del deprecato .dockercfg .
kubernetes.io/basic-auth	Il segreto per la memorizzazione dei dati di autenticazione di base. Deve contenere due chiavi:username e password .
kubernetes.io/ssh-auth	Per archiviare i dati necessari per stabilire una connessione SSH, utilizzare ssh-auth genere. Il campo dati di questo tipo deve contenere una ssh-privatekey coppia chiave-valore.
kubernetes.io/tls	Questo tipo viene utilizzato per archiviare certificati e chiavi TLS. Lo scenario di utilizzo più comune è la cessazione della risorsa Ingress, ma il tls type viene talvolta utilizzato anche con altre risorse.
bootstrap.kubernetes.io/token	I token utilizzati durante il processo di bootstrap del nodo vengono archiviati utilizzando il tipo di token segreto. Questo tipo viene solitamente creato nel kube-system spazio dei nomi.

Per definire un tipo personalizzato di segreto, assegna una stringa non vuota come valore nel type campo del file segreto. Lasciare il campo vuoto indica a Kubernetes di assumere Opaque genere. Il tipo personalizzato libera il segreto dai vincoli posti dai tipi incorporati.

Utilizzo dei segreti di Kubernetes

Quando crei un segreto, deve essere referenziato dal pod che lo utilizzerà. Per rendere disponibile un segreto per un pod:

1. Monta il segreto come file in un volume disponibile per un numero qualsiasi di contenitori in un pod.

2. Importa il segreto come variabile di ambiente in un contenitore.

3. Usa kubelet e imagePullSecrets campo.

Le sezioni seguenti spiegano come creare segreti Kubernetes, nonché come decodificarli e accedervi.

Crea i segreti di Kubernetes

Per creare un segreto Kubernetes, applica uno dei seguenti metodi:

• Usa kubectl per un approccio basato sulla riga di comando.
• Crea un file di configurazione per il segreto.
• Utilizza un generatore, come Kustomize per generare il segreto.

Crea segreti usando kubectl

1. Per iniziare a creare un segreto con kubectl , crea prima i file in cui archiviare le informazioni sensibili:

echo -n '[username]' > [file1]
echo -n '[password]' > [file2]

Il -n l'opzione dice echo non aggiungere una nuova riga alla fine della stringa. Anche la nuova riga viene trattata come un carattere, quindi verrebbe codificata insieme al resto dei caratteri, producendo un valore codificato diverso.

2. Ora usa kubectl per creare un segreto utilizzando i file del passaggio precedente. Utilizza il sottocomando generico per creare un Opaque segreto. Inoltre, aggiungi il --from-file opzione per ciascuno dei file che desideri includere:

kubectl create secret generic [secret-name] \  
--from-file=[file1] \
--from-file=[file2]

L'output conferma la creazione del segreto:

3. Per fornire le chiavi per i valori archiviati nel segreto, utilizzare la seguente sintassi:

kubectl create secret generic [secret-name] \  
--from-file=[key1]=[file1] \  
--from-file=[key2]=[file2]

4. Verifica che il segreto sia stato creato correttamente digitando:

kubectl get secrets

Il comando mostra l'elenco dei segreti disponibili:nomi, tipi, numero di valori di dati che contengono e la loro età:

Crea segreti in un file di configurazione

1. Per creare un segreto specificando le informazioni necessarie in un file di configurazione, inizia codificando i valori che desideri memorizzare:

echo -n '[value1]' | base64
echo -n '[value2]' | base64

2. Ora crea un file yaml usando un editor di testo. Il file dovrebbe assomigliare a questo:

apiVersion: v1
kind: Secret
metadata:  
  name: newsecret
type: Opaque
data:
  username: dXNlcg==
  password: NTRmNDFkMTJlOGZh

3. Salva il file e usa kubectl apply comando per creare il segreto:

kubectl apply -f [file]

Crea Kubernetes Secret con i generatori

Generatori come Kustomize aiutano a generare rapidamente segreti.

1. Per creare un segreto con Kustomize, crea un file denominato kustomization.yaml e formattalo come segue:

secretGenerator:
- name: db-credentials 
  files:
  - username.txt
  - password.txt

L'esempio sopra indica db-credentials come nome del segreto e utilizza due file precedentemente creati, username.txt e password.txt , come valori di dati.

2. In alternativa, per fornire la versione letterale non crittografata dei valori dei dati, includi i literals sezione con le coppie chiave-valore che desideri memorizzare:

secretGenerator:
- name: db-credentials
  literals:
  - username=user
  - password=54f41d12e8fa

3. Salva il file e usa il comando seguente nella cartella in cui kustomization.yaml si trova:

kubectl apply -k .

L'output conferma la creazione del segreto:

Usa kubectl describe per vedere i segreti creati

Il kubectl describe comando mostra le informazioni di base sugli oggetti Kubernetes. Usalo per visualizzare la descrizione di un segreto.

kubectl describe secrets/[secret]

Il primo esempio mostra il segreto creato fornendo file come valori di dati:

Il secondo esempio descrive il segreto creato usando stringhe letterali. Nota la modifica nei Data sezione, che ora mostra i nomi delle chiavi invece dei nomi dei file:

Decodifica i segreti

1. Per decodificare i valori in segreto, accedervi digitando il seguente comando:

kubectl get secret [secret] -o jsonpath='{.data}'

L'output mostra le coppie chiave-valore codificate archiviate nella sezione dati:

2. Usa il comando echo per digitare la stringa codificata e reindirizza l'output a base64 comando:

echo '[encoded-value]' | base64 --decode

Le stringhe decodificate appaiono come output:

Segreti di accesso caricati in un volume

1. Per accedere ai segreti montati su un pod in un volume separato, modificare la definizione del pod per includere un nuovo volume. Scegli il nome del volume che desideri, ma assicurati che corrisponda al nome dell'oggetto segreto.

2. Assicurati di specificare readOnly come vero. Ad esempio, la definizione del pod potrebbe essere simile a questa:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  spec:
    containers:
      - name: test-pod
        image: redis
        volumeMounts:
        - name: newsecret
          mountPath: “/etc/newsecret”
          readOnly: true
    volumes:
    - name: newsecret
      secret:
        secretName: newsecret

2. Apri un'altra istanza di terminale e usa kubectl exec comando per accedere alla shell bash del pod:

kubectl exec -it [pod] -- /bin/bash

3. cd in /etc/newsecret e trova i file contenuti nel segreto:

cd /etc/newsecret

Proietta i segreti in un container utilizzando le variabili d'ambiente

1. Un altro modo per accedere ai segreti in un pod Kubernetes consiste nell'importarli come variabili di ambiente modificando la definizione del pod per includere riferimenti ad essi. Ad esempio:

apiVersion: v1 
kind: Pod 
metadata: 
  name: secret-env-pod 
spec: 
  containers: 
  - name: secret-env-pod
    image: redis 
    env: 
      - name: SECRET_USERNAME 
        valueFrom: 
          secretKeyRef: 
            name: newsecret 
            key: username 
      - name: SECRET_PASSWORD 
        valueFrom: 
          secretKeyRef: 
            name: newsecret 
            key: password 
  restartPolicy: Never

2. Usa kubectl exec di nuovo per colpire un pod.

3. Testare la variabile d'ambiente utilizzando echo comando:

echo $[VARIABLE]

L'output del comando mostra il valore mappato sulla variabile:

Utilizza i segreti per estrarre le immagini Docker dai registri Docker privati

1. Per utilizzare i registri Docker privati, devi prima accedere a Docker:

docker login

2. Quando richiesto, fornisci le tue credenziali di accesso:

3. Se l'accesso ha esito positivo, Docker aggiorna il config.json file con i tuoi dati. Usa il comando cat per visualizzare il file:

cat ~/.docker/config.json

Le auths contiene l'auth key, che è una versione codificata delle credenziali Docker.

4. Usa kubectl per creare un segreto, fornendo la posizione di config.json file e il tipo di segreto:

kubectl create secret generic [secret] \
--from-file=.dockerconfigjson=./.docker/config.json \
--type=kubernetes.io/dockerconfigjson

In alternativa, esegui tutti i passaggi precedenti, incluso l'accesso a Docker, sulla stessa riga:

kubectl create secret docker-registry [secret] --docker-server:[address] --docker-username=[username] --docker-password=[password] --docker-email=[email]

5. Per creare un pod che abbia accesso a questo segreto, crea un yaml file che lo definisce. Il file dovrebbe assomigliare a questo:

apiVersion: v1
kind: Pod
metadata:
  name: private-reg
spec: 
  containers:
  - name: private-reg-container
    image:   
  imagePullSecrets:  
  - name: regcred

6. Completa la creazione del pod attivandolo con kubectl apply :

kubectl apply -f [file]

Considerazioni sui segreti di Kubernetes

I segreti di Kubernetes sono un modo sicuro per archiviare informazioni sensibili. Tuttavia, prima di decidere il metodo migliore per il tuo scenario di utilizzo, dovresti considerare i seguenti punti:

• I nomi utente e le password in Secrets sono codificati con base-64. Questa tecnica di codifica del testo oscura i dati e previene l'esposizione accidentale, ma non è sicura contro gli attacchi informatici dannosi.
• I segreti sono disponibili solo nel cluster in cui si trovano.
• I segreti di solito si basano su una chiave principale che viene utilizzata per sbloccarli tutti. Sebbene esistano metodi per proteggere la chiave master, il loro utilizzo crea solo un altro scenario di chiave master.

Per mitigare questi problemi, applica alcune delle soluzioni seguenti:

• Integra uno strumento di gestione dei segreti che utilizza l'account del servizio Kubernetes per autenticare gli utenti che devono accedere al deposito segreto.
• Integra uno strumento IAM (Identity and Access Management) per consentire al sistema di utilizzare i token di un Secure Token Service.
• Integra un gestore di segreti di terze parti nei pod.