Diese Seite wurde von der Cloud Translation API übersetzt.

Zertifikatbasierten Zugriff für Webanwendungen aktivieren

Auf dieser Seite wird beschrieben, wie Sie die zertifikatsbasierte Zugriff (CBA) für Ihre Webanwendungen. Mit der CBA können Sie den Zugriff von vertrauenswürdigen bis hin zu Webanwendungen in Google Cloud.

Übersicht

Die CBA für Webanwendungen nutzt die Funktionen für den kontextsensitiven Zugriff von Chrome Enterprise Premium und Google Cloud-Netzwerk für den Schutz des Zugriffs durch gegenseitige TLS (mTLS). Folgende sind die wichtigsten Komponenten, mit denen Sie arbeiten, um die CBA für Webanwendungen zu aktivieren:

Mit Access Context Manager können Sie Zugriffsebenen erstellen, für die Zertifikate erforderlich sind, wenn des Zugriffs auf Webanwendungen bestimmen.
Identity-Aware Proxy (IAP): authentifiziert den Nutzerzugriff auf Webanwendungen.
HTTPS-Load-Balancer von Google Cloud: bietet eine gegenseitige Authentifizierung (mTLS) zwischen und Webanwendungen nutzen.
Chrome Enterprise-Richtlinie: Bietet eine gegenseitige Authentifizierung (mTLS) zwischen von Nutzern und Webanwendungen in Chrome.

Hinweise

Prüfen Sie, ob Sie eine aktuelle Version der Google Cloud CLI haben. indem Sie den folgenden Befehl ausführen:

gcloud components update

mTLS für den externen HTTPS-Load-Balancer einrichten

Folgen Sie der Anleitung zur Einrichtung. den externen HTTPS-Load-Balancer. Notieren Sie sich den Namen des Ziel-HTTPS-Proxys, der erstellt wird, da Sie ihn in einem späteren Schritt benötigen.

Vertrauenskonfiguration erstellen

Erstellen Sie eine Konfiguration der Vertrauensstellung, um Ihren Typ von Public-Key-Infrastruktur (PKI) darstellen.

Für diese Aufgabe benötigen Sie das certificatemanager.trustconfigs.create Berechtigung für das Google Cloud-Zielprojekt.

Sie können eine Konfiguration der Vertrauensstellung mit einem von Google ausgestellten Zertifikat (Methode 1), mit Ihrem eigenen Zertifikat (Methode 2) oder mit einem selbst signierten Zertifikat mit Endpunktprüfung (Methode 3) erstellen.

1. Methode

Verwenden Sie ein von Google ausgestelltes Zertifikat, um eine Konfiguration der Vertrauensstellung zu erstellen.

Führen Sie die Schritte unter Root-Zertifizierungsstelle erstellen aus.
Rufen Sie den Inhalt der PEM-Datei ab:
```
gcloud privateca roots describe ROOT_CA_ID \
    --pool=POOL_ID \
    --location=CA_LOCATION \
    --format='value(pemCaCertificates)'
```
Ersetzen Sie Folgendes:
- ROOT_CA_ID: Die Root-Zertifikat-ID.
- POOL_ID: Die ID des Stammzertifikatpools.
- CA_LOCATION: Der Zertifizierungsstellenstandort.
Rufen Sie das Root-Zertifikat ab, das im Feld pemCaCertificates zurückgegeben wird. Das Zertifikat ist der String zwischen den Markierungen BEGIN CERTIFICATE und END CERTIFICATE und enthält beide Markierungen.
Speichern Sie das Root-Zertifikat im PEM-Format in einer Datei.
Konfiguration der Vertrauensstellung erstellen:
1. Legen Sie die folgenden Umgebungsvariablen fest:
```
ROOT_PEM_FILE=TRUST_ANCHOR_PATH
INT_PEM_FILE1=IM_CERT_PATH
INT_PEM_FILE2=SECOND_IM_CERT_PATH
```
  Ersetzen Sie Folgendes:
  - TRUST_ANCHOR_PATH: Der Pfad zu Ihrem PEM-codierten Trust-Anchor.
  - IM_CERT_PATH: Der Pfad zu Ihrem PEM-codierten Zwischenzertifikat.
  - SECOND_IM_CERT_PATH: Der Pfad zu Ihrem zweiten PEM-codierten Zwischenzertifikat.
