Backend-authentifiziertes TLS einrichten

Auf dieser Seite finden Sie eine Anleitung zum Einrichten von Backend-authentifiziertem TLS, auch als Backend-Authentifizierung bezeichnet, mit selbstverwalteten Zertifikaten.

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

Erstellen Sie eine TrustConfig-Ressource, die aus Root- und Zwischenzertifikaten besteht.
Erstellen Sie eine Ressource für die Konfiguration der Backend-Authentifizierung, die auf die Konfiguration der Vertrauensstellung 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-authentifiziertem TLS erforderlich sind.

Vorgang	Berechtigung
Vertrauenskonfiguration erstellen	`certificatemanager.trustconfigs.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 TLS mit Backend-Authentifizierung basierend auf der im folgenden Diagramm gezeigten Architektur beschrieben.

Komponenten des Backend-authentifizierten TLS. — Komponenten für Backend-authentifiziertes TLS (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

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.
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
```
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
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
regional
```
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
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
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 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.

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
    ----
    
```
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-authentifiziertes TLS 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

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-authentifiziertes TLS einrichten