Skip to main content
Une version plus récente de ce produit est disponible.
La version française est une traduction automatique. La version anglaise prévaut sur la française en cas de divergence.

Importer des volumes Trident

PDF

Vous pouvez importer des volumes de stockage existants en tant que PV Kubernetes en utilisant tridentctl import ou en créant une revendication de volume persistant (PVC) avec des annotations d'importation Trident.

Aperçu et considérations

Vous pouvez importer un volume dans Trident pour :

  • Conteneurisez une application et réutilisez son ensemble de données existant

  • Utilisez un clone d'un ensemble de données pour une application éphémère

  • Reconstruire un cluster Kubernetes défaillant

  • Migrer les données d'application lors d'une reprise après sinistre

Considérations

Avant d'importer un volume, examinez les considérations suivantes.

  • Trident peut importer uniquement les volumes ONTAP de type RW (lecture-écriture). Les volumes de type DP (protection des données) sont des volumes de destination SnapMirror. Vous devez rompre la relation de miroir avant d'importer le volume dans Trident.

  • Nous suggérons d'importer les volumes sans connexion active. Pour importer un volume utilisé activement, clonez le volume, puis effectuez l'importation.

    Avertissement Ceci est particulièrement important pour les volumes de blocs, car Kubernetes ignorerait la connexion précédente et pourrait facilement associer un volume actif à un pod. Cela peut entraîner une corruption des données.

  • Bien que StorageClass doive être spécifié sur un PVC, Trident ne l'utilise pas lors de l'importation. Les classes de stockage sont utilisées lors de la création du volume pour sélectionner parmi les pools disponibles en fonction des caractéristiques de stockage. Parce que le volume existe déjà, aucune sélection de pool n'est requise lors de l'importation. Par conséquent, l'importation ne sera pas un échec même si le volume existe sur un backend ou un pool qui ne correspond pas à la classe de stockage spécifiée dans le PVC.

  • La taille du volume existant est déterminée et définie dans le PVC. Après que le volume a été importé par le pilote de stockage, le PV est créé avec un ClaimRef vers le PVC.

    • La politique de récupération est initialement définie sur retain dans le PV. Après que Kubernetes a correctement lié le PVC et le PV, la politique de récupération est mise à jour pour correspondre à la politique de récupération de la Storage Class.

    • Si la politique de récupération de la classe de stockage est delete, Trident supprime le volume de stockage lorsque le PV est supprimé.

  • Par défaut, Trident gère le PVC et renomme le volume FlexVol ainsi que le LUN ou le qtree sur le backend. Vous pouvez passer le --no-manage indicateur pour importer un volume non géré et le --no-rename indicateur pour conserver le nom du volume.

    • --no-manage* - Si vous utilisez le --no-manage flag, Trident n’effectue aucune opération supplémentaire sur le PVC ou le PV pendant tout le cycle de vie des objets. Le volume de stockage n’est pas supprimé lorsque le PV est supprimé et d’autres opérations telles que le clonage de volume et le redimensionnement de volume sont également ignorées.

    • --no-rename* - Si vous utilisez le --no-rename`flag, Trident conserve le nom du volume existant lors de l'importation des volumes et gère le cycle de vie des volumes. Cette option est prise en charge uniquement pour les pilotes `ontap-nas, ontap-san (y compris les systèmes ASA r2), ontap-san-economy, et ontap-nas-economy (importation qtree).

      Astuce Ces options sont utiles si vous souhaitez utiliser Kubernetes pour les charges de travail conteneurisées mais que vous souhaitez par ailleurs gérer le cycle de vie du volume de stockage en dehors de Kubernetes.

  • Une annotation est ajoutée aux PVC et PV et sert à la fois à indiquer que le volume a été importé et si les PVC et PV sont gérés. Cette annotation ne doit pas être modifiée ni supprimée.

Importer un volume

Vous pouvez importer un volume en utilisant soit tridentctl import soit en créant un PVC avec des annotations d'importation Trident.

