Diese Seite wurde von der Cloud Translation API übersetzt.

Nicht Google Cloud-Anwendungen mit dem App-Connector schützen

Auf dieser Seite wird beschrieben, wie Sie den Chrome Enterprise Premium-App-Connector einrichten und verwenden, um Nicht-Google Cloud -Anwendungen zu schützen.

Übersicht

Mit dem Chrome Enterprise Premium-App-Connector können Sie Identitäts- und kontextbezogenen Zugriff auf HTTPS-Anwendungen ermöglichen, die in Umgebungen außerhalb vonGoogle Cloudausgeführt werden. Der Chrome Enterprise Premium-App-Connector ist eine sichere, authentifizierte Schnittstelle zwischen der Chrome Enterprise Premium-Erzwingungsebene und Anwendungen, die in anderen Clouds und lokalen Umgebungen ausgeführt werden.

Ein Vorteil der Verwendung des Chrome Enterprise Premium-App-Connectors besteht darin, dass Sie keine Firewalls öffnen oder Site-to-Site-Cloud VPN-Verbindungen einrichten müssen.

Architektur

Das folgende allgemeine Architekturdiagramm zeigt die Hauptkomponenten des Chrome Enterprise Premium-App-Connectors.

Komponenten von Chrome Enterprise Premium-App-Connectors

Die Komponenten von Chrome Enterprise Premium-App-Connectors werden über drei Haupt-API-Ressourcen verwaltet: App-Connectors, App-Verbindungen und App-Gateways.

App-Connectors: Eine Connector-Ressource definiert einen eindeutigen Remote-Agent des App-Connectors. Remote-Agents des App-Connectors werden in Remote-Unternehmensumgebungen wie anderen Clouds und lokalen Umgebungen bereitgestellt. Remote-Agents initiieren und verwalten Tunnelsitzungen zu Google Cloud, empfangen Traffic vonGoogle Cloudund leiten Traffic an Remote-Anwendungsendpunkte in derselben Umgebung weiter.
App-Verbindungen: Eine Verbindungsressource definiert eine logische Verbindung vonGoogle Cloud zu einem bestimmten Anwendungsendpunkt, der über IP-Adresse:Port oder FQDN:Port identifiziert wird. Eine Verbindungsressource orchestriert eine Reihe von Gateways für verwaltete App-Connectors, die für einen bestimmten Anwendungsendpunkt zugewiesen werden. Die Gateways werden inGoogle Cloud verwaltet und beenden die Tunnelsitzungen von den Remote-Agents, wenn sie nicht mehr benötigt werden.
App-Gateways: Ein App-Gateway ist ein von Google verwalteter Dienst. Remote-Agents des App-Connectors stellen eine Verbindung zu einem oder mehreren Gateways her, über die App-Verbindungen und App-Connectors Traffic von Endnutzern an Remote-Agents weiterleiten können. Traffic für App-Verbindungen, die auf demselben App-Gateway gehostet werden, wird über eine gemeinsame virtuelle Infrastruktur geleitet.; Wenn Sie eine Anwendung über den App-Connector verbinden, werden App-Gateways implizit für Sie erstellt und verwaltet. Sie können auch zusätzliche App-Gateways erstellen, wenn Sie App-Verbindungsressourcen in Gruppen organisieren möchten. App-Gateways bieten die Flexibilität, App-Verbindungen zu gruppieren oder zu trennen, um die App-Isolation zu ermöglichen.; Jedes App-Gateway kann einen Gesamtdurchsatz von bis zu 1 Gbit/s für bis zu 200.000 gleichzeitige Verbindungen unterstützen. Wir empfehlen, dedizierte Gateways für kritische Anwendungen zu erstellen, die eine hohe Leistung erfordern. Sie können maximal 10 Apps pro Gateway zuweisen.; Um bis zu 200.000 gleichzeitige Verbindungen und einen Gesamtdurchsatz von bis zu 1 Gbit/s zu unterstützen,empfehlen wir, eine dedizierte VM mit 8 Kernen und 8 GB Arbeitsspeicher für die Ausführung des Remote-Agents des App-Connectors zu verwenden. Beispielsweise können Sie in einem HA-Cluster mit jeweils 8 Cores und 8 GB Arbeitsspeicher zwei App-Connector-Remote-Agents für eine leistungsstarke Webanwendung (app1.examplecompany.com) mit einem dedizierten App-Gateway (app_gateway1) zuweisen. Erstellen Sie einen weiteren Cluster mit 2 VMs mit jeweils 8 Cores und 8 GB Arbeitsspeicher, um eine Kombination aus 10 Apps mit geringer Nutzung mit einem weiteren dedizierten App-Gateway (app_gateway2) zu unterstützen.

Die Ressourcen für Anwendungs-Connectors, Anwendungsverbindungen und Anwendungsgateways sind regional. Sie können sie nur in einem regionalen Kontext verwenden. Sie können beispielsweise keinen App-Connector in Region A einer App-Verbindung oder einem App-Gateway zuweisen, die in Region B erstellt wurden.

Hinweise

Sie können den Chrome Enterprise Premium-App-Connector nur mit HTTPS-Anwendungen verwenden. Außerdem verwenden HTTPS-Load-Balancer die Erweiterung „Server Name Indication“ (SNI) nicht für Verbindungen zum Backend. Weitere Informationen finden Sie unter Verschlüsselung vom Load-Balancer zu Back-Ends.

Für die Verwendung des Chrome Enterprise Premium-App-Connectors benötigen Sie Folgendes:

Eine Chrome Enterprise Premium-Lizenz.
Google Cloud CLI-Version 392 oder höher.

Für jeden Chrome Enterprise Premium-App-Connector-Agent ist eine Linux-VM erforderlich, auf der Docker ausgeführt wird. Wir empfehlen die folgenden Linux-Distributionen:

Debian 10.7 (Buster)
Red Hat Enterprise Linux Server 7.8 (Maipo) x86_64
Ubuntu 16.04 oder höher

Für die Hardware der Linux-VM empfehlen wir mindestens 2 CPUs mit 2 GB RAM.

Sie können den App-Connector mit gcloud und der API oder über die Google Cloud -Konsole einrichten und aktivieren. Führen Sie die folgenden Schritte aus, um gcloud und APIs zu verwenden. Informationen zur Verwendung der Google Cloud Console finden Sie unter App-Connector mit der Google Cloud Console einrichten.

Google Cloud -Projekt einrichten

