Backend-authentifizierte TLS einrichten

Vorschau

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Auf dieser Seite finden Sie eine Anleitung zum Einrichten von TLS mit Backend-Authentifizierung, auch Backend-Authentifizierung genannt, mit selbst verwalteten Zertifikaten für globale externe Application Load Balancer.

So konfigurieren Sie TLS mit Backend-Authentifizierung:

• Erstellen Sie eine TrustConfig-Ressource, die aus Root- und Zwischenzertifikaten besteht.
• Erstellen Sie eine Backend Authentication Config-Ressource, die auf die Vertrauenskonfiguration verweist.
• Hängen Sie die Ressource „Backend Authentication Config“ an den Backend-Dienst des Load Balancers an.

Hinweise

• Weitere Informationen finden Sie unter Übersicht über backend-authentifiziertes TLS und backend-mTLS.
• Weitere Informationen finden Sie unter Vertrauenskonfigurationen verwalten.

• Wenn Sie die Anleitung in diesem Leitfaden mit der Google Cloud CLI befolgen 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 globalen externen Application Load Balancer mit einem der folgenden unterstützten Back-Ends:

  • Back-Ends von VM-Instanzgruppen
  • Hybridkonnektivitäts-NEGs
  • Zonale NEGs

Berechtigungen

In diesem Abschnitt sind die Berechtigungen aufgeführt, die zum Konfigurieren von backend-authentifiziertem TLS erforderlich sind.

Vorgang	Berechtigung
Vertrauenskonfiguration erstellen	certificatemanager.trustconfigs.create für das Ziel-Google Cloud-Projekt
Konfigurationsressource für die Backend-Authentifizierung erstellen	certificatemanager.certs.use für das Zielzertifikat certificatemanager.trustconfigs.use für die Ziel-Trust-Konfiguration networksecurity.backendauthenticationconfigs.create für das Ziel-Google Cloud-Projekt
Hängen Sie die Ressource „Backend Authentication Config“ an den Backend-Dienst des Load Balancers an.	compute.backendservice.update für den Ziel-Backend-Dienst networksecurity.backendauthenticationconfigs.use für die Zielressource „Konfiguration der Backend-Authentifizierung“

Einrichtung: Übersicht

In den folgenden Abschnitten wird beschrieben, wie Sie backend-authentifiziertes TLS anhand der im folgenden Diagramm dargestellten Architektur konfigurieren:

Backend-authentifizierte TLS-Komponenten (zum Vergrößern anklicken)

Root- und Zwischenzertifikate erstellen

Hinweis:

Wenn Sie bereits Zertifikate haben, die Sie in den Trust Store hochladen möchten, können Sie diesen Schritt überspringen und mit Zertifikate formatieren fortfahren.

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

Ein Root-Zertifikat steht an der Spitze der Zertifikatskette. Ein Zwischenzertifikat ist Teil der Vertrauenskette bis zum Root-Zertifikat. Das Zwischenzertifikat wird kryptografisch vom Stammzertifikat signiert. Wenn der Load Balancer ein Serverzertifikat empfängt, validiert er es, indem er eine Vertrauenskette vom Serverzertifikat zum konfigurierten Trust Anchor herstellt.

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

1. Erstellen Sie eine OpenSSL-Konfigurationsdatei.

   Im folgenden Beispiel enthält die Konfigurationsdatei (example.cnf) den Abschnitt [ca_exts], in dem X.509-Erweiterungen angegeben sind, die das Zertifikat als für eine Zertifizierungsstelle geeignet kennzeichnen. Weitere Informationen zu den Anforderungen an Stamm- und Zwischenzertifikate finden Sie unter Anforderungen an Zertifikate.

   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
   

2. Erstellen Sie ein selbst signiertes 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
   

3. Erstellen Sie die CSR (Certificate Signing Request) 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
   

4. Signieren Sie die CSR, um das X.509-Zwischenzertifikat (int.cert) zu erstellen. Die CSR wird mit dem Stammzertifikat 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 sie in der YAML-Datei der Trust-Konfiguration referenziert werden können.

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')

TrustConfig-Ressource erstellen

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

So erstellen Sie eine Vertrauensstellungsressource:

Console

1. Rufen Sie in der Google Cloud Console die Seite Zertifikatmanager auf.

   Zum Zertifikatmanager

