Anwendungen von Drittanbietern mit dem Anwendungs-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 zu Google Cloud gehören.

Überblick

Mit dem Chrome Enterprise Premium-App-Connector können Sie identitäts- und kontextsensitiven Zugriff auf HTTPS-Anwendungen gewähren, die in Umgebungen außerhalb von Google Cloud ausgeführt werden. Der Chrome Enterprise Premium-App-Connector ist eine sichere, authentifizierte Schnittstelle zwischen der Erzwingungsebene von Chrome Enterprise Premium und Anwendungen, die in anderen Clouds und lokalen Umgebungen ausgeführt werden.

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

Architektur

Im Folgenden finden Sie ein allgemeines Architekturdiagramm mit den Hauptkomponenten des Chrome Enterprise Premium-App-Connectors.

Die Komponenten der Chrome Enterprise Premium-App-Connectors werden mithilfe von drei API-Hauptressourcen verwaltet: Anwendungs-Connectors, Anwendungsverbindungen und Anwendungs-Gateways.

Anwendungs-Connectors

Mit einer Connector-Ressource wird ein eindeutiger Remote-Agent des App-Connectors definiert. Remote-Agents des Anwendungs-Connectors werden in Remote-Unternehmensumgebungen bereitgestellt, z. B. in anderen Clouds und lokalen Umgebungen. Remote-Agents initiieren und verwalten Tunnelsitzungen zu Google Cloud, empfangen Traffic von Google Cloud und leiten Traffic an Remote-Anwendungsendpunkte in derselben Umgebung weiter.

App-Verbindungen

Eine Verbindungsressource definiert eine logische Verbindung von Google Cloud zu einem bestimmten Anwendungsendpunkt, der über die IP-Adresse „address:Port“ oder „FQDN:Port“ identifiziert wird. Eine Verbindungsressource orchestriert eine Reihe von verwalteten Anwendungs-Connector-Gateways, die einem bestimmten Anwendungsendpunkt zugewiesen sind. Die Gateways werden in Google 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 verwaltetes Dienstangebot. Remote-Agents von App-Connectors stellen eine Verbindung zu einem oder mehreren Gateways her, über die App-Verbindungen und App-Connectors Traffic von Endnutzern an Remote-Kundenservicemitarbeiter weiterleiten können. Traffic für Anwendungsverbindungen, die auf demselben Anwendungs-Gateway gehostet werden, wird über eine gemeinsame virtuelle Infrastruktur geleitet.

Wenn Sie eine Anwendung mithilfe des Anwendungs-Connectors verbinden, werden Anwendungsgateways implizit für Sie erstellt und verwaltet. Sie können auch zusätzliche Anwendungs-Gateways erstellen, wenn Sie Anwendungsverbindungsressourcen in Gruppen organisieren möchten. App-Gateways bieten die Flexibilität, Anwendungsverbindungen zu gruppieren oder zu trennen, um die Anwendungsisolierung zu ermöglichen.

Jedes Anwendungsgateway 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 Anwendungen pro Gateway zuweisen.

Um bis zu 200.000 gleichzeitige Verbindungen und einen Gesamtdurchsatz von bis zu 1 Gbit/s zu unterstützen,empfehlen wir die Verwendung einer dedizierten VM mit 8 Kernen und 8 GB Arbeitsspeicher, um den Remote-Agent des Anwendungs-Connectors auszuführen. Sie können beispielsweise zwei Remote-Agents für Anwendungs-Connectors in einem Hochverfügbarkeitscluster mit 8 Kernen und jeweils 8 GB Arbeitsspeicher zuweisen, um eine Hochleistungs-Webanwendung (app1.beispielunternehmen.com) mit einem dedizierten Anwendungs-Gateway (app_gateway1) zu unterstützen. Erstellen Sie einen weiteren Cluster aus 2 VMs mit jeweils 8 Kernen und 8 GB Arbeitsspeicher, um eine Kombination aus 10 Anwendungen mit geringer Nutzung mit einem weiteren dedizierten Anwendungsgateway (app_gateway2) zu unterstützen.

