Aggiunta di File Storage for VPC alle applicazioni

Red Hat OpenShift on IBM Cloud fornisce classi di archiviazione predefinite che è possibile utilizzare per allocare spazio su File Storage for VPC per le applicazioni presenti nel proprio cluster. Ogni classe di archiviazione specifica la capacità disponibile, gli IOPS, il file system e la politica di conservazione per la condivisione di file che si sta configurando. Puoi anche creare le tue classi di archiviazione personalizzate in base alle tue esigenze.

Prima di continuare, leggere le seguenti note e considerazioni.

Dopo aver configurato un tipo specifico di archiviazione utilizzando una classe di archiviazione, non è possibile modificare né il tipo né la politica di conservazione del dispositivo di archiviazione. Tuttavia, puoi modificare la dimensione e l'IOPS se vuoi aumentare la tua capacità di archiviazione e le tue prestazioni. Per modificare il tipo e la politica di conservazione del proprio archivio, è necessario creare una nuova istanza di archivio e copiare i dati dalla vecchia istanza a quella nuova.
Se il cluster e la VPC sono in gruppi di risorse separati, prima di poter eseguire il provisioning delle condivisioni di file, è necessario creare la propria classe di storage e fornire l'ID del gruppo di risorse VPC nella sezione resourceGroup insieme all'ID del gruppo di sicurezza kube-<clusterID> nella sezione securityGroupIDs. Per recuperare l'ID del gruppo di sicurezza, procedere come segue. Per ulteriori informazioni, vedere Creazione della propria classe di archiviazione.
Sono state introdotte nuove regole per i gruppi di sicurezza nelle versioni cluster 4.11 e più tardi. Queste modifiche alle regole implicano che devi sincronizzare i tuoi gruppi di sicurezza prima di poterli utilizzareFile Storage for VPC. Per ulteriori informazioni, vedere AggiuntaFile Storage for VPC alle app.
Nuove classi di archiviazione sono state aggiunte con version2.0 del componente aggiuntivo. Non è più possibile effettuare il provisioning di nuove condivisioni file che utilizzano le classi di archiviazione precedenti. I volumi esistenti che utilizzano le classi di archiviazione precedenti continuano a funzionare, tuttavia non è possibile espandere i volumi creati utilizzando le classi precedenti. Per ulteriori informazioni, vedere il Migrazione a una nuova classe di archiviazione.
La creazione di un PVC utilizzando StorageClassSecrets non è supportata.
Assicurarsi che l'utente che crea il cluster abbia le autorizzazioni Reader, Writer e Operator per VPC Infrastructure Services.
Assicuratevi di impostare un'autorizzazione di servizio dall'Infrastruttura VPC a KMS/HPCS se intendete usare la crittografia sulle vostre condivisioni di file.

IBM Cloud sta modificando i servizi dedicati alla gestione delle chiavi da Hyper Protect Crypto Services a Key Protect dedicati.

Per impostazione predefinita, il componente aggiuntivo cluster File Storage for VPC fornisce le condivisioni file nel gruppo di protezione kube-<clusterID>. Ciò significa che i pod possono accedere alle condivisioni di file tra nodi e zone.
Se si utilizzano restrizioni basate sul contesto, assicurarsi di configurare le zone e le regole di rete. Per ulteriori informazioni, vedere Protezione dei servizi di infrastruttura Virtual Private Cloud(VPC)con restrizioni basate sul contesto.

Le nuove regole dei gruppi di sicurezza sono state introdotte nelle versioni 4.11 e successive. Queste modifiche alle regole implicano che è necessario sincronizzare i gruppi di sicurezza prima di poter utilizzare File Storage for VPC. Se il cluster è stato creato inizialmente con la versione 4.11 o precedenti, eseguire i seguenti comandi per sincronizzare le impostazioni del gruppo di sicurezza.

Ottieni l'ID del tuo cluster.
```
ibmcloud oc cluster ls
```
Ottieni l'ID del gruppo di protezione kube-<clusterID>.
```
ibmcloud is sg kube-CLUSTER_ID  | grep ID
```
Sincronizzare il gruppo di sicurezza kube-<clusterID> utilizzando l'ID recuperato nel passaggio precedente.
```
ibmcloud ks security-group sync -c CLUSTER_ID --security-group ID
```

Guida rapida per File Storage for VPC

Crea una richiesta di volume persistente (PVC) per assegnare dinamicamente un volume di tipo “ File Storage for VPC ” al tuo cluster. Il provisioning dinamico crea automaticamente il volume persistente (PV) corrispondente e ordina la condivisione di file nel tuo account.

Ora è possibile scegliere una classe di archiviazione di seconda generazione.

Accedi al tuo cluster Red Hat OpenShift.
Esamina le classi di archiviazione preinstallate eseguendo il seguente comando. Per ulteriori informazioni, vedi la guida di riferimento alla classe di archiviazione.
```
oc get sc | grep vpc-file
```

Salva il seguente codice YAML in un file. Questo esempio crea una richiesta denominata my-pvc utilizzando la classe di archiviazione ibmc-vpc-file-min-iops con una dimensione di gigabyte di 10Gi.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc # Enter a name for your PVC.
spec:
  accessModes:
  - ReadWriteMany # The file share can be mounted on multiple nodes and pods.
  resources:
    requests:
      storage: 20Gi # Enter the size of the storage in gigabytes (Gi).
  storageClassName: ibmc-vpc-file-min-iops # Enter the name of the storage class that you want to use.

Crea la PVC.
```
oc apply -f my-pvc.yaml
```

Verifica che la tua PVC sia stata creata e associata al PV.

oc describe pvc my-pvc

Output di esempio