Wenn Sie ein Google Cloud -Projekt für die Verwendung mit dem Chrome Enterprise Premium-App-Connector einrichten möchten, müssen Sie die Chrome Enterprise Premium API aktivieren. Aktivieren Sie die API, indem Sie die folgenden Schritte ausführen:

gcloud-CLI

Bevor Sie die folgenden Schritte ausführen, müssen Sie das gcloud CLI SDK installiert haben.

Legen Sie die erforderliche Umgebungsvariable mit dem folgenden Befehl fest:
```
PROJECT_ID=my-project
```
Ersetzen Sie my-project durch die Google Cloud Projekt-ID.

Aktivieren Sie die API mit dem folgenden Befehl:

gcloud config set project $PROJECT_ID
gcloud services enable beyondcorp.googleapis.com

API

Rufen Sie ein Zugriffstoken ab und legen Sie die erforderlichen Umgebungsvariablen und Aliase fest, indem Sie die folgenden Befehle ausführen:
```
PROJECT_NUMBER=my-project-number
ACCESS_TOKEN=my-access-token
```
Ersetzen Sie my-project durch die Google Cloud Projekt-ID.

Richten Sie einen praktischen Alias ein, um Ihr Zugriffstoken zu verwenden:

alias gcurl="curl -H 'Authorization: Bearer ${ACCESS_TOKEN}' -H 'Content-Type: application/json'"

Aktivieren Sie die API mit dem folgenden Befehl:

gcurl https://serviceusage.googleapis.com/v1/projects/${PROJECT_NUMBER}/services/beyondcorp.googleapis.com:enable -d "{}"

Remote-Agent eines App-Connectors installieren

Sie müssen für jede Netzwerkumgebung, in der eine Anwendung gehostet wird, die Sie mit Chrome Enterprise Premium schützen möchten, eine VM mit einem Remote-Agent für App-Connectors bereitstellen. Sie benötigen für jeden Remote-Agent, den Sie erstellen, eine dedizierte VM oder einen Bare-Metal-Server mit installiertem Docker.

So erstellen Sie einen Remote-Agent:

Erstellen Sie eine VM-Instanz in Ihrer Anwendungsumgebung.
1. Achten Sie darauf, dass die Netzwerkfirewall der Remote-Agent-VM den gesamten ausgehenden Traffic zulässt, der an Port 443 für den IAP-TCP-IP-Bereich 35.235.240.0/20 initiiert wird. Informationen zu anderen Domains, zu denen die Firewall der Remote-Agent-VM ausgehenden Traffic zulassen soll, finden Sie unter Firewallkonfiguration prüfen.
Remote-Agent installieren:
1. Prüfen Sie, ob Ihr DNS richtig konfiguriert ist und ob Sie mit curl auf die Anwendung zugreifen können.
2. Installieren Sie die Docker Engine.
  1. Optional: Wenn Sie einen Proxy verwenden, prüfen Sie, ob der Docker-Daemon richtig konfiguriert ist.
3. Optional: Wenn Sie einen Proxy verwenden, prüfen Sie, ob sowohl die HTTP- als auch die HTTPS-Proxy-Umgebungsvariablen festgelegt sind und das http://-Schema verwendet wird.
4. Führen Sie den folgenden Befehl auf der VM des Remote-Agents aus, um den Remote-Agent zu installieren:
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/beyondcorp-applink/main/bash-scripts/install-beyondcorp-runtime -o ./install-beyondcorp-runtime && chmod +x ./install-beyondcorp-runtime && ./install-beyondcorp-runtime
```
5. Führen Sie den folgenden Befehl aus, um den Alias bce-connctl zu Ihrer Shell hinzuzufügen:
```
 source ~/.bce_alias
 