Der Anwendungs-Connector, die Anwendungsverbindung und die Anwendungs-Gateway-Ressourcen sind regional. Sie können sie nur in einem regionalen Kontext verwenden. Beispielsweise können Sie einen Anwendungs-Connector in Region A keiner Anwendungsverbindung oder eines in Region B erstellten Anwendungsgateways zuweisen.

Hinweise

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

Wenn Sie den Chrome Enterprise Premium-App-Connector verwenden möchten, benötigen Sie Folgendes:

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

Jeder Chrome Enterprise Premium-App-Connector-Agent erfordert eine Linux-VM, 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 mithilfe von gcloud und der API oder mit der Google Cloud Console 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 im Hilfeartikel App-Connector mithilfe der Google Cloud Console einrichten.

Google Cloud-Projekt einrichten

Wenn Sie ein Google Cloud-Projekt für den 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, prüfen Sie, ob das gcloud CLI SDK installiert ist.

1. Legen Sie die erforderliche Umgebungsvariable mit dem folgenden Befehl fest:

   PROJECT_ID=my-project
   

   Ersetzen Sie my-project durch die Google Cloud-Projekt-ID.

2. Aktivieren Sie die API mit dem folgenden Befehl:

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

API

1. Rufen Sie ein Zugriffstoken ab und legen Sie die erforderlichen Umgebungsvariablen und Aliasse mit den folgenden Befehlen fest:

   PROJECT_NUMBER=my-project-number
   ACCESS_TOKEN=my-access-token
   

   Ersetzen Sie my-project durch die Google Cloud-Projekt-ID.

2. Richten Sie einen geeigneten Alias für die Verwendung Ihres Zugriffstokens ein:

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

3. 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 VM für den Remote-Agent des Anwendungs-Connectors für jede Netzwerkumgebung bereitstellen, die eine Anwendung hostet, die Sie mit Chrome Enterprise Premium schützen möchten. Sie benötigen für jeden erstellten Remote-Agent eine dedizierte VM oder einen beliebigen Bare-Metal-Server mit installiertem Docker.

So erstellen Sie einen Remote-Agent:

1. Erstellen Sie eine VM-Instanz in Ihrer Anwendungsumgebung.
   1. Sorgen Sie dafür, dass die VM-Netzwerkfirewall des Remote-Agents den gesamten an Port 443 initiierten ausgehenden Traffic für den IAP-TCP-IP-Bereich 35.235.240.0/20 zulässt. Weitere Informationen zu anderen Domains, für die die VM-Firewall des Remote-Agents ausgehenden Traffic zulassen soll, finden Sie unter Firewallkonfiguration prüfen.

2. Installieren Sie den Remote-Agent:

   1. Prüfen Sie mit curl, ob Ihr DNS richtig konfiguriert ist und Sie 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, müssen die Umgebungsvariablen des HTTP- und des HTTPS-Proxys festgelegt sein und das Schema http:// verwenden.
   4. Führen Sie den folgenden Befehl auf der Remote-Agent-VM 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 in Ihre Shell einzufügen:

       source ~/.bce_alias
       

   6. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie die folgenden Befehle ausführen:

      PROJECT_ID=my-project
      REGION=us-central1
      CONNECTOR_NAME=my-connector
      

      Ersetzen Sie dabei Folgendes:
      • my-project: die Google Cloud-Projekt-ID.
      • us-central1: Die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
      • my-connector ist 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 zu kopieren, in Ihre Google Cloud-Projekte einzufügen und die Registrierung des 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 Föderation der Workload Identity, um Ihrer externen Identität mithilfe der Identitätsübernahme des Dienstkontos Zugriff auf Google Cloud zu gewähren.
   2. Laden Sie die Konfiguration der Clientbibliothek herunter und speichern 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, führen Sie einen der folgenden Schritte aus:
         1. Machen Sie IMDSv2 in der EC2-Instanz optional.
         2. Fügen Sie dem Objekt credential_source 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 in Ihrem Cloud Shell- oder gcloud CLI-Endpunkt die erforderliche Umgebungsvariable mit dem folgenden Befehl fest:

      SERVICE_ACCOUNT=my-service-account
      

      Ersetzen Sie Folgendes:
      • my-service-account: das mit der externen Identität verknüpfte Google Cloud-Dienstkonto.

   6. Weisen Sie dem Google Cloud-Dienstkonto die Rolle BeyondCorp Connection Agent zu, indem Sie den folgenden Befehl ausführen:

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

