

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Bereitstellung NVMe/TCP für Linux

FSx for ONTAP unterstützt das Non-Volatile Memory Express over TCP (NVMe/TCP) -Blockspeicherprotokoll. Mit verwenden Sie die ONTAP CLI NVMe/TCP, um Namespaces und Subsysteme bereitzustellen und die Namespaces dann Subsystemen zuzuordnen, ähnlich wie LUNs bereitgestellt und Initiatorgruppen (IGroups) für iSCSI zugeordnet werden. Das NVMe/TCP Protokoll ist auf Dateisystemen der zweiten Generation mit 6 oder weniger Hochverfügbarkeitspaaren (HA) verfügbar. [Verwaltung von Hochverfügbarkeitspaaren (HA)](HA-pairs.md)

**Anmerkung**  
FSx für ONTAP-Dateisysteme verwendet die iSCSI-Endpunkte einer SVM sowohl für iSCSI- als auch für Blockspeicherprotokolle. NVMe/TCP 

Der Konfigurationsprozess NVMe/TCP auf Ihrem Amazon FSx for NetApp ONTAP besteht aus drei Hauptschritten, die in den folgenden Verfahren behandelt werden:

1. Installieren und konfigurieren Sie den NVMe-Client auf dem Linux-Host.

1. Konfigurieren Sie NVMe auf der SVM des Dateisystems.
   + Erstellen Sie einen NVMe-Namespace.
   + Erstellen Sie ein NVMe-Subsystem.
   + Ordnen Sie den Namespace dem Subsystem zu.
   + Fügen Sie den Client-NQN zum Subsystem hinzu.

1. Mounten Sie ein NVMe-Gerät auf dem Linux-Client.

## Bevor Sie beginnen
<a name="nvme-tcp-linux-byb"></a>

