Trident (NetApp)

Trident est le CSI driver open source de NetApp pour Kubernetes, qui automatise le provisionnement de volumes persistants sur les backends de stockage NetApp. Il prend en charge une large gamme de backends : systèmes ONTAP (on-premises ou Cloud), SolidFire (iSCSI), Azure NetApp Files (ANF), Amazon FSx for ONTAP (AWS) et Google Cloud NetApp Volumes (GCNV).

Trident est distribué sous licence Apache 2.0 mais requiert une infrastructure NetApp pour fonctionner utilement. Il est conçu pour les entreprises déjà équipées de baies NetApp qui souhaitent les utiliser comme backend de stockage pour leurs clusters Kubernetes.

Informations essentielles

Origine : NetApp (États-Unis)  ·  Licence : Apache 2.0  ·  Architectures : x86_64, ARM64

Liens : Documentation  ·  GitHub  ·  Releases

Support : Support NetApp inclus avec les contrats de maintenance. Releases trimestrielles (~4/an).

Stack par défaut

Backends supportés

Prérequis

Pour ONTAP NAS (NFS)

# Packages NFS requis sur les nœuds workers
sudo apt-get install -y nfs-common        # Ubuntu/Debian
sudo dnf install -y nfs-utils             # Rocky/AlmaLinux

Pour ONTAP SAN (iSCSI)

# Ubuntu/Debian
sudo apt-get install -y open-iscsi multipath-tools
sudo systemctl enable --now iscsid multipathd

# Rocky/AlmaLinux
sudo dnf install -y iscsi-initiator-utils device-mapper-multipath
sudo systemctl enable --now iscsid multipathd

Installation

Via l'opérateur Trident (recommandé)

# Télécharger le bundle d'installation
TRIDENT_VERSION=24.06.0
curl -Lo trident-installer.tar.gz \
  https://github.com/NetApp/trident/releases/download/v${TRIDENT_VERSION}/trident-installer-${TRIDENT_VERSION}.tar.gz
tar -xzf trident-installer.tar.gz
cd trident-installer

# Installer l'opérateur
kubectl create namespace trident
kubectl apply -f deploy/bundle_pre_1_25.yaml    # K8s < 1.25
# kubectl apply -f deploy/bundle_post_1_25.yaml  # K8s >= 1.25

# Créer le TridentOrchestrator pour lancer l'installation
cat <<EOF | kubectl apply -f -
apiVersion: trident.netapp.io/v1
kind: TridentOrchestrator
metadata:
  name: trident
spec:
  debug: false
  namespace: trident
EOF

# Vérifier
kubectl get tidentorchestrator trident
kubectl get pods -n trident

Via Helm

helm repo add netapp-trident https://netapp.github.io/trident-helm-chart
helm repo update

helm install trident netapp-trident/trident-operator \
  --namespace trident \
  --create-namespace \
  --version 100.2406.0

kubectl get pods -n trident

Vérification de l'installation

# 1. Pods Trident (controller + node plugins)
kubectl get pods -n trident
# trident-controller (6/6) et trident-node-* (2/2) doivent être Running

# 2. Version et état via tridentctl
kubectl exec -n trident deploy/trident-controller \
  -- tridentctl version -n trident
# Doit afficher les versions client ET server

# 3. Vérifier le TridentOrchestrator
kubectl get torc trident
# STATUS = Installed, VERSION = 24.x

# 4. Vérifier les backends (après en avoir configuré un)
kubectl exec -n trident deploy/trident-controller \
  -- tridentctl get backend -n trident
# Chaque backend doit avoir STATE = online

# 5. Vérifier les StorageClasses
kubectl get sc | grep trident

Configurer un backend

Backend ONTAP NAS (NFS)

# backend-ontap-nas.yaml
apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-ontap-nas
  namespace: trident
spec:
  version: 1
  storageDriverName: ontap-nas
  managementLIF: 192.168.1.100         # IP de gestion ONTAP
  dataLIF: 192.168.1.101               # IP de données (NFS)
  svm: svm_nfs                          # Storage Virtual Machine
  credentials:
    name: ontap-credentials             # Secret K8s avec username/password
  defaults:
    spaceReserve: "none"
    snapshotPolicy: "none"
    exportPolicy: "default"
    snapshotDir: "false"

# Créer le secret de credentials
kubectl create secret generic ontap-credentials \
  --from-literal=username=vsadmin \
  --from-literal=password=<password> \
  -n trident

kubectl apply -f backend-ontap-nas.yaml
kubectl get tbc -n trident

Backend ONTAP SAN (iSCSI)

apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-ontap-san
  namespace: trident
spec:
  version: 1
  storageDriverName: ontap-san
  managementLIF: 192.168.1.100
  svm: svm_iscsi
  credentials:
    name: ontap-credentials
  defaults:
    spaceReserve: "none"
    snapshotPolicy: "none"

Backend Azure NetApp Files

apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-anf
  namespace: trident
