Använda Azure Container Storage med Azure Elastic SAN (förhandsversion)

Artikel
08/07/2024

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.

Som förhandsversionsfunktion kan du konfigurera Azure Container Storage att använda Azure Elastic SAN. Den här artikeln beskriver hur du gör den konfigurationen. I slutet av den här artikeln har du en podd som använder Elastic SAN som lagringsplats.

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 (2.35.0 eller senare) 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 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 om du kan installera det lokalt genom att az aks install-cli köra kommandot .
Om du inte redan har installerat Azure Container Storage följer du anvisningarna i Använda Azure Container Storage med Azure Kubernetes Service.
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. Någon av dessa roller beviljar behörigheter som gör att Azure Container Storage kan kommunicera med elastic SAN-resursen. Om du vill göra den här ändringen går du till din prenumerationssida på Azure Portal. 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) Europa, västra
(Europa) Storbritannien, södra
(Europa) Sverige, centrala
(Europa) Schweiz, norra
(Mellanöstern) Förenade Arabemiraten, norra
(Nordamerika) USA, östra
(Nordamerika) USA, östra 2
(Nordamerika) USA, västra
(Nordamerika) USA, västra 2
(Nordamerika) USA, västra 3
(Nordamerika) USA, centrala
(Nordamerika) USA, norra centrala
(Nordamerika) USA, södra centrala
(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ändiga 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 hanteras värdet.
```
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 ett beständiga volymanspråk

Ett beständiga volymanspråk (PVC) används för att automatiskt etablera 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 podd och bifoga en beständiga 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 namnvärde som du använde när du skapade det beständiga volymanspråket.

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 koppla från den igen efter behov. Du kan också ta bort en lagringspool.

Koppla från och koppla från en beständig volym igen

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>

Om du vill återansluta en beständig volym refererar du helt enkelt till namnet på beständiga volymanspråk i YAML-manifestfilen enligt beskrivningen i Distribuera en podd och bifoga en beständiga volym.

Om du vill kontrollera vilken beständig volym som ett beständiga volymanspråk är bundet till kör du 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>

Dela via