Remarque Si vous utilisez des annotations PVC, vous n'avez pas besoin de télécharger ou d'utiliser tridentctl pour importer le volume.
Utilisation de tridentctl
Étapes

  1. Créez un fichier PVC (par exemple, pvc.yaml) qui sera utilisé pour créer le PVC. Le fichier PVC doit inclure name, namespace, accessModes et storageClassName. Vous pouvez éventuellement spécifier unixPermissions dans la définition de votre PVC.

    Voici un exemple de spécification minimale :

    kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: my_claim
  namespace: my_namespace
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: my_storage_class
    Remarque N'indiquez que les paramètres requis. Les paramètres supplémentaires tels que le nom du PV ou la taille du volume peuvent entraîner l'échec de la commande d'importation.

  2. Utilisez la commande tridentctl import pour spécifier le nom du backend Trident contenant le volume et le nom qui identifie de manière unique le volume sur le stockage (par exemple : ONTAP FlexVol, Element Volume). L’argument -f est obligatoire pour spécifier le chemin d’accès au fichier PVC.

    tridentctl import volume <backendName> <volumeName> -f <path-to-pvc-file>
Utilisation des annotations PVC
Étapes

  1. Créez un fichier YAML PVC (par exemple, pvc.yaml) avec les annotations d'importation Trident requises. Le fichier PVC doit inclure :

    • name et namespace dans les métadonnées

    • accessModes, resources.requests.storage, et storageClassName dans les spécifications

    • Annotations :

      • trident.netapp.io/importOriginalName: Nom du volume sur le backend

      • trident.netapp.io/importBackendUUID: UUID du backend où le volume existe

      • trident.netapp.io/notManaged (Facultatif) : Définir sur "true" pour les volumes non gérés. La valeur par défaut est "false".

        Voici un exemple de spécification pour l'importation d'un volume géré :

    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. Appliquez le fichier YAML PVC à votre cluster Kubernetes :

    kubectl apply -f <pvc-file>.yaml

    Trident importera automatiquement le volume et le liera au PVC.

Exemples

Consultez les exemples d'importation de volumes suivants pour les pilotes pris en charge.

ONTAP NAS et ONTAP NAS FlexGroup

Trident prend en charge l'importation de volumes à l'aide des ontap-nas et ontap-nas-flexgroup pilotes.

Remarque

  • Le ontap-nas-economy pilote gère le stockage au niveau du qtree, il ne prend donc pas en charge l’importation d’un volume FlexVol seul. Pour importer des qtrees avec le ontap-nas-economy pilote, consultez Importer des qtrees (Tech Preview). Lorsque Trident importe un qtree, il importe également le volume parent FlexVol en tant que bucket contenant ce qtree.

  • Les ontap-nas et ontap-nas-flexgroup pilotes n'autorisent pas les noms de volume en double.

Chaque volume créé avec le ontap-nas driver est un volume FlexVol sur le cluster ONTAP. L'importation de volumes FlexVol avec le ontap-nas driver fonctionne de la même manière. Un volume FlexVol qui existe déjà sur un cluster ONTAP peut être importé comme un ontap-nas PVC. De même, les volumes FlexGroup peuvent être importés comme des ontap-nas-flexgroup PVC.

Exemples ONTAP NAS utilisant tridentctl

Les exemples suivants montrent comment importer des volumes gérés et non gérés à l'aide de tridentctl.

Volume géré

L'exemple suivant importe un volume nommé managed_volume sur un backend nommé 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    |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
Volume non géré

Lors de l'utilisation de l' `--no-manage`argument, Trident ne renomme pas le volume.

L'exemple suivant importe unmanaged_volume sur le 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   |
+------------------------------------------+---------+---------------+----------+--------------------------------------+--------+---------+
Exemples ONTAP NAS utilisant des annotations PVC

Les exemples suivants montrent comment importer des volumes gérés et non gérés à l'aide d'annotations PVC.

Volume géré

