Skip to main content
Se proporciona el idioma español mediante traducción automática para su comodidad. En caso de alguna inconsistencia, el inglés precede al español.

Importar volúmenes

Colaboradores netapp-aruldeepa juliantap joan-ing netapp-shwetav netapp-mwallis
PDF

Puedes importar volúmenes de almacenamiento existentes como un PV de Kubernetes usando tridentctl import o creando una Persistent Volume Claim (PVC) con anotaciones de importación de Trident.

Descripción general y consideraciones

Es posible importar un volumen en Trident para lo siguiente:

  • Agrupe en contenedores una aplicación y vuelva a utilizar su conjunto de datos existente

  • Utilice el clon de un conjunto de datos para una aplicación efímera

  • Reconstruya un clúster de Kubernetes que haya fallado

  • Migración de datos de aplicaciones durante la recuperación ante desastres

Consideraciones

Antes de importar un volumen, revise las siguientes consideraciones.

  • Trident solo puede importar volúmenes ONTAP de tipo RW (lectura y escritura). Los volúmenes del tipo DP (protección de datos) son volúmenes de destino de SnapMirror. Debe romper la relación de reflejo antes de importar el volumen a Trident.

  • Sugerimos importar volúmenes sin conexiones activas. Para importar un volumen que se usa activamente, clone el volumen y, a continuación, realice la importación.

    Advertencia Esto es especialmente importante en el caso de volúmenes de bloque, ya que Kubernetes no sabía que la conexión anterior y podría conectar fácilmente un volumen activo a un pod. Esto puede provocar daños en los datos.

  • Aunque StorageClass debe especificarse en una RVP, Trident no utiliza este parámetro durante la importación. Durante la creación de volúmenes, se usan las clases de almacenamiento para seleccionar entre los pools disponibles según las características de almacenamiento. Como el volumen ya existe, no se requiere ninguna selección de pool durante la importación. Por lo tanto, la importación no fallará incluso si el volumen existe en un back-end o pool que no coincide con la clase de almacenamiento especificada en la RVP.

  • El tamaño del volumen existente se determina y se establece en la RVP. Una vez que el controlador de almacenamiento importa el volumen, se crea el PV con un ClaimRef al PVC.

    • La política de reclamaciones se establece inicialmente en retain En el PV. Una vez que Kubernetes enlaza correctamente la RVP y el VP, se actualiza la política de reclamaciones para que coincida con la política de reclamaciones de la clase de almacenamiento.

    • Si la política de recuperación de la Storage Class es delete, Trident elimina el volumen de almacenamiento cuando se elimina el PV.

  • De forma predeterminada, Trident gestiona el PVC y cambia el nombre del volumen FlexVol y del LUN o qtree en el backend. Puedes pasar la --no-manage flag para importar un volumen no gestionado y la --no-rename flag para conservar el nombre del volumen.

    • --no-manage* - Si utiliza el --no-manage Trident no realiza ninguna operación adicional en el PVC o PV durante el ciclo de vida de los objetos. El volumen de almacenamiento no se elimina cuando se elimina el PV y otras operaciones como la clonación y el cambio de tamaño del volumen también se ignoran.

    • --no-rename* - Si usas la --no-rename flag, Trident conserva el nombre del volumen existente al importar volúmenes y gestiona el ciclo de vida de los volúmenes. Esta opción solo es compatible con los controladores ontap-nas, ontap-san (incluidos los sistemas ASA r2), ontap-san-economy y ontap-nas-economy (importación de qtree).

      Consejo Estas opciones son útiles si desea utilizar Kubernetes para cargas de trabajo en contenedores, pero por lo demás desea administrar el ciclo de vida del volumen de almacenamiento fuera de Kubernetes.

  • Se agrega una anotación a la RVP y al VP que tiene el doble propósito de indicar que el volumen se importó y si se administran la PVC y la VP. Esta anotación no debe modificarse ni eliminarse.

Importe un volumen

Puedes importar un volumen usando tridentctl import o creando un PVC con anotaciones de importación de Trident.