Name:        my-pvc
Namespace:    default
StorageClass:    ""
Status:        Bound
Volume:        pvc-0d787071-3a67-11e7-aafc-eef80dd2dea2
Labels:        <none>
Capacity:    20Gi
Access Modes:    RWX
Events:
    FirstSeen    LastSeen    Count    From                                SubObjectPath    Type        Reason            Message
    ---------    --------    -----    ----                                -------------    --------    ------            -------
    1m        1m        1    {ibm.io/ibmc-vpc-file 31898035-3011-11e7-a6a4-7a08779efd33 }            Normal        ProvisioningSucceeded    Successfully provisioned volume pvc-0d787071-3a67-11e7-aafc-eef80dd2dea2

Salva la seguente configurazione di distribuzione nel file denominato deployment.yaml e fai riferimento alla PVC che hai creato nel passo precedente.
```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-deployment
spec:
  selector:
    matchLabels:
      app: busybox
  template:
    metadata:
      labels:
        app: busybox
    spec:
      containers:
      - name: busybox
        image: busybox:1.28
        command: [ "sh", "-c", "sleep 1h" ]
        volumeMounts:
        - name: my-vol
          mountPath: /data/demo # Mount path for the application.
      volumes:
      - name: my-vol
        persistentVolumeClaim:
          claimName: my-pvc # Your PVC name.
```
volumeMounts.mountPath

Nella sezione container volume mounts, immetti il percorso assoluto della directory in cui viene montato il volume all'interno del contenitore. I dati scritti nel percorso di montaggio vengono memorizzati nella directory root all'interno dell'istanza fisica di File Storage for VPC. Se desideri condividere un volume tra diverse app, puoi specificare i percorsi secondari del volume per ciascuna delle tue app.

volumeMounts.name

Nella sezione container volume mounts, immetti il nome del volume per montare il tuo pod.

volume.name

Nella sezione volumes, immetti il nome del volume da montare sul tuo pod. In genere questo nome corrisponde a volumeMounts.name.

claimName

Nella sezione volumes persistent volume claim, immetti il nome della PVC che esegue il bind del PV che vuoi utilizzare.
Crea la distribuzione.
```
oc apply -f deployment.yaml
```

Verifica che il PV venga montato correttamente.

oc describe deployment my-deployment

Il punto di montaggio è nel campo Montaggi volume e il volume nel campo Volumi.

Containers:
  Mounts:
    /data/demo from my-vol (rw)
Volumes:
my-vol:
  Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
  ClaimName:  my-pvc
  ReadOnly:   false

Facoltativo: dopo che il tuo pod è in esecuzione, prova a espandere il tuo volume di archiviazione.

Migrazione a una nuova classe di archiviazione

Nuove classi di archiviazione sono state aggiunte con version2.0 del componente aggiuntivo.
Non è più possibile effettuare il provisioning di nuove condivisioni file che utilizzano le classi di archiviazione precedenti.
I volumi esistenti che utilizzano le classi di archiviazione precedenti continuano a funzionare, tuttavia non è possibile espandere i volumi creati utilizzando le classi precedenti.
Se hai bisogno della funzionalità di espansione del volume, completa i seguenti passaggi per migrare le tue app a una classe di archiviazione più recente.
Se non hai bisogno della funzionalità di espansione del volume, non è necessario eseguire la migrazione e i tuoi PVC continueranno a funzionare normalmente.
I passaggi seguenti riguardano la migrazione manuale.

Trova la PVC di cui desideri eseguire la migrazione e prendi nota sia del nome della PVC che del nome del PV associato.
```
oc get pvc
```
Riduci le dimensioni dell'app che utilizza la PVC.
```
oc scale deployment DEPLOYMENT --replicas 0
```

Modifica l'oggetto PV utilizzato dalla tua app per modificare la policy di recupero Retain e classe di archiviazione in ibmc-vpc-file-min-iops.

kubectl edit pv PV

spec:
  accessModes:
  - ReadWriteMany
  capacity:
    storage: 20Gi
  claimRef:
    apiVersion: v1
    kind: PersistentVolumeClaim
    name: <pvc-name>
    namespace: default
    ...
  persistentVolumeReclaimPolicy: Retain # Change delete to retain
  storageClassName: ibmc-vpc-file-min-iops # Enter a new storage class
  volumeMode: Filesystem

Elimina l'oggetto PVC esistente.
```
kubectl delete pvc PVC
```

Modifica nuovamente il PV e rimuovi il file claimRef sezione.

kubectl edit pv PV

spec:
  accessModes:
  - ReadWriteMany
  capacity:
    storage: 20Gi
  #claimRef:
    #apiVersion: v1
    #kind: PersistentVolumeClaim
    #name: <pvc-name>
    #namespace: default
    #resourceVersion: "381270"
    #uid: 4042f319-1233-4187-8549-8249a840a8dd

Crea una PVC che abbia lo stesso nome e le stesse dimensioni della PVC precedente. Questo dovrebbe essere fatto uno per uno per tutti i PVC interessati.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: <pvc-name>
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: <size>Gi
  storageClassName: ibmc-vpc-file-min-iops

Amplia la tua app che utilizzava la PVC.

k scale deployment DEPLOYMENT --replicas x

Per continuare a utilizzare l'espansione del volume, vedere Configurazione dell'espansione del volume.

Configurazione dell'espansione del volume

Per eseguire il provisioning di volumi che supportano l'espansione, è necessario utilizzare la classe di archiviazione allowVolumeExpansion impostata su true.

Il componente aggiuntivo del cluster File Storage for VPC supporta l'espansione sia in modalità online che offline. Tuttavia, l'espansione è possibile solo entro i limiti di dimensione e IOP previsti dal profilo File Storage for VPC.