2. Bereiten Sie den Inhalt der YAML-Datei für die Konfiguration der Vertrauensstellung vor:
```
ROOT=$(cat ROOT_PEM_FILE | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_1=$(cat INT_PEM_FILE1 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_2=$(cat INT_PEM_FILE2 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
```
3. Erstellen Sie die YAML-Datei für die Konfiguration der Vertrauensstellung:
```
cat << EOF > trust_config.yaml
name: "${TRUST_CONFIG_NAME?}"
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT?}"
  intermediateCas:
  - pemCertificate: "${INT_1?}"
  - pemCertificate: "${INT_2?}"
 EOF
```
  Diese YAML-Datei definiert eine Konfiguration der Vertrauensstellung mit dem Namen TRUST_CONFIG_NAME. Die Konfiguration der Vertrauensstellung enthält einen Trust Store, der den und zwei Zwischenzertifikaten.
4. Importieren Sie die Konfiguration der Vertrauensstellung in den Google Cloud Certificate Manager:
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
  --project=GCP_PROJECT \
  --source=${PWD?}/trust_config.yaml
```
  Ersetzen Sie Folgendes:
  - TRUST_CONFIG_NAME: Der Name der Konfiguration der Vertrauensstellung.
  - GCP_PROJECT: die Google Cloud-Projekt-ID.

Wenn Sie eine komplexere Struktur mit Zwischenzertifizierungsstellen bereitstellen, die vom fügen Sie die Zwischendateien als intermediateCAs hinzu.

2. Methode

Verwenden Sie Ihre eigene PKI-Bereitstellung mit vorhandenen Zertifikaten, um eine Konfiguration der Vertrauensstellung zu erstellen.

Bei dieser Art der Konfiguration der Vertrauensstellung wird von einem einfachen Trust Store mit einer einzelnen Vertrauensstellung ausgegangen Anchor, der ein Root-Zertifikat darstellt. Es sind keine Zwischenzertifikate angegeben ist.

Konfiguration der Vertrauensstellung erstellen:

Legen Sie die folgenden Umgebungsvariablen fest:
```
ROOT_PEM_FILE=TRUST_ANCHOR_PATH
INT_PEM_FILE1=IM_CERT_PATH
INT_PEM_FILE2=SECOND_IM_CERT_PATH
```
Ersetzen Sie Folgendes:
- TRUST_ANCHOR_PATH: Der Pfad zu Ihrem PEM-codierten Trust-Anchor.
- IM_CERT_PATH: Der Pfad zu Ihrem PEM-codierten Zwischenzertifikat.
- SECOND_IM_CERT_PATH: der Pfad zu Ihrem zweiten PEM-codierten Zwischenzertifikat.

Bereiten Sie den Inhalt der YAML-Datei für die Konfiguration der Vertrauensstellung vor:

ROOT=$(cat ROOT_PEM_FILE | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_1=$(cat INT_PEM_FILE1 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_2=$(cat INT_PEM_FILE2 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Erstellen Sie die YAML-Datei für die Konfiguration der Vertrauensstellung:
```
cat << EOF > trust_config.yaml
name: "${TRUST_CONFIG_NAME?}"
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT?}"
  intermediateCas:
  - pemCertificate: "${INT_1?}"
  - pemCertificate: "${INT_2?}"
EOF
```
Diese YAML-Datei definiert eine Konfiguration der Vertrauensstellung mit dem Namen TRUST_CONFIG_NAME. Die Konfiguration der Vertrauensstellung enthält einen Trust Store, der den und zwei Zwischenzertifikaten.
Importieren Sie die Konfiguration der Vertrauensstellung in den Google Cloud Certificate Manager:
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
  --project=GCP_PROJECT \
  --source=${PWD?}/trust_config.yaml
```
Ersetzen Sie Folgendes:
- TRUST_CONFIG_NAME: Der Name der Konfiguration der Vertrauensstellung.
- GCP_PROJECT: die Google Cloud-Projekt-ID.