Nota Si usas anotaciones de PVC, no necesitas descargar ni usar tridentctl para importar el volumen.
Usando tridentctl
Pasos

  1. Crea un archivo PVC (por ejemplo, pvc.yaml) que se usará para crear el PVC. El archivo PVC debe incluir name, namespace, accessModes y storageClassName. Opcionalmente, puedes especificar unixPermissions en tu definición de PVC.

    A continuación se muestra un ejemplo de una especificación mínima:

    kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: my_claim
  namespace: my_namespace
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: my_storage_class
    Nota Incluye solo los parámetros necesarios. Parámetros adicionales como el nombre de PV o el tamaño del volumen pueden hacer que falle el comando de import.

  2. Utilice el tridentctl import comando para especificar el nombre del backend de Trident que contiene el volumen y el nombre que identifica de forma única el volumen en el almacenamiento (por ejemplo: ONTAP FlexVol, Element Volume). El -f Se requiere un argumento para especificar la ruta al archivo PVC.

    tridentctl import volume <backendName> <volumeName> -f <path-to-pvc-file>
Uso de anotaciones de PVC
Pasos

  1. Crea un archivo PVC YAML (por ejemplo, pvc.yaml) con las anotaciones de importación de Trident necesarias. El archivo PVC debe incluir:

    • name y namespace en metadatos

    • accessModes, resources.requests.storage y storageClassName en spec

    • Anotaciones:

      • trident.netapp.io/importOriginalName: nombre del volumen en el backend

      • trident.netapp.io/importBackendUUID: UUID del backend donde existe el volumen

      • trident.netapp.io/notManaged (Opcional): configúralo en "true" para volúmenes no gestionados. El valor predeterminado es "false".

        El siguiente es un ejemplo de especificación para importar un volumen gestionado:

    kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: <pvc-name>
  namespace: <namespace>
  annotations:
    trident.netapp.io/importOriginalName: "<volume-name>"
    trident.netapp.io/importBackendUUID: "<backend-uuid>"
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: <size>
  storageClassName: <storage-class-name>

  2. Aplica el archivo YAML de PVC a tu clúster de Kubernetes:

    kubectl apply -f <pvc-file>.yaml

    Trident importará automáticamente el volumen y lo vinculará al PVC.

Ejemplos

Revise los siguientes ejemplos de importación de volúmenes para los controladores compatibles.

NAS de ONTAP y NAS FlexGroup de ONTAP

Trident admite la importación de volúmenes mediante ontap-nas los controladores y. ontap-nas-flexgroup

Nota

  • El ontap-nas-economy driver gestiona el almacenamiento a nivel de qtree, así que no admite importar un volumen FlexVol por sí solo. Para importar qtrees con el ontap-nas-economy driver, consulta Importar qtrees (Tech Preview). Cuando Trident importa un qtree, también importa el FlexVol principal como un bucket que contiene el qtree.

  • La ontap-nas y.. ontap-nas-flexgroup las controladoras no permiten nombres de volúmenes duplicados.

Cada volumen creado con el ontap-nas controlador es un FlexVol volume en el clúster de ONTAP. Al importar los volúmenes de FlexVol con ontap-nas el controlador, funciona igual. Los volúmenes de FlexVol que ya existen en un clúster de ONTAP pueden importarse como ontap-nas una RVP. Del mismo modo, los volúmenes de FlexGroup se pueden importar como ontap-nas-flexgroup RVP.

Ejemplos de ONTAP NAS usando tridentctl

Los siguientes ejemplos muestran cómo importar volúmenes gestionados y no gestionados usando tridentctl.

Volumen gestionado

En el ejemplo siguiente se importa un volumen llamado managed_volume en un backend llamado ontap_nas:

tridentctl import volume ontap_nas managed_volume -f <path-to-pvc-file>

+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE   | STORAGE CLASS | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
| pvc-bf5ad463-afbb-11e9-8d9f-5254004dfdb7 | 1.0 GiB | standard      | file     | c5a6f6a4-b052-423b-80d4-8fb491a14a22 | online | true    |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
Volumen no gestionado

Cuando se utiliza --no-manage el argumento, Trident no cambia el nombre del volumen.

