

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.

# Konfiguration von IPSec mithilfe der Zertifikatsauthentifizierung
<a name="config-ipsec-ca-auth"></a>

Die folgenden Themen enthalten Anweisungen zur Konfiguration der IPSec-Verschlüsselung mithilfe der Zertifikatsauthentifizierung auf einem FSx for ONTAP-Dateisystem und einem Client, auf dem Libreswan IPSec ausgeführt wird. Diese Lösung verwendet AWS Certificate Manager und, um eine private Zertifizierungsstelle AWS Private Certificate Authority zu erstellen und die Zertifikate zu generieren.

Die allgemeinen Schritte zur Konfiguration der IPSec-Verschlüsselung mithilfe der Zertifikatsauthentifizierung auf FSx for ONTAP-Dateisystemen und verbundenen Clients lauten wie folgt:

1. Richten Sie eine Zertifizierungsstelle für die Ausstellung von Zertifikaten ein.

1. Generieren und exportieren Sie CA-Zertifikate für das Dateisystem und den Client.

1. Installieren Sie das Zertifikat und konfigurieren Sie IPSec auf der Client-Instanz.

1. Installieren Sie das Zertifikat und konfigurieren Sie IPSec auf Ihrem Dateisystem.

1. Definieren Sie die Sicherheitsrichtlinien-Datenbank (SPD).

1. Konfigurieren Sie IPSec für den Zugriff mehrerer Clients.

## CA-Zertifikate erstellen und installieren
<a name="create-and-install-certificates"></a>

Für die Zertifikatsauthentifizierung müssen Sie Zertifikate von einer Zertifizierungsstelle auf Ihrem FSx for ONTAP-Dateisystem und den Clients, die auf die Daten in Ihrem Dateisystem zugreifen, generieren und installieren. Im folgenden Beispiel wird AWS Private Certificate Authority eine private Zertifizierungsstelle eingerichtet und die Zertifikate für die Installation im Dateisystem und auf dem Client generiert. Mit dieser AWS Private Certificate Authority Methode können Sie eine vollständig AWS gehostete Hierarchie von Stamm- und untergeordneten Zertifizierungsstellen (CAs) für den internen Gebrauch in Ihrer Organisation erstellen. Dieser Prozess besteht aus fünf Schritten:

1. Erstellen Sie eine private Zertifizierungsstelle (CA) mit AWS Private CA

1. Stellen Sie das Stammzertifikat auf der privaten CA aus und installieren Sie es

1. Fordern Sie ein privates Zertifikat AWS Certificate Manager für Ihr Dateisystem und Ihre Clients an

1. Exportieren Sie das Zertifikat für das Dateisystem und die Clients.

