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

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

Puedes importar un volumen en Trident para:

  • Containerizar una aplicación y reutilizar su conjunto de datos existente

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

  • Reconstruye un clúster de Kubernetes fallido

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

Consideraciones

Antes de importar un volumen, revisa las siguientes consideraciones.

  • Trident solo puede importar volúmenes ONTAP de tipo RW (lectura-escritura). Los volúmenes de tipo DP (protección de datos) son volúmenes destino de SnapMirror. Debes romper la relación de espejo antes de importar el volumen en Trident.

  • Sugerimos importar volúmenes sin conexiones activas. Para importar un volumen en uso activo, clona el volumen y luego haz la importación.

    Advertencia Esto es especialmente importante para los volúmenes de bloques, ya que Kubernetes no sabría de la conexión anterior y podría conectar fácilmente un volumen activo a un pod. Esto puede provocar la corrupción de datos.

  • Aunque StorageClass debe especificarse en una PVC, Trident no usa este parámetro durante la importación. Las clases de almacenamiento se usan durante la creación del volumen para seleccionar entre los pools disponibles según las características del almacenamiento. Como el volumen ya existe, no se requiere seleccionar un pool durante la importación. Así que la importación no fallará incluso si el volumen existe en un backend o pool que no coincide con la clase de almacenamiento especificada en la PVC.

  • El tamaño del volumen existente se determina y se configura en el PVC. Después de que el controlador de almacenamiento importa el volumen, el PV se crea con un ClaimRef al PVC.

    • La política de recuperación se establece inicialmente en retain el PV. Después de que Kubernetes vincula correctamente el PVC y el PV, la política de recuperación se actualiza para que coincida con la política de recuperación de la Storage Class.

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

  • De forma predeterminada, Trident administra el PVC y renombra el volumen FlexVol y el LUN en el backend. Puedes pasar la --no-manage bandera para importar un volumen no administrado y la --no-rename bandera para conservar el nombre del volumen.

    • --no-manage* - Si usas la `--no-manage`flag, Trident no realiza ninguna operación adicional en el PVC ni en el 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 clonar el volumen y redimensionar el 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 administra el ciclo de vida de los volúmenes. Esta opción solo es compatible con los `ontap-nas, ontap-san (incluidos los sistemas ASA r2), y `ontap-san-economy`drivers.

      Consejo Estas opciones son útiles si quieres usar Kubernetes para cargas de trabajo en contenedores, pero si prefieres, puedes gestionar el ciclo de vida del volumen de almacenamiento fuera de Kubernetes.

  • Se añade una anotación al PVC y al PV que cumple una doble función: indicar que el volumen fue importado y si el PVC y el PV están gestionados. Esta anotación no debe modificarse ni eliminarse.

Importar 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.

    El siguiente es 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. Usa 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 argumento -f es necesario 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

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

ONTAP NAS y ONTAP NAS FlexGroup

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

Nota

  • Trident no admite la importación de volúmenes usando el ontap-nas-economy driver.

  • Los ontap-nas y ontap-nas-flexgroup controladores no permiten nombres de volúmenes duplicados.

Cada volumen creado con el ontap-nas controlador es un volumen FlexVol en el clúster ONTAP. Importar volúmenes FlexVol con el ontap-nas controlador funciona igual. Un volumen FlexVol que ya existe en un clúster ONTAP se puede importar como un ontap-nas PVC. De manera similar, los volúmenes FlexGroup se pueden importar como ontap-nas-flexgroup PVCs.

Ejemplos de ONTAP NAS usando tridentctl

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

Volumen administrado

El siguiente ejemplo importa un volumen denominado managed_volume en un backend denominado 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 administrado

Al usar el --no-manage argumento, Trident no cambia el nombre del volumen.

El siguiente ejemplo importa unmanaged_volume en el 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 administrado

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 administrado

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>

ONTAP SAN

Trident admite la importación de volúmenes usando los ontap-san (iSCSI, NVMe/TCP y FC) y ontap-san-economy drivers.

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

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

Volumen administrado

Para los volúmenes administrados, Trident cambia el nombre del FlexVol volumen al pvc-<uuid> formato y el LUN dentro del FlexVol volumen a lun0.

El siguiente ejemplo importa el ontap-san-managed volumen FlexVol que está presente en el ontap_san_default 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 administrado

El siguiente ejemplo importa unmanaged_example_volume en el 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 tienes LUN asignados a igroups que comparten un IQN con un IQN de nodo Kubernetes, como se muestra en el siguiente ejemplo, recibirás el error: LUN already mapped to initiator(s) in this group. Necesitarás eliminar el iniciador o desasignar el LUN para importar el volumen.

Imagen de LUNS mapeados a iqn y cluster iqn.

Elemento

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

Nota El controlador Element admite nombres de volumen duplicados. Sin embargo, Trident devuelve un error si hay nombres de volumen duplicados. Como solución alternativa, clona el volumen, ponle un nombre de volumen único e importa el volumen clonado.

El siguiente ejemplo importa un element-managed volumen en el backend 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 usando el controlador azure-netapp-files.

Nota Para importar un volumen de Azure NetApp Files, identifica el volumen por su ruta de volumen. La ruta de volumen es la parte de la ruta de exportación del volumen después de :/. 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 backend azurenetappfiles_40517 con la ruta de 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    |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+

Google Cloud NetApp Volumes

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

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    |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+

El siguiente ejemplo importa un google-cloud-netapp-volumes volumen cuando hay dos volúmenes presentes 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    |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+