Methode 3

Wenn Sie den Chrome-Browser verwenden und ein selbst signiertes Zertifikat verwenden möchten Endpunktprüfung aktivieren, folgen Sie der Anleitung in dieser .

Folgen Sie der Anleitung, um die Endpunktprüfung bereitzustellen. für Ihr Unternehmen. Die Endpunktprüfung stellt automatisch eine von Google ausgestellte, Zertifikate an Ihre Geräte senden und Sie müssen keine Konfiguration der Vertrauensstellung erstellen.

Erstellen Sie eine TLS-Richtlinie, um mTLS auf Ihrem externen Load-Balancer zu aktivieren

Wenn Sie Methode 3 verwendet haben, können Sie diesen Schritt überspringen.

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen:

certificatemanager.trustconfigs.use für die Konfiguration der Vertrauensstellung, die Sie für ServerTlsPolicy erstellt haben
networksecurity.serverTlsPolicies.create für das Google Cloud-Zielprojekt

Erstellen Sie die YAML-Datei für die TLS-Richtlinie des Servers:
```
cat << EOF > server_tls_policy.yaml
name: "SERVER_TLS_POLICY_NAME"
mtlsPolicy:
  clientValidationMode: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
  clientValidationTrustConfig: projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME
EOF
```
Ersetzen Sie Folgendes:
- SERVER_TLS_POLICY_NAME: Der Name der TLS-Serverrichtlinie.
- GCP_PROJECT: die Google Cloud-Projekt-ID.
- TRUST_CONFIG_NAME: Die Konfiguration der Vertrauensstellung, die Sie die in einem vorherigen Schritt erstellt wurden.
Informationen zu den Clientvalidierungsoptionen für clientValidationMode finden Sie unter MTLS-Clientvalidierungsmodi.

Importieren Sie die YAML-Datei mit der Server-TLS-Richtlinie in das Google Cloud-Projekt:

gcloud network-security server-tls-policies import ${SERVER_TLS_POLICY_NAME?} \
  --project=GCP_PROJECT \
  --source=${PWD?}/server_tls_policy.yaml \
  --location=global

Ersetzen Sie GCP_PROJECT durch die Google Cloud-Projekt-ID.

Nachdem Sie eine TLS-Richtlinie erstellt haben, können Sie sie nicht mehr ändern. Wenn Sie Änderungen an einer vorhandenen TLS-Richtlinie auf, löschen Sie die vorhandene TLS-Richtlinie und erstellen Sie eine neue.

TLS-Richtlinie an Ziel-HTTPS-Richtlinie anhängen

Zum Ausführen dieser Aufgabe benötigen Sie die Berechtigung compute.targetHttpsProxies.get für das Google Cloud-Zielprojekt.

Exportieren Sie Ihren vorhandenen HTTPS-Zielproxy in einen lokalen Datei:
```
gcloud compute target-https-proxies export TARGET_HTTPS_PROXY_NAME \
    --project=GCP_PROJECT \
    --global \
    --destination=${PWD?}/xlb-mtls-target-proxy.yaml
```
Ersetzen Sie Folgendes:
- TARGET_HTTPS_PROXY_NAME: Der Ziel-HTTPS-Proxy.
- GCP_PROJECT: die Google Cloud-Projekt-ID.
Hängen Sie ServerTlsPolicy an die Ziel-HTTPS-Proxykonfiguration an:

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen:
- networksecurity.serverTlsPolicies.use am von Ihnen erstellten ServerTlsPolicy für den Ziel-HTTPS-Proxy
- compute.targetHttpsProxies.update für das Google Cloud-Zielprojekt
```
echo "serverTlsPolicy:
//networksecurity.googleapis.com/projects/GCP_PROJECT/locations/global/serverTlsPolicies/SERVER_TLS_POLICY_NAME" >> xlb-mtls-target-proxy.yaml
```
Ersetzen Sie Folgendes:
- GCP_PROJECT: die Google Cloud-Projekt-ID.
- SERVER_TLS_POLICY_NAME: Die TLS-Serverrichtlinie.
Ziel-HTTPS-Proxy durch Importieren der neuen Konfiguration vom lokalen Proxy aktualisieren Datei:
```
gcloud compute target-https-proxies import TARGET_HTTPS_PROXY_NAME \
    --project=GCP_PROJECT \
    --global \
    --source=${PWD?}/xlb-mtls-target-proxy.yaml
```
Ersetzen Sie Folgendes:
- TARGET_HTTPS_PROXY_NAME: Der Ziel-HTTPS-Proxy.
- GCP_PROJECT: die Google Cloud-Projekt-ID.

