Diese Seite wurde von der Cloud Translation API übersetzt.

Backend-mTLS einrichten

Auf dieser Seite finden Sie eine Anleitung zum Einrichten von Backend-mTLS mit selbstverwalteten Zertifikaten.

Die Schritte zum Konfigurieren von Backend-mTLS ähneln denen für Backend-authentifiziertes TLS. Sie müssen jedoch auch ein Zertifikat für den Load Balancer erstellen. Dieses Zertifikat, auch Clientzertifikat genannt, ist an die Backend-Authentifizierungskonfigurationsressource angehängt. Der Load Balancer verwendet dieses Clientzertifikat, um sich bei den Backends zu authentifizieren.

So konfigurieren Sie Backend-mTLS: Diese Schritte werden in den folgenden Abschnitten dieses Dokuments beschrieben.

Erstellen Sie eine TrustConfig-Ressource, die aus Root- und Zwischenzertifikaten besteht.
Erstellen Sie ein Clientzertifikat und laden Sie es in Certificate Manager hoch.
Erstellen Sie eine Ressource für die Konfiguration der Backend-Authentifizierung, die sowohl auf die Vertrauenskonfiguration als auch auf das Clientzertifikat verweist.
Hängen Sie die Ressource „Konfiguration der Backend-Authentifizierung“ an den Backend-Dienst des Load-Balancers an.

Hinweise

Lesen Sie die Übersicht zum Backend-authentifizierten TLS und Backend-mTLS.
Weitere Informationen finden Sie unter Vertrauenskonfigurationen verwalten.
Wenn Sie die Anleitung in diesem Leitfaden mit der Google Cloud CLI ausführen möchten, müssen Sie sie installieren. Befehle für das Load-Balancing finden Sie in den Referenzen zur API und zur gcloud CLI.

Wenn Sie die gcloud CLI noch nicht ausgeführt haben, führen Sie zuerst den Befehl gcloud init zur Authentifizierung aus.
Aktivieren Sie die folgenden APIs: Compute Engine API, Certificate Manager API, Network Security API und Network Services API. Weitere Informationen finden Sie unter APIs aktivieren.
Konfigurieren Sie einen Load Balancer mit einem der folgenden unterstützten Back-Ends:
- Back-Ends von VM-Instanzgruppen
- Hybridkonnektivitäts-NEGs
- Zonale NEGs

Berechtigungen

In diesem Abschnitt werden die Berechtigungen aufgeführt, die zum Konfigurieren von Backend-mTLS erforderlich sind.

Vorgang	Berechtigung
Vertrauenskonfiguration erstellen	`certificatemanager.trustconfigs.create` für das Zielprojekt Google Cloud
Clientzertifikat erstellen	`certificatemanager.certs.create` für das Zielprojekt Google Cloud
Ressource für die Konfiguration der Backend-Authentifizierung erstellen	`certificatemanager.certs.use` für das Zielzertifikat `certificatemanager.trustconfigs.use` für die Zielkonfiguration für Vertrauen `networksecurity.backendauthenticationconfigs.create` für das Zielprojekt Google Cloud
Hängen Sie die Ressource für die Backend-Authentifizierungskonfiguration an den Backend-Dienst des Load-Balancers an.	`compute.backendservice.update` für den Ziel-Backend-Dienst `networksecurity.backendauthenticationconfigs.use` für die Zielressource für die Konfiguration der Backend-Authentifizierung

Einrichtung: Übersicht

In den folgenden Abschnitten werden die Schritte zum Konfigurieren von Backend-mTLS basierend auf der im folgenden Diagramm gezeigten Architektur beschrieben.

Komponenten von Backend-mTLS. — Backend-mTLS-Komponenten (zum Vergrößern klicken)

Root- und Zwischenzertifikate erstellen

In diesem Abschnitt wird die OpenSSL-Bibliothek verwendet, um das Root-Zertifikat (Vertrauensanker) und das Zwischenzertifikat zu erstellen.

Ein Root-Zertifikat befindet sich am Anfang der Zertifikatskette. Ein Zwischenzertifikat ist Teil der Vertrauenskette zum Root-Zertifikat. Das Zwischenzertifikat ist kryptografisch mit dem Root-Zertifikat signiert. Wenn der Load Balancer ein Serverzertifikat empfängt, validiert er es, indem er eine Vertrauenskette vom Serverzertifikat zurück zum konfigurierten Trust-Anchor herstellt.