spec:
  version: 1
  storageDriverName: azure-netapp-files
  subscriptionID: <azure-subscription-id>
  tenantID: <azure-tenant-id>
  clientID: <azure-service-principal-client-id>
  clientSecret: <azure-service-principal-secret>
  location: westeurope
  serviceLevel: Premium
  virtualNetwork: mon-vnet
  subnet: mon-subnet

StorageClasses

# NFS - ReadWriteMany
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: trident-nfs
provisioner: csi.trident.netapp.io
parameters:
  backendType: "ontap-nas"
  storagePools: "backend-ontap-nas:.*"
reclaimPolicy: Delete
allowVolumeExpansion: true
mountOptions:
  - nfsvers=4.1
---
# iSCSI - ReadWriteOnce
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: trident-iscsi
provisioner: csi.trident.netapp.io
parameters:
  backendType: "ontap-san"
  storagePools: "backend-ontap-san:.*"
  fsType: ext4
reclaimPolicy: Delete
allowVolumeExpansion: true

Fonctionnalités avancées

Snapshot de volume

# VolumeSnapshotClass Trident
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: csi-snapclass
driver: csi.trident.netapp.io
deletionPolicy: Delete
---
# Créer un snapshot
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: mon-snapshot
  namespace: production
spec:
  volumeSnapshotClassName: csi-snapclass
  source:
    persistentVolumeClaimName: mon-pvc

Clone depuis un snapshot

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-clone
  namespace: production
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: trident-nfs
  resources:
    requests:
      storage: 10Gi
  dataSource:
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
    name: mon-snapshot

Premier test de bout en bout

Tester après avoir configuré un backend et créé la StorageClass correspondante.

Test NFS (ReadWriteMany)

# test-trident-nfs.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-trident-nfs
  namespace: default
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: trident-nfs
  resources:
    requests:
      storage: 1Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: test-trident
  namespace: default
spec:
  containers:
  - name: writer
    image: busybox
    command: ["/bin/sh", "-c", "echo 'Trident NFS OK' > /mnt/test.txt && cat /mnt/test.txt && sleep 3600"]
    volumeMounts:
    - name: data
      mountPath: /mnt
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: test-trident-nfs

kubectl apply -f test-trident-nfs.yaml

# Suivre le binding
kubectl get pvc test-trident-nfs -w
# Pending → Bound (quelques secondes avec ONTAP)

kubectl logs test-trident
# Doit afficher "Trident NFS OK"

# Vérifier que le volume existe côté ONTAP (via tridentctl)
kubectl exec -n trident deploy/trident-controller \
  -- tridentctl get volume -n trident
# Le volume doit apparaître avec STATE = online

# Nettoyage
kubectl delete -f test-trident-nfs.yaml

Pièges courants à l'installation

Mise à jour

# Via opérateur Trident
kubectl patch torc trident \
  --type=merge \
  -p '{"spec":{"tridentImage":"docker.io/netapp/trident:24.06.0"}}'

kubectl get torc trident
kubectl get pods -n trident

# Via Helm
helm upgrade trident netapp-trident/trident-operator \
  -n trident \
  --version 100.2406.0 \
  --reuse-values

Troubleshooting

# État du déploiement Trident
kubectl get pods -n trident
kubectl get tbc -n trident              # Backends configurés
kubectl get sc | grep trident           # StorageClasses

# Logs du controller Trident
kubectl logs -n trident -l app=controller.csi.trident.netapp.io --tail=100

# CLI tridentctl (depuis le pod ou binaire local)
kubectl exec -n trident deploy/trident-controller \
  -- tridentctl get backend -n trident

kubectl exec -n trident deploy/trident-controller \
  -- tridentctl get volume -n trident

PVC bloqué en Pending

# Vérifier les backends disponibles
kubectl get tbc -n trident
kubectl describe tbc backend-ontap-nas -n trident

# Logs détaillés
kubectl logs -n trident -l app=controller.csi.trident.netapp.io --tail=200 \
  | grep -i error

Erreur d'authentification ONTAP

# Vérifier le secret de credentials
kubectl get secret ontap-credentials -n trident -o yaml

# Tester la connectivité depuis un pod trident
kubectl exec -n trident deploy/trident-controller \
  -- curl -k https://192.168.1.100/api

Commandes utiles

# tridentctl (depuis le pod controller)
kubectl exec -n trident deploy/trident-controller -- tridentctl version -n trident
kubectl exec -n trident deploy/trident-controller -- tridentctl get backend -n trident
kubectl exec -n trident deploy/trident-controller -- tridentctl get volume -n trident
kubectl exec -n trident deploy/trident-controller -- tridentctl get snapshot -n trident

# Ressources CRD
kubectl get tbc -n trident              # TridentBackendConfig
kubectl get tbe -n trident              # TridentBackend (état interne)
kubectl get sc | grep trident           # StorageClasses
kubectl get pv | grep trident           # PersistentVolumes

Ressources

• Documentation officielle Trident : https://docs.netapp.com/us-en/trident/
• Backends supportés : https://docs.netapp.com/us-en/trident/trident-use/backends.html
• GitHub : https://github.com/NetApp/trident
• Releases : https://github.com/NetApp/trident/releases
• Helm chart : https://github.com/NetApp/trident-helm-chart