Almacenamiento de Kubernetes StorageClass

Enterprise 2023-07-02 13:51:15 views: null

clase de almacenamiento

En el artículo anterior, aprendimos a usar PV y PVC, pero los PV anteriores son todos estáticos, ¿qué significa eso? Si quiero usar un PVC, debo crear manualmente un PV. También dijimos que este método no puede satisfacer nuestras necesidades en gran medida. Por ejemplo, tenemos una aplicación que requiere una concurrencia de almacenamiento relativamente alta. Otra aplicación tiene una concurrencia de almacenamiento relativamente alta. requisitos de velocidad de lectura y escritura, especialmente para aplicaciones de tipo StatefulSet, no es apropiado usar simplemente PV estático. En este caso, necesitamos usar PV dinámico, que es lo que queremos hoy. Aprenda StorageClass.

crear

Para usar StorageClass, tenemos que instalar el programa de configuración automática correspondiente. Por ejemplo, si usamos nfs como backend de almacenamiento aquí, entonces necesitamos usar un programa de configuración automática nfs-client, que también llamamos Provisioner. Este programa usa nuestro El servidor nfs ha sido configurado para crear automáticamente volúmenes persistentes, es decir, para crear automáticamente PV para nosotros.

  • El PV creado automáticamente ${namespace}-${pvcName}-${pvName}se crea en el directorio de datos compartidos en el servidor NFS con este formato de nomenclatura
  • Y cuando se recicle el PV, se archieved-${namespace}-${pvcName}-${pvName}almacenará en el servidor NFS en este formato de nomenclatura.

