Använda Förhandsversionen av Azure Container Storage med Azure-hanterade diskar

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-hanterade diskar som serverdelslagring för dina Kubernetes-arbetsbelastningar. I slutet har du en podd som använder Azure-hanterade diskar 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.

Kommentar

Om du vill använda Azure Container Storage med Azure-hanterade diskar 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).

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. Om du har Azure-hanterade diskar som redan har etablerats kan du skapa en fördefinierad lagringspool med hjälp av dessa diskar.

Viktigt!

Om du vill använda dina egna nycklar för att kryptera dina volymer i stället för att använda Microsoft-hanterade nycklar ska du inte skapa lagringspoolen med hjälp av stegen i det här avsnittet. Gå i stället till Aktivera kryptering på serversidan med kundhanterade nycklar och följ stegen där.

Följ de här stegen för att skapa en lagringspool för Azure Disks.

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. För skuName anger du prestanda- och redundansnivå. Godtagbara värden är Premium_LRS, Standard_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, PremiumV2_LRS och StandardSSD_ZRS. För lagring anger du mängden lagringskapacitet för poolen i Gi eller Ti. Spara filen.
```
apiVersion: containerstorage.azure.com/v1
kind: StoragePool
metadata:
  name: azuredisk
  namespace: acstor
spec:
  poolType:
    azureDisk:
      skuName: Premium_LRS
  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/azuredisk 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 azuredisk.
```
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>. Nu kan du visa tillgängliga lagringsklasser och skapa ett beständiga volymanspråk.

Skapa en fördefinierad lagringspool

Om du har Azure-hanterade diskar som redan har etablerats kan du skapa en fördefinierad lagringspool med hjälp av dessa diskar. Eftersom diskarna redan har etablerats behöver du inte ange skuName- eller lagringskapaciteten när du skapar lagringspoolen.

Följ de här stegen för att skapa en fördefinierad lagringspool för Azure Disks.

Logga in på Azure-portalen.
För varje disk som du vill använda navigerar du till den hanterade Azure-disken och väljer Inställningar> Egenskaper. Kopiera hela strängen under Resurs-ID och placera den i en textfil.
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. Ersätt <resource-id> med resurs-ID:t för varje hanterad disk. Spara filen.

apiVersion: containerstorage.azure.com/v1
kind: StoragePool
metadata:
  name: sp-preprovisioned
  namespace: acstor
spec:
  poolType:
    azureDisk:
      disks:
        - reference <resource-id1>
        - reference <resource-id2>

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/sp-preprovisioned 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 sp-preprovisioned.
```
kubectl describe sp <storage-pool-name> -n acstor
```

Aktivera kryptering på serversidan med kundhanterade nycklar

Om du redan har skapat en lagringspool eller om du föredrar att använda standardnycklarna för Microsoft-hanterad kryptering hoppar du över det här avsnittet och fortsätter till Visa tillgängliga lagringsklasser.

Alla data i ett Azure Storage-konto krypteras i vila. Som standard krypteras data med Microsoft-hanterade nycklar. Om du vill ha mer kontroll över krypteringsnycklar kan du ange kundhanterade nycklar (CMK) för att kryptera de beständiga volymer som du skapar från en Azure Disk-lagringspool.

Om du vill använda din egen nyckel måste du ha ett Azure Key Vault med en nyckel. Key Vault ska ha rensningsskydd aktiverat och måste använda Azure RBAC-behörighetsmodellen. Läs mer om kundhanterade nycklar i Linux.

När du skapar lagringspoolen måste du definiera CMK-parametrarna. De obligatoriska CMK-krypteringsparametrarna är:

keyVersion anger vilken version av nyckeln som ska användas
keyName är namnet på din nyckel
keyVaultUri är den enhetliga resursidentifieraren för Azure Key Vault, till exempel https://user.vault.azure.net
Identitet anger en hanterad identitet med åtkomst till valvet, till exempel/subscriptions/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/resourcegroups/MC_user-acstor-westus2-rg_user-acstor-westus2_westus2/providers/Microsoft.ManagedIdentity/userAssignedIdentities/user-acstor-westus2-agentpool

Följ de här stegen för att skapa en lagringspool med din egen krypteringsnyckel. Alla beständiga volymer som skapas från den här lagringspoolen krypteras med samma nyckel.

Använd din favorittextredigerare för att skapa en YAML-manifestfil, code acstor-storagepool-cmk.yamltill exempel .
Klistra in följande kod, ange de obligatoriska parametrarna och spara filen. Värdet för lagringspoolens namn kan vara vad du vill. För skuName anger du prestanda- och redundansnivå. Godtagbara värden är Premium_LRS, Standard_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, PremiumV2_LRS och StandardSSD_ZRS. För lagring anger du mängden lagringskapacitet för poolen i Gi eller Ti. Se till att ange CMK-krypteringsparametrarna.
```
apiVersion: containerstorage.azure.com/v1
kind: StoragePool
metadata:
  name: azuredisk
  namespace: acstor
spec:
  poolType:
    azureDisk:
      skuName: Premium_LRS
      encryption: {
        keyVersion: "<key-version>",
        keyName: "<key-name>",
        keyVaultUri: "<key-vault-uri>",
        identity: "<identity>"
      }
  resources:
    requests:
      storage: 1Ti
```
Använd YAML-manifestfilen för att skapa lagringspoolen.
```
kubectl apply -f acstor-storagepool-cmk.yaml 
```
När lagringspoolen har skapats visas ett meddelande som:
```
storagepool.containerstorage.azure.com/azuredisk 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 azuredisk.
```
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>.

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: azurediskpvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: acstor-azuredisk # 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/azurediskpvc created
```
Du kan kontrollera status för PVC genom att köra följande kommando:
```
kubectl describe pvc azurediskpvc
```

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: azurediskpv
      persistentVolumeClaim:
        claimName: azurediskpvc
  containers:
    - name: fio
      image: nixery.dev/shell/fio
      args:
        - sleep
        - "1000000"
      volumeMounts:
        - mountPath: "/volume"
          name: azurediskpv

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 azurediskpvc
```

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 Azure Disks 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>.

Expandera en lagringspool

Du kan expandera lagringspooler som backas upp av Azure Disks för att skala upp snabbt och utan driftstopp. Krympande lagringspooler stöds inte för närvarande.