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 Anwendungen zu schützen, die nicht inGoogle Cloud ausgeführt werden.

Übersicht

Mit dem Chrome Enterprise Premium App Connector können Sie einen Identitäts- und kontextsensitiven Zugriff auf HTTPS-Anwendungen bereitstellen, 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 des Chrome Enterprise Premium App Connectors besteht darin, dass Sie keine Firewalls öffnen oder Site-to-Site-Cloud VPN-Verbindungen einrichten müssen.

Architektur

Im folgenden Diagramm ist die allgemeine Architektur mit den Hauptkomponenten des Chrome Enterprise Premium App Connectors dargestellt.

Komponenten von Chrome Enterprise Premium-App-Connectors

Die Komponenten der 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-Agenten des App-Connectors. Remote-Agents des App-Connectors werden in Remote-Unternehmensumgebungen wie anderen Cloud- 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 mit IP-Adresse:Port oder FQDN:Port identifiziert wird. Eine Verbindungsressource orchestriert eine Reihe von verwalteten App-Connector-Gateways, die einem bestimmten Anwendungsendpunkt zugewiesen sind. Die Gateways werden inGoogle Cloud verwaltet und beenden die Tunnelsitzungen der 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 Ressourcen für App-Verbindungen 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, spezielle Gateways für kritische Anwendungen zu erstellen, die eine hohe Leistung erfordern. Sie können maximal 10 Apps pro Gateway zuweisen.; Für bis zu 200.000 gleichzeitige Verbindungen und eine Gesamtübertragungsrate von bis zu 1 Gbit/s empfehlen wir, einen Remote-Agent für den App Connector auf einer dedizierten VM mit 8 Kernen und 8 GB Arbeitsspeicher auszuführen. Sie können beispielsweise zwei App Connector-Remote-Agents in einem HA-Cluster mit jeweils 8 Kernen und 8 GB Arbeitsspeicher für die Unterstützung einer leistungsstarken Webanwendung (app1.beispielfirma.de) mit einem dedizierten App-Gateway (app_gateway1) verwenden. Erstellen Sie einen weiteren Cluster mit zwei VMs mit jeweils 8 Kernen und 8 GB Arbeitsspeicher, um eine Kombination aus 10 Apps mit geringer Auslastung 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 bzw. das in Region B erstellt wurde.

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 Linux-VM-Hardware 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. Wenn Sie die Google Cloud -Console verwenden möchten, lesen Sie den Hilfeartikel 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. Führen Sie die folgenden Schritte aus, um die API zu aktivieren:

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 Projekt-ID Ihrer Google Cloud .

Aktivieren Sie die API mit dem folgenden Befehl:

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

API

Rufe ein Zugriffstoken ab und lege die erforderlichen Umgebungsvariablen und Aliasse fest. Führe dazu die folgenden Befehle aus:
```
PROJECT_NUMBER=my-project-number
ACCESS_TOKEN=my-access-token
```
Ersetzen Sie my-project durch die Projekt-ID Ihrer Google Cloud .

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 des App-Connectors installieren

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

So erstellen Sie einen Remote-Agenten:

Erstellen Sie eine VM-Instanz in Ihrer Anwendungsumgebung.
1. Achten Sie darauf, dass die Netzwerk-Firewall 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.
Installieren Sie den Remote-Agenten:
1. Prüfen Sie, ob Ihr DNS richtig konfiguriert ist und 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 verwenden.
4. Führen Sie den folgenden Befehl auf der VM mit dem Remote-Agent 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 der Shell den Alias bce-connctl 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 in der bce-connctl-Befehlszeile den folgenden Befehl ausführen:
  bce-connctl init --project=$PROJECT_ID --region=$REGION --connector=$CONNECTOR_NAME
2. Folgen Sie der Anleitung auf dem Bildschirm, um das Registrierungsskript mithilfe von Cloud Shell oder der gcloud CLI in Ihre Google Cloud -Projekte einzufügen und die Registrierung des Connectors abzuschließen. Zum Ausführen des Registrierungsscripts benötigen Sie die Berechtigungen Owner für das Projekt.
  
  Wenn das Registrierungsskript abgeschlossen ist, wird die Connector-Konfiguration automatisch von der Laufzeit synchronisiert.
