Anwendungen von Drittanbietern mit dem Anwendungs-Connector schützen

Auf dieser Seite wird beschrieben, wie Sie den BeyondCorp Enterprise-Anwendungs-Connector einrichten und verwenden, um Anwendungen zu schützen, die nicht von Google Cloud stammen.

Überblick

Mit dem BeyondCorp Enterprise-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 BeyondCorp Enterprise-Anwendungs-Connector ist eine sichere, authentifizierte Schnittstelle zwischen der BeyondCorp Enterprise-Erzwingungsebene und Anwendungen, die in anderen Clouds und lokalen Umgebungen ausgeführt werden.

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

Architektur

Im folgenden Architekturdiagramm werden die Hauptkomponenten des BeyondCorp Enterprise-App-Connectors dargestellt.

Komponenten des BeyondCorp Enterprise-App-Connectors

Die Komponenten von BeyondCorp Enterprise-Anwendungs-Connectors werden mithilfe von drei Haupt-API-Ressourcen verwaltet: Anwendungs-Connectors, Anwendungsverbindungen und Anwendungsgateways.

App-Connectors
Mit einer Connector-Ressource wird ein eindeutiger Remote-Agent des App-Connectors definiert. Remote-Agents von App-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 „IP address:Port“ oder „FQDN:Port“ identifiziert wird. Eine Verbindungsressource orchestriert eine Reihe von Gateways für verwaltete Anwendungs-Connectors, die einem bestimmten Anwendungsendpunkt zugewiesen sind. Die Gateways werden in Google Cloud verwaltet und beenden die Tunnelsitzungen von den Remote-Agents, wenn sie nicht mehr benötigt werden.
App-Gateways

Ein App-Gateway ist ein von Google verwalteter Dienst. Remote-Agents von App-Connectors stellen eine Verbindung zu einem oder mehreren Gateways her, damit Anwendungsverbindungen und Anwendungs-Connectors Traffic von Endnutzern an Remote-Agents 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 über den Anwendungs-Connector verbinden, werden App-Gateways implizit für Sie erstellt und verwaltet. Sie können auch zusätzliche Anwendungs-Gateways erstellen, wenn Sie Ressourcen für Anwendungsverbindungen in Gruppen organisieren möchten. App-Gateways bieten die Flexibilität, Anwendungsverbindungen zu gruppieren oder zu trennen, um die Anwendungs-Isolierung 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 bis zu 10 Anwendungen pro Gateway zuweisen.

Zur Unterstützung von bis zu 200.000 gleichzeitigen Verbindungen und einem Gesamtdurchsatz von bis zu 1 Gbit/s empfehlen wir die Verwendung einer dedizierten VM mit 8 Kernen und 8 GB Arbeitsspeicher zum Ausführen des Remote-Agents des Anwendungs-Connectors. Sie können beispielsweise zwei Remote-Agents von Anwendungs-Connectors in einem Cluster für hohe Verfügbarkeit mit jeweils 8 Kernen und jeweils 8 GB Arbeitsspeicher zuweisen, um eine Hochleistungs-Webanwendung (app1.examplecompany.com) mit einem dedizierten Anwendungsgateway (app_gateway1) zu unterstützen. Erstellen Sie einen weiteren Cluster mit 2 VMs mit jeweils 8 Kernen und 8 GB Arbeitsspeicher, um eine Kombination aus 10 Anwendungen mit geringer Nutzung mit einem anderen dedizierten Anwendungsgateway (app_gateway2) zu unterstützen.

Die Ressourcen des Anwendungs-Connectors, der Anwendungsverbindung und des Anwendungs-Gateways sind regional. Sie können nur in einem regionalen Kontext verwendet werden. Beispielsweise ist es nicht möglich, einen Anwendungs-Connector in Region A einer Anwendungsverbindung oder einem Anwendungsgateway zuzuweisen, die in Region B erstellt wurden.

Hinweise

Sie können den BeyondCorp Enterprise-Anwendungs-Connector nur mit HTTPS-Anwendungen verwenden. Darüber hinaus verwenden HTTPS-Load-Balancer nicht die Erweiterung SNI (Server Name Indication) für Verbindungen zum Back-End. Weitere Informationen finden Sie unter Verschlüsselung vom Load-Balancer zu den Back-Ends.