Verwenden Sie die folgenden Befehle, um das Root- und das Zwischenzertifikat zu erstellen.

Erstellen Sie eine OpenSSL-Konfigurationsdatei.

Im folgenden Beispiel enthält die Konfigurationsdatei (example.cnf) den Abschnitt [ca_exts], in dem X.509-Erweiterungen angegeben werden, die das Zertifikat als für eine Zertifizierungsstelle geeignet kennzeichnen. Weitere Informationen zu den Anforderungen an Stamm- und Zwischenzertifikate finden Sie unter Zertifikatsanforderungen.
```
cat > example.cnf << EOF
[req]
distinguished_name = empty_distinguished_name

[empty_distinguished_name]
# Kept empty to allow setting via -subj command-line argument.

[ca_exts]
basicConstraints=critical,CA:TRUE
keyUsage=keyCertSign
extendedKeyUsage=serverAuth

EOF
```

Erstellen Sie ein selbstsigniertes X.509-Root-Zertifikat (root.cert). Das Root-Zertifikat wird mit seinem eigenen privaten Schlüssel (root.key) selbst signiert.

openssl req -x509 \
    -new -sha256 -newkey rsa:2048 -nodes \
    -days 3650 -subj '/CN=root' \
    -config example.cnf \
    -extensions ca_exts \
    -keyout root.key -out root.cert

Erstellen Sie die CSR-Datei int.req für das Zwischenzertifikat.

openssl req -new \
    -sha256 -newkey rsa:2048 -nodes \
    -subj '/CN=int' \
    -config example.cnf \
    -extensions ca_exts \
    -keyout int.key -out int.req

Signieren Sie die CSR, um das X.509-Zwischenzertifikat (int.cert) zu erstellen. Die CSR wird mit dem Root-Zertifikat signiert.

openssl x509 -req \
    -CAkey root.key -CA root.cert \
    -set_serial 1 \
    -days 3650 \
    -extfile example.cnf \
    -extensions ca_exts \
    -in int.req -out int.cert

Zertifikate formatieren

Wenn Sie neue oder vorhandene Zertifikate in einen Trust Store aufnehmen möchten, formatieren Sie die Zertifikate in einer einzelnen Zeile und speichern Sie sie in Umgebungsvariablen, damit in der YAML-Datei für die Trust-Konfiguration darauf verwiesen werden kann.

