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

Artigo
11/01/2024

Depois de configurar os Arquivos NetApp do Azure para o Serviço Kubernetes do Azure, você pode provisionar volumes de Arquivos NetApp do Azure para o Serviço Kubernetes do Azure.

Os Arquivos NetApp do Azure dão suporte a volumes que usam NFS (NFSv3 ou NFSv4.1), SMB ou protocolo duplo (NFSv3 e SMB, ou NFSv4.1 e SMB).

Este artigo descreve detalhes para provisionar volumes NFS estática ou dinamicamente.
Para obter informações sobre como provisionar volumes SMB estática ou dinamicamente, consulte Provisionar volumes SMB de arquivos NetApp do Azure para o Serviço Kubernetes do Azure.
Para obter informações sobre como provisionar volumes de protocolo duplo estaticamente, consulte Provisionar volumes de protocolo duplo do Azure NetApp Files para o Serviço Kubernetes do Azure

Configurar estaticamente para aplicativos que usam volumes NFS

Esta seção descreve como criar um volume NFS nos Arquivos NetApp do Azure e expor o volume estaticamente ao Kubernetes. Ele também descreve como usar o volume com um aplicativo em contêiner.

Criar um volume NFS

Defina variáveis para uso posterior. Substitua myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid e anfSubnetID por um valor apropriado da sua conta e ambiente. O caminho do arquivo deve ser exclusivo em todas as contas 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 az netappfiles volume create comando. Para obter mais informações, consulte Criar um volume NFS para arquivos NetApp do Azure.

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

Liste os detalhes do seu volume usando az netappfiles volume show o comando. Substitua as variáveis por valores apropriados de sua conta e ambiente do Azure NetApp Files se não estiver 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 nomeado pv-nfs.yaml e copie no seguinte YAML. Verifique se o servidor corresponde ao endereço IP de saída da Etapa 1 e se o caminho corresponde à saída de creationToken cima. 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 kubectl apply comando:
```
kubectl apply -f pv-nfs.yaml
```
Verifique se o status do volume persistente está disponível usando o kubectl describe comando:
```
kubectl describe pv pv-nfs
```

Criar uma declaração de volume persistente

Crie um arquivo nomeado pvc-nfs.yaml e copie no seguinte YAML. Este manifesto cria um PVC nomeado pvc-nfs para o modo de armazenamento e ReadWriteMany acesso de 100Gi, correspondente ao PV que você criou.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Crie a declaração de volume persistente usando o kubectl apply comando:
```
kubectl apply -f pvc-nfs.yaml
```
Verifique se o Status da declaração de volume persistente é Bound usando o kubectl describe comando:
```
kubectl describe pvc pvc-nfs
```

Monte com um pod

Crie um arquivo nomeado nginx-nfs.yaml e copie no seguinte YAML. Esse manifesto define um nginx pod 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 kubectl apply comando:
```
kubectl apply -f nginx-nfs.yaml
```
Verifique se o pod está em execução usando o kubectl describe comando:
```
kubectl describe pod nginx-nfs
```

Verifique se o volume foi montado no pod usando kubectl exec para se conectar ao pod e, em seguida, use df -h para verificar se o volume está 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 dinamicamente para aplicativos que usam volumes NFS

O Astra Trident pode ser usado para provisionar dinamicamente arquivos NFS ou SMB nos Arquivos NetApp do Azure. Os volumes SMB provisionados dinamicamente só são suportados com nós de trabalho do Windows.

Esta seção descreve como usar o Astra Trident para criar dinamicamente um volume NFS nos Arquivos NetApp do Azure e montá-lo automaticamente em um aplicativo em contêiner.

Instale o Astra Trident

Para provisionar volumes NFS dinamicamente, você precisa instalar o Astra Trident. O Astra Trident é o provisionador de armazenamento dinâmico da NetApp criado especificamente para o Kubernetes. Simplifique o consumo de armazenamento para aplicativos Kubernetes usando o driver Container Storage Interface (CSI) 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 do 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, consulte o Guia de Instalação do Astra Trident.

Instale o Astra Trident usando o Helm

O leme deve ser instalado na sua estação de trabalho para instalar o Astra Trident utilizando este método. Para 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 para 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 que o Astra Trident foi instalado com êxito, execute o seguinte kubectl describe comando:

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 ele precisa criar volumes, um back-end é criado. Esta etapa requer detalhes sobre a conta que foi criada em uma etapa anterior.

Crie um arquivo nomeado backend-secret.yaml e copie no seguinte YAML. Altere os Client ID e clientSecret para os valores corretos para o 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 nomeado backend-anf.yaml e copie no seguinte YAML. Altere o subscriptionID, tenantID, locatione serviceLevel para os valores corretos para o seu ambiente. Use o subscriptionID para a assinatura do Azure onde o Azure NetApp Files está habilitado. Obtenha o tenantID, clientIDe 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 de 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 arquivos NetApp do Azure para cargas de trabalho 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 kubectl apply comando. 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
```
Aplique 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 kubectl get comando:

 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 nomeado anf-storageclass.yaml e copie no seguinte YAML:

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 kubectl apply comando:
```
kubectl apply -f anf-storageclass.yaml
```
A saída do comando é semelhante ao seguinte exemplo:
```
storageclass/azure-netapp-files created
```

Execute o kubectl get comando 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 declaração de volume persistente (PVC) é 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 de Arquivos NetApp do Azure e o disponibiliza para cargas de trabalho do Kubernetes consumirem.

Crie um arquivo nomeado anf-pvc.yaml e copie no seguinte YAML. Neste exemplo, um volume de 1 TiB é necessário com o 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 de volume persistente com o kubectl apply comando:
```
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 kubectl get comando:

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 girado para montar e acessar o volume de Arquivos NetApp do Azure.

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

Crie um arquivo nomeado anf-nginx-pod.yaml e copie no seguinte YAML:

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 kubectl apply comando:

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 nginx contêiner em /mnt/data. Você pode confirmar verificando os logs de eventos para o pod usando kubectl describe o comando:

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óximos passos

O Astra Trident suporta muitas funcionalidades com os Ficheiros NetApp do Azure. Para obter mais informações, consulte:

Partilhar via

Provisionar volumes NFS do Azure NetApp Files para o Serviço 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

Monte com um pod

Configurar dinamicamente para aplicativos que usam volumes NFS

Instale o Astra Trident

Instale o Astra Trident usando o Helm

Criar um back-end

Criar uma classe de armazenamento

Criar um PVC

Usar o volume persistente

Próximos passos

Recursos adicionais