Archiviazione in Kubernetes

Su questa pagina

Prerequisiti
Cosa faremo?
Crea un pod con un volume di diversi tipi montato al suo interno
1. Volume percorso host con tipo: Directory
2. Volume percorso host con tipo: DirectoryOrCreate
3. vuoto volume Dir
I dati non possono essere archiviati nel pod, quando il pod viene eliminato o terminato i dati al suo interno non rimangono nel sistema. Per fornire archiviazione a lungo termine e temporanea ai pod nel cluster, Kubernetes fornisce diversi tipi di meccanismi di archiviazione.
In questo articolo vedremo esempi di soli 2 tipi di meccanismi di archiviazione.
1. hostPath:
  un volume hostPath monta un file o una directory dal file system dei nodi host nel tuo pod. Questo tipo di volume può essere utilizzato per consentire a un pod di specificare se un determinato hostPath deve esistere prima dell'esecuzione del pod o se deve essere creato. Questo tipo di volume non è qualcosa di cui avrà bisogno la maggior parte dei pod. Il tipo DirectoryOrCreate creerà una directory vuota se non esiste con l'autorizzazione impostata su 0755 e il tipo di directory consente di assicurarsi che esista una directory nel percorso specificato prima che il pod venga creato.
2. emptyDir:
  un volume emptyDir viene creato per la prima volta quando un pod viene assegnato a un nodo ed esiste finché quel pod è in esecuzione su quel nodo. Per impostazione predefinita, i volumi emptyDir vengono archiviati sul tipo di spazio di archiviazione del nostro ambiente. Possiamo anche impostare il campo emptyDir.medium su Memoria per indicare a Kubernetes di montare un file system supportato da RAM
