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.
# NVMe/TCP für Linux bereitstellen
FSx für ONTAP unterstützt Non-Volatile Memory Express über TCP (NVMe/TCP) block storage protocol. With NVMe/TCP, Sie verwenden den ONTAP CLI zur Bereitstellung von Namespaces und Subsystemen und zur anschließenden Zuordnung der Namespaces zu Subsystemen, ähnlich wie bei der Bereitstellung und Zuordnung zu Initiatorgruppen ( LUNs IGroups) für iSCSI. [Das NVMe /TCP-Protokoll ist auf Dateisystemen der zweiten Generation mit 6 oder weniger Hochverfügbarkeitspaaren (HA) verfügbar.](HA-pairs.md)
**Anmerkung**
FSx für ONTAP-Dateisysteme verwenden Sie die iSCSI-Endpunkte einer SVM sowohl für iSCSI- NVMe als auch für /TCP-Blockspeicherprotokolle.
Die Konfiguration von NVMe /TCP auf Ihrem Amazon FSx for NetApp ONTAP umfasst drei Hauptschritte, 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 dem Subsystem hinzu.
1. Mounten Sie ein NVMe Gerät auf dem Linux-Client.
## Bevor Sie beginnen
Bevor Sie mit der Konfiguration Ihres Dateisystems für NVMe /TCP beginnen, müssen Sie die folgenden Punkte abgeschlossen haben.
+ Erstellen Sie ein FSx Dateisystem für ONTAP. Weitere Informationen finden Sie unter [Dateisysteme erstellen](creating-file-systems.md).
+ Erstellen Sie eine EC2 Instanz, auf der Red Hat Enterprise Linux (RHEL) 9.3 in derselben VPC wie das Dateisystem ausgeführt wird. Dies ist der Linux-Host, auf dem Sie Ihre Dateidaten mithilfe von NVMe /TCP für Linux konfigurieren NVMe und darauf zugreifen.
Wenn sich der Host in einer anderen VPC befindet, können Sie, abgesehen vom Umfang dieser Verfahren, 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. [Dateisystem-Zugriffskontrolle mit Amazon VPC](limit-access-security-groups.md)
+ Besorgen Sie sich die Anmeldeinformationen für ONTAP Benutzer mit `fsxadmin` Rechten, die Sie für den Zugriff auf die ONTAP CLI. Weitere Informationen finden Sie unter [ONTAPRollen und Benutzer](roles-and-users.md).
+ Der Linux-Host, für den Sie das für ONTAP konfigurierte NVMe und FSx für den Zugriff auf das Dateisystem verwenden, befindet sich in derselben VPC und. AWS-Konto
+ Wir empfehlen, dass sich die EC2 Instance in derselben Availability Zone wie das bevorzugte Subnetz Ihres Dateisystems befindet.
Wenn auf Ihrer EC2 Instance ein anderes Linux-AMI als RHEL 9.3 ausgeführt wird, sind einige der in diesen Verfahren und Beispielen verwendeten Dienstprogramme möglicherweise bereits installiert, und Sie können andere Befehle verwenden, um die erforderlichen Pakete zu installieren. Abgesehen von der Installation von Paketen gelten die in diesem Abschnitt verwendeten Befehle auch für andere EC2 AMIs Linux-Systeme.
**Topics**
+ [Bevor Sie beginnen](#nvme-tcp-linux-byb)
+ [Installieren und konfigurieren Sie NVMe auf dem Linux-Host](#configure-nvme-on-rhel93)
+ [Konfigurieren Sie NVMe im FSx Dateisystem für ONTAP](#configure-nvme-on-svm)
+ [NVMe Mounten Sie ein Gerät auf Ihrem Linux-Client](#add-nvme-on-rhel93-host)
## Installieren und konfigurieren Sie NVMe auf dem Linux-Host
**Um den NVMe Client zu installieren**
1. Stellen Sie mithilfe eines SSH-Clients eine Connect zu Ihrer Linux-Instance her. Weitere Informationen finden Sie unter [Connect 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 qualifizierten Namen (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 im FSx Dateisystem für ONTAP
**Zur Konfiguration NVMe im Dateisystem**
Connect 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 zuzugreifen ONTAP CLI, 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 der 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 Befehl [https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-namespace-create.html](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-namespace-create.html) NetApp ONTAP CLI. Ein Namespace ist Initiatoren (Clients) zugeordnet und steuert, welche Initiatoren (Clients) Zugriff auf Geräte haben. NVMe
```
::> 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 Befehl [https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-subsystem-create.html](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-subsystem-create.html) NetApp ONTAP CLI.
```
~$ 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 dem 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](https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-subsystem-host-add.html) host add in den ONTAP Docs. NetApp
1. Bestätigen Sie mit dem folgenden Befehl, dass der Namespace existiert: [https://docs.netapp.com/us-en/ontap-cli-9141/vserver-nvme-namespace-show.html](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 [https://docs.netapp.com/us-en/ontap-cli-9141/network-interface-show.html](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**
Die `iscsi_1` LIF wird sowohl für iSCSI als auch für /TCP verwendet. NVMe
In diesem Beispiel lautet die IP-Adresse von iscsi\$11 172.31.16.19 und iscsi\$12 ist 172.31.26.134.
## NVMe Mounten Sie ein Gerät auf Ihrem Linux-Client
Das Mounten des NVMe Geräts auf Ihrem Linux-Client umfasst drei Schritte:
1. Die NVMe Knoten entdecken
1. Partitionierung des Geräts NVMe
1. Das NVMe Gerät auf dem Client montieren
Diese werden in den folgenden Verfahren behandelt.
**Um die NVMe Zielknoten zu entdecken**
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 Ihrem NVMe Dateigerät einen höheren Durchsatz als den EC2 Amazon-Einzelclient-Höchstwert von 5 Gbit/s (\$1625 MBps) zuzuweisen, folgen Sie den unter [Netzwerkbandbreite von Amazon EC2 Instances im Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html) 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 für den Controller-Verlust von mindestens 1800 Sekunden an. Verwenden Sie dabei `iscsi_1` erneut die IP-Adresse für *`iscsi_1_IP`* und die IP-Adresse 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 die Konfiguration erfolgreich war.
```
~$ cat /sys/module/nvme_core/parameters/multipath
Y
```
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Einstellung NVMe `model` -oF auf `NetApp ONTAP Controller` und der Lastenausgleich `iopolicy` `round-robin` für den jeweiligen ONTAP Namespaces, um die 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 aktiv ist und dass er den richtigen Multipathing-Status (Asymmetric Namespace Access, ANA) hat:
```
~$ 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 NetApp Das Plug-in zeigt für jeden die richtigen Werte an ONTAP Namespace-Gerät:
```
~$ 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/mapper/nvme2n1
/dev/nvme2n1
```
1. Partitionieren Sie die Festplatte mit. `fdisk` Sie geben eine interaktive Eingabeaufforderung ein. 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 hängt von der Größe Ihres NVMe Geräts ab (100 GiB in diesem Beispiel).
```
~$ sudo fdisk /dev/mapper/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` wird Ihre neue Partition `/dev/nvme2n1` verfügbar. Das *partition\$1name* hat das Format ****. `1`wurde im vorherigen Schritt als Partitionsnummer im `fdisk` Befehl verwendet.
1. Erstellen Sie Ihr Dateisystem mit `/dev/nvme2n1` dem Pfad.
```
~$ sudo mkfs.ext4 /dev/nvme2n1
```
Das System antwortet 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\$1path* 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 den Besitz des Mount-Verzeichnisses zuweisen 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 auf Ihrem Linux-Client erstellt und bereitgestellt.