3. Prüfen Sie die Installation des Remote-Agents:

   1. Prüfen Sie mit dem folgenden Befehl, 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, prüfen Sie, ob das gcloud CLI SDK installiert ist und Sie mit einem Konto mit der Rolle beyondcorp.admin angemeldet sind.

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie die folgenden Befehle ausführen:

   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 ist der Name des Connectors, der in einem früheren 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, der Ihre Anwendung hostet.
   • APP_PORT: Die Portnummer, mit der eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

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

   Beachten Sie, dass dieser Schritt einige Minuten dauern kann.

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

   Die GATEWAY_URI_L7 wird zum Erstellen einer Weiterleitungsregel verwendet. 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

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie die folgenden Befehle ausführen:

   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 ist der Name des Connectors, der in einem früheren 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, der Ihre Anwendung hostet.
   • my-app-port: Die Portnummer, mit der eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

2. 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}' \
   }"
   

   Beachten Sie, dass dieser Schritt einige Minuten dauern kann.

3. 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'}"
   

   Die GATEWAY_URI_L7 wird zum Erstellen einer Weiterleitungsregel verwendet. 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, prüfen Sie, ob das gcloud CLI SDK installiert ist und Sie mit einem Konto mit der Rolle beyondcorp.admin angemeldet sind.

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie die folgenden Befehle ausführen:

   LB_PREFIX=web-app
   PROJECT_ID=my-project
   REGION=us-central1
   DOMAIN_NAME=app.example.com
   

   Ersetzen Sie dabei 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.

2. 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 Subnetzwerks für die Netzwerkendpunkte in der NEG anzugeben. Wenn keine Angabe erfolgt, kann der Netzwerkendpunkt zu einem beliebigen Subnetzwerk in der Region gehören, in der die Netzwerk-Endpunktgruppe erstellt wird.

3. Erstellen Sie einen NEG-basierten Back-End-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
   

4. Erstellen Sie mit den folgenden Befehlen ein von Google verwaltetes Zertifikat für Ihre Domain:

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

5. Erstellen Sie einen externen Application Load Balancer basierend auf dem Back-End 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.

6. 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. Rufen Sie die IP-Adresse auf, die beim DNS-Anbieter eingerichtet werden soll:

      echo "Load Balancer ip address - $LB_IP"
      

   2. Nachdem Sie das DNS 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

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie die folgenden Befehle ausführen:

   LB_PREFIX=web-app
   PROJECT_ID=my-project
   REGION=us-central1
   DOMAIN_NAME=app.example.com
   

   Ersetzen Sie dabei 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.

2. 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 keine Angabe erfolgt, kann der Netzwerkendpunkt zu einem beliebigen Subnetzwerk in der Region gehören, in der die Netzwerk-Endpunktgruppe erstellt wird.

3. Erstellen Sie einen NEG-basierten Back-End-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' \
       }] \
   }"
   

4. Erstellen Sie mit den folgenden Befehlen ein von Google verwaltetes Zertifikat für Ihre Domain:

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

5. Erstellen Sie einen externen Application Load Balancer basierend auf dem Back-End 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.

6. 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. Rufen Sie die IP-Adresse auf, die beim DNS-Anbieter eingerichtet werden soll:

      echo "Load Balancer ip address - $LB_IP"
      

   2. Nachdem Sie das DNS 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