export ROOT_CERT=$(cat root.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

export INTERMEDIATE_CERT=$(cat int.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Vertrauenskonfiguration erstellen

Eine Vertrauenskonfiguration ist eine Ressource, die Ihre Konfiguration der Public-Key-Infrastruktur (PKI) im Zertifikatmanager darstellt.

So erstellen Sie eine Trust-Konfigurationsressource:

Console

Rufen Sie in der Google Cloud Console die Seite Certificate Manager auf.

Zum Zertifikatmanager
Klicken Sie auf dem Tab Vertrauenskonfigurationen auf Vertrauenskonfiguration hinzufügen.
Geben Sie einen Namen für die Konfiguration ein.
Wählen Sie als Standort die Option Global oder Regional aus.

Der Speicherort gibt an, wo die Vertrauenskonfigurationsressource gespeichert ist. Erstellen Sie für globale externe Application Load Balancer eine globale Vertrauenskonfigurationsressource. Erstellen Sie für regionale externe Application Load Balancer und regionale interne Application Load Balancer eine regionale Vertrauenskonfigurationsressource.
Klicken Sie im Abschnitt Trust Store auf Trust-Anchor hinzufügen und laden Sie die PEM-codierte Zertifikatsdatei hoch oder kopieren Sie den Inhalt des Zertifikats.
Klicken Sie auf Hinzufügen.
Klicken Sie im Abschnitt Trust Store auf Zwischen-CA hinzufügen und laden Sie die PEM-codierte Zertifikatsdatei hoch oder kopieren Sie den Inhalt des Zertifikats. Mit diesem Schritt können Sie eine weitere Vertrauensebene zwischen dem Root-Zertifikat und Ihrem Serverzertifikat hinzufügen.
Klicken Sie auf Hinzufügen, um die Zwischenzertifizierungsstelle hinzuzufügen.
Klicken Sie auf Hinzufügen, um das Zertifikat hinzuzufügen, das Sie der Zulassungsliste hinzugefügt haben.
Klicken Sie auf Erstellen.

Prüfen Sie, ob die neue Vertrauenskonfigurationsressource in der Liste der Konfigurationen angezeigt wird.

gcloud

Erstellen Sie eine YAML-Datei für die Vertrauenskonfiguration (trust_config.yaml), in der die Parameter für die Vertrauenskonfiguration angegeben werden. Diese Beispielressource für die Vertrauenskonfiguration enthält einen Trust Store mit einem Trust-Anchor und einem Zwischenzertifikat. In dieser Beispielkonfigurationsressource für Vertrauensbeziehungen wird der Zertifikatsinhalt aus den Umgebungsvariablen gelesen, die im vorherigen Schritt Zertifikate formatieren erstellt wurden.
```
cat << EOF > trust_config.yaml
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT_CERT}"
  intermediateCas:
  - pemCertificate: "${INTERMEDIATE_CERT}"
EOF
```
Fügen Sie im entsprechenden Abschnitt pemCertificate-Zeilen hinzu, um einen Trust Store mit zusätzlichen Trust-Anchors oder Zwischenzertifikaten zu erstellen.
Verwenden Sie den Befehl gcloud certificate-manager trust-configs import, um die YAML-Datei für die Vertrauenskonfiguration zu importieren.
global
Geben Sie für globale externe Application Load Balancer global als Speicherort der Vertrauenskonfigurationsressource an.
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME  \
    --source=trust_config.yaml \
    --location=global
```
Ersetzen Sie TRUST_CONFIG_NAME durch den Namen der Vertrauenskonfiguration.
regional
Geben Sie für regionale externe Application Load Balancer und regionale interne Application Load Balancer die Region an, in der die Vertrauenskonfigurationsressource gespeichert ist.
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
    --source=trust_config.yaml \
    --location=REGION
```
Ersetzen Sie Folgendes:
- TRUST_CONFIG_NAME: der Name der Vertrauenskonfigurationsressource
- REGION: die Region, in der die Vertrauenskonfigurationsressource gespeichert ist

Clientzertifikat erstellen

Beim Backend-mTLS fungiert der Load Balancer als Client und das Backend als Server.

Damit mTLS für das Backend aktiviert werden kann, muss der Load Balancer seine Identität gegenüber dem Backend nachweisen. Die Authentifizierung erfolgt über ein Clientzertifikat, das der Load-Balancer dem Backend präsentiert. Der Backend-Server muss das Clientzertifikat mit seiner eigenen Vertrauenskette validieren.

Beim Herstellen einer Verbindung zu einem Backend-Server legt der Load-Balancer die Server Name Indication (SNI) auf den in der TLS-Konfiguration angegebenen Hostnamen fest. Der Backend-Server wählt anhand dieses SNI-Werts das passende SSL/TLS-Zertifikat aus. Der Load Balancer erwartet, dass der SNI-Wert mit einem alternativen Namen des Inhabers (Subject Alternative Name, SAN) übereinstimmt, der im Zertifikat des Backend-Servers aufgeführt ist.

Clientzertifikate können verwaltete Zertifikate von einer privaten Zertifizierungsstelle über den Certificate Authority Service oder selbstverwaltete private PKI-Zertifikate sein. In diesem Beispiel wird das Clientzertifikat mit selbstverwalteten Zertifikaten ausgestellt. In diesem Abschnitt wird die OpenSSL-Bibliothek verwendet, um das Root-CA-Zertifikat und das Clientzertifikat zu erstellen.

So erstellen Sie ein Clientzertifikat:

Erstellen Sie eine OpenSSL-Konfigurationsdatei.

Im folgenden Beispiel enthält die Konfigurationsdatei (example.cnf) den Abschnitt [ca_exts], in dem X.509-Erweiterungen angegeben werden, die das Zertifikat als für eine Zertifizierungsstelle (CA) geeignet kennzeichnen. Das Attribut extendedKeyUsage ist auf clientAuth festgelegt. Weitere Informationen zu den Anforderungen für Stamm- und Zwischenzertifikate finden Sie unter Zertifikatsanforderungen.
```
  cat > example.cnf << EOF
  [req]
  distinguished_name = empty_distinguished_name

  [empty_distinguished_name]
  # Kept empty to allow setting via -subj command-line argument.

  [ca_exts]
  basicConstraints=critical,CA:TRUE
  keyUsage=keyCertSign
  extendedKeyUsage=clientAuth

  EOF
```

Erstellen Sie ein selbst signiertes X.509-Root-CA-Zertifikat (root.cert). Das Root-Zertifikat wird mit seinem eigenen privaten Schlüssel (root.key) selbst signiert.

  openssl req -x509 \
      -new -sha256 -newkey rsa:2048 -nodes \
      -days 3650 -subj '/CN=root' \
      -config example.cnf \
      -extensions ca_exts \
      -keyout root.key -out root.cert

Erstellen Sie eine Konfigurationsdatei, um die CSR für das Clientzertifikat zu generieren.

Die folgende Konfigurationsdatei (client.config) enthält den Abschnitt [extension_requirements], in dem die X.509-Erweiterungen angegeben werden, die in die CSR aufgenommen werden sollen. Weitere Informationen zu den Anforderungen an Clientzertifikate finden Sie unter Zertifikatanforderungen.

  cat > client.config << EOF
  [req]
  default_bits              = 2048
  req_extensions            = extension_requirements
  distinguished_name        = dn_requirements
  prompt                    = no

  [extension_requirements]
  basicConstraints          = critical, CA:FALSE
  keyUsage                  = critical, nonRepudiation, digitalSignature, keyEncipherment
  extendedKeyUsage          = clientAuth

  [dn_requirements]
  countryName               = US
  stateOrProvinceName       = California
  localityName              = San Francisco
  0.organizationName        = example
  organizationalUnitName    = test
  commonName                = test.example.com
  emailAddress              = test@example.com

  EOF

Erstellen Sie die CSR (client.csr) für das Clientzertifikat.

  openssl req -new \
      -config client.config \
      -keyout client.key -out client.csr

Erstellen Sie das Clientzertifikat (client.cert) aus der CSR. Die CSR wird mit dem Stamm-CA-Zertifikat signiert, um das X.509-Clientzertifikat auszustellen.

  openssl x509 -req \
      -CAkey root.key -CA root.cert \
      -days 365 \
      -extfile client.config \
      -extensions extension_requirements \
      -in client.csr -out client.cert

Clientzertifikat in den Zertifikatmanager hochladen

Führen Sie die folgenden Schritte aus, um das Clientzertifikat in Certificate Manager hochzuladen:

Console

Rufen Sie in der Google Cloud Console die Seite Certificate Manager auf.

Zum Zertifikatmanager
Klicken Sie auf dem Tab Zertifikate auf Zertifikat hinzufügen.
Geben Sie einen Namen für das Zertifikat ein.

Dieser Name muss für das Projekt eindeutig sein.
Optional: Geben Sie eine Beschreibung für das Zertifikat ein. Die Beschreibung hilft Ihnen, ein bestimmtes Zertifikat später zu identifizieren.
Wählen Sie als Standort die Option Global oder Regional aus.

Der Speicherort gibt an, wo die Vertrauenskonfigurationsressource gespeichert ist. Erstellen Sie für globale externe Application Load Balancer eine globale Vertrauenskonfigurationsressource. Erstellen Sie für regionale externe Application Load Balancer und regionale interne Application Load Balancer eine regionale Vertrauenskonfigurationsressource.
Wählen Sie unter Bereich die Option Clientauthentifizierung aus.
Wählen Sie für Zertifikatstyp die Option Selbstverwaltetes Zertifikat erstellen aus.
Laden Sie für das Feld Zertifikat eine PEM-codierte Zertifikatsdatei hoch oder kopieren Sie den Inhalt eines PEM-codierten Zertifikats und fügen Sie ihn ein.
Laden Sie für das Feld Zertifikat für privaten Schlüssel einen PEM-codierten privaten Schlüssel hoch, der nicht mit einer Passphrase geschützt ist, oder kopieren Sie den Inhalt des PEM-codierten privaten Schlüssels und fügen Sie ihn ein.
Geben Sie ein Label an, das dem Zertifikat zugeordnet werden soll. Bei Bedarf können Sie mehrere Labels hinzufügen. Klicken Sie auf die Schaltfläche Label hinzufügen, um ein Label hinzuzufügen, und geben Sie einen key und einen value für das Label an.
Klicken Sie auf Erstellen. Prüfen Sie, ob das neue Zertifikat in der Liste der Zertifikate angezeigt wird.

gcloud

Verwenden Sie den Befehl gcloud certificate-manager certificates create, um das Clientzertifikat in den Zertifikatmanager hochzuladen. Der Bereich dieses Zertifikats ist client-auth. Das bedeutet, dass dieses Zertifikat als Clientzertifikat in der Backend-mTLS verwendet wird.
global
Erstellen Sie für globale externe Application Load Balancer ein globales Certificate Manager-Zertifikat.
```
gcloud certificate-manager certificates create CLIENT_ CERTIFICATE_NAME \
    --certificate-file=client.cert \
    --private-key-file=client.key \
    --scope=client-auth \
    --location=global
```
Ersetzen Sie CLIENT_CERTIFICATE_NAME durch den Namen der Clientzertifikatsressource. Dieses Clientzertifikat mit dem Bereich client-auth wird von der Ressource für die Backend-Authentifizierungskonfiguration verwendet.
regional
Erstellen Sie für regionale externe Application Load Balancer und regionale interne Application Load Balancer ein regionales Certificate Manager-Zertifikat.
```
gcloud certificate-manager certificates create CLIENT_ CERTIFICATE_NAME \
    --certificate-file=client.cert \
    --private-key-file=client.key \
    --scope=client-auth \
    --location=REGION
```
Ersetzen Sie Folgendes:
- CLIENT_CERTIFICATE_NAME ist der Name der Clientzertifikatsressource. Dieses Clientzertifikat mit dem Bereich client-auth wird von der Ressource für die Back-End-Authentifizierungskonfiguration verwendet.
- REGION: die Region, in der das Zertifikat erstellt werden soll.

Ressource für die Konfiguration der Backend-Authentifizierung erstellen

So erstellen Sie eine BackendAuthenticationConfig-Ressource für die Back-End-Authentifizierung:

Console

Rufen Sie in der Google Cloud Console die Seite Authentifizierungskonfiguration auf.
Zur Authentifizierungskonfiguration
Klicken Sie auf dem Tab Backend Authentication (Backend-Authentifizierung) auf Create (Erstellen).
Geben Sie einen Namen für die Backend-Authentifizierungskonfigurationsressource ein.
Wählen Sie als Standort die Option Global oder Regional aus.
Wählen Sie die Clientzertifikatsressource aus, die Sie zuvor erstellt haben.
Optional: Wählen Sie die öffentlichen Vertrauensanker aus.
Wählen Sie die Konfigurationsressource für die Vertrauensstellung aus, die Sie zuvor erstellt haben.
Klicken Sie auf Erstellen.

Prüfen Sie, ob die Ressource für die Konfiguration der Backend-Authentifizierung angezeigt wird.

gcloud

Erstellen Sie eine YAML-Datei, in der die verschiedenen Attribute der Backend-Authentifizierungskonfigurationsressource deklarativ angegeben werden.
global

Hängen Sie das Clientzertifikat an die Ressource „Konfiguration der Backend-Authentifizierung“ an, um Backend-mTLS zu aktivieren.
```
cat << EOF > BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml
name: projects/PROJECT_ID/locations/global/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
trustConfig: projects/PROJECT_ID/locations/global/trustConfigs/TRUST_CONFIG_NAME
clientCertificate: projects/PROJECT_ID/locations/global/certificates/CLIENT_ CERTIFICATE_NAME
wellKnownRoots: PUBLIC_ROOTS
EOF
```
Ersetzen Sie Folgendes:
- BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME: der Name der YAML-Datei, in der die Konfigurationsressource für die Backend-Authentifizierung definiert ist.
- PROJECT_ID: die ID Ihres Google Cloud -Projekts
- BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource
- TRUST_CONFIG_NAME: der Name der Vertrauenskonfigurationsressource, die Sie zuvor erstellt haben
- CLIENT_CERTIFICATE_NAME: der Name der Clientzertifikatsressource, die Sie zuvor erstellt haben
regional

Hängen Sie das Clientzertifikat an die Ressource „Konfiguration der Backend-Authentifizierung“ an, um Backend-mTLS zu aktivieren.
```
cat << EOF > BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml
name: projects/PROJECT_ID/locations/REGION/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
trustConfig: projects/PROJECT_ID/locations/REGION/trustConfigs/TRUST_CONFIG_NAME
clientCertificate: projects/PROJECT_ID/locations/REGION/certificates/CLIENT_ CERTIFICATE_NAME
wellKnownRoots: PUBLIC_ROOTS
EOF
```
Ersetzen Sie Folgendes:
- BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME: der Name der YAML-Datei, in der die Backend-Authentifizierungskonfigurationsressource definiert ist
- PROJECT_ID: die ID Ihres Google Cloud -Projekts
- REGION: der Name der Region
- BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource
- TRUST_CONFIG_NAME: der Name der Vertrauenskonfigurationsressource, die Sie zuvor erstellt haben
- CLIENT_CERTIFICATE_NAME: der Name der Clientzertifikatsressource, die Sie zuvor erstellt haben
Verwenden Sie den Befehl gcloud network-security backend-authentication-configs import, um die Konfiguration der Backend-Authentifizierung zu importieren.
global
```
gcloud network-security backend-authentication-configs import BACKEND_AUTH_CONFIG_NAME \
    --source=BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml \
    --location=global
```
Ersetzen Sie Folgendes:
- BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource
- BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME: der Name der YAML-Datei, in der die Konfigurationsressource für die Backend-Authentifizierung definiert ist
regional
```
gcloud network-security backend-authentication-configs import BACKEND_AUTH_CONFIG_NAME \
    --source=BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml \
    --location=REGION
```
Ersetzen Sie Folgendes:
- BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource
- BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME: der Name der YAML-Datei, in der die Konfigurationsressource für die Backend-Authentifizierung definiert ist
- REGION: der Name der Region

Backend-Authentifizierungskonfigurationsressource an den Backend-Dienst des Load-Balancers anhängen

Führen Sie die folgenden Schritte aus, um die Backend-Authentifizierungskonfiguration (BackendAuthenticationConfig-Ressource) an den Backend-Dienst des Load Balancers anzuhängen.

Console

Rufen Sie in der Google Cloud Console die Seite Load Balancing auf.

Load Balancing aufrufen
Wählen Sie auf dem Tab Backends den Backend-Dienst aus, für den Sie das Backend-authentifizierte TLS und Backend-mTLS aktivieren möchten.
Klicken Sie auf Bearbeiten.
Maximieren Sie den Abschnitt Erweiterte Konfigurationen.
Klicken Sie im Abschnitt Backend-Authentifizierung das Kästchen Aktivieren an.
Optional: Geben Sie den SNI-Hostname und die akzeptierten SANs an, um das Backend-Zertifikat zu validieren.
Wenn Sie die Ressource „Konfiguration der Backend-Authentifizierung“ an den Backend-Dienst anhängen möchten, wählen Sie in der Liste Konfiguration der Backend-Authentifizierung die Ressource „Konfiguration der Backend-Authentifizierung“ aus.
Klicken Sie auf Weiter.
Klicken Sie zum Aktualisieren der Einstellungen des Backend-Dienstes auf Aktualisieren.

gcloud

Verwenden Sie den Befehl gcloud compute backend-services list, um alle Backend-Dienstressourcen in Ihrem Projekt aufzulisten.
```
gcloud compute backend-services list
```
Notieren Sie sich den Namen des Backend-Dienstes, an den die BackendAuthenticationConfig-Ressource angehängt werden soll. Dieser Name wird in den folgenden Schritten als BACKEND_SERVICE_NAME bezeichnet.
Verwenden Sie den Befehl gcloud compute backend-services export, um die Konfiguration des Back-End-Dienstes in eine Datei zu exportieren.
global
```
gcloud compute backend-services export BACKEND_SERVICE_NAME \
    --destination=BACKEND_SERVICE_FILENAME.yaml \
    --global
```
Ersetzen Sie Folgendes:
- BACKEND_SERVICE_NAME: der Name des Backend-Dienstes
- BACKEND_SERVICE_FILENAME: Name und Pfad einer YAML-Datei, in die die Backend-Dienstkonfiguration exportiert wird
regional
```
gcloud compute backend-services export BACKEND_SERVICE_NAME \
    --destination=BACKEND_SERVICE_FILENAME.yaml \
    --region=REGION
```
Ersetzen Sie Folgendes:
- BACKEND_SERVICE_NAME: der Name des Backend-Dienstes
- BACKEND_SERVICE_FILENAME: Name und Pfad einer YAML-Datei, in die die Backend-Dienstkonfiguration exportiert wird
- REGION: der Name derGoogle Cloud Region, in der sich der Backend-Dienst befindet
Aktualisieren Sie das Attribut tlsSettings des Backend-Dienstes und verweisen Sie es auf die Ressource für die Backend-Authentifizierungskonfiguration. Außerdem können Sie den SNI-Hostname und die akzeptierten SANs für den Backend-Dienst konfigurieren, um das Backend-Zertifikat zu validieren.
global
Hängen Sie die globale Ressource „Konfiguration der Backend-Authentifizierung“ an den Backend-Dienst an.

Die SNI- und SAN-Werte in der folgenden YAML-Deklaration dienen nur als Beispiele. Sie können sie durch reale Werte ersetzen, die für Ihre Konfiguration relevant sind.
```
  cat << EOF >> BACKEND_SERVICE_FILENAME.yaml
  tlsSettings:
    authenticationConfig: //networksecurity.googleapis.com/projects/PROJECT_ID/locations/global/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
    sni: examplepetstore.com
    subjectAltNames:
    - dnsName: examplepetstore.com
    - dnsName: api.examplepetstore.com
  EOF
  
```
Ersetzen Sie Folgendes:
- BACKEND_SERVICE_FILENAME: der Name der YAML-Datei, in die die Backend-Dienstkonfiguration exportiert wird
- PROJECT_ID: die ID Ihres Google Cloud -Projekts
- BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource
regional
Hängen Sie die Ressource für die regionale Konfiguration der Backend-Authentifizierung an den Backend-Dienst an.

Die SNI- und SAN-Werte in der folgenden YAML-Deklaration dienen nur als Beispiele. Sie können sie durch reale Werte ersetzen, die für Ihre Konfiguration relevant sind.
```
  cat << EOF >> BACKEND_SERVICE_FILENAME.yaml
  tlsSettings:
    authenticationConfig: //networksecurity.googleapis.com/projects/PROJECT_ID/locations/REGION/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
    sni: examplepetstore.com
    subjectAltNames:
    - dnsName: examplepetstore.com
    - dnsName: api.examplepetstore.com
  EOF
  
```
Ersetzen Sie Folgendes:
- BACKEND_SERVICE_FILENAME: der Name der YAML-Datei, in die die Backend-Dienstkonfiguration exportiert wird
- PROJECT_ID: die ID Ihres Google Cloud -Projekts
- REGION: der Name derGoogle Cloud -Region, in der die Backend-Authentifizierungskonfiguration erstellt wird
- BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource
Verwenden Sie den Befehl gcloud compute backend-services import, um die aktualisierte Konfiguration des Backend-Dienstes aus einer Datei zu importieren.
global
```
  gcloud compute backend-services import BACKEND_SERVICE_NAME \
      --source=BACKEND_SERVICE_FILENAME.yaml \
      --global
```
Ersetzen Sie Folgendes:
- BACKEND_SERVICE_NAME: der Name des Backend-Dienstes
- BACKEND_SERVICE_FILENAME: der Name der YAML-Datei für die Backend-Dienstkonfiguration
regional
```
  gcloud compute backend-services import BACKEND_SERVICE_NAME \
      --source=BACKEND_SERVICE_FILENAME.yaml \
      --region=REGION
```
Ersetzen Sie Folgendes:
- BACKEND_SERVICE_NAME: der Name des Backend-Dienstes
- BACKEND_SERVICE_FILENAME: der Name der YAML-Datei für die Backend-Dienstkonfiguration
- REGION: der Name derGoogle Cloud Region, in der sich der Backend-Dienst befindet

Backend-Serverzertifikat erstellen

Dieser Abschnitt bietet eine zusätzliche Konfigurationsoption zum Erstellen eines Serverzertifikats (untergeordnetes Zertifikat), das vom Zwischenzertifikat signiert wird, das Teil der Vertrauenskonfiguration ist. So kann eine Vertrauenskette vom Serverzertifikat zurück zum Vertrauensanker aufgebaut werden.

Wenn Sie bereits eine TrustConfig-Ressource mit einem Zwischenzertifikat erstellt haben, gehen Sie so vor:

Erstellen Sie eine Konfigurationsdatei, um die CSR für das Serverzertifikat zu generieren.

Die folgende Konfigurationsdatei (server.config) enthält den Abschnitt [extension_requirements], in dem die X.509-Erweiterungen angegeben werden, die in die CSR aufgenommen werden sollen. Weitere Informationen zu den Anforderungen an Serverzertifikate finden Sie unter Zertifikatanforderungen.

cat > server.config << EOF
[req]
default_bits              = 2048
req_extensions            = extension_requirements
distinguished_name        = dn_requirements
prompt                    = no

[extension_requirements]
basicConstraints          = critical, CA:FALSE
keyUsage                  = critical, nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage          = serverAuth
subjectAltName            = @alt_names

[alt_names]
DNS.1 = examplepetstore.com
DNS.2 = api.examplepetstore.com

[dn_requirements]
countryName               = US
stateOrProvinceName       = California
localityName              = San Francisco
0.organizationName        = example
organizationalUnitName    = test
commonName                = examplepetstore.com
emailAddress              = test@examplepetstore.com

EOF

Erstellen Sie die CSR (server.csr) für das Serverzertifikat.

openssl req -new \
    -sha256 -newkey rsa:2048 -nodes \
    -config server.config \
    -keyout server.key -out server.csr

Signieren Sie den CSR, um das X.509-Serverzertifikat (server.cert) auszustellen. Der CSR wird mit dem Zwischenzertifikat signiert.
```
openssl x509 -req \
    -CAkey int.key -CA int.cert \
    -days 365 \
    -extfile server.config \
    -extensions extension_requirements \
    -in server.csr -out server.cert
```
Wenn der Load-Balancer eine Verbindung zum Backend-Server herstellt, präsentiert der Backend-Server sein Zertifikat (server.cert), um sich gegenüber dem Load-Balancer zu authentifizieren. Damit wird die Backend-Authentifizierung abgeschlossen.

Zusätzliche SSL-Konfigurationsoptionen auf einem Apache-Webserver

In diesem optionalen Abschnitt wird beschrieben, wie Sie die SSL-Konfigurationsoptionen auf einem Apache-Server basierend auf den Client- und Serverzertifikaten aktualisieren, die Sie zuvor erstellt haben.

Kopieren Sie den privaten Serverschlüssel (server.key) und das Serverzertifikat (server.cert) auf den Apache-Webserver.

    cat > server.key << EOF
    -----BEGIN PRIVATE KEY-----
    [...]
    -----END PRIVATE KEY-----
    EOF

    sudo cp ./server.key /etc/ssl/private/server.key

Ersetzen Sie [...] durch den PEM-codierten privaten Serverschlüssel, den Sie zuvor erstellt haben.

    cat > server.cert << EOF
    -----BEGIN CERTIFICATE-----
    [...]
    -----END CERTIFICATE-----
    EOF

    sudo cp ./server.cert /etc/ssl/certs/server.cert

Ersetzen Sie [...] durch das zuvor erstellte PEM-codierte Serverzertifikat.

Laden Sie das Clientzertifikat in die Vertrauenskonfiguration des Servers hoch, um es zu validieren.

      cat > client.cert << EOF
      -----BEGIN CERTIFICATE-----
      [...]
      -----END CERTIFICATE-----
      EOF

      sudo cp ./client.cert /etc/ssl/certs/client.cert

Ersetzen Sie [...] durch das zuvor erstellte PEM-codierte Clientzertifikat.

Aktualisieren Sie die SSL-Konfiguration des Apache-Webservers.

Aktualisieren Sie die SSL-Konfiguration von Apache, um HTTPS-Traffic mit dem angegebenen SSL-Zertifikat und privaten Schlüssel zu ermöglichen.

    sudo vi /etc/apache2/sites-available/default-ssl.conf

    ----
    SSLCertificateFile      /etc/ssl/certs/server.cert
    SSLCertificateKeyFile /etc/ssl/private/server.key
    ----

Aktualisieren Sie die SSL-Konfiguration von Apache, um die Authentifizierung mit Clientzertifikaten zu erzwingen und das CA-Zertifikat für die Validierung anzugeben.

    sudo vi /etc/apache2/sites-available/default-ssl.conf

    ----
    SSLVerifyClient require
    SSLVerifyDepth 5
    SSLCACertificateFile /etc/ssl/certs/client.cert
    ----

CA-Zertifikate neu hashen.
```
    sudo c_rehash /etc/ssl/certs/
    
```
Starten Sie den Apache-Webserver neu, damit die Änderungen übernommen werden.
```
    sudo systemctl restart apache2.service
    
```

Backend-mTLS einrichten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweise

Berechtigungen

Einrichtung: Übersicht

Root- und Zwischenzertifikate erstellen

Zertifikate formatieren

Vertrauenskonfiguration erstellen

Console

gcloud

global

regional

Clientzertifikat erstellen

Clientzertifikat in den Zertifikatmanager hochladen

Console

gcloud

global

regional

Ressource für die Konfiguration der Backend-Authentifizierung erstellen

Console

gcloud

global

regional

global

regional

Backend-Authentifizierungskonfigurationsressource an den Backend-Dienst des Load-Balancers anhängen

Console

gcloud

global

regional

global

regional

global

regional

Backend-Serverzertifikat erstellen

Zusätzliche SSL-Konfigurationsoptionen auf einem Apache-Webserver

Nächste Schritte

Backend-mTLS einrichten