2. Klicken Sie auf dem Tab Trust Configs (Vertrauenskonfigurationen) auf Add Trust Config (Vertrauenskonfiguration hinzufügen).

3. Geben Sie einen Namen für die Konfiguration ein.

4. Wählen Sie unter Standort die Option Global aus. Der Speicherort gibt an, wo die Trust-Config-Ressource gespeichert ist. Für globale externe Application Load Balancer müssen Sie eine globale Vertrauenskonfiguratierungsressource erstellen.

5. Klicken Sie im Bereich Trust Store auf Trust Anchor hinzufügen und laden Sie die PEM-codierte Zertifikatsdatei hoch oder kopieren Sie den Inhalt des Zertifikats.

6. Klicken Sie auf Hinzufügen.

7. Klicken Sie im Bereich 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.

8. Klicken Sie auf Hinzufügen, um die Zwischenzertifizierungsstelle hinzuzufügen.

9. Klicken Sie auf Hinzufügen, um das Zertifikat hinzuzufügen, das Sie der Zulassungsliste hinzugefügt haben.

10. Klicken Sie auf Erstellen.

Prüfen Sie, ob die neue Trust-Konfigurationsressource in der Liste der Konfigurationen aufgeführt ist.

gcloud

1. Erstellen Sie eine YAML-Datei für die Vertrauensstellung (trust_config.yaml), in der die Parameter für die Vertrauensstellung angegeben sind. Diese Beispielressource für die Vertrauenskonfiguration enthält einen Trust Store mit einem Trust-Anchor und einem Zwischenzertifikat. In dieser Beispielressource für die Vertrauenskonfiguration 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 Zwischen-CA-Zertifikaten zu erstellen.

2. Verwenden Sie den Befehl gcloud certificate-manager trust-configs import, um die YAML-Datei für die Vertrauensstellung zu importieren:

   Geben Sie für globale externe Application Load Balancer global als Speicherort der Trust-Konfigurationsressource an.

   gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME  \
       --source=trust_config.yaml \
       --location=global
   

   Ersetzen Sie Folgendes:

   • TRUST_CONFIG_NAME: der Name der Vertrauenskonfigurationsressource

Konfigurationsressource für die Backend-Authentifizierung erstellen

So erstellst du eine Backend-Authentifizierungskonfiguration (BackendAuthenticationConfig):

Console

1. Rufen Sie in der Google Cloud Console die Seite Authentifizierungskonfiguration auf.

   Zur Authentifizierungskonfiguration

2. Klicken Sie auf dem Tab Backend-Authentifizierung auf Erstellen.
3. Geben Sie einen Namen für die Ressource „Backend Authentication Config“ ein.
4. Optional: Wählen Sie die öffentlichen Stammzertifizierungsstellen aus.
5. Wählen Sie die zuvor erstellte Konfigurationsressource für die Vertrauensstellung aus.
6. Klicken Sie auf Erstellen.

Prüfen Sie, ob die Ressource „Backend Authentication Config“ angezeigt wird.

gcloud

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

   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 Backend-Authentifizierungs-Konfigurationsressource definiert ist.
   • PROJECT_ID: die ID Ihres Google Cloud-Projekts
   • BACKEND_AUTH_CONFIG_NAME: der Name der Konfiguration der Backend-Authentifizierung
   • TRUST_CONFIG_NAME: Der Name der zuvor erstellten Vertrauenskonfigurationsressource.

2. Verwenden Sie den Befehl gcloud beta network-security backend-authentication-configs import, um die Back-End-Authentifizierungskonfiguration zu importieren:

   gcloud beta 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 Backend-Authentifizierungs-Konfigurationsressource definiert ist.

Hängen Sie die Ressource „Backend Authentication Config“ an den Backend-Dienst des Load Balancers an.

So binden Sie die Ressource „Backend Authentication Config“ (BackendAuthenticationConfig) an den Backend-Dienst des Load Balancers an:

Console

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

   Load-Balancing aufrufen

2. Wählen Sie auf dem Tab Backends den Backend-Dienst aus, für den Sie backendauthentifiziertes TLS und backend-mTLS aktivieren möchten.

3. Klicken Sie auf Bearbeiten.