Sie benötigen Folgendes, um den BeyondCorp Enterprise-App-Connector verwenden zu können:

Für jeden BeyondCorp Enterprise-Anwendungs-Connector 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 werden mindestens zwei CPUs mit 2 GB RAM empfohlen.

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

Google Cloud-Projekt einrichten

Wenn Sie ein Google Cloud-Projekt für die Verwendung mit dem BeyondCorp Enterprise-App-Connector einrichten möchten, müssen Sie die BeyondCorp Enterprise API aktivieren. Führen Sie die folgenden Schritte aus, um die API zu aktivieren:

gcloud-CLI

Bevor Sie die folgenden Schritte ausführen, muss das gcloud CLI SDK installiert sein.

  1. Legen Sie die erforderliche Umgebungsvariable fest, indem Sie den folgenden Befehl ausführen: 

    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 fest. Dazu führen Sie die folgenden Befehle aus: 

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

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

  2. Richten Sie einen praktischen 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 Anwendungs-Connectors installieren

Sie müssen für jede Netzwerkumgebung, in der eine Anwendung gehostet wird, die Sie mit BeyondCorp Enterprise schützen möchten, eine Remote-Agent-VM des Anwendungs-Connectors bereitstellen. Sie benötigen für jeden von Ihnen 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 der Anwendungsumgebung.
    1. Achten Sie darauf, dass die Netzwerkfirewall des Remote-Agent-VM-Netzwerks 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 des Remote-Agent-VM ausgehenden Traffic zulassen soll, finden Sie unter Firewallkonfiguration prüfen.

  2. Installieren Sie den Remote-Agent:

    1. Prüfen Sie, ob Ihr DNS richtig konfiguriert ist und ob Sie mit curl auf die Anwendung zugreifen können.
    2. Installieren Sie die Docker Engine.
      1. Optional: Wenn Sie einen Proxy verwenden, prüfen Sie, ob der Docker-Daemon richtig konfiguriert ist.
    3. Optional: Wenn Sie einen Proxy verwenden, prüfen Sie, ob sowohl die HTTP- als auch die HTTPS-Proxy-Umgebungsvariablen festgelegt sind und das 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 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 Folgendes:

      • my-project: die Google Cloud-Projekt-ID.
      • us-central1: Die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
      • my-connector: der Name des Connectors

    7. Registrieren Sie den Connector mit einem der folgenden Anmeldedatentypen:

    Dienstkonto

    1. Registrieren Sie den Connector, indem Sie den folgenden Befehl in der bce-connctl-Befehlszeile ausführen: 

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

    2. Folgen Sie der Anleitung auf dem Bildschirm, um das Registrierungsskript 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 Registrierungsskripts benötigen Sie Owner-Berechtigungen 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 Identitätsföderation von Arbeitslasten, um Ihrer externen Identität über die Dienstkonto-Identitätsübernahme 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 für die 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 auf dem Cloud Shell- oder gcloud CLI-Endpunkt die erforderliche Umgebungsvariable fest, indem Sie den folgenden Befehl ausführen: 
      SERVICE_ACCOUNT=my-service-account
      Dabei gilt:
      • my-service-account: Das Google Cloud-Dienstkonto, das mit der externen Identität verknüpft ist.

    6. Gewähren Sie dem Google Cloud-Dienstkonto die Rolle BeyondCorp Connection Agent, 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 Ressource des Google Cloud-Anwendungs-Connectors 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 prüfen, indem Sie den folgenden Befehl ausführen: 
      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 angemeldet sind, das die Rolle beyondcorp.admin hat.

  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: der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
    • my-connection: Ein eindeutiger Name für die Verbindung.
    • my-project: die Google Cloud-Projekt-ID.
    • us-central1: Die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
    • APP_HOST: die lokale IP-Adresse oder ein FQDN, 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 der VPC zu erstellen:

    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.

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

    GATEWAY_URI_L7 wird zum Erstellen einer Weiterleitungsregel verwendet. Der BeyondCorp Enterprise-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: der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
    • my-connection: Ein eindeutiger Name für die Verbindung.
    • my-project: die Google Cloud-Projekt-ID.
    • us-central1: Die Region, in der die Verbindung und die Gateways bereitgestellt werden sollen.
    • my-app-host: die lokale IP-Adresse oder ein FQDN, 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 der VPC zu erstellen:

    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.

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

    GATEWAY_URI_L7 wird zum Erstellen einer Weiterleitungsregel verwendet. Der BeyondCorp Enterprise-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 angemeldet sind, das die Rolle beyondcorp.admin hat.

  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 Folgendes:

    • web-app: das an die Namen aller Load-Balancer-Ressourcen angehängte Präfix.
    • 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 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, indem Sie die folgenden Befehle ausführen:

    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, indem Sie die folgenden Befehle ausführen:

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

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

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

    Nachdem der externe Application Load Balancer erstellt wurde, ist Ihre Anwendung über diese IP-Adresse ü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, ob der Domainname in die IP-Adresse aufgelöst wird. Führen Sie dazu den folgenden Befehl aus: 
      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 Folgendes:

    • web-app: das an die Namen aller Load-Balancer-Ressourcen angehängte Präfix.
    • 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 im Feld network die URL des Netzwerks für die Netzwerkendpunkte in der NEG fest. Wenn keine Angabe erfolgt, wird das Standardprojektnetzwerk verwendet.
    • Legen Sie im Feld subnetwork die URL des Subnetzwerks für die Netzwerkendpunkte in der NEG fest. Wenn nicht angegeben, 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, indem Sie die folgenden Befehle ausführen:

    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, indem Sie die folgenden Befehle ausführen:

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

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

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

    Nachdem der externe Application Load Balancer erstellt wurde, ist Ihre Anwendung über diese IP-Adresse ü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, ob der Domainname in die IP-Adresse aufgelöst wird. Führen Sie dazu den folgenden Befehl aus: 
      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

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

  1. Rufen Sie die Seite „IAP“ auf:
    IAP

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

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

