Använda Azure Container Storage (version 1.x.x) med Azure Elastic SAN (förhandsversion)

2025-09-11

Azure Container Storage är en molnbaserad volymhanterings-, distributions- och orkestreringstjänst som skapats internt för containrar. Azure Elastic SAN är en helt integrerad lösning som förenklar distribution, skalning, hantering och konfiguration av ett SAN, samtidigt som den erbjuder inbyggda molnfunktioner som hög tillgänglighet.

Den här artikeln visar hur du konfigurerar Azure Container Storage (version 1.x.x) för att använda Azure Elastic SAN. I slutet av den här artikeln har du en podd som använder Elastic SAN som lagringsplats.

Viktigt!

Den här artikeln beskriver funktioner som är tillgängliga i Azure Container Storage (version 1.x.x). Azure Container Storage (version 2.x.x) är nu tillgängligt, men stöder för närvarande endast lokal NVMe för säkerhetskopiering av lagring.

Förutsättningar

Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.
Den här artikeln kräver den senaste versionen av Azure CLI. Se Så här installerar du Azure CLI. Om du använder Bash-miljön i Azure Cloud Shell är den senaste versionen förmodligen redan installerad. Om du planerar att köra kommandona lokalt i stället för i Azure Cloud Shell ska du köra dem med administratörsbehörighet. Mer information finns i Kom igång med Azure Cloud Shell.
Du behöver Kubernetes kommandoradsklient, kubectl. Det är redan installerat om du använder Azure Cloud Shell, eller så kan du installera det lokalt genom att köra kommandot az aks install-cli.
Kontrollera om målregionen stöds i Azure Container Storage-regioner.

Kontrollera att du har rollen som Azure Container Storage-ägare eller Azure Container Storage-deltagare i din prenumeration. Rollen Azure Container Storage-deltagare ger dig de behörigheter som krävs för att utföra Azure Arc-tilläggsåtgärder och för att skriva till och ta bort resurser. Rollen Azure Container Storage-ägare ger dig samma behörigheter och gör att du kan hantera elastiska SAN-volymer utanför klustret. Om du vill göra den här ändringen går du till din prenumerationssida i Azure-portalen. Välj Åtkomstkontroll (IAM) > Lägg till rolltilldelning och sök efter antingen "Azure Container Storage-ägare" eller "Azure Container Storage-deltagare" på fliken Jobbfunktionsroller . Välj Visa > tilldelningar > Lägg till tilldelning och lägg till ditt konto.
Om du vill använda Azure Container Storage med Azure Elastic SAN (förhandsversion) måste ditt AKS-kluster ha en nodpool på minst tre virtuella datorer för generell användning, till exempel standard_d4s_v5 för klusternoderna, var och en med minst fyra virtuella processorer (vCPU:er).

Begränsningar

Följande funktioner stöds inte för närvarande när du använder Azure Container Storage för att distribuera och orkestrera ett elastiskt SAN.

Ögonblicksbilder av volymer
Expansion av lagringspool

Regional tillgänglighet

Azure Container Storage är endast tillgängligt för en delmängd av Azure-regioner:

(Afrika) Sydafrika, norra
(Asien och stillahavsområdet) Australien, östra
(Asien och Stillahavsområdet) Asien, östra
(Asien och stillahavsområdet) Japan, östra
(Asien och Stillahavsområdet) Korea, centrala
(Asien och Stillahavsområdet) Sydostasien
(Asien och stillahavsområdet) Indien, centrala
(Europa) Frankrike, centrala
(Europa) Tyskland, västra centrala
(Europa) Europa, norra
(Europa) Västeuropa
(Europa) Storbritannien, södra
(Europa) Sverige, centrala
(Europa) Schweiz, norra
(Mellanöstern) Förenade Arabemiraten, norra
(Nordamerika) USA, östra
(Nordamerika) Östra USA 2
(Nordamerika) Västra USA
(Nordamerika) Västra USA 2
(Nordamerika) Västra USA 3
(Nordamerika) USA, centrala
(Nordamerika) USA, norra centrala
(Nordamerika) Södra centrala USA
(Nordamerika) USA, västra centrala
(Nordamerika) Kanada, centrala
(Nordamerika) Kanada, östra
(Sydamerika) Brasilien, södra

Skapa och koppla beständiga volymer

Följ de här stegen för att skapa och koppla en beständig volym.

1. Skapa en lagringspool

Skapa först en lagringspool, som är en logisk gruppering av lagring för ditt Kubernetes-kluster, genom att definiera den i en YAML-manifestfil.

Om du har aktiverat Azure Container Storage med hjälp av az aks create eller az aks update kommandon kanske du redan har en lagringspool. Använd kubectl get sp -n acstor för att hämta listan över lagringspooler. Om du redan har en tillgänglig lagringspool som du vill använda kan du hoppa över det här avsnittet och fortsätta till Visa tillgängliga lagringsklasser.

Följ de här stegen för att skapa en lagringspool med Azure Elastic SAN (förhandsversion).