Zugriffsebene erstellen, für die Zertifikate erforderlich sind

Console

Folgen Sie der Anleitung zum Erstellen einer benutzerdefinierten Zugriffsebene.
Fügen Sie der benutzerdefinierten Zugriffsebene den folgenden Ausdruck hinzu:

Wenn Sie eine Konfiguration der Vertrauensstellung erstellt haben (Methode 1 oder Methode 2), fügen Sie Folgendes hinzu: im Feld Bedingungen Ihrer benutzerdefinierten Zugriffsebene, die Sie verwenden möchten PKI-Attestierungsbindung bei der Authentifizierung:
```
certIsPkiAttested(origin, ["TLS_POLICY_FULL_RESOURCE_PATH1", "TLS_POLICY_FULL_RESOURCE_PATH2", …]) == true
```
Dabei sind TLS_POLICY_FULL_RESOURCE_PATH1 und TLS_POLICY_FULL_RESOURCE_PATH2 die Pfade, die für Mehrere Konfigurationen der Vertrauensstellung: certificatemanager.googleapis.com/projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME.

Sie müssen mindestens einen Pfad für die Konfiguration der Vertrauensstellung angeben.

Ersetzen Sie Folgendes:
- GCP_PROJECT: die Google Cloud-Projekt-ID.
- TRUST_CONFIG_NAME: Der Name der Konfiguration der Vertrauensstellung.
Wenn Sie ein von Google ausgestelltes, selbst signiertes (Methode 3) haben, fügen Sie den folgenden Ausdruck in die Bedingungen Ihrer benutzerdefinierten Zugriffsebene, um das Zertifikat zu verwenden Bindung bei der Authentifizierung:
```
certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE
```

gcloud

Wenn Sie eine Konfiguration der Vertrauensstellung erstellt haben (Methode 1 oder Methode 2), führen Sie den folgenden Befehl aus: zum Erstellen einer benutzerdefinierten Zugriffsebene, PKI-Attestierungsbindung bei der Authentifizierung:

gcloud access-context-manager levels create ACCESS_LEVEL_NAME \
    --title=TITLE \
    --custom-level-spec=FILE \
    --description=DESCRIPTION \
    --policy=POLICY_NAME

Ersetzen Sie Folgendes:

ACCESS_LEVEL_NAME: Ein eindeutiger Name für die Zugriffsebene.
TITLE: ein für Menschen lesbarer Titel.
FILE: Eine YAML-Datei, die den folgenden Ausdruck enthält:

certIsPkiAttested(origin, ["TLS_POLICY_FULL_RESOURCE_PATH1", "TLS_POLICY_FULL_RESOURCE_PATH2", …]) == true

Dabei sind TLS_POLICY_FULL_RESOURCE_PATH1 und TLS_POLICY_FULL_RESOURCE_PATH2 die Pfade, die für Mehrere Konfigurationen der Vertrauensstellung: certificatemanager.googleapis.com/projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME.

Sie müssen mindestens einen Pfad für die Konfiguration der Vertrauensstellung angeben.

