Provisionar os volumes NFS do Azure NetApp Files para o Serviço de Kubernetes do Azure

Artigo
08/02/2024

Depois de configurar o Azure NetApp Files para o Serviço de Kubernetes do Azure, você pode provisionar volumes de um para o outro.

O Azure NetApp Files dá suporte à volumes usando NFS (NFSv3 ou NFSv4.1), SMB ou de protocolo duplo (NFSv3 e SMB ou NFSv4.1 e SMB).

Este artigo descreve detalhes para provisionar volumes NFS de forma estática e dinâmica.
Para obter informações sobre como provisionar volumes SMB de forma estática e dinâmica, consulte Provisionar volumes SMB do Azure NetApp Files para o Serviço de Kubernetes do Azure.
Para obter informações sobre como provisionar volumes de protocolo duplo de forma estática, consulte Provisionar volumes de protocolo duplo do Azure NetApp Files para o Serviço de Kubernetes do Azure

Configurar estaticamente para aplicativos que usam volumes NFS

Esta seção descreve como criar um volume NFS no Azure NetApp Files e expor o volume estaticamente ao Kubernetes. Ela também descreve como usar o volume com um aplicativo conteinerizado.

Criar um volume NFS

Definir variáveis para usar mais tarde. Substitua myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid e anfSubnetID por um valor apropriado de sua conta e ambiente. O caminho do arquivo deve ser exclusivo em todas as contas do ANF.

RESOURCE_GROUP="myresourcegroup"
LOCATION="mylocation"
ANF_ACCOUNT_NAME="myaccountname"
POOL_NAME="mypool1"
SERVICE_LEVEL="premium" # Valid values are Standard, Premium, and Ultra
UNIQUE_FILE_PATH="myfilepath"
VOLUME_SIZE_GIB="myvolsize"
VOLUME_NAME="myvolname"
VNET_ID="vnetId"
SUBNET_ID="anfSubnetId"

Crie um volume usando o comando az netappfiles volume create. Para obter mais informações, confira Criar um volume NFS para o Azure NetApp Files.

az netappfiles volume create \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --name "$VOLUME_NAME" \
    --service-level $SERVICE_LEVEL \
    --vnet $VNET_ID \
    --subnet $SUBNET_ID \
    --usage-threshold $VOLUME_SIZE_GIB \
    --file-path $UNIQUE_FILE_PATH \
    --protocol-types NFSv3

Criar o volume persistente

Listar os detalhes do volume usando o comando az netappfiles volume show. Substitua as variáveis por valores apropriados de sua conta e ambiente do Azure NetApp Files caso não tenha definido em uma etapa anterior.

az netappfiles volume show \
    --resource-group $RESOURCE_GROUP \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --volume-name "$VOLUME_NAME -o JSON

A saída a seguir é um exemplo do comando acima executado com valores reais.

{
  ...
  "creationToken": "myfilepath2",
  ...
  "mountTargets": [
    {
      ...
      "ipAddress": "10.0.0.4",
      ...
    }
  ],
  ...
}

Crie um arquivo chamado pv-nfs.yaml e copie no YAML a seguir. Verifique se o servidor corresponde ao endereço IP de saída da Etapa 1 e se o caminho corresponde à saída acima creationToken. A capacidade também deve corresponder ao tamanho do volume da etapa acima.
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-nfs
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  mountOptions:
    - vers=3
  nfs:
    server: 10.0.0.4
    path: /myfilepath2