Bevor Sie mit der Konfiguration Ihres Dateisystems für beginnen NVMe/TCP, müssen Sie die folgenden Schritte ausführen.
+ Erstellen Sie ein FSx for ONTAP-Dateisystem. Weitere Informationen finden Sie unter [Erstellen von Dateisystemen](creating-file-systems.md).
+ Erstellen Sie eine EC2-Instance, auf der Red Hat Enterprise Linux (RHEL) 9.3 ausgeführt wird, in derselben VPC wie das Dateisystem. Dies ist der Linux-Host, auf dem Sie NVMe konfigurieren und mit Linux auf Ihre Dateidaten zugreifen werden. NVMe/TCP 

  Wenn sich der Host in einer anderen VPC befindet, können Sie über diese Verfahren hinaus VPC-Peering verwenden oder anderen VPCs Zugriff auf die AWS Transit Gateway iSCSI-Endpunkte des Volumes gewähren. Weitere Informationen finden Sie unter [Zugreifen auf Daten von außerhalb der Bereitstellungs-VPC](supported-fsx-clients.md#access-from-outside-deployment-vpc).
+ Konfigurieren Sie die VPC-Sicherheitsgruppen des Linux-Hosts so, dass eingehender und ausgehender Datenverkehr zugelassen wird, wie unter beschrieben. [Zugriffskontrolle für Dateisysteme mit Amazon VPC](limit-access-security-groups.md)
+ Besorgen Sie sich die Anmeldeinformationen für den ONTAP Benutzer mit den `fsxadmin` Rechten, die Sie für den Zugriff auf die CLI verwenden werden. ONTAP Weitere Informationen finden Sie unter [AUF TAP Rollen und Benutzer](roles-and-users.md).
+ Der Linux-Host, den Sie für NVMe konfigurieren und den Sie für den Zugriff auf das FSx for ONTAP-Dateisystem verwenden, befindet sich in derselben VPC und. AWS-Konto
+ Wir empfehlen, dass sich die EC2-Instance in derselben Verfügbarkeitszone befindet wie das bevorzugte Subnetz Ihres Dateisystems.

Wenn Ihre EC2-Instance ein anderes Linux-AMI als RHEL 9.3 ausführt, sind einige der in diesen Verfahren und Beispielen verwendeten Dienstprogramme möglicherweise bereits installiert, und Sie verwenden möglicherweise andere Befehle, um die erforderlichen Pakete zu installieren. Abgesehen von der Installation von Paketen gelten die in diesem Abschnitt verwendeten Befehle für andere EC2-Linux-AMIs.

**Anmerkung**  
Das automatische Failover zwischen Ihren Dateiservern NVMe/TCP basiert auf nativem NVMe-Multipathing, das in RHEL 9.3 standardmäßig aktiviert ist. Einige andere Linux-Distributionen und AMIs ermöglichen standardmäßig kein natives NVMe-Multipathing. In diesem Fall ist ein automatisches Failover zwischen Ihren Dateiservern nicht verfügbar. In der Dokumentation Ihrer Distribution finden Sie Informationen zur Unterstützung von nativem NVMe-Multipathing und zu den Schritten zu deren Aktivierung.

**Topics**
+ [Bevor Sie beginnen](#nvme-tcp-linux-byb)
+ [Installieren und konfigurieren Sie NVMe auf dem Linux-Host](#configure-nvme-on-rhel93)
+ [Konfigurieren Sie NVMe auf dem FSx for ONTAP-Dateisystem](#configure-nvme-on-svm)
+ [Mounten Sie ein NVMe-Gerät auf Ihrem Linux-Client](#add-nvme-on-rhel93-host)

## Installieren und konfigurieren Sie NVMe auf dem Linux-Host
<a name="configure-nvme-on-rhel93"></a>

**Um den NVMe-Client zu installieren**

1. Stellen Sie mithilfe eines SSH-Clients eine Verbindung zu Ihrer Linux-Instance her. Weitere Informationen finden Sie unter [ Herstellen einer Verbindung zu Ihrer Linux-Instance von Linux oder macOS aus mithilfe von SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-ssh.html).

1. Installieren Sie `nvme-cli` mit dem folgenden Befehl:

   ```
   ~$ sudo yum install -y nvme-cli
   ```

1. Laden Sie das `nvme-tcp` Modul auf den Host:

   ```
   $ sudo modprobe nvme-tcp
   ```

1. Rufen Sie den NVMe Qualified Name (NQN) des Linux-Hosts mit dem folgenden Befehl ab:

   ```
   $ cat /etc/nvme/hostnqn
   nqn.2014-08.org.nvmexpress:uuid:9ed5b327-b9fc-4cf5-97b3-1b5d986345d1
   ```

   Notieren Sie die Antwort zur Verwendung in einem späteren Schritt.

## Konfigurieren Sie NVMe auf dem FSx for ONTAP-Dateisystem
<a name="configure-nvme-on-svm"></a>

**Um NVMe im Dateisystem zu konfigurieren**

Stellen Sie eine Verbindung zur NetApp ONTAP CLI auf dem FSx for ONTAP-Dateisystem her, auf dem Sie die NVMe-Geräte erstellen möchten.

1. Um auf die ONTAP CLI zuzugreifen, richten Sie eine SSH-Sitzung auf dem Management-Port des Amazon FSx for NetApp ONTAP-Dateisystems oder der SVM ein, indem Sie den folgenden Befehl ausführen. `{{management_endpoint_ip}}`Ersetzen Sie es durch die IP-Adresse des Management-Ports des Dateisystems.

   ```
   [~]$ ssh fsxadmin@{{management_endpoint_ip}}
   ```

   Weitere Informationen finden Sie unter [Verwaltung von Dateisystemen mit dem ONTAP CLI](managing-resources-ontap-apps.md#fsxadmin-ontap-cli). 

1. Erstellen Sie ein neues Volume auf der SVM, die Sie für den Zugriff auf die NVMe-Schnittstelle verwenden.

   ```
   ::> vol create -vserver fsx -volume nvme_vol1 -aggregate aggr1 -size 1t
        [Job 597] Job succeeded: Successful
   ```

1. Erstellen Sie den NVMe-Namespace `ns_1` mit dem ONTAP-CLI-Befehl [`vserver nvme namespace create`](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-namespace-create.html) NetApp . Ein Namespace ist Initiatoren (Clients) zugeordnet und steuert, welche Initiatoren (Clients) Zugriff auf NVMe-Geräte haben.

   ```
   ::> vserver nvme namespace create -vserver fsx -path /vol/nvme_vol1/ns_1 -size 100g -ostype linux
   Created a namespace of size 100GB (107374182400).
   ```

1. Erstellen Sie das NVMe-Subsystem mit dem ONTAP-CLI-Befehl. [`vserver nvme subsystem create`](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-subsystem-create.html) NetApp 

   ```
   ~$ vserver nvme subsystem create -vserver fsx -subsystem sub_1 -ostype linux
   ```

1. Ordnen Sie den Namespace dem Subsystem zu, das Sie gerade erstellt haben.

   ```
   ::> vserver nvme subsystem map add -vserver fsx -subsystem sub_1 -path /vol/nvme_vol1/ns_1
   ```

1. Fügen Sie den Client mithilfe des zuvor abgerufenen NQN zum Subsystem hinzu.

   ```
   ::> vserver nvme subsystem host add -subsystem sub_1 -host-nqn nqn.2014-08.org.nvmexpress:uuid:ec21b083-1860-d690-1f29-44528e4f4e0e -vserver fsx
   ```

   Wenn Sie die diesem Subsystem zugewiesenen Geräte mehreren Hosts zur Verfügung stellen möchten, können Sie mehrere Initiatornamen in einer durch Kommas getrennten Liste angeben. Weitere Informationen finden Sie unter [ vserver nvme subsystem host add in den ONTAP-Dokumenten. ](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-subsystem-host-add.html) NetApp 

1. Bestätigen Sie mit dem folgenden Befehl, ob der Namespace existiert: [**vserver nvme namespace show**](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-namespace-show.html)

   ```
   ::> vserver nvme namespace show -vserver fsx -instance
   Vserver Name: fsx
               Namespace Path: /vol/nvme_vol1/ns_1
                         Size: 100GB
                    Size Used: 90.59GB
                      OS Type: linux
                      Comment: 
                   Block Size: 4KB
                        State: online
            Space Reservation: false
   Space Reservations Honored: false
                 Is Read Only: false
                Creation Time: 5/20/2024 17:03:08
               Namespace UUID: c51793c0-8840-4a77-903a-c869186e74e3
                     Vdisk ID: 80d42c6f00000000187cca9
         Restore Inaccessible: false
      Inconsistent Filesystem: false
          Inconsistent Blocks: false
                       NVFail: false
   Node Hosting the Namespace: FsxId062e9bb6e05143fcb-01
                  Volume Name: nvme_vol1
                   Qtree Name: 
             Mapped Subsystem: sub_1
               Subsystem UUID: db526ec7-16ca-11ef-a612-d320bd5b74a9               
                 Namespace ID: 00000001h
                 ANA Group ID: 00000001h
                 Vserver UUID: 656d410a-1460-11ef-a612-d320bd5b74a9
                   Vserver ID: 3
                  Volume MSID: 2161388655
                  Volume DSID: 1029
                    Aggregate: aggr1
               Aggregate UUID: cfa8e6ee-145f-11ef-a612-d320bd5b74a9
    Namespace Container State: online
           Autodelete Enabled: false
             Application UUID: -
                  Application: -
     Has Metadata Provisioned: true
     
   1 entries were displayed.
   ```

1. Verwenden Sie den [** network interface show -vserver**](https://docs.netapp.com/us-en/ontap-cli-9141/network-interface-show.html) Befehl, um die Adressen der Blockspeicherschnittstellen für die SVM abzurufen, auf der Sie Ihre NVMe-Geräte erstellt haben.

   ```
   ::> network interface show -vserver {{svm_name}} -data-protocol nvme-tcp
               Logical               Status     Network            Current                    Current Is 
   Vserver     Interface             Admin/Oper Address/Mask       Node                       Port    Home
   ----------- ----------            ---------- ------------------ -------------              ------- ----
   {{svm_name}}
               iscsi_1               up/up      172.31.16.19/20    FSxId0123456789abcdef8-01  e0e     true
               iscsi_2               up/up      172.31.26.134/20   FSxId0123456789abcdef8-02  e0e     true
   2 entries were displayed.
   ```
**Anmerkung**  
Das `iscsi_1` LIF wird sowohl für iSCSI als auch für. NVMe/TCP

   In diesem Beispiel lautet die IP-Adresse von iscsi\_1 172.31.16.19 und iscsi\_2 ist 172.31.26.134.

## Mounten Sie ein NVMe-Gerät auf Ihrem Linux-Client
<a name="add-nvme-on-rhel93-host"></a>

Das Mounten des NVMe-Geräts auf Ihrem Linux-Client umfasst drei Schritte:

1. Erkennen der NVMe-Knoten

1. Partitionierung des NVMe-Geräts

1. Mounten des NVMe-Geräts auf dem Client

Diese werden in den folgenden Verfahren behandelt.

**Um die NVMe-Zielknoten zu ermitteln**

1. Verwenden Sie auf Ihrem Linux-Client den folgenden Befehl, um die NVMe-Zielknoten zu ermitteln. {{`iscsi_1_IP`}}Ersetzen `iscsi_1` Sie durch die IP-Adresse und {{`client_IP`}} die IP-Adresse des Clients.
**Anmerkung**  
`iscsi_1`und `iscsi_2` LIFs werden sowohl für iSCSI- als auch für NVMe-Speicher verwendet.

   ```
   ~$ sudo nvme discover -t tcp -w {{client_IP}} -a {{iscsi_1_IP}}
   ```

   ```
   Discovery Log Number of Records 4, Generation counter 11
   =====Discovery Log Entry 0======
   trtype:  tcp
   adrfam:  ipv4
   subtype: current discovery subsystem
   treq:    not specified
   portid:  0
   trsvcid: 8009
   subnqn:  nqn.1992-08.com.netapp:sn.656d410a146011efa612d320bd5b74a9:discovery
   traddr:  172.31.26.134
   eflags:  explicit discovery connections, duplicate discovery information
   sectype: none
   =====Discovery Log Entry 1======
   trtype:  tcp
   adrfam:  ipv4
   subtype: current discovery subsystem
   treq:    not specified
   portid:  1
   trsvcid: 8009
   subnqn:  nqn.1992-08.com.netapp:sn.656d410a146011efa612d320bd5b74a9:discovery
   traddr:  172.31.16.19
   eflags:  explicit discovery connections, duplicate discovery information
   sectype: none
   ```

1. (Optional) Um für Ihr Datei-NVMe-Gerät einen höheren Durchsatz als der Amazon EC2-Einzelclient von maximal 5 Gbit/s (\~625 Mbit/s) zu erzielen, folgen Sie den unter [ Amazon EC2-Instance-Netzwerkbandbreite ](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html) im Amazon Elastic Compute Cloud-Benutzerhandbuch für Linux-Instances beschriebenen Verfahren, um zusätzliche Sitzungen einzurichten.

1. Melden Sie sich bei den Zielinitiatoren mit einem Timeout von mindestens 1800 Sekunden für den Controller-Verlust an. Verwenden Sie erneut die IP-Adresse für {{`iscsi_1_IP`}} und die IP-Adresse `iscsi_1` des Clients für. {{`client_IP`}} Ihre NVMe-Geräte werden als verfügbare Festplatten angezeigt.

   ```
   ~$ sudo nvme connect-all -t tcp -w {{client_IP}} -a {{iscsi_1}} -l 1800
   ```

1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob der NVMe-Stack die mehreren Sitzungen identifiziert und zusammengeführt und Multipathing konfiguriert hat. Der Befehl kehrt zurück, `Y` wenn natives NVMe-Multipathing aktiviert ist, was für ein automatisches, transparentes Failover zwischen Ihren Dateiservern erforderlich ist. Wenn der Befehl zurückgegeben wird `N` oder die Datei nicht existiert, ist in Ihrem Linux-Kernel das native NVMe-Multipathing nicht aktiviert, und ein automatisches Failover zwischen Ihren Dateiservern ist nicht verfügbar. Weitere Informationen finden Sie in dem Hinweis unter. [Bevor Sie beginnen](#nvme-tcp-linux-byb)

   ```
   ~$ cat /sys/module/nvme_core/parameters/multipath
   Y
   ```

1. Stellen Sie mit den folgenden Befehlen sicher, dass die NVMe-oF Einstellung `model` auf `NetApp ONTAP Controller` und der Lastausgleich `round-robin` für die jeweiligen ONTAP Namespaces auf gesetzt `iopolicy` ist, um sie I/O auf alle verfügbaren Pfade zu verteilen

   ```
   ~$ cat /sys/class/nvme-subsystem/nvme-subsys*/model
   Amazon Elastic Block Store              
   NetApp ONTAP Controller
   ~$ cat /sys/class/nvme-subsystem/nvme-subsys*/iopolicy
   numa
   round-robin
   ```

1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob die Namespaces auf dem Host erstellt und korrekt erkannt wurden:

   ```
   ~$ sudo nvme list
   Node                  Generic               SN                   Model                                    Namespace  Usage                      Format           FW Rev  
   --------------------- --------------------- -------------------- ---------------------------------------- ---------- -------------------------- ---------------- --------
   /dev/nvme0n1          /dev/ng0n1            vol05955547c003f0580 Amazon Elastic Block Store               0x1         25.77  GB /  25.77  GB    512   B +  0 B   1.0     
   /dev/nvme2n1          /dev/ng2n1            lWB12JWY/XLKAAAAAAAC NetApp ONTAP Controller                  0x1        107.37  GB / 107.37  GB      4 KiB +  0 B   FFFFFFFF
   ```

   Das neue Gerät in der Ausgabe ist. `/dev/nvme2n1` Dieses Benennungsschema kann je nach Ihrer Linux-Installation unterschiedlich sein.

1. Stellen Sie sicher, dass der Controller-Status jedes Pfads live ist und den richtigen ANA-Multipathing-Status (Asymmetric Namespace Access) aufweist:

   ```
   ~$ nvme list-subsys /dev/nvme2n1
   nvme-subsys2 - NQN=nqn.1992-08.com.netapp:sn.656d410a146011efa612d320bd5b74a9:subsystem.rhel
                  hostnqn=nqn.2014-08.org.nvmexpress:uuid:ec2a70bf-3ab2-6cb0-f997-8730057ceb24
                  iopolicy=round-robin
   \
    +- nvme2 tcp traddr=172.31.26.134,trsvcid=4420,host_traddr=172.31.25.143,src_addr=172.31.25.143 live non-optimized
    +- nvme3 tcp traddr=172.31.16.19,trsvcid=4420,host_traddr=172.31.25.143,src_addr=172.31.25.143 live optimized
   ```

   In diesem Beispiel hat der NVMe-Stack automatisch die alternative LIF Ihres Dateisystems erkannt, 172.31.26.134. `iscsi_2`

1. Stellen Sie sicher, dass das NetApp Plug-In die richtigen Werte für jedes Namespace-Gerät anzeigt: ONTAP

   ```
   ~$ sudo nvme netapp ontapdevices -o column
   Device           Vserver                   Namespace Path                                     NSID UUID                                   Size     
   ---------------- ------------------------- -------------------------------------------------- ---- -------------------------------------- ---------
   /dev/nvme2n1     fsx                       /vol/nvme_vol1/ns_1                                1    0441c609-3db1-4b0b-aa83-790d0d448ece   107.37GB
   ```

**Um das Gerät zu partitionieren**

1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob der Pfad zu Ihrem Gerätenamen vorhanden `nvme2n1` ist.

   ```
   ~$ ls /dev/nvme2n1
   /dev/nvme2n1
   ```

1. Partitionieren Sie die Festplatte mit. `fdisk` Sie werden eine interaktive Eingabeaufforderung eingeben. Geben Sie die Optionen in der angegebenen Reihenfolge ein. Sie können mehrere Partitionen erstellen, indem Sie einen Wert verwenden, der kleiner als der letzte Sektor ist (`20971519`in diesem Beispiel).
**Anmerkung**  
Der `Last sector` Wert variiert je nach Größe Ihres NVMe-Geräts (100 GiB in diesem Beispiel).

   ```
   ~$ sudo fdisk /dev/nvme2n1
   ```

   Die `fsdisk` interaktive Eingabeaufforderung wird gestartet.

   ```
   Welcome to fdisk (util-linux 2.37.4). 
   Changes will remain in memory only, until you decide to write them. 
   Be careful before using the write command. 
   
   Device does not contain a recognized partition table. 
   Created a new DOS disklabel with disk identifier 0x66595cb0. 
   
   Command (m for help): n
   Partition type 
      p primary (0 primary, 0 extended, 4 free) 
      e extended (container for logical partitions) 
   Select (default p): p
   Partition number (1-4, default 1): 1 
   First sector (256-26214399, default 256): 
   Last sector, +sectors or +size{K,M,G,T,P} (256-26214399, default 26214399): 20971519
                                       
   Created a new partition 1 of type 'Linux' and of size 100 GiB.
   Command (m for help): w
   The partition table has been altered.
   Calling ioctl() to re-read partition table. 
   Syncing disks.
   ```

   Nach der Eingabe `w` `/dev/nvme2n1` wird Ihre neue Partition verfügbar. Die {{partition\_name}} hat das Format {{<device\_name>}}{{<partition\_number>}}. `1`wurde im vorherigen Schritt als Partitionsnummer im `fdisk` Befehl verwendet.

1. Erstellen Sie Ihr Dateisystem unter Verwendung `/dev/nvme2n1` als Pfad.

   ```
   ~$ sudo mkfs.ext4 /dev/nvme2n1
   ```

   Das System reagiert mit der folgenden Ausgabe:

   ```
   mke2fs 1.46.5 (30-Dec-2021)
   Found a dos partition table in /dev/nvme2n1
   Proceed anyway? (y,N) y
   Creating filesystem with 26214400 4k blocks and 6553600 inodes
   Filesystem UUID: 372fb2fd-ae0e-4e74-ac06-3eb3eabd55fb
   Superblock backups stored on blocks: 
       32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
       4096000, 7962624, 11239424, 20480000, 23887872
   
   Allocating group tables: done                            
   Writing inode tables: done                            
   Creating journal (131072 blocks): done
   Writing superblocks and filesystem accounting information: done
   ```

**Um das NVMe-Gerät auf dem Linux-Client zu mounten**

1. Erstellen Sie ein Verzeichnis {{directory\_path}} als Bereitstellungspunkt für Ihr Dateisystem auf der Linux-Instance.

   ```
   ~$ sudo mkdir /{{directory_path}}/{{mount_point}}
   ```

1. Mounten Sie das Dateisystem mit dem folgenden Befehl.

   ```
   ~$ sudo mount -t ext4 /dev/nvme2n1 /{{directory_path}}/{{mount_point}}
   ```

1. (Optional) Wenn Sie einem bestimmten Benutzer die Verantwortung für das Mount-Verzeichnis übertragen möchten, {{`username`}} ersetzen Sie es durch den Benutzernamen des Besitzers.

   ```
   ~$ sudo chown {{username}}:{{username}} /{{directory_path}}/{{mount_point}}
   ```

1. (Optional) Stellen Sie sicher, dass Sie Daten aus dem Dateisystem lesen und in das Dateisystem schreiben können.

   ```
   ~$ echo "Hello world!" > /{{directory_path}}/{{mount_point}}/HelloWorld.txt
   ~$ cat {{directory_path}}/HelloWorld.txt
   Hello world!
   ```

   Sie haben erfolgreich ein NVMe-Gerät erstellt und auf Ihrem Linux-Client gemountet.