Per conoscere altri meccanismi di archiviazione in Kubernetes, fai clic qui.
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 18.04 EC2.
Che cosa faremo?
1. Crea un pod con un volume di diversi tipi montato al suo interno
Crea un pod con un volume di diversi tipi montato al suo interno
Volume percorso host con tipo: Directory
Crea un file di definizione dell'oggetto per montare una directory esistente nel pod.
```
vim volume-hostpath-1.yml
```
```
apiVersion: v1
kind: Pod
metadata:
  name: volume-hostpath-example-1
spec:
  containers:
  - image: nginx
    name: my-container
    volumeMounts:
    - mountPath: /opt/mounted-here
      name: my-volume-1
  volumes:
  - name: my-volume-1
    hostPath:
      path: /dir
      type: Directory
```
Ottieni un elenco di pod e crea un pod che monterà \/opt/monted-here\ all'interno del pod su \/dir\ dall'host.
```
kubectl  get pods
```
```
kubectl  create -f volume-hostpath-1.yml
```
```
kubectl  get pods
```
```
kubectl  describe pod volume-hostpath-example-1
```
Ora, se descrivi il pod, vedrai che la creazione del pod non è riuscita. Il montaggio non è riuscito perché la directory \/dir\ non esiste sull'host. Per montare un volume nel pod con \tipo: Directory\, la directory host deve esistere.
Ora creiamo una directory \/dir\ sull'host, ad esempio sul nodo di lavoro.
```
sudo mkdir /dir
```
Dopo aver creato una directory sui nodi di lavoro, possiamo eliminare il pod precedentemente creato e provare a ricreare un nuovo pod.
```
kubectl  delete -f volume-hostpath-1.yml
```
```
kubectl  create -f volume-hostpath-1.yml
```
```
kubectl  get pods
```
```
kubectl  describe pod volume-hostpath-example-1
```
Questa volta puoi vedere che il pod è stato creato correttamente e sotto i volumi è possibile vedere il percorso \/dir\ montato.
Ora accedi al pod e crea un file
```
kubectl  get pods
```
```
kubectl  exec -it volume-hostpath-example-1  /bin/bash
```
```
touch /opt/mounted-here/new-file
```
Il file che abbiamo creato nel pod ora può essere visto dal nodo di lavoro nella directory montata \/dir\
```
ll /dir/ #Execute this command on the worker node
```
Questa volta eliminiamo il pod che abbiamo creato e vediamo se il file esiste ancora nella directory host \/dir\ oppure no.
```
exit
```
```
kubectl  get pods
```
```
kubectl delete pod volume-hostpath-example-1
```
Elenca i file in \/dir\ sul nodo di lavoro.
```
ll /dir/ #Execute this command on the worker node
```
Possiamo vedere che anche dopo aver eliminato il pod, il file esiste ancora in \/dir\ sul nodo di lavoro. Ciò significa che i dati persistono anche dopo che il pod è stato eliminato o terminato.
In questo esempio, abbiamo osservato che la directory host che deve essere montata all'interno della porta deve esistere.
Volume percorso host con tipo: DirectoryOrCreate
Per assicurarci che una directory host sia disponibile prima del montaggio, possiamo utilizzare \type: DirectoryOrCreate\ invece di \type: Directory\ nel volume hostpath.
Crea un nuovo file con il tipo \tipo: DirectoryOrCreate\.
```
vim volume-hostpath-2.yml
```
```
apiVersion: v1
kind: Pod
metadata:
  name: volume-hostpath-example-2
spec:
  containers:
  - image: nginx
    name: my-container
    volumeMounts:
    - mountPath: /opt/mounted-here
      name: my-volume-2
  volumes:
  - name: my-volume-2
    hostPath:
      # directory location on host
      path: /mount-this
      type: DirectoryOrCreate
```
Ottieni un elenco di pod esistenti e crea un nuovo pod con il file creato nello stato precedente.
```
kubectl  get pods
```
```
kubectl create -f volume-hostpath-2.yml
```
```
kubectl  get pods
```
```
kubectl  describe pod volume-hostpath-example-2
```
Quando descriviamo il pod, si può vedere che il pod è stato creato correttamente. E la directory \/mount-this\ che non esiste sull'host/nodo di lavoro è stata creata sull'host durante il montaggio nel volume.
Vai ai nodi di lavoro e verifica se la directory è stata creata o meno
```
ll /mount-this/ #Execute this command on the worker node
```
Ora crea un nuovo file sui nodi di lavoro nella directory \/mount-this\ che è montato nel pod.
```
sudo touch /mount-this/created-on-host #Execute this command on the worker node
```
Accediamo al pod e controlliamo la directory \/opt/mount-here/\ per vedere se il file \/mount-this/created-on-host\ che abbiamo creato nel nodo di lavoro esiste nel pod.
```
kubectl  get pods
```
```
kubectl  exec -it volume-hostpath-example-2 /bin/bash
```
```
ls -l /opt/mounted-here/
```
Ora elimina il pod e verifica se il file esiste ancora nel nodo di lavoro in \/mount-this/\
```
exit
```
```
kubectl  get pods
```
```
kubectl delete pod volume-hostpath-example-2
```
Esegui il seguente comando per elencare il file sul nodo di lavoro in \/mount-this/\
```
sudo ls -lt /mount-this/ #Execute this command on the worker node
```
In questo esempio, abbiamo visto che anche se la directory host non esiste, viene creata sulla macchina host prima di essere montata nel pod.
volume vuotoDir
Crea un file di definizione dell'oggetto utilizzando quanto segue.
```
vim volume-emptydir.yml
```
```
apiVersion: v1
kind: Pod
metadata:
  name: volume-emptydir-example
spec:
  containers:
  - image: nginx
    name: my-container
    volumeMounts:
    - mountPath: /opt/this
      name: my-volume-3
  volumes:
  - name: my-volume-3
    emptyDir: {}
```
Ottieni un elenco di pod e crea un nuovo pod per montare un volume con il tipo \Dirvuoto\
```
kubectl  get pods
```
```
kubectl  create -f volume-emptydir.yml #Create an object using the file
```
```
kubectl  get pods
```
```
kubectl  describe pod volume-emptydir-example #Get details  of the specified pod
```
Nello screenshot sopra, puoi vedere che il pod è stato creato e il volume è disponibile.
Ora accedi al pod e crea una directory nel percorso di montaggio \/opt/this\. Questa volta non abbiamo alcun volume dall'host.
```
kubectl exec -it volume-emptydir-example /bin/bash #Login into the Pod
```
Ora possiamo eliminare il pod se non è più necessario.
```
kubectl get pods #Get a list of Pods
```
```
kubectl  delete pod volume-emptydir-example #Delete the specified pod
```
Conclusione
In questo articolo, abbiamo visto i passaggi e i file di esempio per creare pod con un volume di tipo hostPath e emptyDir. Abbiamo visto come \type:DirectoryOrCreate\ nel tipo di volume hostPath può aiutarci a montare una directory che non esiste sul nodo di lavoro/host.

Archiviazione in Kubernetes

Su questa pagina

Prerequisiti

Che cosa faremo?

Crea un pod con un volume di diversi tipi montato al suo interno

Volume percorso host con tipo: Directory

Volume percorso host con tipo: DirectoryOrCreate

volume vuotoDir

Conclusione