Por supuesto, antes de la implementación nfs-client, primero debemos instalar correctamente el servidor nfs. Ya lo hemos aprobado en el artículo anterior. La dirección del servicio es 10.151.30.57 , y el directorio de datos compartidos es **/data/k8s/**, y luego implementamos nfs -client es suficiente, también podemos consultar directamente la documentación de nfs-client: https://github.com/kubernetes-incubator/external-storage/tree/master/nfs-client, simplemente instálelo .

Paso 1 : configure la implementación, reemplace los parámetros correspondientes dentro con nuestra propia configuración nfs (nfs-client.yaml)

kind: Deployment
apiVersion: apps/v1
metadata:
  name: nfs-client-provisioner
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nfs-client-provisioner
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccountName: nfs-client-provisioner
      containers:
        - name: nfs-client-provisioner
          image: quay.io/external_storage/nfs-client-provisioner:latest
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: fuseim.pri/ifs
            - name: NFS_SERVER
              value: 10.151.30.57
            - name: NFS_PATH
              value: /data/k8s
      volumes:
        - name: nfs-client-root
          nfs:
            server: 10.151.30.57
            path: /data/k8s

Paso 2 : Reemplace las variables de entorno NFS_SERVER y NFS_PATH y, por supuesto, también incluya la configuración de nfs a continuación. Podemos ver que aquí usamos un nfs-client-provisioner, por lo que también necesitamos crear un sa y luego vincularlo. Permisos serviceAccountcorrespondientes : (nfs-cliente-sa.yaml)

apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-client-provisioner

---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: nfs-client-provisioner-runner
rules:
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get", "list", "watch", "create", "delete"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims"]
    verbs: ["get", "list", "watch", "update"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["list", "watch", "create", "update", "patch"]
  - apiGroups: [""]
    resources: ["endpoints"]
    verbs: ["create", "delete", "get", "list", "watch", "patch", "update"]

---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: run-nfs-client-provisioner
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    namespace: default
roleRef:
  kind: ClusterRole
  name: nfs-client-provisioner-runner
  apiGroup: rbac.authorization.k8s.io

Creamos uno nuevo llamado nfs-client-provisioner aquí ServiceAccount, y luego vinculamos un nfs-client-provisioner-runner llamado ClusterRole, que ClusterRoledeclaró algunos permisos, incluidos agregar persistentvolumes, eliminar, modificar, verificar, etc. Permisos, por lo que podemos usar esto ServiceAccountpara crear automáticamente PV.

Paso 3 : después de completar la declaración de implementación de nfs-client, podemos crear un StorageClassobjeto: (nfs-client-class.yaml)

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: course-nfs-storage
provisioner: fuseim.pri/ifs # or choose another name, must match deployment's env PROVISIONER_NAME'

Declaramos un objeto denominado Course-nfs-storage , tenga en cuenta que el valor correspondiente StorageClassa continuación debe ser el mismo que el valor de la variable de entorno PROVISIONER_NAME anterior.provisionerDeployment

Ahora vamos a crear estos objetos de recursos:

$ kubectl create -f nfs-client.yaml
$ kubectl create -f nfs-client-sa.yaml
$ kubectl create -f nfs-client-class.yaml

Una vez completada la creación, verifique el estado del recurso:

$ kubectl get pods
NAME                                             READY     STATUS             RESTARTS   AGE
...
nfs-client-provisioner-7648b664bc-7f9pk          1/1       Running            0          7h
...
$ kubectl get storageclass
NAME                 PROVISIONER      AGE
course-nfs-storage   fuseim.pri/ifs   11s

nueva construcción

StorageClassEl objeto de recurso se creó con éxito arriba . A continuación, probemos el PV dinámico a través de un ejemplo. Primero, cree un objeto de PVC: (test-pvc.yaml)

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: test-pvc
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Mi

Aquí declaramos un objeto PVC, adoptamos el modo de acceso de ReadWriteMany y solicitamos un espacio de 1Mi, pero podemos ver que no hemos identificado ninguna información asociada con StorageClass en el archivo PVC anterior, por lo que si creamos directamente este objeto PVC ahora , podemos enlazar automáticamente al objeto PV apropiado? Obviamente no (siempre que no haya un PV adecuado), aquí tenemos dos métodos para usar el objeto StorageClass que creamos anteriormente para crear automáticamente un PV adecuado para nosotros:

  • El primer método: agregue un identificador para declarar el objeto StorageClass en este objeto de PVC, aquí podemos usar un atributo de anotaciones para identificarlo, de la siguiente manera:
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-pvc
  annotations:
    volume.beta.kubernetes.io/storage-class: "course-nfs-storage"
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Mi
  • El segundo método: podemos configurar StorageClass de este curso-nfs-storage como el backend de almacenamiento predeterminado de Kubernetes, y podemos usar el comando kubectl patch para actualizar:
$ kubectl patch storageclass course-nfs-storage -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'

Los dos métodos anteriores son posibles. Por supuesto, para no afectar el comportamiento predeterminado del sistema, aún usamos el primer método aquí, simplemente créelo directamente:

$ kubectl create -f test-pvc.yaml
persistentvolumeclaim "test-pvc" created
$ kubectl get pvc
NAME         STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS          AGE
...
test-pvc     Bound     pvc-73b5ffd2-8b4b-11e8-b585-525400db4df7   1Mi        RWX            course-nfs-storage    2m
...

Podemos ver que un objeto de PVC llamado test-pvc se ha creado con éxito, y el estado ya es Bound. ¿También se generó un objeto VOLUME correspondiente? La columna más importante es STORAGECLASS. ¿Tiene valor ahora? El objeto StorageClass que acabamos de crear es curso-nfs-almacenamiento.

Luego mira el objeto PV:

$ kubectl get pv
NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM                STORAGECLASS          REASON    AGE
...
pvc-73b5ffd2-8b4b-11e8-b585-525400db4df7   1Mi        RWX            Delete           Bound       default/test-pvc     course-nfs-storage              8m
...

Puede ver si un objeto PV asociado se genera automáticamente, el modo de acceso es RWX y la política de reciclaje es Eliminar. Este objeto PV no lo creamos manualmente, pero se crea automáticamente a través de nuestro objeto StorageClass anterior. Así es como se crea StorageClass.

prueba

A continuación, usemos un ejemplo simple para probar el objeto de PVC que declaramos anteriormente con StorageClass: (test-pod.yaml)

kind: Pod
apiVersion: v1
metadata:
  name: test-pod
spec:
  containers:
  - name: test-pod
    image: busybox
    imagePullPolicy: IfNotPresent
    command:
    - "/bin/sh"
    args:
    - "-c"
    - "touch /mnt/SUCCESS && exit 0 || exit 1"
    volumeMounts:
    - name: nfs-pvc
      mountPath: "/mnt"
  restartPolicy: "Never"
  volumes:
  - name: nfs-pvc
    persistentVolumeClaim:
      claimName: test-pvc

El Pod anterior es muy simple. Utiliza un contenedor busybox para crear un archivo SUCCESS en el directorio /mnt, y luego monta el directorio /mnt en el objeto de recurso test-pvc recién creado arriba. La verificación es muy simple, solo necesita para verificar si hay un archivo SUCCESS en el directorio de datos compartidos en nuestro servidor nfs:

$ kubectl create -f test-pod.yaml
pod "test-pod" created

Luego podemos ver los datos en el directorio de datos compartidos del servidor nfs:

$ ls /data/k8s/
default-test-pvc-pvc-73b5ffd2-8b4b-11e8-b585-525400db4df7

Podemos ver que hay una carpeta con un nombre largo debajo. ¿Es el método de nomenclatura de esta carpeta el mismo que nuestras reglas anteriores: ** espacio de nombres − {espacio de nombres}-nam es p a ce − {pvcName}-${pvName}** es el mismo, y luego verifique si hay otros archivos en esta carpeta:

$ ls /data/k8s/default-test-pvc-pvc-73b5ffd2-8b4b-11e8-b585-525400db4df7
SUCCESS

Vemos que hay un archivo SUCCESS a continuación, ¿prueba que nuestra verificación anterior fue exitosa?

Además, podemos ver que estamos creando manualmente un objeto PVC aquí. En el trabajo real, usar StorageClass es más un tipo de servicio StatefulSet. Para el tipo de servicio StatefulSet, también podemos usar directamente StorageClass a través de un atributo volumeClaimTemplates, de la siguiente manera : ( prueba-statefulset-nfs.yaml)

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: nfs-web
spec:
  serviceName: "nginx"
  replicas: 3
  selector:
    matchLabels:
      app: nfs-web
  template:
    metadata:
      labels:
        app: nfs-web
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
      annotations:
        volume.beta.kubernetes.io/storage-class: course-nfs-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

De hecho, en volumeClaimTemplates hay una plantilla de un objeto de PVC, que es similar a la plantilla de nuestro StatefulSet. En realidad, es una plantilla de un pod. No creamos objetos de PVC por separado, pero usamos esta plantilla para crear objetos dinámicamente. Sí , este método se usa mucho bajo el tipo de servicio StatefulSet.

Cree el objeto anterior directamente:

$ kubectl create -f test-statefulset-nfs.yaml
statefulset.apps "nfs-web" created
$ kubectl get pods
NAME                                             READY     STATUS              RESTARTS   AGE
...
nfs-web-0                                        1/1       Running             0          1m
nfs-web-1                                        1/1       Running             0          1m
nfs-web-2                                        1/1       Running             0          33s
...

Una vez completada la creación, puede ver que los tres pods anteriores se ejecutaron correctamente y luego verifique el objeto de PVC:

$ kubectl get pvc
NAME            STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS          AGE
...
www-nfs-web-0   Bound     pvc-cc36b3ce-8b50-11e8-b585-525400db4df7   1Gi        RWO            course-nfs-storage    2m
www-nfs-web-1   Bound     pvc-d38285f9-8b50-11e8-b585-525400db4df7   1Gi        RWO            course-nfs-storage    2m
www-nfs-web-2   Bound     pvc-e348250b-8b50-11e8-b585-525400db4df7   1Gi        RWO            course-nfs-storage    1m
...

Podemos ver si también se generan 3 objetos PVC. El nombre está compuesto por el nombre de la plantilla y el nombre del Pod. Estos 3 objetos PVC también están vinculados. Obviamente, también podemos verlo cuando verificamos el PV. Los 3 objetos PV correspondientes :

$ kubectl get pv
NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM                   STORAGECLASS          REASON    AGE
...                                                        1d
pvc-cc36b3ce-8b50-11e8-b585-525400db4df7   1Gi        RWO            Delete           Bound       default/www-nfs-web-0   course-nfs-storage              4m
pvc-d38285f9-8b50-11e8-b585-525400db4df7   1Gi        RWO            Delete           Bound       default/www-nfs-web-1   course-nfs-storage              4m
pvc-e348250b-8b50-11e8-b585-525400db4df7   1Gi        RWO            Delete           Bound       default/www-nfs-web-2   course-nfs-storage              4m
...

Ver el directorio de datos compartidos en el servidor nfs:

$ ls /data/k8s/
...
default-www-nfs-web-0-pvc-cc36b3ce-8b50-11e8-b585-525400db4df7
default-www-nfs-web-1-pvc-d38285f9-8b50-11e8-b585-525400db4df7
default-www-nfs-web-2-pvc-e348250b-8b50-11e8-b585-525400db4df7
...

¿También tiene tres directorios de datos correspondientes? Así es como usamos StorageClass. StorageClass se usa principalmente para servicios de tipo StatefulSet. Continuaremos aprendiendo sobre esto en los siguientes artículos.

Supongo que te gusta

Origin blog.csdn.net/u010674953/article/details/129708193
Recomendado
Clasificación
Diario
Más
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)
2024-04-28(9)

Code World

© 2018 codetd.com