Weitere Informationen finden Sie unter [Private CA-Administration](https://docs.aws.amazon.com/privateca/latest/userguide/creating-managing.html) im AWS Private Certificate Authority Benutzerhandbuch.

**Um die private Root-CA zu erstellen**

1. Wenn Sie eine Zertifizierungsstelle erstellen, müssen Sie die CA-Konfiguration in einer von Ihnen bereitgestellten Datei angeben. Der folgende Befehl verwendet den Nano-Texteditor, um die `ca_config.txt` Datei zu erstellen, in der die folgenden Informationen angegeben sind:
   + Den Namen des Algorithmus
   + Der Signaturalgorithmus, den die CA zum Signieren verwendet
   + X.500 Informationen zum Thema

   ```
   $ > nano ca_config.txt
   ```

   Der Texteditor wird angezeigt.

1. Bearbeiten Sie die Datei mit den Spezifikationen für Ihre CA.

   ```
   {
      "KeyAlgorithm":"RSA_2048",
      "SigningAlgorithm":"SHA256WITHRSA",
      "Subject":{
         "Country":"US",
         "Organization":"Example Corp",
         "OrganizationalUnit":"Sales",
         "State":"WA",
         "Locality":"Seattle",
         "CommonName":"*.ec2.internal"
      }
   }
   ```

1. Speichern und schließen Sie die Datei und beenden Sie den Texteditor. Weitere Informationen finden Sie im AWS Private Certificate Authority Benutzerhandbuch unter [Verfahren zum Erstellen einer Zertifizierungsstelle](https://docs.aws.amazon.com/privateca/latest/userguide/Create-CA-CLI.html).

1. Verwenden Sie den AWS Private CA CLI-Befehl [create-certificate-authority](https://docs.aws.amazon.com/cli/latest/reference/acm-pca/create-certificate-authority.html), um eine private CA zu erstellen.

   ```
   ~/home > aws acm-pca create-certificate-authority \
        --certificate-authority-configuration file://ca_config.txt \
        --certificate-authority-type "ROOT" \
        --idempotency-token 01234567 --region {{aws-region}}
   ```

   Bei Erfolg gibt dieser Befehl den Amazon-Ressourcennamen (ARN) der CA aus.

   ```
   {
      "CertificateAuthorityArn": "arn:aws:acm-pca:{{aws-region}}:111122223333:certificate-authority/{{12345678-1234-1234-1234-123456789012}}"
   }
   ```<a name="create-install-root-cert-CA"></a>

**Um ein Zertifikat für Ihre private Root-CA zu erstellen und zu installieren (AWS CLI)**

1. Generieren Sie mit dem [https://docs.aws.amazon.com/cli/latest/reference/acm-pca/get-certificate-authority-csr.html](https://docs.aws.amazon.com/cli/latest/reference/acm-pca/get-certificate-authority-csr.html) AWS CLI-Befehl eine Certificate Signing Request (CSR).

   ```
   $ aws acm-pca get-certificate-authority-csr \
        --certificate-authority-arn arn:aws:acm-pca:{{aws-region}}:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012 \
        --output text \
        --endpoint https://acm-pca.{{aws-region}}.amazonaws.com \
        --region eu-west-1 > ca.csr
   ```

   Die resultierende Datei`ca.csr`, eine im Base64-Format codierte PEM-Datei, hat das folgende Aussehen.

   ```
   -----BEGIN CERTIFICATE-----
    MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
    VVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
    b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
    BgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wHhcNMTEwNDI1MjA0NTIxWhcN
    MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYD
    VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25z
    b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFt
    YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ
    21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
    rDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
    Ibb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
    nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
    FFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTb
    NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
    -----END CERTIFICATE-----
   ```

   Weitere Informationen finden Sie im Benutzerhandbuch unter [Installation eines Root-CA-Zertifikats](https://docs.aws.amazon.com/privateca/latest/userguide/PCACertInstall.html#InstallRoot). AWS Private Certificate Authority 

1. Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/acm-pca/issue-certificate.html](https://docs.aws.amazon.com/cli/latest/reference/acm-pca/issue-certificate.html) AWS CLI Befehl, um das Root-Zertifikat auszustellen und auf Ihrer privaten CA zu installieren.

   ```
   $ aws acm-pca issue-certificate \
        --certificate-authority-arn arn:aws:acm-pca:{{aws-region}}:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012 \
        --csr file://ca.csr \
        --signing-algorithm SHA256WITHRSA \
        --template-arn arn:aws:acm-pca:::template/RootCACertificate/V1 \
        --validity Value=3650,Type=DAYS --region {{aws-region}}
   ```

1. Laden Sie das Stammzertifikat mit dem [https://docs.aws.amazon.com/cli/latest/reference/acm-pca/get-certificate.html](https://docs.aws.amazon.com/cli/latest/reference/acm-pca/get-certificate.html) AWS CLI Befehl herunter.

   ```
   $ aws acm-pca get-certificate \
       --certificate-authority-arn arn:aws:acm-pca:{{aws-region}}:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012 \
       --certificate-arn arn:aws:acm-pca:{{aws-region}}:486768734100:certificate-authority/12345678-1234-1234-1234-123456789012/certificate/abcdef0123456789abcdef0123456789 \
       --output text --region {{aws-region}} > rootCA.pem
   ```

1. Installieren Sie das Stammzertifikat mit dem [https://docs.aws.amazon.com/cli/latest/reference/acm-pca/import-certificate-authority-certificate.html](https://docs.aws.amazon.com/cli/latest/reference/acm-pca/import-certificate-authority-certificate.html) AWS CLI Befehl auf Ihrer privaten CA.

   ```
   $ aws acm-pca import-certificate-authority-certificate \
        --certificate-authority-arn arn:aws:acm-pca:{{aws-region}}:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012 \
        --certificate file://rootCA.pem --region {{aws-region}}
   ```<a name="generate-certificate"></a>

**Generieren und exportieren Sie das Dateisystem und das Client-Zertifikat**

1. Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/acm/request-certificate.html](https://docs.aws.amazon.com/cli/latest/reference/acm/request-certificate.html) AWS CLI Befehl, um ein AWS Certificate Manager Zertifikat für Ihr Dateisystem und Ihre Clients anzufordern.

   ```
   $ aws acm request-certificate \
       --domain-name *.ec2.internal \
       --idempotency-token 12345 \
       --region {{aws-region}} \
       --certificate-authority-arn arn:aws:acm-pca:{{aws-region}}:111122223333:certificate-authority/12345678-1234-1234-1234-123456789012
   ```

   Wenn die Anfrage erfolgreich ist, wird der ARN des ausgestellten Zertifikats zurückgegeben.

1. Aus Sicherheitsgründen müssen Sie dem privaten Schlüssel beim Exportieren eine Passphrase zuweisen. Erstellen Sie eine Passphrase und speichern Sie sie in einer Datei mit dem Namen `passphrase.txt`

1. Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/acm/export-certificate.html](https://docs.aws.amazon.com/cli/latest/reference/acm/export-certificate.html) AWS CLI Befehl, um das zuvor ausgestellte private Zertifikat zu exportieren. Die exportierte Datei enthält das Zertifikat, die Zertifikatskette und den verschlüsselten privaten 2048-Bit-RSA-Schlüssel, der dem öffentlichen Schlüssel zugeordnet ist, der in das Zertifikat eingebettet ist. Aus Sicherheitsgründen müssen Sie dem privaten Schlüssel beim Exportieren eine Passphrase zuweisen. Das folgende Beispiel bezieht sich auf eine Linux EC2-Instance.

   ```
   $ aws acm export-certificate \
        --certificate-arn arn:aws:acm:{{aws-region}}:111122223333:certificate/12345678-1234-1234-1234-123456789012 \
        --passphrase $(cat passphrase.txt | base64) --region {{aws-region}} > exported_cert.json
   ```

1. Verwenden Sie die folgenden `jq` Befehle, um den privaten Schlüssel und das Zertifikat aus der JSON-Antwort zu extrahieren.

   ```
   $ passphrase=$(cat passphrase.txt | base64)
   cat exported_cert.json | jq -r .PrivateKey > prv.key                                    
   cat exported_cert.json | jq -r .Certificate > cert.pem
   ```

1. Verwenden Sie den folgenden `openssl` Befehl, um den privaten Schlüssel aus der JSON-Antwort zu entschlüsseln. Nach Eingabe des Befehls werden Sie zur Eingabe der Passphrase aufgefordert.

   ```
   $ openssl rsa -in prv.key -passin pass:$passphrase -out decrypted.key 
   ```

## Installation und Konfiguration von Libreswan IPSec auf einem Amazon Linux 2-Client
<a name="install-configure-libreswan"></a>

Die folgenden Abschnitte enthalten Anweisungen zur Installation und Konfiguration von Libreswan IPSec auf einer Amazon EC2 EC2-Instance, auf der Amazon Linux 2 ausgeführt wird.

**Um Libreswan zu installieren und zu konfigurieren**

1. Stellen Sie über SSH eine Connect zu Ihrer EC2-Instance her. Spezifische Anweisungen dazu finden Sie unter Herstellen einer [Connect zu Ihrer Linux-Instance mithilfe eines SSH-Clients](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html#AccessingInstancesLinuxSSHClient) im Amazon Elastic Compute Cloud-Benutzerhandbuch für Linux-Instances.

1. Führen Sie zur Installation `libreswan` den folgenden Befehl aus:

   ```
   $ sudo yum install libreswan
   ```

1. (Optional) Bei der Überprüfung von IPSec in einem späteren Schritt werden diese Eigenschaften möglicherweise ohne diese Einstellungen gekennzeichnet. Wir empfehlen, Ihr Setup zunächst ohne diese Einstellungen zu testen. Wenn bei Ihrer Verbindung Probleme auftreten, kehren Sie zu diesem Schritt zurück und nehmen Sie die folgenden Änderungen vor.

   Verwenden Sie nach Abschluss der Installation Ihren bevorzugten Texteditor, um der `/etc/sysctl.conf` Datei die folgenden Einträge hinzuzufügen.

   ```
   net.ipv4.ip_forward=1
   net.ipv4.conf.all.accept_redirects = 0
   net.ipv4.conf.all.secure_redirects = 0
   net.ipv4.conf.all.send_redirects = 0
   net.ipv4.conf.default.accept_redirects = 0
   net.ipv4.conf.default.send_redirects = 0
   net.ipv4.conf.lo.accept_redirects = 0
   net.ipv4.conf.lo.send_redirects = 0
   net.ipv4.conf.all.rp_filter = 0
   net.ipv4.conf.default.rp_filter = 0
   net.ipv4.conf.eth0.rp_filter = 0
   ```

   Speichern Sie die Änderungen und beenden Sie den Texteditor.

1. Übernehmen Sie die Änderungen.

   ```
   $ sudo sysctl -p
   ```

1. Überprüfen Sie die IPSec-Konfiguration.

   ```
   $ sudo ipsec verify
   ```

   Stellen Sie sicher, dass die Version von `Libreswan` Ihnen installiert ist, läuft.

1. Initialisieren Sie die IPSec-NSS-Datenbank.

   ```
   $ sudo ipsec checknss
   ```

**Um das Zertifikat auf dem Client zu installieren**

1. Kopieren Sie das [Zertifikat, das Sie für den Client generiert haben](#generate-certificate), in das Arbeitsverzeichnis auf der EC2-Instance. Sie

1. Exportieren Sie das zuvor generierte Zertifikat in ein Format, das mit `libreswan` kompatibel ist. 

   ```
   $ openssl pkcs12 -export -in cert.pem -inkey decrypted.key \ 
       -certfile rootCA.pem -out certkey.p12 -name fsx
   ```

1. Importieren Sie den neu formatierten Schlüssel und geben Sie die Passphrase an, wenn Sie dazu aufgefordert werden.

   ```
   $ sudo ipsec import certkey.p12
   ```

1. Erstellen Sie mit dem bevorzugten Texteditor eine IPSec-Konfigurationsdatei.

   ```
   $ sudo cat /etc/ipsec.d/nfs.conf
   ```

   Fügen Sie der Konfigurationsdatei die folgenden Einträge hinzu:

   ```
   conn fsxn
       authby=rsasig
       left=172.31.77.6
       right=198.19.254.13
       auto=start
       type=transport
       ikev2=insist
       keyexchange=ike
       ike=aes256-sha2_384;dh20
       esp=aes_gcm_c256
       leftcert=fsx
       leftrsasigkey=%cert
       leftid=%fromcert
       rightid=%fromcert
       rightrsasigkey=%cert
   ```

Sie starten IPSec auf dem Client, nachdem Sie IPSec auf Ihrem Dateisystem konfiguriert haben.

## Konfiguration von IPSec auf Ihrem Dateisystem
<a name="configure-ipsec-fsx-ontap-file-system"></a>

Dieser Abschnitt enthält Anweisungen zur Installation des Zertifikats auf Ihrem FSx for ONTAP-Dateisystem und zur Konfiguration von IPSec.

**Um das Zertifikat auf Ihrem Dateisystem zu installieren**

1. Kopieren Sie das Stammzertifikat ()`rootCA.pem)`, das Client-Zertifikat (`cert.pem`) und die entschlüsselten Schlüsseldateien (`decrypted.key`) in Ihr Dateisystem. Sie müssen die Passphrase für das Zertifikat kennen.

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 ONTAP CLI](managing-resources-ontap-apps.md#fsxadmin-ontap-cli). 

1. Verwenden Sie es **cat** auf einem Client (nicht in Ihrem Dateisystem), um den Inhalt der `decrypted.key` Dateien aufzulisten`rootCA.pem`, `cert.pem` sodass Sie die Ausgabe jeder Datei kopieren und einfügen können, wenn Sie in den folgenden Schritten dazu aufgefordert werden.

   ```
   $ > cat cert.pem
   ```

   Kopieren Sie den Inhalt des Zertifikats.

1. Sie müssen alle CA-Zertifikate, die während der gegenseitigen Authentifizierung verwendet wurden, einschließlich ONTAP-side sowohl der clientseitigen Zertifizierungsstellen als auch der clientseitigen Zertifizierungsstellen, in der ONTAP Zertifikatsverwaltung installieren, sofern sie nicht bereits installiert ist (wie es bei einer selbstsignierten ONTAP-Root-CA der Fall ist).

   Verwenden Sie den `security certificate install` NetApp CLI-Befehl wie folgt, um das Client-Zertifikat zu installieren:

   ```
   FSxID123:: > security certificate install -vserver {{dr}} -type client -cert-name ipsec-client-cert
   ```

   ```
   Please enter Certificate: Press <Enter> when done
   ```

   Fügen Sie den Inhalt der `cert.pem` Datei ein, die Sie zuvor kopiert haben, und drücken Sie die Eingabetaste.

   ```
   Please enter Private Key: Press <Enter> when done
   ```

   Fügen Sie den Inhalt der `decrypted.key` Datei ein und drücken Sie die Eingabetaste.

   ```
   Do you want to continue entering root and/or intermediate certificates {y|n}: 
   ```

   Geben Sie `n` die Eingabetaste ein, um die Eingabe des Client-Zertifikats abzuschließen.

1. Erstellen und installieren Sie ein Zertifikat zur Verwendung durch die SVM. Die ausstellende Zertifizierungsstelle dieses Zertifikats muss bereits in IPSec installiert ONTAP und zu IPSec hinzugefügt worden sein.

   Verwenden Sie den folgenden Befehl, um das Stammzertifikat zu installieren.

   ```
   FSxID123:: > security certificate install -vserver {{dr}} -type server-ca -cert-name ipsec-ca-cert 
   ```

   ```
   Please enter Certificate: Press <Enter> when done
   ```

   Fügen Sie den Inhalt der `rootCA.pem` Datei ein und drücken Sie die Eingabetaste.

1. Um sicherzustellen, dass sich die installierte Zertifizierungsstelle während der Authentifizierung innerhalb des IPSec-CA-Suchpfads befindet, fügen Sie die ONTAP Zertifizierungsstellen für die Zertifikatsverwaltung mithilfe des Befehls „security ipsec ca-certificate add“ zum IPSec-Modul hinzu.

   Geben Sie den folgenden Befehl ein, um das Stammzertifikat hinzuzufügen.

   ```
   FSxID123:: > security ipsec ca-certificate add -vserver {{dr}} -ca-certs ipsec-ca-cert
   ```

1. Geben Sie den folgenden Befehl ein, um die erforderliche IPSec-Richtlinie in der Security Policy Database (SPD) zu erstellen.

   ```
   security ipsec policy create -vserver {{dr}} -name {{policy-name}} -local-ip-subnets {{198.19.254.13/32}} -remote-ip-subnets {{172.31.0.0/16}} -auth-method PKI -action ESP_TRA -cipher-suite SUITEB_GCM256 -cert-name ipsec-client-cert -local-identity "CN=*.ec2.internal" -remote-identity "CN=*.ec2.internal"
   ```

1. Verwenden Sie den folgenden Befehl, um die IPSec-Richtlinie für das Dateisystem zur Bestätigung anzuzeigen.

   ```
   FSxID123:: > security ipsec policy show -vserver {{dr}} -instance
   
                                       Vserver: dr
                                   Policy Name: promise
                              Local IP Subnets: 198.19.254.13/32
                             Remote IP Subnets: 172.31.0.0/16
                                   Local Ports: 0-0
                                  Remote Ports: 0-0
                                     Protocols: any
                                        Action: ESP_TRA
                                  Cipher Suite: SUITEB_GCM256
             IKE Security Association Lifetime: 86400
           IPsec Security Association Lifetime: 28800
   IPsec Security Association Lifetime (bytes): 0
                             Is Policy Enabled: true
                                Local Identity: CN=*.ec2.internal
                               Remote Identity: CN=*.ec2.internal
                         Authentication Method: PKI
                Certificate for Local Identity: ipsec-client-cert
   ```

## Starten Sie IPSec auf dem Client
<a name="start-ipsec-client"></a>

Jetzt ist IPSec sowohl auf dem FSx for ONTAP-Dateisystem als auch auf dem Client konfiguriert. Sie können IPSec auf dem Client starten.

1. Stellen Sie über SSH eine Connect zu Ihrem Clientsystem her.

1. Starten Sie IPSec.

   ```
   $ sudo ipsec start
   ```

1. Überprüfen Sie den Status von IPSec.

   ```
   $ sudo ipsec status
   ```

1. Hängen Sie ein Volume in Ihr Dateisystem ein.

   ```
   $ sudo mount -t nfs {{198.19.254.13:/benchmark}} {{/home/ec2-user/acm/dr}}
   ```

1. Überprüfen Sie das IPSec-Setup, indem Sie die verschlüsselte Verbindung auf Ihrem FSx for ONTAP-Dateisystem anzeigen.

   ```
   FSxID123:: > security ipsec show-ikesa -node FsxId{{123}}
   FsxId08ac16c7ec2781a58::> security ipsec show-ikesa -node FsxId08ac16c7ec2781a58-01
               Policy Local           Remote
   Vserver     Name   Address         Address         Initator-SPI     State
   ----------- ------ --------------- --------------- ---------------- -----------
   dr          {{policy-name}}
                      198.19.254.13   172.31.77.6     551c55de57fe8976 ESTABLISHED
   fsx         {{policy-name}}
                      198.19.254.38   172.31.65.193   4fd3f22c993e60c5 ESTABLISHED
   2 entries were displayed.
   ```

## IPSec für mehrere Clients einrichten
<a name="ipsec-multi-client-setup"></a>

Wenn eine kleine Anzahl von Clients IPSec nutzen muss, ist die Verwendung eines einzigen SPD-Eintrags für jeden Client ausreichend. Wenn jedoch Hunderte oder sogar Tausende von Clients IPSec nutzen müssen, empfehlen wir, die IPSec-Konfiguration für mehrere Clients zu verwenden.

FSx for ONTAP unterstützt die Verbindung mehrerer Clients in vielen Netzwerken mit einer einzigen SVM-IP-Adresse mit aktiviertem IPSec. Sie können dies entweder mithilfe der `subnet` Konfiguration oder der Konfiguration erreichen, die `Allow all clients` in den folgenden Verfahren erläutert werden:

**So konfigurieren Sie IPSec für mehrere Clients mithilfe einer Subnetzkonfiguration**

Um alle Clients in einem bestimmten Subnetz zuzulassen (192.168.134. 0/24 Um beispielsweise mithilfe eines einzigen SPD-Richtlinieneintrags eine Verbindung zu einer einzelnen SVM-IP-Adresse herzustellen, müssen Sie dies im `remote-ip-subnets` Subnetzformat angeben. Darüber hinaus müssen Sie das `remote-identity` Feld mit der richtigen clientseitigen Identität angeben.
**Wichtig**  
Bei Verwendung der Zertifikatsauthentifizierung kann jeder Client entweder sein eigenes eindeutiges Zertifikat oder ein gemeinsames Zertifikat zur Authentifizierung verwenden. FSx for ONTAP IPSec überprüft die Gültigkeit des Zertifikats anhand der CAs, die in seinem lokalen Trust Store installiert sind. FSx for ONTAP unterstützt auch die Überprüfung von Zertifikatssperrlisten (CRL).

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 ONTAP CLI](managing-resources-ontap-apps.md#fsxadmin-ontap-cli). 

1. Verwenden Sie den `security ipsec policy create` NetApp ONTAP CLI-Befehl wie folgt und ersetzen Sie die {{sample}} Werte durch Ihre spezifischen Werte.

   ```
   FsxId123456::> security ipsec policy create -vserver {{svm_name}} -name {{policy_name}} \
     -local-ip-subnets {{192.168.134.34/32}} -remote-ip-subnets {{192.168.134.0/24}} \
     -local-ports {{2049}} -protocols {{tcp}} -auth-method PSK \
     -cert-name {{my_nfs_server_cert}} -local-identity {{ontap_side_identity}} \
     -remote-identity {{client_side_identity}}
   ```

**So konfigurieren Sie IPSec für mehrere Clients mithilfe der Konfiguration „Alle Clients zulassen“**

Damit jeder Client unabhängig von seiner Quell-IP-Adresse eine Verbindung zur IPsec-enabled SVM-IP-Adresse herstellen kann, verwenden Sie bei der Angabe des `0.0.0.0/0` Felds den Platzhalter. `remote-ip-subnets`

Darüber hinaus müssen Sie das `remote-identity` Feld mit der richtigen clientseitigen Identität angeben. Für die Zertifikatsauthentifizierung können Sie Folgendes eingeben`ANYTHING`.

Ebenfalls, wenn die 0.0.0. 0/0 Wenn ein Platzhalter verwendet wird, müssen Sie eine bestimmte lokale oder Remote-Portnummer konfigurieren, die verwendet werden soll. Zum Beispiel NFS-Port 2049.

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 ONTAP CLI](managing-resources-ontap-apps.md#fsxadmin-ontap-cli). 

1. Verwenden Sie den `security ipsec policy create` NetApp ONTAP CLI-Befehl wie folgt und ersetzen Sie die {{sample}} Werte durch Ihre spezifischen Werte.

   ```
   FsxId123456::> security ipsec policy create -vserver {{svm_name}} -name {{policy_name}} \
     -local-ip-subnets {{192.168.134.34/32}} -remote-ip-subnets 0.0.0.0/0 \
     -local-ports {{2049}} -protocols {{tcp}} -auth-method PSK \
     -cert-name {{my_nfs_server_cert}} -local-identity {{ontap_side_identity}} \
     -local-ports {{2049}} -remote-identity {{client_side_identity}}
   ```