Föderierte Identität
1. Folgen Sie der Anleitung zur Workload Identity-Föderation, um Ihrer externen Identität über die Identitätsübernahme des Dienstkontos Zugriff auf Google Cloudzu gewähren.
2. Laden Sie die Konfiguration der Clientbibliothek 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 Remote-Agent-VM verwenden, gehen Sie so vor:
    
    Machen Sie IMDSv2 auf der EC2-Instanz optional.
    
    Fügen Sie dem credential_source-Objekt in der Konfigurationsdatei der Clientbibliothek die folgende Zeile hinzu:
    "imdsv2_session_token_url": "http://169.254.169.254/latest/api/token"
3. Führen Sie auf der Remote-Agent-VM 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 abzurufen:
  sudo systemctl restart beyondcorp
5. Legen Sie die erforderliche Umgebungsvariable an Ihrem Cloud Shell- oder gcloud CLI-Endpunkt fest. Führen Sie dazu den folgenden Befehl aus:
  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 zu. Führen Sie dazu den folgenden Befehl aus:
  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, wird die Connector-Konfiguration automatisch von der Remote-Agent-Laufzeit synchronisiert.
Prüfen Sie die Installation des Remote-Agents:
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.

Remote-Anwendung 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, das die Rolle beyondcorp.admin hat.

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: 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 IP-Adresse der lokalen Umgebung 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.

Führen Sie nach dem Erstellen der Verbindung 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: 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 IP-Adresse vor Ort 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.

Führen Sie nach dem Erstellen der Verbindung 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, das die Rolle beyondcorp.admin hat.

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 ist 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 Standardnetzwerk des Projekts 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 verbinden Sie ihn mit einem Private Service Connect-Dienstanhang. Führen Sie dazu die folgenden Befehle aus:

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. Führen Sie dazu die folgenden Befehle aus:

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. Führen Sie dazu die folgenden Befehle aus:

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 über das Internet zugänglich.

Nachdem der externe Application Load Balancer erstellt wurde, müssen Sie seine IP-Adresse mit dem Domainnamen verknüpfen, 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. Zeigen Sie die IP-Adresse an, die beim DNS-Anbieter eingerichtet werden soll:
```
echo "Load Balancer ip address - $LB_IP"
```
2. Nachdem Sie das DNS eingerichtet haben, prüfen Sie mit dem folgenden Befehl, ob der Domainname auf die IP-Adresse aufgelöst wird:
```
dig $DOMAIN_NAME
```
3. Führen Sie den folgenden Befehl aus, um den Bereitstellungsstatus abzurufen:
```
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 ist 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 im Feld network die URL des Netzwerks für die Netzwerkendpunkte in der NEG fest. Wenn keine Angabe erfolgt, wird das Standardnetzwerk des Projekts verwendet.
- Legen Sie im Feld subnetwork die URL des Subnetzwerks für die Netzwerkendpunkte in der NEG fest. Wenn kein Subnetz angegeben ist, kann der Netzwerkendpunkt zu einem beliebigen Subnetz in der Region gehören, in der die Netzwerk-Endpunktgruppe erstellt wird.

Erstellen Sie einen NEG-basierten Backend-Dienst und verbinden Sie ihn mit einem Private Service Connect-Dienstanhang. Führen Sie dazu die folgenden Befehle aus:

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. Führen Sie dazu die folgenden Befehle aus:

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. Führen Sie dazu die folgenden Befehle aus:

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 über das Internet zugänglich.

Nachdem der externe Application Load Balancer erstellt wurde, müssen Sie seine IP-Adresse mit dem Domainnamen verknüpfen, 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. Zeigen Sie die IP-Adresse an, die beim DNS-Anbieter eingerichtet werden soll:
```
echo "Load Balancer ip address - $LB_IP"
```
2. Nachdem Sie das DNS eingerichtet haben, prüfen Sie mit dem folgenden Befehl, ob der Domainname auf die IP-Adresse aufgelöst wird:
```
dig $DOMAIN_NAME
```
3. Führen Sie den folgenden Befehl aus, um den Bereitstellungsstatus abzurufen:
```
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 Dokumentation zu Identity-Aware Proxy (IAP), um Identity-Aware Proxy einzurichten. Nachdem Sie IAP eingerichtet haben, aktivieren Sie IAP für den Backend-Dienst. Gehen Sie dazu so vor:

Rufen Sie die Seite „IAP“ auf:
IAP
Suchen Sie unter HTTPS-RESSOURCEN nach $LB_PREFIX-backend-service. Klicken Sie in der Spalte „IAP“ auf den Schalter, um IAP für diese Ressource zu aktivieren. 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.
Wenn Sie Nutzern Zugriff auf Ihre Anwendung gewähren möchten, 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. Klicken Sie das Kästchen für $LB_PREFIX-backend-service an.
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.

App-Connector mit der Google Cloud -Console einrichten

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

Geben Sie die Details Ihrer Anwendung ein.

Fügen Sie die Details Ihrer Anwendung hinzu. Gehen Sie dazu so vor:

Rufen Sie in der Google Cloud -Konsole die Seite „IAP“ auf.
Zu IAP
Klicken Sie auf die Schaltfläche NEUE ANWEDUNG 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 einer anderen Umgebung herzustellen, die nichtGoogle Cloud ist.

Klicken Sie auf die Schaltfläche APP-CONNECTOR ERSTELLLEN 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 unter Wo kann Google Cloud Ihre Anwendung finden? die folgenden Informationen eingeben:
- Interner Hostname: Die lokale IP-Adresse oder der FQDN, auf dem Ihre Anwendung gehostet wird.
- Port: Die Portnummer für die Verbindung zu Ihrer Anwendung.

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@beispiel.gserviceaccount.com
- Google Workspace-Domain: beispiel.de
- Beliebig: Geben Sie allUsers ein, um allen Nutzern Zugriff zu gewähren.
- Alle Google-Konten: allAuthenticatedUsers, um allen in einem Google-Konto angemeldeten Nutzern Zugriff zu gewähren
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 ANTWORT SICHER VERÖFFENTLICHEN, um Ihre Antwort 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 mit dem DNS-Namen verknüpfen.
Nachdem Sie den DNS-Eintrag erstellt haben, klicken Sie auf die Schaltfläche TESTEN, um ihn zu testen. Sie sollten die Bestätigung DNS-Test erfolgreich erhalten.
Klicken Sie auf FERTIG.

IAP aktivieren

Rufen Sie die Seite „IAP“ 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 Dialogfeld IAP aktivieren auf das Kästchen 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 geleitet.

So erstellen und geben Sie ein App-Gateway an:

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: 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 IP-Adresse vor Ort 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 in einem create connection-Aufruf ein App-Gateway 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: 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 IP-Adresse vor Ort 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 in einem create connection-Aufruf ein App-Gateway 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 Schützen 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, verwenden Sie die neuen Standardressourcen AppConnector und AppConnection für den App-Connector. Beispiel: gcloud alpha beyondcorp app connectors und gcloud alpha beyondcorp app connections verweisen beide auf die neuen Ressourcen.

Verwenden Sie das Keyword legacy, um auf ältere Ressourcen zuzugreifen, die mit einer gcloud CLI-Version vor 392.0.0 erstellt wurden. Beispielsweise beziehen sich gcloud alpha beyondcorp app legacy connectors und gcloud alpha beyondcorp app legacy connections beide auf die alten Ressourcen.

Konfigurationen, die alte Ressourcen verwenden, funktionieren vorerst weiter, werden aber in Zukunft eingestellt.

Empfohlene Maßnahmen

Folgen Sie der Anleitung in diesem Leitfaden, um neue Ressourcen zu konfigurieren.
Wenn in Ihrer Konfiguration alte Ressourcen verwendet werden, verwenden Sie das Keyword legacy, um diese Ressourcen zu finden und zu entfernen. Erstellen Sie die Ressourcen neu. Folgen Sie dazu der Anleitung in diesem Dokument.
Wenn Sie eine unvollständige Konfiguration haben, in der alte Ressourcen verwendet werden, können Sie diese mit dem Keyword legacy finden und entfernen. Erstellen Sie die Ressourcen neu. Folgen Sie dazu der Anleitung in diesem Dokument.

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 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, nachdem die Weiterleitung zur Anmeldeseite erfolgt ist.

Empfohlene Maßnahmen