Anwendungs-Connector mit der Google Cloud Console einrichten

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

Anwendungsdetails eingeben

So fügen Sie die Details zu Ihrem Antrag hinzu:

  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 Name der Anwendung den Namen der Anwendung ein, die Sie sichern möchten.

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

  5. Klicken Sie auf Next (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 CREATE APP CONNECTOR 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 sollen.

  2. Klicken Sie 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 VERBINDUNGSSTATUS TESTEN, um die Verbindung zu testen.

  5. Konfigurieren Sie den im vorherigen Schritt erstellten Connector. Geben Sie dazu unter Wo findet Google Cloud Ihre Anwendung? die folgenden Informationen ein:

    • Interner Hostname: Die lokale IP-Adresse oder der FQDN, der Ihre Anwendung hostet.
    • Port: Die Portnummer, die mit Ihrer Anwendung verbunden werden soll.

Zugriff auf Ihre Anwendung gewähren (optional)

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

    • Google-Konto-E-Mail: nutzer@gmail.com
    • Google Group: admins@googlegroups.com
    • Dienstkonto: server@example.gserviceaccount.com
    • Google Workspace-Domain: beispiel.de
    • anybody: Geben Sie allUsers ein, um allen Nutzern Zugriff zu gewähren.
    • Alle Google-Konten: allAuthenticatedUsers, um jedem Nutzer, der in einem Google-Konto angemeldet ist, Zugriff zu gewähren

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

Anwendung veröffentlichen

  1. Klicken Sie auf die Schaltfläche ANWENDUNG SICHER VERÖFFENTLICHEN, um Ihre Anwendung zu veröffentlichen.

  2. Nachdem Sie Ihre Anwendung veröffentlicht haben und die Bestätigung Sicher veröffentlichte Anwendung erhalten wurde, 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. Erstellen Sie mithilfe dieser Adresse einen DNS-Eintrag. Folgen Sie dazu den Anweisungen Ihres DNS-Anbieters, um die IP-Adresse mit dem DNS-Namen zu verknüpfen.

  3. Testen Sie den DNS-Eintrag, nachdem Sie ihn erstellt haben, 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 Ihre Anwendung und klicken Sie dann auf die Schaltfläche in der Spalte IAP.

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

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

App-Gateway erstellen (optional)

Anwendungsgateways werden implizit erstellt und verwaltet, wenn Sie eine Anwendung über den App-Connector verbinden. Sie können auch eigene Anwendungs-Gateways erstellen, um Ressourcen für Anwendungsverbindungen in Gruppen zu organisieren. Der 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: der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
    • CONNECTION_NAME: Ein eindeutiger Name für die Verbindung.
    • GATEWAY_NAME: der Name des App-Gateways.
    • PROJECT_ID: die Google Cloud-Projekt-ID.
    • REGION: Die Region, in der das 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 Anwendungsgateway 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: der Name des Connectors, der in einem vorherigen Schritt definiert wurde.
    • CONNECTION_NAME: Ein eindeutiger Name für die Verbindung.
    • GATEWAY_NAME: der Name des App-Gateways.
    • PROJECT_ID: die Google Cloud-Projekt-ID.
    • REGION: Die Region, in der das 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 Anwendungsgateway 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

Fehlerbehebung

Keine zuvor erstellten Ressourcen gefunden

Verwenden Sie ab Version 392.0.0 der gcloud CLI die neuen Standardressourcen AppConnector und AppConnection des Anwendungs-Connectors. Beispielsweise beziehen sich 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 beziehen sich 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 weiter, werden aber in Zukunft eingestellt.

  • Folgen Sie den Schritten in dieser Anleitung, um neue Ressourcen zu konfigurieren.
  • Wenn in Ihrer Konfiguration Legacy-Ressourcen verwendet werden, verwenden Sie das Schlüsselwort legacy, um diese Ressourcen zu finden und zu entfernen. Erstellen Sie die Ressourcen neu. Folgen Sie dazu den Schritten in diesem Dokument.
  • Wenn Ihre Konfiguration unvollständig ist und Legacy-Ressourcen verwendet, verwenden Sie das Schlüsselwort legacy, um diese Ressourcen zu finden und zu entfernen. Erstellen Sie die Ressourcen neu. Folgen Sie dazu den Schritten 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.

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

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

  • Prüfen Sie mit curl, ob der Anwendungsendpunkt ü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

Die einer Verbindung zugeordneten 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: 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: der Name des Connectors
    • my-connection: der Name der zu aktualisierenden Verbindung.
    • us-central1: Die Region, in der die Verbindung bereitgestellt wird.
    • my-project: die Google Cloud-Projekt-ID.

  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 das Update 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 BeyondCorp-Systemdatei. Wenn Sie den Remote-Agent vor diesem Zeitpunkt installiert haben und einen Proxy verwenden möchten, installieren Sie den Remote-Agent neu.

  • Prüfen Sie, ob der Docker-Daemon ordnungsgemäß für die Arbeit mit Proxys konfiguriert ist.

  • Prüfen Sie, ob die Umgebungsvariablen für den HTTP- und den HTTPS-Proxy festgelegt sind und ob 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, NO_PROXY und ihre Entsprechungen in Kleinbuchstaben unterstützt.

  • Wenn Sie die Proxyeinstellungen nach der Installation aktualisieren müssen, aktualisieren Sie die Umgebungsvariablen in /var/beyondcorp/env/PROXY, wenn Sie den beyondcorp-Standardnutzer verwenden. Wenn Sie einen benutzerdefinierten Nutzer verwenden, aktualisieren Sie /home/$USER/.docker/config.json gemäß der Anleitung unter Docker-Client konfigurieren. 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 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, wechseln Sie zur Remote-Agent-VM 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 BeyondCorp Enterprise-Supportteam weitergeben können. Führen Sie den folgenden Befehl aus, um dieses Diagnoseskript auszuführen:

sudo /var/beyondcorp/scripts/run-diagnostics

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

Remote-Agent-Befehlszeile

bce-connctl ist die Befehlszeile des Remote-Agent-Administrators für die lokale Interaktion mit dem Remote-Agent. Diese Befehlszeile unterstützt verschiedene Befehle, z. B. zum Registrieren des Remote-Agents, zum Überprü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

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 Verbindungen aufzulisten, die von diesem Agent unterstützt werden. 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>

Befehle für die Registrierung

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

  • Beschreibung: 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 das Flag -h oder --help an jeden bce-connctl-Befehl anhängen, um Nutzungsinformationen auszugeben.

bce-connctl init -h