L'exemple suivant importe un volume de 1 GiB ontap-nas nommé ontap_volume1 à partir du backend 81abcb27-ea63-49bb-b606-0a5315ac5f21 avec le mode d'accès RWO défini à l'aide d'annotations 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>
Volume non géré

L'exemple suivant importe 1Gi ontap-nas volume nommé ontap-volume2 depuis le backend 34abcb27-ea63-49bb-b606-0a5315ac5f34 avec le mode d'accès RWO défini à l'aide d'annotations 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>

Importer des qtrees

Remarque

L'importation Qtree est une fonctionnalité en avant-première technique de Trident 26.06. Les fonctionnalités en avant-première technique ne sont pas prises en charge pour une utilisation en production.

À partir de Trident 26.06, vous pouvez importer des qtrees ONTAP existants dans Trident à l'aide du ontap-nas-economy driver. Identifiez le qtree par son volume FlexVol et le nom du qtree au format flexvol/qtree, ainsi que par l'UUID du backend qui le contient. Les considérations générales d'importation dans Aperçu et considérations s'appliquent également à l'importation de qtrees.

Importer un qtree à l'aide de tridentctl

Spécifiez le qtree au format flexvol/qtree comme nom du volume. L'exemple suivant importe le qtree qtree1 du volume FlexVol flexvol1 sur le backend ontap_nas_economy :

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

Pour importer le qtree sans le renommer, ajoutez l `--no-rename`option. Pour importer le qtree sans que Trident gère son cycle de vie, ajoutez l `--no-manage`option.

Importer un qtree à l'aide d'annotations PVC

Créez un PVC avec les annotations suivantes :

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>

Pour conserver les noms de volume FlexVol et de qtree existants, ajoutez l' `trident.netapp.io/importNoRename: "true"`annotation. Pour importer le qtree comme non géré, ajoutez l' `trident.netapp.io/notManaged: "true"`annotation.

Comportement de dénomination et de gestion
Importation gérée (par défaut)

Trident renomme le qtree pour qu'il corresponde au nom du PVC et renomme le volume FlexVol selon la convention d'appellation ontap-nas-economy. Le chemin de jonction ne change pas.

--no-rename

Trident conserve les noms de volumes FlexVol® et de qtrees existants. Les noms doivent déjà respecter les conventions de nommage de Trident, sinon Trident ne peut pas gérer les opérations de suppression ou de montage pour le qtree.

--no-manage

Trident fait référence au qtree mais n'en gère pas le cycle de vie. Les noms doivent respecter les conventions d'appellation de Trident, et Trident n'utilise ni ne gère les règles d'export automatiques pour le qtree.

Comportement des règles d'export

Si le backend utilise des règles d'export automatiques, le qtree importé utilise le modèle de règles d'export par qtree, dans lequel chaque qtree possède sa propre règle d'export. Lors de l'importation, Trident attribue au qtree une règle d'export vide. Au moment de la publication, Trident met à jour le volume FlexVol avec la règle d'export du backend si l'export automatique est activé et si la règle d'export FlexVol existante est default ou vide.

Avertissement

La mise à jour des règles d'export du volume FlexVol peut perturber les autres qtrees du même volume FlexVol qui sont actuellement montés. Importez les qtrees uniquement lorsque les qtrees du volume FlexVol sont démontés.
Avertissement

Ne faites pas pointer deux clusters Kubernetes vers la même SVM active et n'importez pas un qtree déjà géré par un autre cluster. Si les deux clusters gèrent le même volume, des opérations conflictuelles peuvent corrompre ou détruire les données.

ONTAP SAN

Trident prend en charge l'importation de volumes à l'aide des ontap-san (iSCSI, NVMe/TCP et FC) et ontap-san-economy pilotes.

Trident peut importer des volumes SAN ONTAP FlexVol qui contiennent un seul LUN. Cela est cohérent avec le ontap-san driver, qui crée un volume FlexVol pour chaque PVC et un LUN dans le volume FlexVol. Trident importe le volume FlexVol et l’associe à la définition du PVC. Trident peut importer des volumes ontap-san-economy qui contiennent plusieurs LUN.