Con la versione 2.0 sono state introdotte nuove classi di archiviazione. L'espansione del volume non funziona per le condivisioni che utilizzano le classi di archiviazione delle versioni precedenti del componente aggiuntivo.

Prima di iniziare

Per utilizzare l'espansione del volume, assicurarsi di aggiornare il componente aggiuntivo almeno alla versione 2.0.
Assicuratevi che la vostra applicazione utilizzi una delle classi di archiviazione più recenti. Per i passaggi della migrazione, vedere Migrazione a una nuova classe di archiviazione
Se non disponi di un'app in esecuzione, inizia distribuendo il file esempio di avvio rapido PVC e distribuzione.

Espansione di un volume montato

Dopo che la tua PVC è stata montata da un pod dell'applicazione, puoi espandere il tuo volume modificando il valore del campo spec.resources.requests.storage nella tua PVC. Per espandere il volume, modifica la tua PVC e aumenta il valore nel campo spec.resources.requests.storage.
```
kubectl edit pvc my-pvc
```
```
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 50Gi
```
Salva e chiudi il file PVC. Attendere alcuni minuti per l'espansione del volume.

Verifica che il volume sia espanso.

kubectl get pvc

Output di esempio

NAME     STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS        AGE
my-pvc   Bound    pvc-25b6912e-75bf-41ca-b6b2-567fa4f9d245   50Gi       RWX            ibmc-vpc-file-min-iops   3m31s

Allegare l'archiviazione file esistente a un'app

Crea una richiesta di volume persistente (PVC) per assegnare in modo statico un volume di tipo “ File Storage for VPC ” al tuo cluster. Il provisioning statico consente agli amministratori del cluster di rendere le periferiche di storage esistenti disponibili per un cluster.

Ottieni il tuo ID cluster.
```
ibmcloud ks cluster ls
```
Ottenere l'ID del gruppo di sicurezza kube-<clusterID>.
```
ibmcloud is sg kube-CLUSTER_ID  | grep ID
```
Creare una condivisione file. Per ulteriori informazioni, consultare Creazione di condivisioni file e destinazioni di montaggio.
```
ibmcloud is share-create --name my-file-share --zone us-south-2 --profile dp2 --size 1000 --iops 1000
```

Creare una destinazione di montaggio della condivisione e specificare l'ID del gruppo di sicurezza kube-<clusterID> recuperato in precedenza nell'opzione --vni-sgs.

ibmcloud is share-mount-target-create my-file-share --subnet my-subnet --name NAME --vni-name my-share-vni-1  --vni-sgs kube-CLUSTER_ID --resource-group-name Default --vpc ID

Prima di poter creare un volume persistente (PV), richiama i dettagli sulla tua condivisione file.
```
ibmcloud is shares
```

Scopri i dettagli della tua quota. Prendere nota delle destinazioni di montaggio.

ibmcloud is share SHARE-ID

Comando di esempio.

ibmcloud is share r134-bad98878-1f63-45d2-a3fd-60447094c2e6

Output di esempio

ID                           r134-bad98878-1f63-45d2-a3fd-60447094c2e6   
Name                         pvc-e7e005a9-e96b-41ad-9d6e-74650a9110a0   
CRN                          crn:v1:staging:public:is:us-south-1:a/77f2bceddaeb577dcaddb4073fe82c1c::share:r134-bad98878-1f63-45d2-a3fd-60447094c2e6   
Lifecycle state              stable   
Access control mode          security_group   
Zone                         us-south-1   
Profile                      dp2   
Size(GB)                     10   
IOPS                         100   
User Tags                    clusterid:cpjao3l20dl78jadqkd0,namespace:default,provisioner:vpc.file.csi.ibm.io,pv:pvc-e7e005a9-e96b-41ad-9d6e-74650a9110a0,pvc:pv-file,reclaimpolicy:delete,storageclass:custom-eni   
Encryption                   provider_managed   
Mount Targets                ID                                          Name      
                            r134-aa2aabb8-f616-47be-886b-99220852b728   pvc-e7e005a9-e96b-41ad-9d6e-74650a9110a0      
Resource group               ID                                 Name      
                            300b9469ee8676f9a038ecdf408c1a9d   Default      
Created                      2024-06-11T19:55:11+05:30   
Replication role             none   
Replication status           none   
Replication status reasons   Status code   Status message

Richiamare nfsServerPath, denominato anche Mount Path.

ibmcloud is share-mount-target SHARE-ID SHARE-TARGET-ID

Comando di esempio.

ibmcloud is share-mount-target  r134-bad98878-1f63-45d2-a3fd-60447094c2e6 r134-aa2aabb8-f616-47be-886b-99220852b728

Output di esempio

ID                          r134-aa2aabb8-f616-47be-886b-99220852b728   
Name                        pvc-e7e005a9-e96b-41ad-9d6e-74650a9110a0   
VPC                         ID                                          Name      
                            r134-f05922d4-d8ab-4f64-9a3d-82664b303bc1   vpc-public      
Access control mode         security_group   
Resource type               share_mount_target   
Virtual network interface   ID                                          Name      
                            0716-6407fb4b-e962-49c4-8556-dc94f4574b4b   defective-chloride-huffy-gladly      
Lifecycle state             stable   
Mount path                  10.240.0.23:/89d8a454_f552_42bf_8374_4d31481edf4d   
Transit Encryption          none   
Created                     2024-06-11T19:55:12+05:30