```
Crie o volume persistente usando o comando kubectl apply:
```
kubectl apply -f pv-nfs.yaml
```
Verifique se o status do volume persistente é Disponível usando o comando kubectl describe:
```
kubectl describe pv pv-nfs
```

Criar uma declaração de volume persistente

Crie um arquivo chamado pvc-nfs.yaml e copie no YAML a seguir. Esse manifesto cria um PVC chamado pvc-nfs para o modo de acesso ReadWriteMany e armazenamento de 100Gi, correspondendo ao PV criado.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Crie a declaração do volume persistente usando o comando kubectl apply:
```
kubectl apply -f pvc-nfs.yaml
```
Verifique se o Status da declaração de volume persistente é Limitado usando o comando kubectl describe:
```
kubectl describe pvc pvc-nfs
```

Montar com um pod

Crie um arquivo chamado nginx-nfs.yaml e copie no YAML a seguir. Esse manifesto define um pod nginx que usa a declaração de volume persistente.

kind: Pod
apiVersion: v1
metadata:
  name: nginx-nfs
spec:
  containers:
  - image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    name: nginx-nfs
    command:
    - "/bin/sh"
    - "-c"
    - while true; do echo $(date) >> /mnt/azure/outfile; sleep 1; done
    volumeMounts:
    - name: disk01
      mountPath: /mnt/azure
  volumes:
  - name: disk01
    persistentVolumeClaim:
      claimName: pvc-nfs

Crie o pod usando o comando kubectl apply:
```
kubectl apply -f nginx-nfs.yaml
```
Verifique se o pod está Em execução usando o comando kubectl describe:
```
kubectl describe pod nginx-nfs
```

Verifique se o volume foi montado no pod usando kubectl exec para se conectar ao pod e df -h para verificar se o volume foi montado.

kubectl exec -it nginx-nfs -- sh

/ # df -h
Filesystem             Size  Used Avail Use% Mounted on
...
10.0.0.4:/myfilepath2  100T  384K  100T   1% /mnt/azure
...

Configurar de forma dinâmica para aplicativos que usam volumes NFS

O Astra Trident pode ser usado para provisionar arquivos NFS ou SMB de forma dinâmica no Azure NetApp Files. Os volumes SMB provisionados de forma dinâmica só têm suporte com nós de trabalho do Windows.

Esta seção descreve como usar o Astra Trident para criar de forma dinâmica um volume NFS no Azure NetApp Files e montá-lo automaticamente em um aplicativo conteinerizado.

Instalar o Astra Trident

Para provisionar volumes NFS de forma dinâmica, você precisa instalar o Astra Trident. O Astra Trident é o provisionamento de armazenamento dinâmico da NetApp criado especificamente para Kubernetes. Simplifique o consumo de armazenamento para aplicativos Kubernetes usando o driver de CSI (Interface de Armazenamento de Contêiner) padrão do setor do Astra Trident. O Astra Trident implanta em clusters Kubernetes como pods e fornece serviços de orquestração de armazenamento dinâmico para suas cargas de trabalho em Kubernetes.

O Trident pode ser instalado usando o operador Trident (manualmente ou usando Helm) ou tridentctl. Para saber mais sobre esses métodos de instalação e como eles funcionam, confira o Guia de instalação Astra Trident.

Instalar o Astra Trident usando o Helm

O Helm deve ser instalado em sua estação de trabalho para instalar o Astra Trident usando esse método. Para obter outros métodos de instalação do Astra Trident, consulte o Guia de instalação do Astra Trident.

Para instalar o Astra Trident usando o Helm de um cluster com apenas nós de trabalho do Linux, execute os seguintes comandos:

helm repo add netapp-trident https://netapp.github.io/trident-helm-chart   
helm install trident netapp-trident/trident-operator --version 23.04.0  --create-namespace --namespace trident

A saída do comando é semelhante ao seguinte exemplo:

NAME: trident
LAST DEPLOYED: Fri May  5 13:55:36 2023
NAMESPACE: trident
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Thank you for installing trident-operator, which will deploy and manage NetApp's Trident CSI storage provisioner for Kubernetes.

Your release is named 'trident' and is installed into the 'trident' namespace.
Please note that there must be only one instance of Trident (and trident-operator) in a Kubernetes cluster.

To configure Trident to manage storage resources, you will need a copy of tridentctl, which is available in pre-packaged Trident releases.  You may find all Trident releases and source code online at https://github.com/NetApp/trident. 

To learn more about the release, try:

    $ helm status trident
      $ helm get all trident

Para confirmar se o Astra Trident foi instalado com êxito, execute o seguinte comando kubectl describe:

kubectl describe torc trident

A saída do comando é semelhante ao seguinte exemplo:

Name:         trident
Namespace:    
Labels:       app.kubernetes.io/managed-by=Helm
Annotations:  meta.helm.sh/release-name: trident
              meta.helm.sh/release-namespace: trident
API Version:  trident.netapp.io/v1
Kind:         TridentOrchestrator
Metadata:
    ...
Spec:
  IPv6:                  false
  Autosupport Image:     docker.io/netapp/trident-autosupport:23.04
  Autosupport Proxy:     <nil>
  Disable Audit Log:     true
  Enable Force Detach:   false
  Http Request Timeout:  90s
  Image Pull Policy:     IfNotPresent
  k8sTimeout:            0
  Kubelet Dir:           <nil>
  Log Format:            text
  Log Layers:            <nil>
  Log Workflows:         <nil>
  Namespace:             trident
  Probe Port:            17546
  Silence Autosupport:   false
  Trident Image:         docker.io/netapp/trident:23.04.0
  Windows:               false
Status:
  Current Installation Params:
    IPv6:                       false
    Autosupport Hostname:       
    Autosupport Image:          docker.io/netapp/trident-autosupport:23.04
    Autosupport Proxy:          
    Autosupport Serial Number:  
    Debug:                      false
    Disable Audit Log:          true
    Enable Force Detach:        false
    Http Request Timeout:       90s
    Image Pull Policy:          IfNotPresent
    Image Pull Secrets:
    Image Registry:       
    k8sTimeout:           30
    Kubelet Dir:          /var/lib/kubelet
    Log Format:           text
    Log Layers:           
    Log Level:            info
    Log Workflows:        
    Probe Port:           17546
    Silence Autosupport:  false
    Trident Image:        docker.io/netapp/trident:23.04.0
  Message:                Trident installed
  Namespace:              trident
  Status:                 Installed
  Version:                v23.04.0
Events:
  Type    Reason      Age    From                        Message
  ----    ------      ----   ----                        -------
  Normal  Installing  2m59s  trident-operator.netapp.io  Installing Trident
  Normal  Installed   2m31s  trident-operator.netapp.io  Trident installed

Criar um back-end

Para instruir o Astra Trident sobre a assinatura do Azure NetApp Files e onde é preciso criar volumes, um back-end é criado. Esta etapa exige detalhes sobre a conta que foi criada em uma etapa anterior.

Crie um arquivo chamado backend-secret.yaml e copie no YAML a seguir. Altere a Client ID e o clientSecret para os valores corretos do seu ambiente.

apiVersion: v1
kind: Secret
metadata:
  name: backend-tbc-anf-secret
type: Opaque
stringData:
  clientID: 00001111-aaaa-2222-bbbb-3333cccc4444
  clientSecret: rR0rUmWXfNioN1KhtHisiSAnoTherboGuskey6pU

Crie um arquivo chamado backend-anf.yaml e copie no YAML a seguir. Altere a subscriptionID, tenantID, location e serviceLevel para os valores corretos do seu ambiente. Use a subscriptionID para a assinatura do Azure na qual o Azure NetApp Files está habilitado. Obtenha a tenantID, clientID e clientSecret de um registro de aplicativo no Microsoft Entra ID com permissões suficientes para o serviço Azure NetApp Files. O registro do aplicativo inclui a função Proprietário ou Colaborador predefinida pelo Azure. O local deve ser um local do Azure que contenha pelo menos uma sub-rede delegada criada em uma etapa anterior. O serviceLevel deve corresponder ao serviceLevel configurado para o pool de capacidade em Configurar o Azure NetApp Files para cargas de trabalho do AKS.
```
apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-anf
spec:
  version: 1
  storageDriverName: azure-netapp-files
  subscriptionID: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e
  tenantID: aaaabbbb-0000-cccc-1111-dddd2222eeee
  location: eastus
  serviceLevel: Premium
  credentials:
    name: backend-tbc-anf-secret