Använd din favorittextredigerare för att skapa en YAML-manifestfil, code acstor-storagepool.yamltill exempel .
Klistra in följande kod. Värdet för lagringspoolens namn kan vara vad du vill. Justera lagringen så att den återspeglar den lagringskapacitet som du vill använda i Gi eller Ti och spara filen. Azure Elastic SAN stöder för närvarande inte storleksändring av lagringspooler.
```
apiVersion: containerstorage.azure.com/v1
kind: StoragePool
metadata:
  name: managed
  namespace: acstor
spec:
  poolType:
    elasticSan: {}
  resources:
    requests: {"storage": 1Ti}
```
Använd YAML-manifestfilen för att skapa lagringspoolen.
```
kubectl apply -f acstor-storagepool.yaml 
```
När lagringspoolen har skapats visas ett meddelande som:
```
storagepool.containerstorage.azure.com/managed created
```
Du kan också köra det här kommandot för att kontrollera lagringspoolens status. Ersätt <storage-pool-name> med värdet för lagringspoolens namn . I det här exemplet skulle värdet vara hanterat.
```
kubectl describe sp <storage-pool-name> -n acstor
```

När lagringspoolen skapas skapar Azure Container Storage en lagringsklass åt dig med hjälp av namngivningskonventionen acstor-<storage-pool-name>. Den skapar också en Azure Elastic SAN-resurs.

2. Visa tillgängliga lagringsklasser

När lagringspoolen är redo att användas måste du välja en lagringsklass för att definiera hur lagring skapas dynamiskt när du skapar beständiga volymanspråk och distribuerar beständiga volymer.

Kör kubectl get sc för att visa tillgängliga lagringsklasser. Du bör se en lagringsklass med namnet acstor-<storage-pool-name>.

Viktigt!

Använd inte lagringsklassen som är markerad som intern. Det är en intern lagringsklass som behövs för att Azure Container Storage ska fungera.

3. Skapa en persistent volymskrav

Ett beständigt volymbegäran (PVC) används för att automatiskt tilldela lagring baserat på en lagringsklass. Följ dessa steg för att skapa en PVC med hjälp av den nya lagringsklassen.

Använd din favorittextredigerare för att skapa en YAML-manifestfil, code acstor-pvc.yamltill exempel .

Klistra in följande kod och spara filen. PVC-värdet name kan vara vad du vill.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: managedpvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: acstor-managed # replace with the name of your storage class if different
  resources:
    requests:
      storage: 100Gi

Använd YAML-manifestfilen för att skapa PVC.
```
kubectl apply -f acstor-pvc.yaml
```
Du bör se utdata som liknar följande:
```
persistentvolumeclaim/managedpvc created
```
Du kan kontrollera status för PVC genom att köra följande kommando:
```
kubectl describe pvc managedpvc
```

När PVC:en har skapats är den redo att användas av en podd.

4. Distribuera en pod och bifoga en beständig volym

Skapa en podd med Fio (flexibel I/O-testare) för benchmarking och arbetsbelastningssimulering och ange en monteringssökväg för den beständiga volymen. För claimName använder du det namn som du använde när du skapade anspråket för den beständiga volymen.

Använd din favorittextredigerare för att skapa en YAML-manifestfil, code acstor-pod.yamltill exempel .

Klistra in följande kod och spara filen.

kind: Pod
apiVersion: v1
metadata:
  name: fiopod
spec:
  nodeSelector:
    acstor.azure.com/io-engine: acstor
  volumes:
    - name: managedpv
      persistentVolumeClaim:
        claimName: managedpvc
  containers:
    - name: fio
      image: nixery.dev/shell/fio
      args:
        - sleep
        - "1000000"
      volumeMounts:
        - mountPath: "/volume"
          name: managedpv

Använd YAML-manifestfilen för att distribuera podden.
```
kubectl apply -f acstor-pod.yaml
```
Du bör se utdata som liknar följande:
```
pod/fiopod created
```
Kontrollera att podden körs och att det beständiga volymanspråket har bundits till podden:
```
kubectl describe pod fiopod
kubectl describe pvc managedpvc
```

Kontrollera fio-testningen för att se dess aktuella status:

kubectl exec -it fiopod -- fio --name=benchtest --size=800m --filename=/volume/test --direct=1 --rw=randrw --ioengine=libaio --bs=4k --iodepth=16 --numjobs=8 --time_based --runtime=60

Nu har du distribuerat en podd som använder ett elastiskt SAN som lagringsplats, och du kan använda den för dina Kubernetes-arbetsbelastningar.

Hantera beständiga volymer och lagringspooler

Nu när du har skapat en beständig volym kan du koppla från och återansluta den efter behov. Du kan också ta bort en lagringspool.

Koppla från och återanslut en beständig volym

Om du vill koppla från en beständiga volym tar du bort podden som den beständiga volymen är kopplad till. Ersätt <pod-name> med poddens namn, till exempel fiopod.

kubectl delete pods <pod-name>

För att återansluta en beständig volym refererar du enkelt till beständig volymanspråksnamnet i YAML-manifestfilen enligt beskrivningen i Distribuera en podd och anslut en beständig volym.

Om du vill kontrollera vilken beständig volym ett beständigt volymkrav är bundet till, kör kubectl get pvc <persistent-volume-claim-name>.

Ta bort en lagringspool

Kör följande kommando om du vill ta bort en lagringspool. Ersätt <storage-pool-name> med namnet på lagringspoolen.

kubectl delete sp -n acstor <storage-pool-name>

Se även

Feedback

Var den här sidan till hjälp?