Crea un file di configurazione PV denominato static-file-share.yaml che fa riferimento alla tua condivisione file.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: static-file-share
spec:
  mountOptions:
  - hard
  - nfsvers=4.1
  - sec=sys
  accessModes:
  - ReadWriteMany
  capacity:
    storage: 10Gi
  csi:
    volumeAttributes:
      nfsServerPath: NFS-SERVER-PATH
    driver: vpc.file.csi.ibm.io
    volumeHandle: FILE-SHARE-ID#SHARE-TARGET-ID

Crea il PV.
```
oc apply -f static-file-share.yaml
```

Crea una PVC.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-static
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
  storageClassName: "" #Leave the storage class blank.

Crea la PVC per eseguire il bind del tuo PV.
```
oc apply -f pvc-static.yaml
```
Creare un nome di file di distribuzione testpod.yaml per allegare il fileshare a un pod di applicazione.
```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: testpod
  labels:
    app: testpod
spec:
  selector:
    matchLabels:
      app: busybox
  template:
    metadata:
      labels:
        app: busybox
    spec:
      containers:
      - name: busybox
        image: busybox:1.28
        command: [ "sh", "-c", "sleep 1h" ]
        volumeMounts:
        - name: my-vol
          mountPath: /data/demo # Mount path for the application.
      volumes:
      - name: pvc-name
        persistentVolumeClaim:
          claimName: pvc-static # The name of the PVC that you created earlier
```
spec.containers.volumeMounts.mountPath

Immetti il percorso assoluto della directory in cui viene montato il volume nel contenitore. I dati scritti nel percorso di montaggio vengono memorizzati nella directory root all'interno dell'istanza fisica di File Storage for VPC. Se desideri condividere un volume tra diverse app, puoi specificare i percorsi secondari del volume per ciascuna delle tue app.

volumeMounts.name

Immetti il nome del volume da montare sul tuo pod.

volume.name

Immetti il nome del volume da montare sul tuo pod. In genere questo nome corrisponde a volumeMounts.name.

volumes.persistentVolumeClaim.claimName

Inserisci il nome del PVC associato al PV che desideri utilizzare.
Crea la distribuzione.
```
oc apply -f testpod.yaml
```

Creazione della tua classe di memoria

È possibile creare una classe di archiviazione personalizzata con le impostazioni preferite per l'istanza File Storage for VPC. Per mantenere i costi bassi, è possibile fornire inizialmente un PVC con un throughput minimo, quindi in un secondo momento è possibile accedere al PVC e regolare il throughput man mano che si definiscono le esigenze.

Se hai bisogno delle seguenti funzioni, devi creare la tua classe di archiviazione.

La tua app deve essere eseguita come non root.
Il tuo cluster si trova in un gruppo di risorse differente dal tuo VPC e sottorete.
Devi limitare l'accesso di condivisione file ai pod su un determinato nodo o in una determinata zona.
Devi utilizzare la tua crittografia (BYOK) utilizzando un provider KMS come HPCS o Key Protect.
È necessario specificare manualmente la sottorete o l'indirizzo IP di VNI(Virtual Network Interface).
È necessario un maggiore controllo sulla capacità e sulla larghezza di banda. In questo caso, è possibile utilizzare il profilo rfs. Per ulteriori informazioni, vedere Panoramica sulle condivisioni di file regionali.
Si desidera arrotondare automaticamente per eccesso la capacità PVC richiesta alla capacità minima supportata per un profilo dp2 con IOPS fisse. Per ulteriori informazioni, consultare la sezione " Abilitazione dell'arrotondamento automatico della capacità per i profili IOPS fissi ".

Se il cluster e la VPC non sono nello stesso gruppo di risorse, è necessario specificare l'ID del gruppo di risorse VPC nella sezione resourceGroup e l'ID del gruppo di sicurezza kube-<clusterID> nella sezione securityGroupIDs. È possibile trovare l'ID del gruppo di sicurezza kube-<clusterID> eseguendo ibmcloud is sg kube-CLUSTER_ID | grep ID.

Creare un file di configurazione della classe di memoria. L'esempio seguente utilizza il profilo dp2. Scegliete tra una classe di archiviazione di prima generazione e una di seconda generazione.

Esempio di prima generazione:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ibmc-vpc-file-custom-sc
  labels:
    app.kubernetes.io/name: ibm-vpc-file-csi-driver
provisioner: vpc.file.csi.ibm.io
mountOptions:
  - hard
  - nfsvers=4.1
  - sec=sys
parameters:
    profile: "dp2" # or rfs
    billingType: "hourly" # hourly or monthly
    encrypted: "false"
    encryptionKey: "" # If encrypted is true, then a user must specify the CRK-CRN.
    resourceGroup: "" # Resource group ID. By default, the resource group of the cluster will be used from storage-secrete-store secret.
    isENIEnabled: "true" # VPC File Share VNI feature will be used by all PVCs created with this storage class.
    securityGroupIDs: "" # By default cluster security group i.e kube-<clusterID> will be used. User can provide their own comma separated SGs.
    subnetID: "" # User can provide subnetID in which the VNI will be created. Zone and region are mandatory for this. If not provided CSI driver will use the subnetID available in the cluster's VPC zone.
    region: "" # VPC CSI driver will select a region from cluster node's topology. The user can override this default.
    zone: "" # VPC CSI driver will select a region from cluster node's topology. The user can override this default.
    primaryIPID: "" # Existing ID of reserved IP from the same subnet as the file share zone. Zone and region are mandatory for this. SubnetID is not mandatory for this.
    primaryIPAddress: "" # IPAddress for VNI to be created in the subnet of the zone. Zone, region and subnetID are mandatory for this.
    iops: "" # Example: 100, this option is valid only for the dp2 profile.
    allowCapacityRoundoffForIops: "true" # Optional. Enables automatic capacity roundoff for fixed IOPS dp2 profiles. When set to "true", if the requested PVC size is lower than the minimum supported capacity for the requested IOPS, the driver automatically provisions the volume at the minimum supported capacity. Disabled by default. Requires a Virtual Private Endpoint Gateway (VPEG) to IBM Global Catalog.
    throughput: "" # Example: 2000, this option is valid only for the rfs profile
    tags: "" # User can add a list of tags "a, b, c" that will be used at the time of provisioning file share, by default CSI driver has its own tags.
    uid: "0" # The initial user identifier for the file share, by default its root.
    gid: "0" # The initial group identifier for the file share, by default its root.
    classVersion: "1"
