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 von Drittanbietern zu schützen.

Übersicht

Mit dem Chrome Enterprise Premium-App-Connector können Sie kontextsensitiver Zugriff auf HTTPS-Anwendungen, die nicht in Google Cloud ausgeführt werden Umgebungen. Der Chrome Enterprise Premium-App-Connector ist ein Schnittstelle zwischen der Erzwingungsebene von Chrome Enterprise Premium und Anwendungen in anderen Clouds und lokalen Umgebungen ausgeführt werden.

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

Architektur

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

Die Komponenten des Chrome Enterprise Premium-App-Connectors werden über drei Haupt-APIs gesteuert. Ressourcen: Anwendungs-Connectors, Anwendungsverbindungen und Anwendungsgateways.

Anwendungs-Connectors

Mit einer Connector-Ressource wird ein eindeutiger Remote-Agent des App-Connectors definiert. App-Connector Remote-Kundenservicemitarbeiter werden in Remote-Unternehmensumgebungen bereitgestellt, z. B. in anderen Clouds und lokale Umgebungen. Remote-Agents initiieren und verwalten Tunnel Sitzungen in Google Cloud, Traffic empfangen von Google Cloud und Weiterleiten von Traffic an Remote-Anwendungsendpunkte in derselben Umgebung.

App-Verbindungen

Eine Verbindungsressource definiert eine logische Verbindung von Google Cloud zu einem bestimmten Anwendungsendpunkt IP-Adresse:Port oder FQDN:Port identifiziert. Eine Verbindungsressource orchestriert eine Reihe verwalteter App-Connector-Gateways, die einem Anwendungsendpunkt. Die Gateways werden verwaltet in Google Cloud und beenden die Tunnelsitzungen über das Remote-Netzwerk wenn sie nicht mehr benötigt werden.

App-Gateways

Ein App-Gateway ist ein von Google verwaltetes Dienstangebot. Fernbedienung des App-Connectors Agents stellen eine Verbindung zu einem oder mehreren Gateways her, die Anwendungsverbindungen und die Anwendung zulassen Connectors, um Traffic von Endnutzern an Remote-Kundenservicemitarbeiter weiterzuleiten. Zugriffe für die App Verbindungen, die auf demselben Anwendungs-Gateway gehostet werden, durch einen gemeinsamen virtuelle Infrastruktur.

Wenn Sie eine Anwendung mit dem Anwendungs-Connector verbinden, werden Anwendungsgateways die implizit für Sie erstellt und verwaltet werden. Sie können auch zusätzliche Apps Gateways, wenn Sie Ressourcen für Anwendungsverbindungen in Gruppen organisieren möchten. App-Kampagnen Gateways bieten die Flexibilität, Anwendungsverbindungen zu lassen Sie die App-Isolierung zu.

Jedes App-Gateway kann einen Gesamtdurchsatz von bis zu 1 Gbit/s bis zu 200.000 gleichzeitige Verbindungen. Wir empfehlen, dedizierte Gateways für kritische Anwendungen, die eine hohe Leistung erfordern. Sie können maximal 10 Apps pro Gateway zuweisen.

Zur Unterstützung von bis zu 200.000 gleichzeitigen Verbindungen und insgesamt bis zu 1 Gbit/s Durchsatz haben, empfehlen wir die Verwendung einer dedizierten VM mit 8 Kernen und 8 GB Arbeitsspeicher, um den Remote-Agent des App-Connectors auszuführen. Sie können beispielsweise zwei Remote-Agents des App-Connectors in einem Hochverfügbarkeitscluster mit 8 Kernen und 8 GB Arbeitsspeicher jeweils zur Unterstützung einer Hochleistungs-Webanwendung (app1.beispielunternehmen.com) mit einem dedizierten Anwendungs-Gateway (app_gateway1). Weiteren Cluster mit 2 VMs erstellen jeweils mit 8 Kernen und 8 GB Arbeitsspeicher, um eine Kombination aus 10 niedrigen Auslastungswerten zu unterstützen Apps mit einem anderen dedizierten App-Gateway (app_gateway2)

Der Anwendungs-Connector, die Anwendungsverbindung und die Anwendungs-Gateway-Ressourcen sind regional. Ich können sie nur in einem regionalen Kontext verwenden. Sie können beispielsweise keine App-Connector in Region A mit einer Anwendungsverbindung oder einem in der Region erstellten App-Gateway B)

Hinweise

Sie können den Chrome Enterprise Premium-App-Connector nur mit HTTPS verwenden Anwendungen. Außerdem verwenden HTTPS-Load-Balancer nicht den Servernamen SNI-Erweiterung (Indication) 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, die mit Docker. 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

Google Cloud-Projekt zur Verwendung mit der Chrome Enterprise Premium App einrichten müssen Sie die Chrome Enterprise Premium API aktivieren. Aktivieren Sie die API durch 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. Zugriff erhalten Token und legen Sie den erforderliche Umgebungsvariablen und Aliasse. Führen Sie dazu folgenden Befehl aus: Befehle:

   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, hostet eine Anwendung, die Sie mit Chrome Enterprise Premium schützen möchten. Du musst eine dedizierte VM oder einen beliebigen Bare-Metal-Server mit installiertem Docker haben, einen von Ihnen erstellten Remote-Agent.

So erstellen Sie einen Remote-Agent:

1. Erstellen Sie eine VM-Instanz in Ihrer Anwendungsumgebung.
   1. Achten Sie darauf, dass die VM-Netzwerkfirewall des Remote-Agents jegliche ausgehenden Zugriffe zulässt Traffic, der an Port 443 für den IAP-TCP-IP-Bereich initiiert wird 35.235.240.0/20. Siehe Firewallkonfiguration prüfen für andere Domains, für die die VM-Firewall des Remote-Agents ausgehende Verbindungen zulassen soll nach dem die Zugriffe erfolgen.

2. Installieren Sie den Remote-Agent:

   1. Stellen Sie sicher, dass Ihr DNS richtig konfiguriert ist und Sie auf das curl-Anwendung ausführen.
   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 die Umgebungsvariablen des HTTP- und des HTTPS-Proxys festgelegt sind und verwendet werden das http://-Schema.
   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 der Shell den Alias bce-connctl hinzuzufü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 die Registrierung zu kopieren und einzufügen in Ihre Google Cloud-Projekte ein. Nutzen Sie dafür Cloud Shell oder das gcloud CLI und schließen Sie die Registrierung des Connectors ab. Um den Skript registrieren können, 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 Zugriff auf Google Cloud zu gewähren mit Identitätsübernahme des Dienstkontos.
   2. Laden Sie die Konfiguration der Clientbibliothek herunter. und legen Sie die Datei unter /var/beyondcorp/credentials/credentials.json auf der Remote-Agent-VM ab.
      1. Wenn Sie eine AWS EC2-Instanz als Remote-Agent-VM verwenden, führen Sie einen der folgenden Schritte aus: <ph type="x-smartling-placeholder">
         </ph>
         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 dabei 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. Führen Sie den folgenden Befehl aus, um sicherzustellen, dass 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. Überprüfen Sie, ob alle drei werden Container mit dem folgenden Befehl ausgeführt:

      docker ps --filter name=bce
      

   3. Optional: Sie können die Logdateien der Docker-Container prüfen, indem Sie den folgenden Befehl:

      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 hostet Ihre Anwendung.
   • 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 nicht angegeben, kann der Netzwerkendpunkt zu einem beliebigen Subnetzwerk in Die Region, 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 ein von Google verwaltetes Zertifikat für Ihre Domain, indem Sie Folgendes ausführen: Befehle:

   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 Backend aus dem vorherigen Schritt, und führen Sie 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, kann auf Ihre Anwendung über mit dem Internet über diese IP-Adresse.

6. Nachdem der externe Application Load Balancer erstellt wurde, müssen Sie seine IP-Adresse verknüpfen durch den Domainnamen, damit Google Cloud ein SSL-Zertifikat bereitstellen kann. Zertifikat. Folgen Sie der Anleitung Ihres DNS-Anbieters, um die IP-Adresse zu verknüpfen durch den DNS-Namen. Führen Sie den folgenden Befehl aus, um die Bereitstellung zu prüfen Status:

   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, ob der Domainname aufgelöst wird. an die IP-Adresse an, indem Sie den folgenden Befehl ausführen:

      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 nicht angegeben, kann der Netzwerkendpunkt zu einem beliebigen Subnetzwerk in der Region, 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 ein von Google verwaltetes Zertifikat für Ihre Domain, indem Sie Folgendes ausführen: Befehle:

   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 Backend aus dem vorherigen Schritt, und führen Sie 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, kann auf Ihre Anwendung über mit dem Internet über diese IP-Adresse.

6. Nachdem der externe Application Load Balancer erstellt wurde, müssen Sie seine IP-Adresse verknüpfen durch den Domainnamen, damit Google Cloud ein SSL-Zertifikat bereitstellen kann. Zertifikat. Folgen Sie der Anleitung Ihres DNS-Anbieters, um die IP-Adresse zu verknüpfen durch den DNS-Namen. Führen Sie den folgenden Befehl aus, um die Bereitstellung zu prüfen Status:

   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, ob der Domainname aufgelöst wird. an die IP-Adresse an, indem Sie den folgenden Befehl ausführen:

      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 Seite für IAP auf:
   In-App-Kauf

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 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 Verbinden über App-Connector.

3. Geben Sie im Feld Name der Anwendung den Namen der Anwendung ein, die Sie aktualisieren möchten. sicher.

4. Geben Sie unter Extern sichtbare Anwendungs-URL eine öffentlich zugängliche URL für damit Ihre Nutzer auf Ihre 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 nicht mit Google Cloud verknüpft ist.

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, indem Sie den Parameter die folgenden Informationen unter Wo finde ich Ihre Anwendung?:

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

Veröffentlichen Sie die Anwendung

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 Sie die Sichere Veröffentlichung bestätigen, müssen Sie einen DNS-Eintrag erstellen, um Ihre externe Anwendungs-URL zur IP-Adresse des Proxys. 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)

App-Gateways werden implizit erstellt und verwaltet, wenn Sie eine Verbindung zu einer Anwendung herstellen mit dem App-Connector. Sie können auch eigene App-Gateways erstellen, Ressourcen für App-Verbindungen in Gruppen organisieren. Traffic für gehostete App-Verbindungen in verschiedenen App-Gateways durch 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 App-Gateway in einem Aufruf zum Erstellen einer Verbindung an, indem Sie Folgendes ausführen: Befehl:

   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 App-Gateway in einem Aufruf zum Erstellen einer Verbindung an, indem Sie Folgendes ausführen: Befehl:

   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

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 am BeyondCorp systemd-Datei. Wenn Sie den Remote-Agent 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 senden 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.

• Beschreiben Sie: 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