Les exemples suivants montrent comment importer des volumes gérés et non gérés :

Volume géré

Pour les volumes gérés, Trident renomme le volume FlexVol au format pvc-<uuid> et le LUN à l'intérieur du volume FlexVol en lun0.

L'exemple suivant importe le ontap-san-managed volume FlexVol qui est présent sur le 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    |
+------------------------------------------+--------+---------------+----------+--------------------------------------+--------+---------+
Volume non géré

L'exemple suivant importe unmanaged_example_volume sur le 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 vous avez des LUN mappés à des igroups qui partagent un IQN avec l'IQN d'un nœud Kubernetes, comme illustré dans l'exemple suivant, vous recevrez l'erreur : LUN already mapped to initiator(s) in this group. Vous devrez supprimer l'initiateur ou dissocier le LUN pour importer le volume.

Image des LUNS mappées sur iqn et cluster iqn.

Exemples d'économie SAN ONTAP

Les exemples suivants montrent comment importer des volumes gérés et non gérés pour le backend ontap-san-economy.

Volume géré

Lors de l'importation d'un volume géré, Trident prend possession du FlexVol et le renomme. Vous devez tenir compte de ce renommage lors de l'importation de plusieurs LUN provenant du même FlexVol.

L'exemple suivant importe lun1 du FlexVol toimport en tant que volume géré nommé vol-managed-saneco :

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

Après l'importation lun1, Trident renomme le FlexVol (par exemple, en trident_lun_pool_xyz). Pour importer d'autres LUNs du même FlexVol, utilisez le nouveau nom FlexVol :

tridentctl import volume vol-managed-saneco trident_lun_pool_xyz/lun2 -f import2.yaml
Remarque Le ontap-san-economy backend importe une LUN à la fois. Vous pouvez automatiser plusieurs importations à l'aide d'un script.
Volume non géré

Lorsque vous importez un volume non géré, Trident ne prend pas possession du FlexVol®. Cependant, le FlexVol® et la LUN doivent suivre les conventions de nommage Trident.

Format de nommage FlexVol®
trident_lun_pool_STORAGEPREFIX_RANDOMSTRING

  • STORAGEPREFIX est la valeur de storagePrefix dans votre configuration backend. La valeur par défaut est trident.

  • RANDOMSTRING est n'importe quelle chaîne de caractères que vous choisissez.

Exigence de dénomination des LUN

Le LUN doit être nommé lun0.

Exemple

Si votre storagePrefix est xyz, le chemin complet vers le LUN est :

trident_lun_pool_xyz_randomstring/lun0

Élément

Trident prend en charge le logiciel NetApp Element et l'importation de volumes NetApp HCI à l'aide du pilote solidfire-san.

Remarque Le pilote Element prend en charge les noms de volumes identiques. Cependant, Trident renvoie une erreur s'il existe des noms de volumes en double. Pour contourner ce problème, clonez le volume, attribuez un nom de volume unique et importez le volume cloné.

L'exemple suivant importe un element-managed volume sur le 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 prend en charge l'importation de volumes à l'aide du azure-netapp-files driver.

Remarque Pour importer un volume Azure NetApp Files, identifiez le volume par son chemin de volume. Le chemin de volume est la partie du chemin d'exportation du volume après le :/. Par exemple, si le chemin de montage est 10.0.0.2:/importvol1, le chemin de volume est importvol1.

L'exemple suivant importe un azure-netapp-files volume sur le backend azurenetappfiles_40517 avec le chemin de volume 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 prend en charge l'importation de volumes à l'aide du google-cloud-netapp-volumes driver.

L'exemple suivant importe un volume sur le backend backend-tbc-gcnv1 avec le volume 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    |
+------------------------------------------+---------+----------------------+----------+--------------------------------------+--------+---------+

L'exemple suivant importe un google-cloud-netapp-volumes volume lorsque deux volumes sont présents dans la même région :

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