reclaimPolicy: "Delete"
allowVolumeExpansion: true

Esempio di seconda generazione:

Se si effettua il provisioning di un PVC 10Gi utilizzando la classe di storage ibmc-vpc-file-min-iops di prima generazione, l'IOPS massimo è di 1.000. L'allocazione predefinita è 100 e il throughput è fissato a 210 Mbps, non sintonizzabile.

Tuttavia, se si effettua il provisioning di un PVC 10Gi utilizzando la classe di storage ibmc-vpc-file-regional di seconda generazione, l'IOPS è fisso a 35.000 e il throughput massimo è sintonizzabile fino a 8192 Mbps, anche se l'impostazione predefinita è 8 Mbps.

Ad esempio, se inizialmente si effettua il provisioning di un PVC con dimensioni inferiori a 16 TB e IOPS fisso 500 utilizzando la classe di storage ibmc-vpc-file-500-iops di prima generazione, le IOPS e il throughput sono fissi e calcolati in base alle dimensioni e alle IOPS.

Per espandere il PVC oltre i 16 TB, la classe di archiviazione ibmc-vpc-file-500-iops di prima generazione non può funzionare. Utilizzando invece la classe di storage di seconda generazione ibmc-vpc-file-regional-max-bandwidth, è possibile eseguire il provisioning di un PVC di qualsiasi dimensione fino a 32 TB, con un massimo di 35000 IOPS e un throughput predefinito di 8192 Mbps, che può essere regolato.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ibmc-vpc-file-regional-max-bandwidth
  labels:
    app.kubernetes.io/name: ibm-vpc-file-csi-driver
  annotations:
    version: v2.0
    revision: "1"
provisioner: vpc.file.csi.ibm.io
mountOptions:
  - hard
  - nfsvers=4.1
  - sec=sys
parameters:
  profile: "rfs" # general-purpose, sdp, 5iops-tier, 10iops-tier, or custom
  billingType: "hourly"
  encrypted: "false"
  encryptionKey: ""
  resourceGroup: ""
  throughput: "8192" # Example: 2000
  classVersion: "1"
  isENIEnabled: "true"   # VPC File Share ENI/VNI feature will be used by all PVCs created with this storage class.
  securityGroupIDs: ""   # By default cluster security group i.e kube-<clusterID> will be used. User can provide their own command separated SGs.
  subnetID: ""         # User can provide subnetID in which the ENI/VNI will be created.If not provided CSI driver will use the subnetID available in the cluster' VPC zone.
  primaryIPID: ""      # Existing ID of reserved IP from any of subnets within the VPC,subnetID is not mandatory for this.
  primaryIPAddress: "" # IPAddress for ENI/VNI to be created in the respective subnet,subnetID is mandatory for this.
  uid: "0"             # The initial user identifier for the file share, by default its root.
  gid: "0"             # The initial group identifier for the file share, by default its root.
allowVolumeExpansion: true # Select true or false. Only supported on version 3.0.1 and later
reclaimPolicy: "Delete"

Crea la classe di archiviazione personalizzata nel tuo cluster.
```
oc apply -f custom-storageclass.yaml
```
Verifica che la tua classe di archiviazione sia disponibile nel cluster.
```
oc get sc
```
Output di esempio
```
ibmc-vpc-file-custom-sc                       vpc.file.csi.ibm.io
```

Impostazione della classe di archiviazione predefinita

La modifica della classe di archiviazione predefinita è disponibile solo per il componente aggiuntivo versione 2.0 o successiva.
È possibile impostare la classe di archiviazione predefinita su una delle classi preinstallate File Storage for VPC o sulla propria classe di archiviazione personalizzata. Se si utilizza una classe di archiviazione personalizzata, assicurarsi che il provisioner sia impostato su vpc.file.csi.ibm.io.
Se più classi di archiviazione sono impostate come predefinite in un cluster, è possibile utilizzare una qualsiasi delle classi di archiviazione predefinite. Come best practice e per garantire l'uso della classe di archiviazione corretta, rimuovere tutte le classi di archiviazione predefinite esistenti nel cluster prima di impostare una nuova classe predefinita. Se è installato anche il componente aggiuntivo VPC Block Storage, è possibile che una classe di archiviazione VPC Block Storage sia già impostata come predefinita. Per rimuoverla prima di impostare un nuovo valore predefinito, consulta la sezione Modifica della classe di archiviazione predefinita per l'archiviazione a blocchi VPC.

Modificare la configmap addon-vpc-file-csi-driver-configmap e specificare il nome della classe di archiviazione nel parametro SET_DEFAULT_STORAGE_CLASS.
```
oc edit cm addon-vpc-file-csi-driver-configmap -n kube-system
```
Output di esempio
```
SET_DEFAULT_STORAGE_CLASS: "ibmc-vpc-file-eit"
```

Verificare che il valore predefinito sia impostato correttamente descrivendo la file-csi-driver-status configmap.

oc describe cm file-csi-driver-status -n kube-system

Output di esempio.