Prüfen Sie, ob der in der Verbindung verwendete Anwendungsendpunkt HTTPS ist.
Prüfen Sie mit curl, ob auf den App-Endpunkt von der Remote-Agent-VM aus zugegriffen werden kann:
```
curl https://$APP_ENDPOINT
```
Möglicherweise müssen Sie das Flag -k verwenden, wenn Ihr Anwendungszertifikat selbst signiert 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 Anschlüsse ä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 Verbindung, die aktualisiert werden soll.
- 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 Verbindung, die aktualisiert werden soll.
- 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 prüfen, indem Sie den folgenden Befehl ausführen und das Feld connectors in der Ausgabe prüfen:

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 systemd-Datei von BeyondCorp. Wenn Sie den Remote-Agent vor diesem Datum installiert haben und einen Proxy verwenden möchten, installieren Sie den Remote-Agent noch einmal.

Prüfen Sie, ob der Docker-Daemon richtig für die Verwendung mit Proxys konfiguriert ist.
Prüfen Sie, ob sowohl die HTTP- als auch die HTTPS-Proxy-Umgebungsvariablen festgelegt sind und 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. Führen Sie dazu den Befehl env aus.
Nur HTTP_PROXY, HTTPS_PROXY, NO_PROXY und ihre Kleinbuchstabenvarianten werden 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. Um die Proxy-Änderungen anzuwenden, starten Sie den Remote-Agent mit dem folgenden Befehl neu:
```
sudo systemctl restart beyondcorp
```

Diagnosetools

run-post-install-checks

run-post-install-checks ist ein in /var/beyondcorp/scripts/ installiertes Script, das prüft, ob der Remote-Agent richtig installiert, registriert und fehlerfrei ist. Nachdem Sie eine 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, wird eine Erfolgsmeldung ausgegeben.

`run-diagnostics`

run-diagnostics ist ein Script, das in /var/beyondcorp/scripts/ installiert ist und häufige Probleme auf der Remote-Agent-VM diagnostiziert. Es druckt einen Bericht aus, den Sie an das Chrome Enterprise Premium-Supportteam senden können. Führen Sie den folgenden Befehl aus, um dieses Diagnosescript auszuführen:

sudo /var/beyondcorp/scripts/run-diagnostics

Der Diagnosebericht wird sowohl in der Console als auch in ./diagnostics-report.txt geschrieben.

Remote-Agent-Befehlszeile

bce-connctl ist die Befehlszeile für die Remote-Kundenservicemitarbeiter, mit der sie lokal mit dem Remote-Kundenservicemitarbeiter 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 Script 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-Kundenservicemitarbeiters verwalten.

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

Config-Befehle

Mit den Config-Befehlen können Sie die Konfigurationswerte für Ihren Remote-Kundenservicemitarbeiter verwalten.

List: Mit diesem Befehl können Sie die Konfigurationswerte des Remote-Agents auflisten. Beispiel: bce-connctl config list
Set: Mit diesem Befehl können Sie einen Konfigurationswert des Remote-Agenten festlegen. Beispiel: bce-connctl config set <key> <value>

Befehle zur Registrierung

Mit den Befehlen zur Registrierung kannst du die Registrierung des Remote-Kundenservicemitarbeiters verwalten.

Beschreibung: 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 wurde und der öffentliche Schlüssel erfolgreich hochgeladen wurde, lautet der Status ENROLLED.

Hilfe

Sie können jedem bce-connctl-Befehl das Flag -h oder --help anhängen, um Nutzungsinformationen zu drucken.

bce-connctl init -h

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

Übersicht

Architektur

Hinweise

Google Cloud -Projekt einrichten

gcloud-CLI

API

Remote-Agent des App-Connectors installieren

Dienstkonto

Föderierte Identität

Remote-Anwendung mit einer VPC verbinden

gcloud-CLI

API

Externen Application Load Balancer konfigurieren

gcloud-CLI

API

Identity-Aware Proxy aktivieren

App-Connector mit der Google Cloud -Console einrichten

Geben Sie die Details Ihrer Anwendung 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 Anschlüsse ändern

gcloud

API

Proxy

Diagnosetools

run-post-install-checks

run-diagnostics

Remote-Agent-Befehlszeile

Init-Befehl

Statusbefehle

Config-Befehle

Befehle zur Registrierung

Hilfe

`ERR_SSL_VERSION_OR_CIPHER_MISMATCH`

`TLS error`

`run-diagnostics`