El siguiente ejemplo importa unmanaged_volume en la ontap_nas backend:

tridentctl import volume nas_blog unmanaged_volume -f <path-to-pvc-file> --no-manage

+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE   | STORAGE CLASS | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
| pvc-df07d542-afbc-11e9-8d9f-5254004dfdb7 | 1.0 GiB | standard      | file     | c5a6f6a4-b052-423b-80d4-8fb491a14a22 | online | false   |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
Ejemplos de ONTAP NAS usando anotaciones de PVC

Los siguientes ejemplos muestran cómo importar volúmenes gestionados y no gestionados usando anotaciones de PVC.

Volumen gestionado

El siguiente ejemplo importa un volumen de 1GiB ontap-nas llamado ontap_volume1 desde backend 81abcb27-ea63-49bb-b606-0a5315ac5f21 con el modo de acceso RWO establecido usando anotaciones PVC:

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: <managed-imported-volume>
  namespace: <namespace>
  annotations:
    trident.netapp.io/importOriginalName: "ontap_volume1"
    trident.netapp.io/importBackendUUID: "81abcb27-ea63-49bb-b606-0a5315ac5f21"
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
  storageClassName: <storage-class-name>
Volumen no gestionado

El siguiente ejemplo importa 1Gi ontap-nas volumen llamado ontap-volume2 desde backend 34abcb27-ea63-49bb-b606-0a5315ac5f34 con el modo de acceso RWO configurado usando anotaciones PVC:

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: <umanaged-imported-volume>
  namespace: <namespace>
  annotations:
    trident.netapp.io/importOriginalName: "ontap-volume2"
    trident.netapp.io/importBackendUUID: "34abcb27-ea63-49bb-b606-0a5315ac5f34"
    trident.netapp.io/notManaged: "true"
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
  storageClassName: <storage-class-name>

Importar qtrees

Nota

La importación de qtree es una función en fase de Tech Preview de Trident 26.06. Las funciones en fase de Tech Preview no son compatibles para uso en producción.

A partir de Trident 26.06, es posible importar qtrees de ONTAP ya existentes a Trident usando el controlador ontap-nas-economy. Identifica el qtree por su volumen FlexVol y los nombres del qtree en formato flexvol/qtree, junto con el UUID del backend que lo contiene. Las consideraciones generales sobre la importación en Descripción general y consideraciones también se aplican a la importación de qtrees.

Importar un qtree usando tridentctl

Especifica el qtree en formato flexvol/qtree como nombre del volumen. El siguiente ejemplo importa el qtree qtree1 desde el volumen FlexVol flexvol1 en el backend ontap_nas_economy:

tridentctl import volume ontap_nas_economy flexvol1/qtree1 -f <path-to-pvc-file>

Para importar el qtree sin cambiarle el nombre, añade el --no-rename flag. Para importar el qtree sin que Trident gestione su ciclo de vida, añade el --no-manage flag.

Importar un qtree usando anotaciones PVC

Crea un PVC con las siguientes anotaciones:

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: <pvc-name>
  namespace: <namespace>
  annotations:
    trident.netapp.io/importOriginalName: "flexvol1/qtree1"
    trident.netapp.io/importBackendUUID: "<backend-uuid>"
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: <size>
  storageClassName: <storage-class-name>

Para conservar los nombres existentes del volumen FlexVol y del qtree, añade la anotación trident.netapp.io/importNoRename: "true". Para importar el qtree como no gestionado, añade la anotación trident.netapp.io/notManaged: "true".

Nomenclatura y comportamiento de gestión
Importación gestionada (predeterminada)

Trident cambia el nombre del qtree para que coincida con el nombre del PVC y renombra el volumen FlexVol según la ontap-nas-economy convención de nomenclatura. La ruta de unión no cambia.

--no-rename

Trident conserva los nombres actuales de los volúmenes FlexVol y de las qtree. Los nombres ya deben seguir las convenciones de nomenclatura de Trident, o Trident no podrá gestionar las operaciones de eliminación o montaje de la qtree.

--no-manage