events:
----
- event: EnableVPCFileCSIDriver
  description: 'VPC File CSI Driver enable successful, DriverVersion: v2.0.6'
  timestamp: "2024-09-20 12:01:02"
- event: Change default storage class request
  description: Successfully set 'ibmc-vpc-file-eit' as default storage class
  timestamp: "2024-09-20 12:01:36"

Distribuzione di un'applicazione che viene eseguita come non root

I parametri uid e gid nella classe di archiviazione definiscono gli identificatori iniziali dell'utente e del gruppo per la condivisione di file a livello di infrastruttura. Per informazioni generali sul funzionamento degli ID supplementari nell'archiviazione file VPC, consultare la sezione " ID supplementari per le condivisioni di file VPC ".

Crea la tua classe di archiviazione e specifica l'ID gruppo o l'ID utente che vuoi utilizzare per la tua applicazione.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ibmc-vpc-file-custom-sc
  labels:
    app.kubernetes.io/name: ibm-vpc-file-csi-driver
provisioner: vpc.file.csi.ibm.io
mountOptions:
  - hard
  - nfsvers=4.1
  - sec=sys
parameters:
    profile: "dp2"
    iops: "100"
    billingType: "hourly" # hourly or monthly
    encrypted: "false"
    uid: "3000" # The initial user identifier for the file share.
    gid: "1000" # The initial group identifier for the file share.
    classVersion: "1"
reclaimPolicy: "Delete"
allowVolumeExpansion: true

Salvare il seguente YAML in un file denominato my-pvc.yaml.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
  storageClassName: ibmc-vpc-file-custom-sc

Crea la PVC.
```
oc apply -f my-pvc.yaml
```

Crea un pod che monti la PVC.

apiVersion: v1
kind: Pod
metadata:
  name: security-context-demo
spec:
  securityContext:
    runAsUser: 3000
    runAsGroup: 1000
  volumes:
  - name: sec-ctx-vol
    persistentVolumeClaim:
        claimName: my-pvc
  containers:
  - name: sec-ctx-demo
    image: busybox:1.28
    command: [ "sh", "-c", "sleep 1h" ]
    volumeMounts:
    - name: sec-ctx-vol
      mountPath: /data/demo
    securityContext:
      allowPrivilegeEscalation: false

Verificare che il pod sia in esecuzione.
```
oc get pods
```

Impostazione della crittografia KMS per File Storage for VPC

Utilizza un provider di servizi di gestione delle chiavi (KMS), come IBM® Key Protect o Hyper Protect Crypto Services, per creare una chiave root privata da utilizzare nell'istanza di File Storage for VPC per crittografare i dati mentre vengono scritti nell'archivio. Dopo aver creato la chiave root privata, crea una classe di archiviazione personalizzata o un segreto " Kubernetes " utilizzando la tua chiave root, quindi utilizza tale classe di archiviazione o segreto per configurare la tua istanza File Storage for VPC.

Creare un'istanza del provider KMS che si desidera utilizzare.
- Key Protect.
- Hyper Protect Crypto Services.
Crea una chiave principale nella tua istanza KMS.
- Key Protect chiave principale.
- Hyper Protect Crypto Services chiave di root. Per impostazione predefinita, la chiave root viene creata senza una data di scadenza.
Completare i prerequisiti per la crittografia gestita dal cliente e autorizzare File Storage for VPC ad accedere a IBM® Key Protect. Assicurarsi di dare a File Storage for VPC almeno Reader l'accesso alla propria istanza KMS.

Creare una classe di archiviazione personalizzata e specificare i dettagli del KMS.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: custom-sc-encrypted
  labels:
    app.kubernetes.io/name: ibm-vpc-file-csi-driver
provisioner: vpc.file.csi.ibm.io
mountOptions:
  - hard
  - nfsvers=4.1
  - sec=sys
parameters:
    profile: "dp2"
    billingType: "hourly" # hourly or monthly
    encrypted: "true"
    encryptionKey: "" # Specify the root key CRN.
    resourceGroup: "" # Resource group ID. By default, the resource group of the cluster will be used from storage-secrete-store secret.
    isENIEnabled: "true" # VPC File Share VNI feature will be used by all PVCs created with this storage class.
    securityGroupIDs: "" # By default cluster security group i.e kube-<clusterID> will be used. User can provide their own comma separated SGs.
    subnetID: "" # User can provide subnetID in which the VNI will be created. Zone and region are mandatory for this. If not provided CSI driver will use the subnetID available in the cluster's VPC zone.
    region: "" # VPC CSI driver will select a region from cluster node's topology. The user can override this default.
    zone: "" # VPC CSI driver will select a region from cluster node's topology. The user can override this default.
    primaryIPID: "" # Existing ID of reserved IP from the same subnet as the file share zone. Zone and region are mandatory for this. SubnetID is not mandatory for this.
    primaryIPAddress: "" # IPAddress for VNI to be created in the subnet of the zone. Zone, region and subnetID are mandatory for this.
    tags: "" # User can add a list of tags "a, b, c" that will be used at the time of provisioning file share, by default CSI driver has its own tags.
    uid: "0" # The initial user identifier for the file share, by default its root.
    gid: "0" # The initial group identifier for the file share, by default its root.
    classVersion: "1"
reclaimPolicy: "Delete"
allowVolumeExpansion: true

Crea la classe di archiviazione.
```
oc apply -f encrypted-class.yaml
```

Salvare il seguente YAML in un file denominato my-pvc.yaml.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
  storageClassName: custom-sc-encrypted