```
Para obter mais informações sobre back-ends, consulte Opções e exemplos de configuração de back-end do Azure NetApp Files.
Aplique o segredo e o back-end usando o comando kubectl apply. Primeiro aplique o segredo:
```
kubectl apply -f backend-secret.yaml -n trident
```
A saída do comando é semelhante ao seguinte exemplo:
```
secret/backend-tbc-anf-secret created
```
Aplicar o back-end:
```
kubectl apply -f backend-anf.yaml -n trident
```
A saída do comando é semelhante ao seguinte exemplo:
```
tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
```

Confirme se o back-end foi criado usando o comando kubectl get:

 kubectl get tridentbackends -n trident

A saída do comando é semelhante ao seguinte exemplo:

NAME        BACKEND               BACKEND UUID
tbe-kfrdh   backend-tbc-anf   8da4e926-9dd4-4a40-8d6a-375aab28c566

Criar uma classe de armazenamento

Uma classe de armazenamento é usada para definir como uma unidade de armazenamento é criada dinamicamente com um volume persistente. Para consumir volumes do Azure NetApp Files, uma classe de armazenamento deve ser criada.

Crie um arquivo chamado anf-storageclass.yaml e o copie no YAML a seguir:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azure-netapp-files
provisioner: csi.trident.netapp.io
parameters:
  backendType: "azure-netapp-files"
  fsType: "nfs"

Crie a classe de armazenamento usando o comando kubectl apply:
```
kubectl apply -f anf-storageclass.yaml
```
A saída do comando é semelhante ao seguinte exemplo:
```
storageclass/azure-netapp-files created
```

Execute o comando kubectl get para exibir o status da classe de armazenamento:

kubectl get sc
NAME                 PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
azure-netapp-files   csi.trident.netapp.io   Delete          Immediate           false

Criar um PVC

Uma PVC (declaração de volume persistente) é uma solicitação de armazenamento por um usuário. Após a criação de uma declaração de volume persistente, o Astra Trident cria automaticamente um volume Azure NetApp Files e o disponibiliza para que as cargas de trabalho do Kubernetes o consumam.

Crie um arquivo chamado anf-pvc.yaml e copie no YAML a seguir. Neste exemplo, um volume de 1 TiB é necessário com acesso ReadWriteMany.

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: anf-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Ti
  storageClassName: azure-netapp-files

Crie a declaração do volume persistente com o comando kubectl apply:
```
kubectl apply -f anf-pvc.yaml
```
A saída do comando é semelhante ao seguinte exemplo:
```
persistentvolumeclaim/anf-pvc created
```

Para exibir informações sobre a declaração de volume persistente, execute o comando kubectl get:

kubectl get pvc

A saída do comando é semelhante ao seguinte exemplo:

kubectl get pvc -n trident
NAME      STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS         AGE
anf-pvc   Bound    pvc-bffa315d-3f44-4770-86eb-c922f567a075   1Ti        RWO            azure-netapp-files   62s

Usar o volume persistente

Depois que o PVC é criado, o Astra Trident cria o volume persistente. Um pod pode ser criado para montar e acessar o volume do Azure NetApp Files.

O manifesto a seguir pode ser usado para definir um pod NGINX que monta o volume do Azure NetApp Files criado na etapa anterior. Neste exemplo, o volume é montado em /mnt/data.

Crie um arquivo chamado anf-nginx-pod.yaml e o copie no YAML a seguir:

kind: Pod
apiVersion: v1
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 250m
        memory: 256Mi
    volumeMounts:
    - mountPath: "/mnt/data"
      name: volume
  volumes:
    - name: volume
      persistentVolumeClaim:
        claimName: anf-pvc

Crie o pod usando o comando kubectl apply:

kubectl apply -f anf-nginx-pod.yaml

A saída do comando é semelhante ao seguinte exemplo:

pod/nginx-pod created

O Kubernetes criou um pod com o volume montado e acessível dentro do contêiner nginx em /mnt/data. Você pode confirmar verificando os logs de eventos para o pod usando o comando kubectl describe:

kubectl describe pod nginx-pod

A saída do comando é semelhante ao seguinte exemplo:

[...]
Volumes:
  volume:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  anf-pvc
    ReadOnly:   false
  default-token-k7952:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-k7952
    Optional:    false
[...]
Events:
  Type    Reason                  Age   From                     Message
  ----    ------                  ----  ----                     -------
  Normal  Scheduled               15s   default-scheduler        Successfully assigned trident/nginx-pod to brameshb-non-root-test
  Normal  SuccessfulAttachVolume  15s   attachdetach-controller  AttachVolume.Attach succeeded for volume "pvc-bffa315d-3f44-4770-86eb-c922f567a075"
  Normal  Pulled                  12s   kubelet                  Container image "mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine" already present on machine
  Normal  Created                 11s   kubelet                  Created container nginx
  Normal  Started                 10s   kubelet                  Started container nginx

Próximas etapas

O Astra Trident é compatível com muitos recursos do Azure NetApp Files. Para obter mais informações, consulte:

Compartilhar via

Provisionar os volumes NFS do Azure NetApp Files para o Serviço de Kubernetes do Azure

Configurar estaticamente para aplicativos que usam volumes NFS

Criar um volume NFS

Criar o volume persistente

Criar uma declaração de volume persistente

Montar com um pod

Configurar de forma dinâmica para aplicativos que usam volumes NFS

Instalar o Astra Trident

Instalar o Astra Trident usando o Helm

Criar um back-end

Criar uma classe de armazenamento

Criar um PVC

Usar o volume persistente

Próximas etapas

Recursos adicionais