Informationen zum Einrichten von Identity-Aware Proxy finden Sie in der Dokumentation zu Identity-Aware Proxy (IAP). Nachdem Sie IAP eingerichtet haben, aktivieren Sie IAP für den Back-End-Dienst, indem Sie die folgenden Schritte ausführen:

1. Rufen Sie die IAP-Seite auf:
   IAP

2. Suchen Sie unter HTTPS-RESSOURCEN nach $LB_PREFIX-backend-service. Klicken Sie auf die Ein/Aus-Schaltfläche in der IAP-Spalte, 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. Klicken Sie auf AKTIVIEREN, um zu bestätigen, dass IAP Ihre Ressource sichern soll.

3. 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. Gehen Sie dazu so vor:

   1. Klicken Sie das Kästchen $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 Ihren Antrag 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 Console bereitzustellen.

Anwendungsdetails eingeben

Fügen Sie die Details Ihrer Anwendung hinzu, indem Sie die folgenden Schritte ausführen:

1. Rufen Sie in der Google Cloud Console die Seite "IAP" auf.
   Zu IAP

2. Klicken Sie auf die Schaltfläche NEUE ANWENDUNG VERBINDEN und wählen Sie dann Über App-Connector verbinden aus.

3. Geben Sie unter Anwendungsname den Namen der Anwendung ein, die Sie sichern möchten.

4. Geben Sie unter Extern verwendbare Anwendungs-URL eine öffentlich zugängliche URL ein, über die Nutzer auf die Anwendung zugreifen können.

5. Klicken Sie auf Weiter.

Verbindung zu Google Cloud einrichten

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

1. 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 Verbindungsgateways und der Connector bereitgestellt werden.

2. Klicke auf ERSTELLEN.

3. Folgen Sie der Anleitung im Bereich Virtuelle Maschine bereitstellen, um den Remote-Agent auf Ihrer VM bereitzustellen.

4. Klicken Sie auf die Schaltfläche TEST CONNECTION STATUS, um die Verbindung zu testen.

5. Konfigurieren Sie den Connector, den Sie im vorherigen Schritt erstellt haben. Geben Sie dazu unter Wo kann Google Cloud Ihre Anwendung finden? die folgenden Informationen ein:

   • Interner Hostname: Die lokale IP-Adresse oder der FQDN, der Ihre Anwendung hostet.
   • Port: Die Portnummer zur Verbindung mit Ihrer Anwendung.

Zugriff auf Ihre Anwendung gewähren (optional)

1. Geben Sie unter Neue Hauptkonten mindestens eine der folgenden Optionen ein:

   • Google-Konto-E-Mail: [e-mail]
   • Google Group: [e-mail]
   • Dienstkonto: [e-mail]
   • Google Workspace-Domain: beispiel.de
   • anybody: Geben Sie allUsers ein, um allen Nutzern Zugriff zu gewähren.
   • alle Google-Konten: allAuthenticatedUsers, um allen bei einem Google-Konto angemeldeten Nutzern Zugriff zu gewähren

2. Wählen Sie eine oder mehrere Zugriffsebenen aus und klicken Sie dann auf WEITER.

Anwendung veröffentlichen

1. Klicken Sie zum Veröffentlichen Ihrer Anwendung auf die Schaltfläche ANWENDUNG SICHER VERÖFFENTLICHEN.

2. Nachdem Sie Ihre Anwendung veröffentlicht haben und die Bestätigung Sicher veröffentlichte Anwendung erhalten haben, müssen Sie einen DNS-Eintrag erstellen, um die extern verwendbare Anwendungs-URL auf die IP-Adresse des Proxys zu verweisen. 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, um die IP-Adresse mit dem DNS-Namen zu verknüpfen.

3. Nachdem Sie den DNS-Eintrag erstellt haben, können Sie ihn testen, indem Sie auf die Schaltfläche TEST klicken. Sie sollten die Bestätigung DNS-Test bestanden. erhalten.

4. Klicken Sie auf FERTIG.