Crea la PVC.
```
oc apply -f my-pvc.yaml
```
Salva la seguente configurazione di distribuzione nel file denominato deployment.yaml e fai riferimento alla PVC che hai creato nel passo precedente.
```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-deployment
spec:
  selector:
    matchLabels:
      app: busybox
  template:
    metadata:
      labels:
        app: busybox
    spec:
      containers:
      - name: busybox
        image: busybox:1.28
        command: [ "sh", "-c", "sleep 1h" ]
        volumeMounts:
        - name: my-vol
          mountPath: /data/demo # Mount path for the application.
      volumes:
      - name: my-vol
        persistentVolumeClaim:
          claimName: my-pvc # Your PVC name.
```
volumeMounts.mountPath

Nella sezione container volume mounts, immetti il percorso assoluto della directory in cui viene montato il volume all'interno del contenitore. I dati scritti nel percorso di montaggio vengono memorizzati nella directory root all'interno dell'istanza fisica di File Storage for VPC. Se desideri condividere un volume tra diverse app, puoi specificare i percorsi secondari del volume per ciascuna delle tue app.

volumeMounts.name

Nella sezione container volume mounts, immetti il nome del volume per montare il tuo pod.

volume.name

Nella sezione volumes, immetti il nome del volume da montare sul tuo pod. In genere questo nome corrisponde a volumeMounts.name.
Crea la distribuzione.
```
oc apply -f deployment.yaml
```

Configurazione della crittografia in transito (EIT)

Per configurare la crittografia in transito per File Storage for VPC, consultare la sezione " Crittografia in transito per IBM Cloud File Storage for VPC ". Questo argomento riguarda sia le condivisioni di file zonali (profilo dp2 ) sia le condivisioni di file regionali (profilo rfs, versione beta).

Aggiornamento delle richieste e dei limiti relativi alle risorse dei container

È possibile personalizzare le richieste e i limiti relativi alle risorse di CPU e memoria per i container in esecuzione nell'add-on " File Storage for VPC ". La regolazione di questi valori può aiutarti a ottimizzare le prestazioni in cluster di grandi dimensioni o in ambienti con risorse limitate.

I parametri seguono lo schema di denominazione <ContainerName>CPULimit, <ContainerName>CPURequest, <ContainerName>MemoryLimit e <ContainerName>MemoryRequest. Applicarle ai container del controller e del server dei nodi.

Modifica la mappa di configurazione addon-vpc-file-csi-driver-configmap e aggiungi i parametri delle risorse relativi ai container che desideri modificare. L'esempio seguente imposta i valori relativi alla CPU e alla memoria per i container del controller e del server dei nodi.

oc edit cm addon-vpc-file-csi-driver-configmap -n kube-system

Valori di esempio:

controllerCPULimit: "200m"
controllerCPURequest: "100m"
controllerMemoryLimit: "256Mi"
controllerMemoryRequest: "128Mi"
nodeServerCPULimit: "200m"
nodeServerCPURequest: "100m"
nodeServerMemoryLimit: "256Mi"
nodeServerMemoryRequest: "128Mi"

Verificare che le modifiche alla risorsa siano state applicate correttamente descrivendo la mappa di configurazione “ file-csi-driver-status ”. Cerca un evento “ Successfully set container resources ” nella sezione “ events ”.
```
oc describe cm file-csi-driver-status -n kube-system
```
Output di esempio:
```
events:
----
- description: Successfully set container resources
  event: Change container resources
  timestamp: "2026-06-26 08:32:05"
```

Limitazione dell'accesso alla condivisione file per pool di nodi di lavoro, zona o nodo di lavoro

Il comportamento predefinito per il componente aggiuntivo del cluster File Storage for VPC è che i pod su qualsiasi nodo possono accedere alle condivisioni file. Puoi anche applicare un controllo più dettagliato su come i pod accedono alle tue condivisioni file. Ad esempio, potresti limitare l'accesso alla condivisione file solo ai pod su uno specifico nodo, in una specifica zona, su un pool di nodi di lavoro specifico. Esamina i seguenti scenari per come puoi configurare l'accesso pod alle tue condivisioni file.

Quando viene creato un PVC, viene creata una destinazione di condivisione file per ogni PVC e viene riservato un IP VNI su quella sottorete nella zona. Ciò significa che il numero massimo di PVC per l'archiviazione file VPC dipende dagli indirizzi IP disponibili su tale sottorete.

Se utilizzi le seguenti funzioni VNI per limitare l'accesso del pod alle tue condivisioni file, la tua applicazione potrebbe non essere altamente disponibile.

Prima di iniziare

Per limitare l'accesso alla condivisione file per nodo, zona o gruppo di risorse, devi prima creare un gruppo di sicurezza VPC personalizzato.

Elencare i cluster e prendere nota dell'ID cluster in cui si desidera distribuire l'archiviazione file.
```
ibmcloud ks cluster ls
```
Ottenete i dettagli del vostro pool di lavoratori.
```
ibmcloud ks worker-pool ls --cluster CLUSTER
```

Ottenere i dettagli della sottorete.

ibmcloud ks worker-pool get WORKER_POOL --cluster CLUSTER | grep -A 3 Subnets

Ottenere i CIDR della sottorete. Ripetere questo passaggio per ogni sottorete. Questo intervallo CIDR verrà utilizzato in seguito.
```
ibmcloud is subnet SUBNET_ID | grep "IPv4 CIDR"
```

Elencare i gruppi di sicurezza e prendere nota del gruppo di protezione ID kube-<clusterID> per il cluster. Hai bisogno dell'ID del gruppo di sicurezza in seguito quando aggiungi le regole del gruppo di sicurezza.

ibmcloud is sg

Output di esempio

ID                                          Name                                             Rules   Targets   VPC       Resource group
r006-4aaec88f-4986-4b7c-a737-401f7fef1555   kube-clusterID                       15      0         my-vpc   default

