Använda Azure Container Storage Preview med Azure Elastic SAN

Artikel
03/22/2024

Azure Container Storage är en molnbaserad volymhanterings-, distributions- och orkestreringstjänst som skapats internt för containrar. Den här artikeln visar hur du konfigurerar Azure Container Storage att använda Azure Elastic SAN som serverdelslagring för dina Kubernetes-arbetsbelastningar. I slutet 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 Komma 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 Installera Azure Container Storage.
Se till att din prenumeration har rollen Azure-rollbaserad åtkomstkontroll (Azure RBAC). För att Azure Container Storage ska kunna kommunicera med Elastic SAN:s API behöver det särskilda behörigheter som ägarrollen beviljar.

Kommentar

Om du vill använda Azure Container Storage med Azure Elastic SAN bör 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) 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 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.

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.

Tilldela rollen Deltagare till AKS-hanterad identitet i Azure Elastic SAN-prenumeration

Därefter måste du tilldela den inbyggda rollen Deltagare i Azure RBAC till den AKS-hanterade identiteten i din Azure Elastic SAN-prenumeration. Du behöver en ägarroll för din Azure-prenumeration för att kunna göra detta. Om du inte har tillräcklig behörighet ber du administratören att utföra de här stegen.

Logga in på Azure-portalen.
Välj Prenumerationer och leta upp och välj den prenumeration som är associerad med Azure Elastic SAN-resursen som Azure Container Storage skapade åt dig. Detta kommer sannolikt att vara samma prenumeration som AKS-klustret som Azure Container Storage är installerat på. Du kan kontrollera detta genom att hitta den elastiska SAN-resursen i resursgruppen som AKS skapade (MC_YourResourceGroup_YourAKSClusterName_Region).
Välj Åtkomstkontroll (IAM) i det vänstra fönstret.
Välj Lägg till lägg till > rolltilldelning.
Under Tilldelningstyp väljer du Privilegierade administratörsroller och sedan Deltagare och sedan Nästa. Om du inte har rollen Ägare i prenumerationen kan du inte lägga till rollen Deltagare.
Under Tilldela åtkomst till väljer du Hanterad identitet.
Under Medlemmar klickar du på + Välj medlemmar. Menyn Välj hanterade identiteter visas.
Under Hanterad identitet väljer du Användartilldelad hanterad identitet.
Under Välj söker du efter och väljer den hanterade identiteten med ditt klusternamn och -agentpool läggs till.
Klicka på Välj och sedan på Granska + tilldela.

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.

Skapa ett beständigt 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.

Distribuera en podd 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 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.

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>