mTLS für das Backend einrichten

Auf dieser Seite finden Sie eine Anleitung zum Einrichten von Backend-mTLS mit selbstverwalteten Zertifikaten für globale externe Application Load Balancer.

Die Schritte zum Konfigurieren von Backend-mTLS ähneln denen für TLS mit authentifiziertem Backend. Der einzige Unterschied besteht darin, dass Sie auch ein Zertifikat für den Load Balancer erstellen müssen. Dieses Zertifikat, auch Clientzertifikat genannt, ist an die Ressource „Backend Authentication Config“ angehängt. Der Load Balancer verwendet dieses Clientzertifikat, um sich bei den Backends zu authentifizieren.

Führen Sie die Schritte in den folgenden Abschnitten aus, um Backend-mTLS zu konfigurieren:

1. Erstellen Sie eine Vertrauenskonfigurationsressource, die aus Stamm- und Zwischenzertifikaten besteht.
2. Clientzertifikat erstellen und in den Zertifikatmanager hochladen
3. Erstellen Sie eine Ressource vom Typ „Konfiguration der Backend-Authentifizierung“, die sowohl auf die Vertrauenskonfiguration als auch auf das Clientzertifikat verweist.
4. Backend Authentication Config-Ressource an den Backend-Dienst des Load Balancers anhängen

Hinweise

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

• Wenn Sie der Anleitung in diesem Leitfaden mit der Google Cloud CLI folgen 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 Backends:

  • 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
Ressource „Konfiguration der Backend-Authentifizierung“ an den Backend-Dienst des Load-Balancers anhängen	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 werden die Schritte zum Konfigurieren von Backend-mTLS basierend auf der Architektur im folgenden Diagramm beschrieben:

Komponenten für mTLS für das Backend (zum Vergrößern klicken).

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

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

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

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

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

TrustConfig-Ressource erstellen

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

So erstellen Sie eine Vertrauenskonfigurationsressource:

Console

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

   Zum Zertifikatmanager

2. Klicken Sie auf dem Tab Vertrauenskonfigurationen auf 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-Konfigurationsressource gespeichert ist. Für globale externe Application Load Balancer müssen Sie eine globale Vertrauenskonfigurationsressource erstellen.

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

6. Klicken Sie auf Hinzufügen.

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

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 Vertrauenskonfigurationsressource in der Liste der Konfigurationen angezeigt wird.

gcloud

1. 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 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 Zwischenzertifikaten zu erstellen.

2. Verwenden Sie den gcloud certificate-manager trust-configs import-Befehl, um die YAML-Datei mit der Vertrauenskonfiguration zu importieren:

   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 Folgendes:

   • TRUST_CONFIG_NAME: der Name der Vertrauenskonfigurationsressource

Clientzertifikat erstellen

Wichtig :Sie können das Clientzertifikat nicht an die Ressource „Konfiguration der Backend-Authentifizierung“ anhängen, nachdem diese Ressource erstellt wurde. Wenn Sie Backend-mTLS aktivieren möchten, müssen Sie also ein Clientzertifikat erstellen, bevor Sie die Ressource „Konfiguration der Backend-Authentifizierung“ konfigurieren.

Beim Back-End-mTLS fungiert der Load Balancer als Client und das Back-End 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 Antragstellernamen (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:

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

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

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

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

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

5. Erstellen Sie das Clientzertifikat (client.cert) aus der CSR. Die CSR wird vom 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

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

   Zum Zertifikatmanager

2. Klicken Sie auf dem Tab Zertifikate auf Zertifikat hinzufügen.

3. Geben Sie einen Namen für das Zertifikat ein.

   Dieser Name muss für das Projekt eindeutig sein.

4. Optional: Geben Sie eine Beschreibung für das Zertifikat ein. Anhand der Beschreibung können Sie ein bestimmtes Zertifikat später leichter identifizieren.

5. Wählen Sie unter Standort die Option Global aus.

6. Wählen Sie unter Bereich die Option Clientauthentifizierung aus.

7. Wählen Sie für Zertifikatstyp die Option Selbstverwaltetes Zertifikat erstellen aus.

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

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

10. Geben Sie ein Label an, das dem Zertifikat zugeordnet werden soll. Sie können bei Bedarf 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.

11. Klicken Sie auf Erstellen. Prüfen Sie, ob das neue Zertifikat in der Liste der Zertifikate angezeigt wird.

gcloud

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

   gcloud certificate-manager certificates create CLIENT_ CERTIFICATE_NAME \
       --certificate-file=client.cert \
       --private-key-file=client.key \
       --scope=client-auth \
       --global
   

   Ersetzen Sie Folgendes:

   • CLIENT_CERTIFICATE_NAME ist der Name der Clientzertifikatsressource. Dieses Clientzertifikat mit dem Bereich client-auth wird von der Ressource „Backend Authentication Config“ verwendet.

Ressource für die Konfiguration der Backend-Authentifizierung erstellen

So erstellen Sie eine BackendAuthenticationConfig-Ressource (Backend Authentication Config):

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 Backend Authentication Config-Ressource ein.
4. Wählen Sie die Clientzertifikatsressource aus, die Sie zuvor erstellt haben.
5. Optional: Wählen Sie die öffentlichen Vertrauensanker aus.
6. Wählen Sie die Konfigurationsressource für die Vertrauensstellung aus, die Sie zuvor erstellt haben.
7. 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 Authentication Config-Ressource deklarativ angegeben werden.

   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 Backend Authentication Config-Ressource 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.

2. Verwenden Sie den Befehl gcloud network-security backend-authentication-configs import, um die Backend Authentication Config-Ressource zu importieren:

   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 Authentication Config-Ressource

   • BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME: Der Name der YAML-Datei, in der die Backend Authentication Config-Ressource definiert ist.

Ressource „Konfiguration der Backend-Authentifizierung“ an den Backend-Dienst des Load-Balancers anhängen

So hängen 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 backend-authentifiziertes TLS und Backend-mTLS aktivieren müssen.

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-Hostname und die akzeptierten SANs an, um das Back-End-Zertifikat zu validieren.

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

8. Klicken Sie auf Weiter.

9. Klicken Sie zum Aktualisieren der Einstellungen des Backend-Dienstes auf 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 einer YAML-Datei, in die die Backend-Dienstkonfiguration exportiert wird

3. Aktualisieren Sie das Attribut tlsSettings des Backend-Dienstes und verweisen Sie es auf die Ressource „Backend Authentication Config“. Außerdem können Sie den SNI-Hostname und die akzeptierten SANs für den 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 reale 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: die ID Ihres Google Cloud -Projekts

   • BACKEND_AUTH_CONFIG_NAME: der Name der Backend Authentication Config-Ressource

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 Backend-Dienstkonfiguration

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 Trust-Anker aufgebaut 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 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              = [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 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 ist 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.

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 zuvor erstellte PEM-codierte Serverzertifikat.

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

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

4. CA-Zertifikate neu hashen.

       sudo c_rehash /etc/ssl/certs/
       

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

       sudo systemctl restart apache2.service
       

Nächste Schritte

• mTLS-Übersicht
• mTLS mit einer privaten CA einrichten