Crea un gruppo di sicurezza personalizzato nello stesso VPC del tuo cluster. È possibile utilizzare questo gruppo di sicurezza per controllare l'accesso alle condivisioni file aggiungendo regole del gruppo di sicurezza.
```
ibmcloud is security-group-create my-custom-security-group VPC-ID
```
Crea la tua classe di archiviazione e immetti l'ID del gruppo di protezione personalizzato che hai creato in precedenza. Tutte le PVC create da questa classe di memoria si trovano nel gruppo di protezione personalizzato.

Crea una PVC che utilizza la tua classe di archiviazione.

  apiVersion: v1
  kind: PersistentVolumeClaim
  metadata:
    name: pvc-custom-vni
  spec:
    accessModes:
    - ReadWriteMany
    resources:
      requests:
        storage: 10Gi
    storageClassName: "" # For example: my-custom-storage-class

Dopo che il PV si collega alla PVC, ottieni i dettagli del PV e prendi nota del valore nfsServerPath per trovare l'indirizzo IP VNI.
```
kubectl get pv pvc-XXXX -o yaml | grep nfsServerPath
```
Output di esempio
```
nfsServerPath: XXX.XX.XX.XXX:/XX # VNI IP address
```

Limitazione dell'accesso alla condivisione file ai pod su un nodo di lavoro

Assicuratevi di aver completato i prerequisiti.

Aggiungi la seguente regola al gruppo di protezione personalizzato che hai creato in precedenza.

ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.240.0.20 # Worker node IP

Aggiungi la seguente regola al gruppo di sicurezza kube-clusterID.

ibmcloud is sg-rulec kube-<cluster-id> outbound tcp --port-min 111 --port-max 2049 --remote 10.240.0.10 # VNI IP

Crea una distribuzione che utilizza la tua PVC. Solo i pod distribuiti sul nodo di lavoro che corrispondono alla regola che hai creato sono in grado di montare o utilizzare la PVC. I pod distribuiti su altri nodi sono bloccati nello stato creating del contenitore.

Limitazione dell'accesso alla condivisione file ai pod sui nodi di lavoro in una zona singola

Assicuratevi di aver completato i prerequisiti.

Aggiungi la seguente regola al gruppo di protezione personalizzato che hai creato in precedenza.

ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.240.0.0/24 # zone subnet cidr range

Aggiungi la seguente regola al gruppo di sicurezza kube-clusterID. Specificare l'indirizzo IP della VNI (virtual network interface).
```
ibmcloud is sg-rulec kube-<cluster-ID> outbound tcp --port-min 111 --port-max 2049 --remote 10.240.0.10 # VNI IP
```
Crea una distribuzione che utilizza la tua PVC. Solo i pod distribuiti nella zona elencata nella regola precedente possono montare la PVC. I pod distribuiti in altre zone non possono accedere alla PVC e sono bloccati nello stato creating del contenitore.

Limitazione dell'accesso di condivisione file ai pod sui nodi di lavoro in un unico pool di nodi di lavoro

Assicuratevi di aver completato i prerequisiti.

Crea regole in entrata per ogni intervallo di sottoreti del pool di lavoro.

ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.240.0.0/24 # zone 1 subnet cidr range
ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.240.1.0/24 # zone 2 subnet cidr range

Aggiungi la seguente regola al gruppo di sicurezza kube-clusterID. Specificare l'indirizzo IP della VNI (virtual network interface) come remoto o origine.
```
ibmcloud is sg-rulec kube-<cluster-ID> outbound tcp --port-min 111 --port-max 2049 --remote 10.240.0.10 # VNI IP
```
Distribuisci un'applicazione che utilizza la PVC che hai creato in precedenza. Solo i pod sui pool di lavoro indicati nella regola precedente possono montare la PVC. Oppure, se distribuisci la tua applicazione in un daemonset, i pod verranno distribuiti correttamente solo sui nodi di lavoro per cui hai creato le regole del gruppo di sicurezza. I pod sui pool di nodi di lavoro che non sono nel pool di nodi di lavoro specificato non riescono con un errore MountVolume.SetUp failed for volume "pvc-184b8c92-33ea-4874-b2ac-17665e53c060" : rpc error: code = DeadlineExceeded desc = context deadline exceeded.

Limitazione dell'accesso di condivisione file ai pod sui nodi di lavoro in più pool di nodi di lavoro

Assicuratevi di aver completato i prerequisiti.

Aggiungi le seguenti regole al gruppo di sicurezza personalizzato. Specifica i pool di nodi di lavoro e gli intervalli CIDR della sottorete come remoto o di origine.

ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.240.1.0/24 # worker pool 1, zone 1 subnet CIDR range
ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.240.1.0/24 # worker pool 1, zone 2 subnet CIDR range
ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.241.0.0/24 # worker pool 2, zone 1 subnet CIDR range
ibmcloud is sg-rulec CUSTOM-SG inbound tcp --port-min 111 --port-max 2049 --remote 10.241.1.0/24 # worker pool 2, zone 2subnet CIDR range

Aggiungi la seguente regola al gruppo di sicurezza kube-<clusterID>. Specificare l'indirizzo IP della VNI (virtual network interface) come remoto o origine.
```
ibmcloud is sg-rulec kube-<clusterID> outbound tcp --port-min 111 --port-max 2049 --remote 10.240.1.7 # VNI-IP
```
Crea una distribuzione che utilizza la tua PVC. Solo i pod distribuiti nella zona indicata nella regola possono montare la PVC. I pod distribuiti sui nodi di lavoro limitati sono bloccati nello stato Contenitore creating.