4. Maximieren Sie den Abschnitt Erweiterte Konfigurationen.

5. Klicken Sie im Abschnitt Backend-Authentifizierung das Kästchen Aktivieren an.

6. Optional: Geben Sie den SNI-Hostnamen und die zulässigen SANs an, um das Backend-Zertifikat zu validieren.

7. Wenn Sie die Ressource „Backend Authentication Config“ (Konfiguration der Backend-Authentifizierung) an den Back-End-Dienst anhängen möchten, wählen Sie sie in der Liste Backend Authentication Config (Konfiguration der Backend-Authentifizierung) aus.

8. Klicken Sie auf Weiter.

9. Klicken Sie auf Aktualisieren, um die Einstellungen für den Backend-Dienst zu aktualisieren.

gcloud

1. 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.

2. Verwenden Sie den Befehl gcloud beta compute backend-services export, um die Konfiguration des Back-End-Dienstes in eine Datei zu exportieren.

   gcloud beta 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 zu einer YAML-Datei, in die die Konfiguration des Backend-Dienstes exportiert wird

3. Aktualisieren Sie das Attribut tlsSettings des Backend-Dienstes und verweisen Sie darauf. Außerdem können Sie den SNI-Hostnamen und die zulässigen SANs im Backend-Dienst konfigurieren, um das Backend-Zertifikat zu validieren.

     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
     

   Die SNI- und SAN-Werte in der vorherigen YAML-Deklaration dienen nur als Beispiele. Sie können sie durch realistische Werte ersetzen, die für Ihre Konfiguration relevant sind.

   Ersetzen Sie Folgendes:

   • BACKEND_SERVICE_FILENAME: der Name der YAML-Datei, in die die Backend-Dienstkonfiguration exportiert wird

   • PROJECT_ID ist die ID Ihres Google Cloud-Projekts

   • BACKEND_AUTH_CONFIG_NAME: der Name der Backend-Authentifizierungskonfigurationsressource

4. Verwenden Sie den Befehl gcloud beta compute backend-services import, um die aktualisierte Konfiguration des Backend-Dienstes aus einer Datei zu importieren.

   gcloud beta 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 Konfiguration des Backend-Dienstes

Backend-Serverzertifikat erstellen

Dieser Abschnitt bietet eine zusätzliche Konfigurationsoption zum Erstellen eines Serverzertifikats (untergeordnetes Zertifikat), das vom Zwischenzertifikat signiert ist, das Teil der Vertrauenskonfiguration ist. So kann eine Vertrauenskette vom Serverzertifikat bis zum Trust Anchor hergestellt werden.

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

1. 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 sind, die in das CSR aufgenommen werden sollen. Weitere Informationen zu den Anforderungen an Serverzertifikate finden Sie unter Zertifikatsanforderungen.

   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              = [e-mail]
   
   EOF
   

2. 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
   

3. Signieren Sie die CSR, um das X.509-Serverzertifikat (server.cert) auszustellen. Die CSR wird vom 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 Back-End-Server herstellt, präsentiert dieser sein Zertifikat (server.cert), um sich beim Load Balancer zu authentifizieren. Damit ist die Back-End-Authentifizierung abgeschlossen.

Zusätzliche SSL-Konfigurationsoptionen auf einem Apache-Webserver

In diesem optionalen Abschnitt erfahren Sie, wie Sie die SSL-Konfigurationsoptionen auf einem Apache-Server anhand der zuvor erstellten Serverzertifikate aktualisieren.

1. 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 PEM-codierte Serverzertifikat, das Sie zuvor erstellt haben.

2. Aktualisieren Sie die SSL-Konfiguration des Apache-Webservers.

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

       sudo vi /etc/apache2/sites-available/default-ssl.conf
   
       ----
       SSLCertificateFile      /etc/ssl/certs/server.cert
       SSLCertificateKeyFile /etc/ssl/private/server.key
       ----
       

3. CA-Zertifikate noch einmal hashieren.

       sudo c_rehash /etc/ssl/certs/
       

4. Starten Sie den Apache-Webserver neu, damit die Änderungen übernommen werden.

       sudo systemctl restart apache2.service
       

Nächste Schritte

• mTLS für das Backend einrichten
• mTLS-Übersicht
• mTLS mit einer privaten Zertifizierungsstelle einrichten