```
6. Legen Sie die erforderlichen Umgebungsvariablen mit den folgenden Befehlen fest:
```
PROJECT_ID=my-project
REGION=us-central1
CONNECTOR_NAME=my-connector
```
  Ersetzen Sie Folgendes:
  - my-project: die Google Cloud Projekt-ID.
  - us-central1: die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
  - my-connector: der Name des Connectors.
7. Registrieren Sie den Connector mit einem der folgenden Anmeldedatentypen:
Dienstkonto
1. Registrieren Sie den Connector, indem Sie den folgenden Befehl in der bce-connctl-Befehlszeile ausführen:
  bce-connctl init --project=$PROJECT_ID --region=$REGION --connector=$CONNECTOR_NAME
2. Folgen Sie der Anleitung auf dem Bildschirm, um das Registrierungsskript mit Cloud Shell oder der gcloud CLI in Ihre Google Cloud -Projekte zu kopieren und einzufügen und die Registrierung Ihres Connectors abzuschließen. Zum Ausführen des Registrierungsskripts benötigen Sie die Berechtigung Owner für das Projekt.
  
  Wenn das Registrierungsskript abgeschlossen ist, synchronisiert die Laufzeit die Connector-Konfiguration automatisch.
Föderierte Identität
1. Folgen Sie der Anleitung zur Workload Identity-Föderation, um Ihrer externen Identität mithilfe der Identitätsübernahme des Dienstkontos Zugriff auf Google Cloudzu gewähren.
2. Laden Sie die Clientbibliothekskonfiguration herunter und platzieren Sie die Datei auf der Remote-Agent-VM unter /var/beyondcorp/credentials/credentials.json.
  1. Wenn Sie eine AWS EC2-Instanz als VM für den Remote-Agent verwenden, haben Sie folgende Möglichkeiten:
    
    IMDSv2 auf der EC2-Instanz optional machen.
    
    Fügen Sie der Konfigurationsdatei der Clientbibliothek die folgende Zeile zum Objekt credential_source hinzu:
    "imdsv2_session_token_url": "http://169.254.169.254/latest/api/token"
3. Führen Sie auf der VM des Remote-Agents die folgenden Befehle in der bce-connctl-Befehlszeile aus:
  bce-connctl config set project $PROJECT_ID bce-connctl config set region $REGION bce-connctl config set connector $CONNECTOR_NAME
4. Führen Sie den folgenden Befehl aus, um den Agent neu zu starten und die Anmeldedaten zu übernehmen:
  sudo systemctl restart beyondcorp
5. Legen Sie in Ihrem Cloud Shell- oder gcloud CLI-Endpunkt die erforderliche Umgebungsvariable fest, indem Sie den folgenden Befehl ausführen:
  SERVICE_ACCOUNT=my-service-account
  Ersetzen Sie Folgendes:
  - my-service-account: das Google Cloud Dienstkonto, das mit der externen Identität verknüpft ist.
6. Weisen Sie dem Google Cloud -Dienstkonto die Rolle BeyondCorp Connection Agent mit dem folgenden Befehl zu:
  gcloud projects add-iam-policy-binding $PROJECT_ID \ --member="serviceAccount:$SERVICE_ACCOUNT" \ --role="roles/beyondcorp.connectionAgent"
7. Führen Sie den folgenden Befehl aus, um die Google Cloud -App-Connector-Ressource zu erstellen.
  gcloud alpha beyondcorp app connectors create $CONNECTOR_NAME \ --project=$PROJECT_ID \ --location=$REGION \ --member="serviceAccount:$SERVICE_ACCOUNT" \ --display-name=$CONNECTOR_NAME
  Nachdem die App-Connector-Ressource erstellt wurde, synchronisiert die Remote-Agent-Laufzeit die Connector-Konfiguration automatisch.
Installation des Remote-Agents prüfen:
1. Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Dienst ausgeführt wird:
```
sudo systemctl status beyondcorp
```
2. Der Remote-Agent besteht aus drei Docker-Containern: bce-control-runtime, bce-logagent und bce-connector. Prüfen Sie mit dem folgenden Befehl, ob alle drei Container ausgeführt werden:
```
docker ps --filter name=bce
```
3. Optional: Sie können die Logdateien der Docker-Container mit dem folgenden Befehl prüfen:
```
docker logs -f CONTAINER_NAME
```
  Ersetzen Sie CONTAINER_NAME durch den Namen des Docker-Containers.

Remoteanwendung mit einer VPC verbinden

gcloud-CLI

Bevor Sie die folgenden Schritte ausführen, müssen Sie das gcloud CLI SDK installiert haben und mit einem Konto angemeldet sein, dem die Rolle beyondcorp.admin zugewiesen ist.

Legen Sie die erforderlichen Umgebungsvariablen mit den folgenden Befehlen fest:
```
CONNECTOR_NAME=my-connector
CONNECTION_NAME=my-connection
PROJECT_ID=my-project
REGION=us-central1
APP_ENDPOINT=APP_HOST:APP_PORT
```
Ersetzen Sie Folgendes:
- my-connector: Der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
- my-connection: ein eindeutiger Name für die Verbindung.
- my-project: die Google Cloud Projekt-ID.
- us-central1: die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
- APP_HOST: Die lokale IP-Adresse oder ein FQDN, auf dem Ihre Anwendung gehostet wird.
- APP_PORT: die Portnummer, über die eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

Führen Sie den folgenden Befehl aus, um eine Verbindung zwischen Ihrer Anwendung und Ihrer VPC herzustellen:

gcloud alpha beyondcorp app connections create $CONNECTION_NAME \
    --project=$PROJECT_ID \
    --location=$REGION \
    --application-endpoint=$APP_ENDPOINT \
    --type=tcp \
    --connectors=$CONNECTOR_NAME \
    --display-name=$CONNECTION_NAME

Dieser Schritt kann einige Minuten dauern.

Nachdem Sie die Verbindung erstellt haben, führen Sie die folgenden Befehle aus, um die Gateway-URIs abzurufen:
```
GATEWAY_URI="$(gcloud alpha beyondcorp app connections describe $CONNECTION_NAME --project=$PROJECT_ID --location=$REGION --format='get(gateway.uri)')"
GATEWAY_URI_L7="${GATEWAY_URI/bce-psc/bce-ps7}"
```
Mit GATEWAY_URI_L7 wird eine Weiterleitungsregel erstellt. Der Chrome Enterprise Premium-App-Connector verwendet Private Service Connect, um das Nutzerprojekt mit den verwalteten Ressourcen in von Google verwalteten Projekten zu verknüpfen.

API

Legen Sie die erforderlichen Umgebungsvariablen mit den folgenden Befehlen fest:
```
CONNECTOR_NAME=my-connector
CONNECTION_NAME=my-connection
PROJECT_ID=my-project
REGION=us-central1
APP_HOST=my-app-host
APP_PORT=my-app-port
```
Ersetzen Sie Folgendes:
- my-connector: Der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
- my-connection: ein eindeutiger Name für die Verbindung.
- my-project: die Google Cloud Projekt-ID.
- us-central1: die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
- my-app-host: Die lokale IP-Adresse oder ein FQDN, auf dem Ihre Anwendung gehostet wird.
- my-app-port: die Portnummer, über die eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

Führen Sie den folgenden Befehl aus, um eine Verbindung zwischen Ihrer Anwendung und Ihrer VPC herzustellen:

gcurl https://beyondcorp.googleapis.com/v1/projects/${PROJECT_NUMBER}/locations/${REGION}/appConnections?app_connection_id=${CONNECTION_NAME} \
-d "{ \
    'application_endpoint': \
    { \
        'host': '${APP_HOST}', \
        'port': '${APP_PORT}' \
    }, \
    'type': 'TCP_PROXY', \
    'display_name': '${CONNECTION_NAME}' \
}"

Dieser Schritt kann einige Minuten dauern.

Nachdem Sie die Verbindung erstellt haben, führen Sie die folgenden Befehle aus, um die Gateway-URIs abzurufen:
```
GATEWAY_URI=$(gcurl https://beyondcorp.googleapis.com/v1/projects/${PROJECT_NUMBER}/locations/${REGION}/appConnections/${CONNECTION_NAME} | jq -r '.gateway.uri')
GATEWAY_URI_L7="${GATEWAY_URI/bce-psc/'bce-ps7'}"
```
Mit GATEWAY_URI_L7 wird eine Weiterleitungsregel erstellt. Der Chrome Enterprise Premium-App-Connector verwendet Private Service Connect, um das Nutzerprojekt mit den verwalteten Ressourcen in von Google verwalteten Projekten zu verknüpfen.

Externen Application Load Balancer konfigurieren

Sie können nur HTTPS-Anwendungen mit einem externen Application Load Balancer verbinden. HTTP-Anwendungen werden nicht unterstützt.

gcloud-CLI

Bevor Sie die folgenden Schritte ausführen, müssen Sie das gcloud CLI SDK installiert haben und mit einem Konto angemeldet sein, dem die Rolle beyondcorp.admin zugewiesen ist.

Legen Sie die erforderlichen Umgebungsvariablen mit den folgenden Befehlen fest:
```
LB_PREFIX=web-app
PROJECT_ID=my-project
REGION=us-central1
DOMAIN_NAME=app.example.com
```
Ersetzen Sie Folgendes:
- web-app: Das Präfix, das an die Namen aller Load-Balancer-Ressourcen angehängt wird.
- my-project: die Google Cloud Projekt-ID.
- us-central1: die Region, in der die Verbindung und die Gateways bereitgestellt werden.
- app.example.com: der Domainname Ihrer Anwendung.
Erstellen Sie mit dem folgenden Befehl eine Netzwerk-Endpunktgruppe (NEG):
```
gcloud beta compute network-endpoint-groups create $LB_PREFIX-neg \
    --region=$REGION \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=$GATEWAY_URI_L7
```
Optionale Flags:
- Legen Sie das Flag --network fest, um den Namen des Netzwerks für die Netzwerkendpunkte in der NEG anzugeben. Wenn keine Angabe erfolgt, wird das Standardprojektnetzwerk verwendet.
- Legen Sie das Flag --subnet fest, um den Namen des Subnetzes für die Netzwerkendpunkte in der NEG anzugeben. Wenn kein Subnetz angegeben ist, kann der Netzwerkendpunkt zu einem beliebigen Subnetzwerk in der Region gehören, in der die Netzwerk-Endpunktgruppe erstellt wird.

Erstellen Sie einen NEG-basierten Backend-Dienst und stellen Sie mit den folgenden Befehlen eine Verbindung zu einem Private Service Connect-Dienstanhang her:

gcloud beta compute backend-services create $LB_PREFIX-backend-service \
    --global \
    --protocol=HTTPS \
    --load-balancing-scheme=EXTERNAL_MANAGED

gcloud beta compute backend-services add-backend $LB_PREFIX-backend-service \
    --global \
    --network-endpoint-group=$LB_PREFIX-neg \
    --network-endpoint-group-region=$REGION

Erstellen Sie ein von Google verwaltetes Zertifikat für Ihre Domain, indem Sie die folgenden Befehle ausführen:

gcloud compute addresses create $LB_PREFIX-static-ip \
    --ip-version=IPV4 \
    --global
gcloud compute ssl-certificates create $LB_PREFIX-ssl-cert \
    --domains=$DOMAIN_NAME \
    --global

LB_IP="$(gcloud compute addresses describe $LB_PREFIX-static-ip --global --format='value(address)')"

Erstellen Sie einen externen Application Load Balancer basierend auf dem Backend aus dem vorherigen Schritt, indem Sie die folgenden Befehle ausführen:

gcloud compute url-maps create $LB_PREFIX-map-https \
    --default-service=$LB_PREFIX-backend-service

gcloud compute target-https-proxies create $LB_PREFIX-https-lb-proxy \
    --url-map=$LB_PREFIX-map-https \
    --ssl-certificates=$LB_PREFIX-ssl-cert

gcloud beta compute forwarding-rules create "$LB_PREFIX-https-lb-forwarding-rule" \
    --global \
    --target-https-proxy=$LB_PREFIX-https-lb-proxy \
    --address=$LB_IP \
    --ports=443 \
    --load-balancing-scheme=EXTERNAL_MANAGED

Nachdem der externe Application Load Balancer erstellt wurde, ist Ihre Anwendung über diese IP-Adresse im Internet erreichbar.

Nachdem der externe Application Load Balancer erstellt wurde, müssen Sie seine IP-Adresse dem Domainnamen zuordnen, damit Google Cloud ein SSL-Zertifikat bereitstellen kann. Folgen Sie der Anleitung Ihres DNS-Anbieters, um die IP-Adresse mit dem DNS-Namen zu verknüpfen. Führen Sie den folgenden Befehl aus, um den Bereitstellungsstatus zu prüfen:
1. IP-Adresse anzeigen, die beim DNS-Anbieter eingerichtet werden muss:
```
echo "Load Balancer ip address - $LB_IP"
```
2. Nachdem Sie die DNS-Einstellungen festgelegt haben, prüfen Sie mit dem folgenden Befehl, ob der Domainname in die IP-Adresse aufgelöst wird:
```
dig $DOMAIN_NAME
```
3. Rufen Sie den Bereitstellungsstatus mit dem folgenden Befehl ab:
```
gcloud compute ssl-certificates describe $LB_PREFIX-ssl-cert \
    --global \
    --format="get(name,managed.status, managed.domainStatus)"
```
Nachdem das SSL-Zertifikat bereitgestellt wurde, sollten Sie über den DNS-Namen auf Ihre Anwendung zugreifen können.

API

Legen Sie die erforderlichen Umgebungsvariablen mit den folgenden Befehlen fest:
```
LB_PREFIX=web-app
PROJECT_ID=my-project
REGION=us-central1
DOMAIN_NAME=app.example.com
```
Ersetzen Sie Folgendes:
- web-app: Das Präfix, das an die Namen aller Load-Balancer-Ressourcen angehängt wird.
- my-project: die Google Cloud Projekt-ID.
- us-central1: die Region, in der die Verbindung und die Gateways bereitgestellt werden.
- app.example.com: der Domainname Ihrer Anwendung.
Erstellen Sie mit dem folgenden Befehl eine Netzwerk-Endpunktgruppe (NEG):
```
gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/regions/${REGION}/networkEndpointGroups \
-d "{ \
    'name': '${LB_PREFIX}-neg', \
    'network_endpoint_type': 'private-service-connect', \
    'psc_target_service': '${GATEWAY_URI_L7}' \
}"
```
Optionale Felder:
- Legen Sie das Feld network fest, um die URL des Netzwerks für die Netzwerkendpunkte in der NEG anzugeben. Wenn keine Angabe erfolgt, wird das Standardprojektnetzwerk verwendet.
- Legen Sie das Feld subnetwork fest, um die URL des Subnetzwerks für die Netzwerkendpunkte in der NEG anzugeben. Wenn nichts angegeben ist, kann der Netzwerkendpunkt zu einem beliebigen Subnetzwerk in der Region gehören, in der die Netzwerk-Endpunktgruppe erstellt wird.

Erstellen Sie einen NEG-basierten Backend-Dienst und stellen Sie mit den folgenden Befehlen eine Verbindung zu einem Private Service Connect-Dienstanhang her:

gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/backendServices \
-d "{ \
    'name': '${LB_PREFIX}-backend-service', \
    'service_protocol': 'HTTPS', \
    'port_name': 'https', \
    'load_balancing_scheme': 'EXTERNAL_MANAGED' \
}"

gcurl -X PATCH https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/backendServices/${LB_PREFIX}-backend-service \
-d "{ \
    'backends': \
    [{ \
        'group': 'https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/regions/${REGION}/networkEndpointGroups/${LB_PREFIX}-neg' \
    }] \
}"

Erstellen Sie ein von Google verwaltetes Zertifikat für Ihre Domain, indem Sie die folgenden Befehle ausführen:

gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/addresses \
-d "{ \
    'name': '${LB_PREFIX}-static-ip', \
    'ip_version': 'IPV4' \
}"

gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/sslCertificates \
-d "{ \
    'name': '${LB_PREFIX}-ssl-cert', \
    'managed': \
    { \
        'domains': '${DOMAIN_NAME}' \
    }, \
    'type': 'MANAGED' \
}"

LB_IP=$(gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/addresses/${LB_PREFIX}-static-ip | jq -r '.address')

Erstellen Sie einen externen Application Load Balancer basierend auf dem Backend aus dem vorherigen Schritt, indem Sie die folgenden Befehle ausführen:

gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/urlMaps \
-d "{ \
    'name': '${LB_PREFIX}-map-https', \
    'default_service': 'https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/backendServices/${LB_PREFIX}-backend-service' \
}"

gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/targetHttpsProxies \
-d "{ \
    'name': '${LB_PREFIX}-https-lb-proxy', \
    'url_map': 'https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/urlMaps/${LB_PREFIX}-map-https', \
    'ssl_certificate': 'https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/sslCertificates/${LB_PREFIX}-ssl-cert' \
}"

gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/forwardingRules \
-d "{ \
    'name': '${LB_PREFIX}-https-lb-forwarding-rule', \
    target: 'https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/targetHttpsProxies/${LB_PREFIX}-https-lb-proxy', \
    'ip_address': '${LB_IP}', \
    'port_range': '443-443', \
    'load_balancing_scheme': 'EXTERNAL_MANAGED' \
}"

Nachdem der externe Application Load Balancer erstellt wurde, ist Ihre Anwendung über diese IP-Adresse im Internet erreichbar.

Nachdem der externe Application Load Balancer erstellt wurde, müssen Sie seine IP-Adresse dem Domainnamen zuordnen, damit Google Cloud ein SSL-Zertifikat bereitstellen kann. Folgen Sie der Anleitung Ihres DNS-Anbieters, um die IP-Adresse mit dem DNS-Namen zu verknüpfen. Führen Sie den folgenden Befehl aus, um den Bereitstellungsstatus zu prüfen:
1. IP-Adresse anzeigen, die beim DNS-Anbieter eingerichtet werden muss:
```
echo "Load Balancer ip address - $LB_IP"
```
2. Nachdem Sie die DNS-Einstellungen festgelegt haben, prüfen Sie mit dem folgenden Befehl, ob der Domainname in die IP-Adresse aufgelöst wird:
```
dig $DOMAIN_NAME
```
3. Rufen Sie den Bereitstellungsstatus mit dem folgenden Befehl ab:
```
echo $(gcurl https://www.googleapis.com/compute/v1/projects/${PROJECT_NUMBER}/global/sslCertificates/${LB_PREFIX}-ssl-cert \
| jq -r '.name + " " + .managed.status + " " + (.managed.domainStatus | keys[]) + "=" + .managed.domainStatus[]')
```
Nachdem das SSL-Zertifikat bereitgestellt wurde, sollten Sie über den DNS-Namen auf Ihre Anwendung zugreifen können.

Identity-Aware Proxy aktivieren

Folgen Sie der Identity-Aware Proxy-Dokumentation (IAP) zum Einrichten von Identity-Aware Proxy. Nachdem Sie IAP eingerichtet haben, aktivieren Sie IAP für den Backend-Dienst, indem Sie die folgenden Schritte ausführen:

Rufen Sie die Seite „IAP“ auf:
IAP
Suchen Sie unter HTTPS-RESSOURCEN nach $LB_PREFIX-backend-service. Wenn Sie IAP für diese Ressource aktivieren möchten, klicken Sie in der Spalte „IAP“ auf den Schalter. Klicken Sie im angezeigten Fenster IAP aktivieren auf das Kästchen, um die Konfigurationsanforderungen dieser Ressource zu bestätigen, und klicken Sie auf AKTIVIEREN, um zu bestätigen, dass die Ressource durch IAP gesichert werden soll.
Damit Nutzer auf Ihre Anwendung zugreifen können, müssen Sie ihnen die Rolle Nutzer von IAP-gesicherten Web-Apps für das Projekt zuweisen. Führen Sie dazu die folgenden Schritte aus:
1. Aktivieren Sie das Kästchen $LB_PREFIX-backend-service.
2. Wählen Sie im Infofeld die Option HAUPTKONTO HINZUFÜGEN aus und geben Sie dann die E‑Mail-Adressen der Gruppen oder Einzelpersonen ein, die Zugriff auf Ihre Anwendung haben sollen.
3. Wählen Sie in der Drop-down-Liste Rolle auswählen die Option Cloud IAP > Nutzer von IAP-gesicherten Web-Apps aus und klicken Sie dann auf Speichern.

Ihre lokale Anwendung sollte jetzt im Internet veröffentlicht und durch Chrome Enterprise Premium geschützt sein.

Anwendungs-Connector mit der Google Cloud Console einrichten

Führen Sie die Schritte in diesem Abschnitt aus, um den Chrome Enterprise Premium-App-Connector über die Google Cloud Konsole bereitzustellen.

Geben Sie Ihre Antragsdetails ein.

Führen Sie die folgenden Schritte aus, um die Details Ihrer Anwendung hinzuzufügen:

Rufen Sie in der Google Cloud Console die IAP-Seite auf.
Zu IAP
Klicken Sie auf die Schaltfläche NEUE ANWENDUNG VERBINDEN und wählen Sie dann Über App-Connector verbinden aus.
Geben Sie unter Name der Anwendung den Namen der Anwendung ein, die Sie schützen möchten.
Geben Sie unter Extern verwendbare Anwendungs-URL eine öffentlich zugängliche URL ein, über die Ihre Nutzer auf Ihre Anwendung zugreifen können.
Klicken Sie auf Weiter.

Verbindung zu Google Cloudeinrichten

Führen Sie die folgenden Schritte aus, um eine Verbindung zwischen Google Cloud und Ihrer Nicht-Google Cloud -Umgebung herzustellen.

Klicken Sie auf die Schaltfläche APP-CONNECTOR ERSTELLEN und geben Sie die folgenden Informationen ein:
- Name des App-Connectors: Ein Name für den Connector.
- Region: Die Region, in der die Verbindungs-Gateways und der Connector bereitgestellt werden sollen.
Klicken Sie auf die Schaltfläche ERSTELLEN.
Folgen Sie der Anleitung im Bereich Virtuelle Maschine bereitstellen, um den Remote-Agent auf Ihrer VM bereitzustellen.
Klicken Sie auf die Schaltfläche VERBINDUNGSSTATUS TESTEN, um die Verbindung zu testen.
Konfigurieren Sie den im vorherigen Schritt erstellten Connector, indem Sie die folgenden Informationen unter Wo kann Google Cloud Ihre Anwendung finden? eingeben:
- Interner Hostname: Die lokale IP-Adresse oder der FQDN, auf dem Ihre Anwendung gehostet wird.
- Port: Die Portnummer, über die eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

Zugriff auf Ihre Anwendung gewähren (optional)

Geben Sie unter Neue Hauptkonten eine oder mehrere der folgenden Optionen ein:
- Google-Konto-E-Mail: nutzer@gmail.com
- Google Group: admins@googlegroups.com
- Dienstkonto: server@example.gserviceaccount.com
- Google Workspace-Domain: beispiel.de
- beliebig: Geben Sie allUsers ein, wenn Sie allen Nutzern Zugriff gewähren möchten
- Alle Google-Konten: Geben Sie allAuthenticatedUsers ein, wenn Sie allen bei einem Google-Konto angemeldeten Nutzern den Zugriff gewähren möchten.
Wählen Sie eine oder mehrere Zugriffsebenen aus und klicken Sie dann auf WEITER.

Veröffentlichen Sie die Anwendung

Klicken Sie auf die Schaltfläche SECURELY PUBLISH APPLICATION (Anwendung sicher veröffentlichen), um Ihre Anwendung zu veröffentlichen.
Nachdem Sie Ihre Anwendung veröffentlicht und die Bestätigung Sicher veröffentlichte Anwendung erhalten haben, müssen Sie einen DNS-Eintrag erstellen, der die extern verwendbare Anwendungs-URL auf die IP-Adresse des Proxys verweist. Führen Sie diese Schritte aus:
- Kopieren Sie im Abschnitt SCHRITT 2: DNS aktualisieren die IP-Adresse aus dem Feld IP-Adresse. Verwenden Sie die Adresse, um einen DNS-Eintrag zu erstellen. Folgen Sie dazu der Anleitung Ihres DNS-Anbieters, wie Sie die IP-Adresse dem DNS-Namen zuordnen.
Nachdem Sie den DNS-Eintrag erstellt haben, testen Sie ihn, indem Sie auf die Schaltfläche TESTEN klicken. Sie sollten die Bestätigung DNS-Test erfolgreich. erhalten.
Klicken Sie auf FERTIG.

IAP aktivieren

Rufen Sie die IAP-Seite auf.
Zu IAP
Suchen Sie in der Liste der Ressourcen nach Ihrer Anwendung und wählen Sie dann die Schaltfläche in der Spalte „IAP“ aus.
Klicken Sie im eingeblendeten Dialogfeld IAP aktivieren auf das Kästchen neben Ich habe die Konfigurationsanforderungen gelesen und meinen Backend-Dienst entsprechend der Dokumentation konfiguriert. und dann auf AKTIVIEREN.

Ihre lokale Anwendung sollte jetzt im Internet veröffentlicht und durch Chrome Enterprise Premium geschützt sein.

App-Gateway erstellen (optional)

App-Gateways werden implizit erstellt und verwaltet, wenn Sie eine Anwendung über den App-Connector verbinden. Sie können auch eigene App-Gateways erstellen, um Ressourcen für App-Verbindungen in Gruppen zu organisieren. Traffic für App-Verbindungen, die in verschiedenen App-Gateways gehostet werden, wird über eine separate virtuelle Infrastruktur weitergeleitet.

So erstellen und konfigurieren Sie ein App-Gateway:

gcloud-CLI

Legen Sie die erforderlichen Umgebungsvariablen mit dem folgenden Befehl fest:
```
CONNECTOR_NAME=CONNECTOR_NAME
CONNECTION_NAME=CONNECTION_NAME
GATEWAY_NAME=GATEWAY_NAME
PROJECT_ID=PROJECT_ID
REGION=REGION
APP_ENDPOINT=APP_HOST:APP_PORT
```
Ersetzen Sie Folgendes:
- CONNECTOR_NAME: Der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
- CONNECTION_NAME: ein eindeutiger Name für die Verbindung.
- GATEWAY_NAME: der Name des App-Gateways.
- PROJECT_ID: die Google Cloud Projekt-ID.
- REGION: Die Region, in der das App-Gateway bereitgestellt werden soll, z. B. us-central1.
- APP_HOST: Die lokale IP-Adresse oder ein FQDN, auf dem Ihre Anwendung gehostet wird.
- APP_PORT: die Portnummer, über die eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

Erstellen Sie ein App-Gateway mit dem folgenden Befehl:

gcloud beta beyondcorp app gateways create $GATEWAY_NAME \
--project=$PROJECT_ID --location=$REGION --display-name=$GATEWAY_NAME

Geben Sie ein App-Gateway in einem Aufruf zum Erstellen einer Verbindung an, indem Sie den folgenden Befehl ausführen:

gcloud beta beyondcorp app connections create $CONNECTION_NAME \
--project=$PROJECT_ID \
--location=$REGION \
--application-endpoint=$APP_ENDPOINT \
--type=tcp \
--connectors=$CONNECTOR_NAME \
--display-name=$CONNECTION_NAME \
--app-gateway=$GATEWAY_NAME

API

Legen Sie die erforderlichen Umgebungsvariablen mit dem folgenden Befehl fest:
```
CONNECTOR_NAME=CONNECTOR_NAME
CONNECTION_NAME=CONNECTION_NAME
GATEWAY_NAME=GATEWAY_NAME
PROJECT_ID=PROJECT_ID
REGION=REGION
APP_ENDPOINT=APP_HOST:APP_PORT
```
Ersetzen Sie Folgendes:
- CONNECTOR_NAME: Der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
- CONNECTION_NAME: ein eindeutiger Name für die Verbindung.
- GATEWAY_NAME: der Name des App-Gateways.
- PROJECT_ID: die Google Cloud Projekt-ID.
- REGION: Die Region, in der das App-Gateway bereitgestellt werden soll, z. B. us-central1.
- APP_HOST: Die lokale IP-Adresse oder ein FQDN, auf dem Ihre Anwendung gehostet wird.
- APP_PORT: die Portnummer, über die eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

Erstellen Sie ein App-Gateway mit dem folgenden Befehl:

gcurl https://beyondcorp.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/appGateways?app_gateway_id=${GATEWAY_NAME} \
-d "{ \
'type': 'TCP_PROXY', \
'display_name': '${CONNECTION_NAME}' \
}"

Geben Sie ein App-Gateway in einem Aufruf zum Erstellen einer Verbindung an, indem Sie den folgenden Befehl ausführen:

gcurl https://beyondcorp.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/appConnections?app_connection_id=${CONNECTION_NAME} \
-d "{ \
'application_endpoint': \
{ \
'host': '${APP_HOST}', \
'port': '${APP_PORT}' \
}, \
'gateway': { 'app_gateway' : 'projects/${PROJECT_ID}/locations/${REGION}/appGateways/${GATEWAY_NAME}'}, \
'connectors':['projects/${PROJECT_ID}/locations/${REGION}/appConnectors/${CONNECTOR_NAME}'], \
'type': 'TCP_PROXY', \
'display_name': '${CONNECTION_NAME}' \

Nächste Schritte

Informationen zum Sichern einer VPC finden Sie unter VPC Service Controls.
Umfassendere Kontextregeln durch Anwenden von Zugriffsebenen festlegen
Mehr über Zugriffsanfragen durch Cloud-Audit-Logs aktivieren erfahren

Fehlerbehebung

Zuvor erstellte Ressourcen können nicht gefunden werden

Wenn Sie die gcloud CLI-Version 392.0.0 oder höher verwenden, nutzen Sie die neuen Standardressourcen für App-Connectors AppConnector und AppConnection. gcloud alpha beyondcorp app connectors und gcloud alpha beyondcorp app connections verweisen beispielsweise beide auf die neuen Ressourcen.

Wenn Sie auf Legacy-Ressourcen zugreifen möchten, die mit einer gcloud CLI-Version vor Version 392.0.0 erstellt wurden, verwenden Sie das Keyword legacy. Beispielsweise beziehen sich gcloud alpha beyondcorp app legacy connectors und gcloud alpha beyondcorp app legacy connections beide auf die alten Ressourcen.

Konfigurationen, in denen Legacy-Ressourcen verwendet werden, funktionieren vorerst weiterhin, werden aber in Zukunft eingestellt.

Empfohlene Maßnahmen

Folgen Sie der Anleitung in diesem Leitfaden, um neue Ressourcen zu konfigurieren.
Wenn in Ihrer Konfiguration Legacy-Ressourcen verwendet werden, suchen Sie mit dem Keyword legacy nach diesen Ressourcen und entfernen Sie sie. Erstellen Sie die Ressourcen neu, indem Sie der Anleitung in diesem Dokument folgen.
Wenn Sie eine unvollständige Konfiguration mit alten Ressourcen haben, verwenden Sie das Keyword legacy, um diese Ressourcen zu finden und zu entfernen. Erstellen Sie die Ressourcen neu, indem Sie der Anleitung in diesem Dokument folgen.

TLS/SSL-Fehler

`ERR_SSL_VERSION_OR_CIPHER_MISMATCH`

Der Browser zeigt den Fehler ERR_SSL_VERSION_OR_CIPHER_MISMATCH oder ähnliche TLS/SSL-Fehler an und leitet nicht zur Anmeldeseite weiter.

Empfohlene Maßnahmen

Prüfen Sie den Status der Zertifikate auf der Detailseite des Google Cloud Load-Balancers.

HINWEIS: Die Bereitstellung eines von Google verwalteten Zertifikats kann bis zu 60 Minuten dauern.

`TLS error`

Der Browser zeigt nach der Weiterleitung zur Anmeldeseite den Fehler upstream connect error or disconnect/reset before headers. retried and the latest reset reason: connection failure, transport failure reason: TLS error oder ähnliche TLS-/SSL-Fehler an.

Empfohlene Maßnahmen

Prüfen Sie, ob der in der Verbindung verwendete Anwendungsendpunkt HTTPS verwendet.
Prüfen Sie, ob der App-Endpunkt von der VM des Remote-Agents aus mit „curl“ erreichbar ist:
```
curl https://$APP_ENDPOINT
```
Möglicherweise müssen Sie das Flag -k verwenden, wenn Ihr Anwendungszertifikat selbstsigniert ist.

Firewallkonfiguration prüfen

Achten Sie darauf, dass Firewalls zwischen dem Remote-Agent und dem Internet ausgehende Verbindungen zu den folgenden Domains zulassen:

Verbindungstyp	Domain	Port
TCP	raw.githubusercontent.com	443
TCP	gcr.io	443
TCP	*.googleapis.com	443
TCP	tunnel.cloudproxy.app	443
TCP	*.tunnel.cloudproxy.app	443
TCP	accounts.google.com	443
TCP	oauth2.googleapis.com	443

Mit einer Verbindung verknüpfte Connectors ändern

gcloud

Legen Sie die erforderlichen Umgebungsvariablen mit dem folgenden Befehl fest:
```
CONNECTOR_NAME=my-connector
CONNECTION_NAME=my-connection
REGION=us-central1
PROJECT_ID=my-project
```
Ersetzen Sie Folgendes:
- my-connector: der Name des Connectors. Dies kann auch eine durch Kommas getrennte Liste wie connector1,connector2 sein.
- my-connection: der Name der zu aktualisierenden Verbindung.
- us-central1: die Region, in der die Verbindung bereitgestellt wird.
- my-project: die Google Cloud Projekt-ID.

Führen Sie den folgenden Befehl aus, um die mit einer Verbindung verknüpften Connectors zu ändern:

gcloud alpha beyondcorp app connections update $CONNECTION_NAME \
    --project=$PROJECT_ID \
    --location=$REGION \
    --connectors=$CONNECTOR_NAME

API

Legen Sie die erforderlichen Umgebungsvariablen mit dem folgenden Befehl fest:
```
CONNECTOR_NAME=my-connector
CONNECTION_NAME=my-connection
REGION=us-central1
PROJECT_ID=my-project
```
Ersetzen Sie Folgendes:
- my-connector: der Name des Connectors.
- my-connection: Der Name der zu aktualisierenden Verbindung.
- us-central1: die Region, in der die Verbindung bereitgestellt wird.
- my-project: die Google Cloud Projekt-ID.

Führen Sie den folgenden Befehl aus, um die mit einer Verbindung verknüpften Connectors zu ändern:

gcurl -X PATCH \
https://beyondcorp.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/appConnections/${CONNECTION_NAME}?update_mask=connectors \
-d "{ \
    'connectors': ['projects/${PROJECT_ID}/locations/${REGION}/appConnectors/${CONNECTOR_NAME}'], \
}"

Sie können die Aktualisierung mit dem folgenden Befehl prüfen. Sehen Sie sich dazu das Feld connectors der Ausgabe an:

gcurl https://beyondcorp.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/appConnections/${CONNECTION_NAME}

Proxy

Die Unterstützung für Proxys wurde Anfang 2024 eingeführt und erfordert Änderungen an der BeyondCorp-Systemd-Datei. Wenn Sie den Remote-Agent vor diesem Zeitpunkt installiert haben und einen Proxy verwenden möchten, installieren Sie den Remote-Agent neu.

Prüfen Sie, ob der Docker-Daemon richtig konfiguriert ist, um mit Proxys zu arbeiten.
Prüfen Sie, ob sowohl die HTTP- als auch die HTTPS-Proxy-Umgebungsvariablen festgelegt sind und ob beide das http://-Schema verwenden. Das https://-Schema und andere Schemas werden nicht unterstützt.
Prüfen Sie, ob die Proxy-Umgebungsvariablen in untergeordnete Prozesse exportiert werden, indem Sie den Befehl env ausführen.
Es werden nur HTTP_PROXY, HTTPS_PROXY, NO_PROXY und ihre Entsprechungen in Kleinbuchstaben unterstützt.
Wenn Sie die Proxyeinstellungen nach der Installation aktualisieren müssen, aktualisieren Sie die Umgebungsvariablen in /var/beyondcorp/env/PROXY, wenn Sie den Standardnutzer beyondcorp verwenden. Wenn Sie einen benutzerdefinierten Nutzer verwenden, aktualisieren Sie /home/$USER/.docker/config.json gemäß der Anleitung zum Konfigurieren des Docker-Clients. Starten Sie den Remote-Agent mit dem folgenden Befehl neu, um die Proxy-Änderungen zu übernehmen:
```
sudo systemctl restart beyondcorp
```

Diagnosetools

run-post-install-checks

run-post-install-checks ist ein Skript, das in /var/beyondcorp/scripts/ installiert wird und prüft, ob Ihr Remote-Agent richtig installiert, registriert und fehlerfrei ist. Nachdem Sie erfolgreich ein app connection erstellt und einem Remote-Agent (Connector) zugewiesen haben, rufen Sie die VM des Remote-Agents auf und führen Sie run-post-install-checks mit dem folgenden Befehl aus:

sudo /var/beyondcorp/scripts/run-post-install-checks

Wenn alles in Ordnung ist, gibt das Skript eine Erfolgsmeldung aus.

`run-diagnostics`

run-diagnostics ist ein Skript, das in /var/beyondcorp/scripts/ installiert wird. Es diagnostiziert häufige Probleme auf der VM des Remote-Agents und gibt einen Bericht aus, den Sie mit dem Chrome Enterprise Premium-Supportteam teilen können. Führen Sie den folgenden Befehl aus, um dieses Diagnoseskript auszuführen:

sudo /var/beyondcorp/scripts/run-diagnostics

Der Diagnosebericht wird in die Console und in ./diagnostics-report.txt geschrieben.

Remote-Agent-Befehlszeile

bce-connctl ist die Befehlszeile für die Remote-Agent-Administration, mit der Sie lokal mit dem Remote-Agent interagieren können. Diese Befehlszeile unterstützt verschiedene Befehle, z. B. zum Registrieren des Remote-Agents, zum Prüfen des Status und zum Festlegen von Konfigurationswerten.

Init-Befehl

Mit dem Befehl „Init“ können Sie den Remote-Agent initialisieren und ein Skript zum Registrieren des Agents generieren.

Beispiel:

bce-connctl init --project=$PROJECT_ID --region=$REGION --connector=$CONNECTOR_NAME

Statusbefehle

Mit den Statusbefehlen können Sie den Status des Remote-Agents verwalten.

List: Mit diesem Befehl können Sie den Gesamtstatus des Remote-Agents sowie den Status aller von diesem Agent unterstützten Verbindungen auflisten. Beispiel: bce-connctl status list

Konfigurationsbefehle

Mit den Konfigurationsbefehlen können Sie Konfigurationswerte für Ihren Remote-Agent verwalten.

List: Mit diesem Befehl werden die Konfigurationswerte des Remote-Agents aufgelistet. Beispiel: bce-connctl config list
Festlegen: Mit diesem Befehl legen Sie einen Konfigurationswert des Remote-Agents fest. Beispiel: bce-connctl config set <key> <value>

Registrierungsbefehle

Mit den Registrierungsbefehlen können Sie die Registrierung des Remote-Agents verwalten.

Beschreiben: Mit diesem Befehl können Sie den Registrierungsstatus des Remote-Agents abrufen. Beispiel: bce-connctl enrollment describe

Wenn das Registrierungsskript von bce-connctl init erfolgreich abgeschlossen und der öffentliche Schlüssel hochgeladen wurde, lautet der Status ENROLLED.

Hilfe

Sie können das Flag -h oder --help an jeden bce-connctl-Befehl anhängen, um Nutzungsinformationen auszugeben.

bce-connctl init -h

Nicht Google Cloud-Anwendungen mit dem App-Connector schützen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Übersicht

Architektur

Hinweise

Google Cloud -Projekt einrichten

gcloud-CLI

API

Remote-Agent eines App-Connectors installieren

Dienstkonto

Föderierte Identität

Remoteanwendung mit einer VPC verbinden

gcloud-CLI

API

Externen Application Load Balancer konfigurieren

gcloud-CLI

API

Identity-Aware Proxy aktivieren

Anwendungs-Connector mit der Google Cloud Console einrichten

Geben Sie Ihre Antragsdetails ein.

Verbindung zu Google Cloudeinrichten

Zugriff auf Ihre Anwendung gewähren (optional)

Veröffentlichen Sie die Anwendung

IAP aktivieren

App-Gateway erstellen (optional)

gcloud-CLI

API

Nächste Schritte

Fehlerbehebung

Zuvor erstellte Ressourcen können nicht gefunden werden

Empfohlene Maßnahmen

TLS/SSL-Fehler

ERR_SSL_VERSION_OR_CIPHER_MISMATCH

Empfohlene Maßnahmen

TLS error

Empfohlene Maßnahmen

Firewallkonfiguration prüfen

Mit einer Verbindung verknüpfte Connectors ändern

gcloud

API

Proxy

Diagnosetools

run-post-install-checks

run-diagnostics

Remote-Agent-Befehlszeile

Init-Befehl

Statusbefehle

Konfigurationsbefehle

Registrierungsbefehle

Hilfe

Nicht Google Cloud-Anwendungen mit dem App-Connector schützen

`ERR_SSL_VERSION_OR_CIPHER_MISMATCH`

`TLS error`

`run-diagnostics`