IAP aktivieren

1. Rufen Sie die Seite IAP auf.
   Zu IAP

2. Suchen Sie in der Liste der Ressourcen nach Ihrer Anwendung und klicken Sie auf die Schaltfläche in der Spalte IAP.

3. Klicken Sie im angezeigten Dialogfeld IAP aktivieren auf das Kästchen Ich habe die Konfigurationsanforderungen gelesen und meinen Back-End-Dienst gemäß der Dokumentation konfiguriert.Klicken Sie dann auf AKTIVIEREN.

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

Anwendungsgateway erstellen (optional)

Anwendungsgateways werden implizit erstellt und verwaltet, wenn Sie eine Anwendung mithilfe des Anwendungs-Connectors verbinden. Sie können auch eigene Anwendungsgateways erstellen, um Ressourcen für Anwendungsverbindungen in Gruppen zu organisieren. Traffic für Anwendungsverbindungen, die in verschiedenen Anwendungs-Gateways gehostet werden, wird über eine separate virtuelle Infrastruktur geleitet.

Führen Sie die folgenden Schritte aus, um ein App-Gateway zu erstellen und anzugeben.

gcloud-CLI

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie den folgenden Befehl ausführen:

   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 ist der Name des Connectors, der in einem früheren Schritt definiert wurde.
   • CONNECTION_NAME: Ein eindeutiger Name für die Verbindung.
   • GATEWAY_NAME: der Name des Anwendungs-Gateways.
   • PROJECT_ID: die Google Cloud-Projekt-ID.
   • REGION: Die Region, in der das Anwendungs-Gateway bereitgestellt werden soll, z. B. us-central1.
   • APP_HOST: die lokale IP-Adresse oder ein FQDN, der Ihre Anwendung hostet.
   • APP_PORT: Die Portnummer, mit der eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

2. Erstellen Sie mit dem folgenden Befehl ein App-Gateway:

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

3. Geben Sie ein Anwendungs-Gateway in einem Aufruf zum Erstellen einer Verbindung an. Führen Sie dazu den folgenden Befehl aus:

   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

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie den folgenden Befehl ausführen:

   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 ist der Name des Connectors, der in einem früheren Schritt definiert wurde.
   • CONNECTION_NAME: Ein eindeutiger Name für die Verbindung.
   • GATEWAY_NAME: der Name des Anwendungs-Gateways.
   • PROJECT_ID: die Google Cloud-Projekt-ID.
   • REGION: Die Region, in der das Anwendungs-Gateway bereitgestellt werden soll, z. B. us-central1.
   • APP_HOST: die lokale IP-Adresse oder ein FQDN, der Ihre Anwendung hostet.
   • APP_PORT: Die Portnummer, mit der eine Verbindung zu Ihrer Anwendung hergestellt werden soll.

2. Erstellen Sie mit dem folgenden Befehl ein App-Gateway:

   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}' \
   }"
   

3. Geben Sie ein Anwendungs-Gateway in einem Aufruf zum Erstellen einer Verbindung an. Führen Sie dazu den folgenden Befehl aus:

   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}' \
   

Weitere Informationen

• 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

Verwenden Sie ab Version 392.0.0 der gcloud CLI die neuen Standardressourcen AppConnector und AppConnection des App-Connectors. Beispielsweise verweisen gcloud alpha beyondcorp app connectors und gcloud alpha beyondcorp app connections beide auf die neuen Ressourcen.

Für den Zugriff auf Legacy-Ressourcen, die mit einer gcloud CLI vor Version 392.0.0 erstellt wurden, verwenden Sie das Schlüsselwort legacy. Beispielsweise verweisen gcloud alpha beyondcorp app legacy connectors und gcloud alpha beyondcorp app legacy connections beide auf die Legacy-Ressourcen.

Konfigurationen, die Legacy-Ressourcen verwenden, funktionieren vorerst weiterhin, werden aber in Zukunft verworfen.

Empfohlene Maßnahmen