Ersetzen Sie Folgendes:
- GCP_PROJECT: die Google Cloud-Projekt-ID.
- TRUST_CONFIG_NAME: Der Name der Konfiguration der Vertrauensstellung.
DESCRIPTION: Eine ausführliche Beschreibung der Zugriffsebene.
POLICY_NAME: die Zugriffsrichtlinie Ihrer Organisation.

Wenn Sie keine Konfiguration der Vertrauensstellung haben, weil Sie eine selbst signierte mit Endpunktprüfung (Methode 3), fügen Sie den folgenden Ausdruck zu Ihrem benutzerdefinierte Zugriffsebene:

certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE

Zertifikatbasierten Zugriff mit Identity-Aware Proxy (IAP) erzwingen

In der Architektur der CBA für Webanwendungen bietet IAP prinzipalbasierte Richtlinienerzwingung um Ihre Webanwendungen vor nicht vertrauenswürdigen Geräten zu schützen.

Führen Sie die folgenden Schritte aus, um IAP zu aktivieren und die CBA-Richtlinie zu konfigurieren:

Wenn Sie IAP noch nicht eingerichtet haben, folgen Sie dieser Anleitung. um IAP einzurichten.
Wechseln Sie zu IAP, um die zuvor erstellte Zugriffsebene anzuhängen:
Zu IAP
Wählen Sie die Ressource aus, die Sie mit der CBA sichern möchten, und klicken Sie dann auf Settings (Einstellungen).
Geben Sie im Feld Zugriffsebenen den Namen der von Ihnen erstellten Zugriffsebene ein.

Informationen zum Konfigurieren einer CBA-Richtlinie in IAP mit der Google Cloud CLI finden Sie in der Dokumentation zur Google Cloud CLI.

Browser so konfigurieren, dass das Zertifikat automatisch ausgewählt wird

Damit Ihr Browser bei der Zugriffsbestimmung automatisch das Zertifikat auswählt, führen Sie die Schritte für Ihren Browser aus.

Chrome

Konfigurieren Sie die Chrome-Richtlinie „AutoSelectCertificateForURLs“ so, dass Chrome das richtige Zertifikat während des mTLS-Handshakes.

Achten Sie darauf, dass der Chrome-Browser von der Chrome-Browser-Cloud verwaltet wird Verwaltungs- oder Windows-Gruppenrichtlinie:
- Windows, macOS, Linux: Führen Sie die Schritte zum Einrichten eines verwalteten Chrome-Profils aus.
- Chrome: Registrieren Sie das Gerät im Unternehmen.
Fügen Sie die Richtlinie AutoSelectCertificateForUrls hinzu:
1. Gehen Sie in der Admin-Konsole zu Geräte > Chrome > Einstellungen > Nutzer und Browsereinstellungen > Clientzertifikate.
2. Wählen Sie eine Organisation aus.
3. Fügen Sie eine AutoSelectCertificateForUrls-Richtlinie für die URL Ihrer Webanwendung und die Informationen zum Root-Zertifikat hinzu.

Weitere Informationen finden Sie in der Dokumentation zum Richtlinienschema. Im Folgenden finden Sie ein Beispiel für eine Richtlinienkonfiguration, die das Zertifikat aus der Endpunktprüfung verwendet:

{
  "pattern":"https://[*.].mysite.com",
  "Filter":{
    "ISSUER":{
      "CN":"Google Endpoint Verification"
    }
  }
}

Safari

Konfigurieren Sie die Identitätseinstellungen:

Öffnen Sie die Schlüsselbundverwaltung und wählen Sie Alle Elemente aus.
Wählen Sie das Zertifikat aus, das Sie konfigurieren möchten.
Klicken Sie auf Datei > Neue Identitätseinstellung.
Geben Sie die URL ein und klicken Sie auf Hinzufügen.

Dadurch wird in Ihrem Schlüsselbund ein neuer Eintrag für die Identitätseinstellung erstellt, den Sie aktualisieren können.

Edge

Legen Sie die Richtlinie AutoSelectCertificateForUrls Edge gemäß der Anleitung fest in der Edge-Dokumentation.