Trident hace referencia al qtree, pero no gestiona su ciclo de vida. Los nombres deben seguir las convenciones de nomenclatura de Trident, y Trident no utiliza ni gestiona políticas de exportación automática para el qtree.

Comportamiento de la política de exportación

Si el backend utiliza políticas de exportación automática, el qtree importado utiliza el modelo de políticas de exportación por qtree, en el que cada qtree tiene su propia política de exportación. Trident asigna al qtree una política de exportación vacía en el momento de la importación. En el momento de la publicación, Trident actualiza el volumen FlexVol con la política de exportación específica de cada backend si la exportación automática está habilitada y la política de exportación existente FlexVol es default o está vacía.

Precaución

Actualizar la política de exportación del volumen FlexVol puede interrumpir otros qtrees en el mismo volumen FlexVol que estén montados actualmente. Importa los qtrees solo cuando los qtrees en el volumen FlexVol estén desmontados.
Advertencia

No apuntes dos clústeres de Kubernetes al mismo SVM activo, y no importes un qtree que otro clúster siga gestionando. Si ambos clústeres gestionan el mismo volumen, las operaciones conflictivas pueden dañar o destruir los datos.

SAN de ONTAP

Trident admite la importación de volumen mediante el ontap-san (iSCSI, NVMe/TCP y FC) y ontap-san-economy Conductores.

Trident puede importar volúmenes ONTAP SAN FlexVol que contengan un solo LUN. Esto es coherente con la ontap-san controlador, que crea un FlexVol volume para cada PVC y un LUN dentro del FlexVol volume. Trident importa el FlexVol volume y lo asocia con la definición de PVC. Trident puede importar ontap-san-economy volúmenes que contienen múltiples LUN.

Los siguientes ejemplos muestran cómo importar volúmenes gestionados y no gestionados:

Volumen gestionado

Para los volúmenes gestionados, Trident cambia el nombre de FlexVol volume al pvc-<uuid> formato y a la LUN dentro de FlexVol volume a lun0.

El siguiente ejemplo importa el ontap-san-managed FlexVol volume que está presente en ontap_san_default el backend:

tridentctl import volume ontapsan_san_default ontap-san-managed -f pvc-basic-import.yaml -n trident -d

+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE  | STORAGE CLASS | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+
| pvc-d6ee4f54-4e40-4454-92fd-d00fc228d74a | 20 MiB | basic         | block    | cd394786-ddd5-4470-adc3-10c5ce4ca757 | online | true    |
+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+
Volumen no gestionado

El siguiente ejemplo importa unmanaged_example_volume en la ontap_san backend:

tridentctl import volume -n trident san_blog unmanaged_example_volume -f pvc-import.yaml --no-manage
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE   | STORAGE CLASS | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
| pvc-1fc999c9-ce8c-459c-82e4-ed4380a4b228 | 1.0 GiB | san-blog      | block    | e3275890-7d80-4af6-90cc-c7a0759f555a | online | false   |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+

Si tiene LUN asignadas a iGroups que comparten un IQN con un IQN de nodo de Kubernetes, como se muestra en el ejemplo siguiente, recibirá el error: LUN already mapped to initiator(s) in this group. Deberá quitar el iniciador o desasignar la LUN para importar el volumen.

Imagen de LAS LUN asignadas a iqn e iqn del clúster.

Ejemplos de ONTAP SAN-economy

Los siguientes ejemplos muestran cómo importar volúmenes gestionados y no gestionados para el ontap-san-economy backend.

Volumen gestionado

Al importar un volumen gestionado, Trident toma posesión del FlexVol y le cambia el nombre. Debes tener en cuenta este cambio de nombre cuando importes varios LUN del mismo FlexVol.

El siguiente ejemplo importa lun1 desde el FlexVol toimport como un volumen gestionado llamado vol-managed-saneco:

tridentctl import volume vol-managed-saneco toimport/lun1 -f import1.yaml

Después de importar lun1, Trident cambia el nombre del FlexVol (por ejemplo, a trident_lun_pool_xyz). Para importar LUN adicionales del mismo FlexVol, usa el nuevo nombre de FlexVol:

tridentctl import volume vol-managed-saneco trident_lun_pool_xyz/lun2 -f import2.yaml
Nota El backend ontap-san-economy importa un LUN a la vez. Puedes automatizar varias importaciones usando un script.
Volumen no gestionado

Al importar un volumen no gestionado, Trident no se apropia del FlexVol. Sin embargo, el FlexVol y el LUN deben seguir las convenciones de nomenclatura de Trident.

Formato de nomenclatura de FlexVol
trident_lun_pool_STORAGEPREFIX_RANDOMSTRING

  • STORAGEPREFIX es el valor de storagePrefix en tu configuración de backend. El valor predeterminado es trident.

  • RANDOMSTRING es cualquier cadena que elijas.

Requisito de nomenclatura LUN

El LUN debe llamarse lun0.

Ejemplo

Si tu storagePrefix es xyz, la ruta completa al LUN es:

trident_lun_pool_xyz_randomstring/lun0

Elemento

Trident admite el software NetApp Element y la importación de volúmenes NetApp HCI mediante solidfire-san el controlador.

Nota El controlador Element admite los nombres de volúmenes duplicados. Sin embargo, Trident devuelve un error si hay nombres de volúmenes duplicados. Como solución alternativa, clone el volumen, proporcione un nombre de volumen único e importe el volumen clonado.

El siguiente ejemplo importa un element-managed volumen en el back-end element_default.

tridentctl import volume element_default element-managed -f pvc-basic-import.yaml -n trident -d

+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE  | STORAGE CLASS | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+
| pvc-970ce1ca-2096-4ecd-8545-ac7edc24a8fe | 10 GiB | basic-element | block    | d3ba047a-ea0b-43f9-9c42-e38e58301c49 | online | true    |
+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+

Azure NetApp Files

Trident admite la importación de volúmenes utilizando azure-netapp-files el controlador.

Nota Para importar un volumen de Azure NetApp Files, identifique el volumen por su ruta de volumen. La ruta del volumen es la parte de la ruta de exportación del volumen después del :/. Por ejemplo, si la ruta de montaje es 10.0.0.2:/importvol1, la ruta de volumen es importvol1.

El siguiente ejemplo importa un azure-netapp-files volumen en el back-end azurenetappfiles_40517 con la ruta del volumen importvol1.

tridentctl import volume azurenetappfiles_40517 importvol1 -f <path-to-pvc-file> -n trident

+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE   | STORAGE CLASS | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
| pvc-0ee95d60-fd5c-448d-b505-b72901b3a4ab | 100 GiB | anf-storage   | file     | 1c01274f-d94b-44a3-98a3-04c953c9a51e | online | true    |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+

NetApp Volumes para Google Cloud

Trident admite la importación de volúmenes utilizando google-cloud-netapp-volumes el controlador.

El siguiente ejemplo importa un volumen en backend backend-tbc-gcnv1 con el volumen testvoleasiaeast1.

tridentctl import volume backend-tbc-gcnv1 "testvoleasiaeast1" -f < path-to-pvc> -n trident

+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE   | STORAGE CLASS        | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+
| pvc-a69cda19-218c-4ca9-a941-aea05dd13dc0 |  10 GiB | gcnv-nfs-sc-identity | file     | 8c18cdf1-0770-4bc0-bcc5-c6295fe6d837 | online | true    |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+

En el siguiente ejemplo se importa google-cloud-netapp-volumes un volumen cuando hay dos volúmenes en la misma región:

tridentctl import volume backend-tbc-gcnv1 "projects/123456789100/locations/asia-east1-a/volumes/testvoleasiaeast1" -f <path-to-pvc> -n trident

+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+
|                   NAME                   |  SIZE   | STORAGE CLASS        | PROTOCOL |             BACKEND UUID             | STATE  | MANAGED |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+
| pvc-a69cda19-218c-4ca9-a941-aea05dd13dc0 |  10 GiB | gcnv-nfs-sc-identity | file     | 8c18cdf1-0770-4bc0-bcc5-c6295fe6d837 | online | true    |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+