• Befolgen Sie die Verfahren in diesem Leitfaden, um neue Ressourcen zu konfigurieren.
• Wenn Ihre Konfiguration alte Ressourcen verwendet, verwenden Sie das Schlüsselwort legacy, um diese Ressourcen zu finden und zu entfernen. Erstellen Sie die Ressourcen wie in diesem Dokument beschrieben neu.
• Wenn Sie eine unvollständige Konfiguration mit Legacy-Ressourcen haben, verwenden Sie das Schlüsselwort legacy, um diese Ressourcen zu finden und zu entfernen. Erstellen Sie die Ressourcen wie in diesem Dokument beschrieben neu.

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

Im Browser wird nach der Weiterleitung zur Anmeldeseite der 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 angezeigt.

Empfohlene Maßnahmen

• Prüfen Sie, ob der in der Verbindung verwendete Anwendungsendpunkt HTTPS ist.

• Prüfen Sie mit curl, ob der Endpunkt der Anwendung über die Remote-Agent-VM zugänglich ist:

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

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie den folgenden Befehl ausführen:

   CONNECTOR_NAME=my-connector
   CONNECTION_NAME=my-connection
   REGION=us-central1
   PROJECT_ID=my-project
   

   Ersetzen Sie Folgendes:

   • my-connector ist 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.

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

1. Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie den folgenden Befehl ausführen:

   CONNECTOR_NAME=my-connector
   CONNECTION_NAME=my-connection
   REGION=us-central1
   PROJECT_ID=my-project
   

   Ersetzen Sie Folgendes:

   • my-connector ist 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.

2. 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 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 bereits früher installiert haben und einen Proxy verwenden möchten, installieren Sie den Remote-Agent neu.

• Überprüfen Sie, ob der Docker-Daemon korrekt konfiguriert ist, damit er mit Proxys funktioniert.

• Prüfen Sie, ob die Umgebungsvariablen des HTTP- und des HTTPS-Proxys festgelegt sind und beide das Schema http:// verwenden. Das Schema https:// und andere Schemas werden nicht unterstützt.

• Prüfen Sie mit dem Befehl env, ob die Proxy-Umgebungsvariablen in Unterprozesse exportiert werden.

• Es werden nur HTTP_PROXY, HTTPS_PROXY und NO_PROXY sowie die entsprechenden 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 beyondcorp-Standardnutzer 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 anzuwenden:

  sudo systemctl restart beyondcorp
  

Diagnosetools

run-post-install-checks

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

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

Das Skript gibt eine Erfolgsmeldung aus, wenn alles in Ordnung ist.

run-diagnostics

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

sudo /var/beyondcorp/scripts/run-diagnostics

Der Diagnosebericht wird in der Console sowie in ./diagnostics-report.txt geschrieben.

Remote-Agent-Befehlszeile

bce-connctl ist die Befehlszeile des Remote-Agents für die lokale Interaktion mit dem Remote-Agent. 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 generieren, um den Agent zu registrieren.

Beispiel:

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

Statusbefehle

Sie können die Statusbefehle verwenden, um den Status des Remote-Agents zu verwalten.

• List (Liste): Verwenden Sie diesen Befehl, um den Gesamtstatus des Remote-Agents sowie den Status aller von diesem Agent unterstützten Verbindungen aufzulisten. Beispiel: bce-connctl status list

Config-Befehle

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

• List (Liste): Verwenden Sie diesen Befehl, um die Konfigurationswerte des Remote-Agents aufzulisten. Beispiel: bce-connctl config list
• Festlegen: Verwenden Sie diesen Befehl, um einen Konfigurationswert für den Remote-Agent festzulegen. Beispiel: bce-connctl config set <key> <value>

Registrierungsbefehle

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

• Beschreibe: Verwenden Sie diesen Befehl, um den Registrierungsstatus des Remote-Agents abzurufen. Beispiel: bce-connctl enrollment describe

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

Hilfe

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

bce-connctl init -h