Proteger aplicativos que não são do Google Cloud usando o conector de apps

Nesta página, descrevemos como configurar e usar o conector de apps do Chrome Enterprise Premium para proteger aplicativos que não são do Google Cloud.

Visão geral

Use o conector de apps do Chrome Enterprise Premium para fornecer acesso baseado no contexto e identidade a aplicativos HTTPS executados em ambientes fora do Google Cloud. O conector de apps do Chrome Enterprise Premium é uma interface segura e autenticada entre o plano de aplicação do Chrome Enterprise Premium e os aplicativos em execução em outras nuvens e ambientes locais.

Uma vantagem de usar o conector de apps do Chrome Enterprise Premium é que você não precisa abrir firewalls nem configurar conexões de Cloud VPN site a site.

Arquitetura

Veja a seguir um diagrama detalhado da arquitetura que descreve os principais componentes do conector de apps do Chrome Enterprise Premium.

Componentes do conector de apps do Chrome Enterprise Premium

Os componentes do conector de apps do Chrome Enterprise Premium são regidos por três recursos principais da API: conectores, conexões e gateways de apps.

Conectores de apps
Um recurso do conector define um agente remoto exclusivo do conector de app. Os agentes remotos do conector de app são implantados em ambientes corporativos remotos, como em outras nuvens e ambientes locais. Agentes remotos iniciam e mantêm sessões de túnel para o Google Cloud, recebem tráfego do Google Cloud e redirecionam o tráfego para endpoints de aplicativos remotos no mesmo ambiente.
Conexões do app
Um recurso de conexão define uma conexão lógica do Google Cloud com um endpoint de aplicativo específico, identificado usando endereço IP:porta ou FQDN:porta. Um recurso de conexão orquestra um conjunto de gateways de conectores de app gerenciados alocados para um determinado endpoint de aplicativo. Os gateways são gerenciados no Google Cloud e encerram as sessões de túnel dos agentes remotos quando não são mais necessários.
Gateways de apps

Um gateway de app é uma oferta de serviço gerenciado do Google. Os agentes remotos do conector de app se conectam a um ou mais gateways que permitem que as conexões e os conectores de aplicativos redirecionem o tráfego de usuários finais para agentes remotos. O tráfego das conexões de apps hospedadas no mesmo gateway de app é roteado por uma infraestrutura virtual comum.

Ao conectar um aplicativo usando o conector de app, os gateways são criados e gerenciados implicitamente para você. Também é possível criar gateways de aplicativos adicionais se você quiser organizar os recursos de conexões de aplicativos em grupos. Os gateways de apps oferecem a flexibilidade de agrupar ou separar conexões de apps para permitir o isolamento deles.

Cada gateway de app aceita até 1 Gbps na capacidade total para até 200.000 conexões simultâneas. Recomendamos que você crie gateways dedicados para aplicativos essenciais que exigem alto desempenho. É possível alocar no máximo até 10 apps por gateway.

Para aceitar até 200.000 conexões simultâneas e até 1 Gbps no total, recomendamos que você use uma VM dedicada de 8 núcleos e 8 GB de memória para executar o agente remoto do conector de app. Por exemplo, é possível dedicar dois agentes remotos do conector de app em um cluster de alta disponibilidade com 8 núcleos e 8 GB de memória cada um para dar suporte a um aplicativo da Web de alto desempenho (app1.examplecompany.com) com um gateway de app dedicado (app_gateway1). Crie outro cluster de duas VMs, cada uma com 8 núcleos e 8 GB de memória, para dar suporte a uma combinação de 10 aplicativos de baixo uso com outro gateway de app dedicado (app_gateway2).

Os recursos de conector, conexão e gateway de app são regionais. Só é possível usá-las em um contexto regional. Por exemplo, não é possível atribuir um conector de app na região A a uma conexão ou gateway de app criado na região B.

Antes de começar

Só é possível usar o conector de apps do Chrome Enterprise Premium com aplicativos HTTPS. Além disso, os balanceadores de carga HTTPS não usam a extensão Server Name Indication (SNI) para conexões com o back-end. Para mais detalhes, consulte Criptografia do balanceador de carga nos back-ends.

Para usar o conector de apps do Chrome Enterprise Premium, você precisa ter o seguinte:

Cada agente do conector de apps do Chrome Enterprise Premium requer uma VM do Linux que esteja executando o Docker. Recomendamos as seguintes distribuições do Linux:

  • Debian 10.7 (buster)
  • Red Hat Enterprise Linux Server 7.8 (Maipo) x86_64
  • Ubuntu 16.04 ou posterior

Para o hardware da VM do Linux, recomendamos no mínimo duas CPUs com 2 GB de RAM.

É possível configurar e ativar o conector de app usando a gcloud e a API ou o console do Google Cloud. Para usar a gcloud e as APIs, conclua as etapas a seguir. Para usar o console do Google Cloud, acesse Configurar o conector de app usando o console do Google Cloud.

Como configurar o projeto do Google Cloud

Para configurar um projeto do Google Cloud para usar com o conector de apps do Chrome Enterprise Premium, ative a API Chrome Enterprise Premium. Para ativar a API, siga estas etapas:

CLI da gcloud

Antes de concluir as etapas a seguir, verifique se o SDK da CLI gcloud está instalado.

  1. Defina a variável de ambiente necessária executando o seguinte comando: 

    PROJECT_ID=my-project

    Substitua my-project pelo ID do projeto do Google Cloud.

  2. Execute o seguinte comando para ativar a API: 

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

API

  1. Receba um token de acesso e defina as variáveis de ambiente e os aliases necessários executando os seguintes comandos:

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

    Substitua my-project pelo ID do projeto do Google Cloud.

  2. Configure um alias conveniente para usar seu token de acesso: 

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

  3. Execute o seguinte comando para ativar a API: 

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

Como instalar um agente remoto do conector de app

Implante uma VM do agente remoto do conector de app para cada ambiente de rede que hospeda um aplicativo que você quer proteger com o Chrome Enterprise Premium. É necessário ter uma VM dedicada ou qualquer servidor Bare Metal com o Docker instalado para cada agente remoto criado.

Para criar um agente remoto, conclua as etapas a seguir:

  1. Crie uma instância de VM no ambiente do aplicativo.
    1. Verifique se o firewall de rede da VM do agente remoto permite todo o tráfego de saída iniciado na porta 443 para o intervalo IP 35.235.240.0/20 do IAP-TCP. Consulte Verificar a configuração do firewall para ver outros domínios para os quais o firewall da VM do agente remoto precisa permitir o tráfego de saída.

  2. Instale o agente remoto:

    1. Verifique se o DNS está configurado corretamente e se é possível acessar o aplicativo usando curl.
    2. Instale o Docker Engine.
      1. Opcional: se você estiver usando um proxy, verifique se o daemon do Docker está configurado corretamente.
    3. Opcional: se você estiver usando um proxy, verifique se as variáveis de ambiente de proxy HTTP e HTTPS estão definidas e usando o esquema http://.
    4. Execute o seguinte comando na VM do agente remoto para instalá-lo: 
      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. Para adicionar o alias bce-connctl ao seu shell, execute o seguinte comando: 
       source ~/.bce_alias

    6. Defina as variáveis de ambiente necessárias executando os seguintes comandos: 

      PROJECT_ID=my-project
REGION=us-central1
CONNECTOR_NAME=my-connector
      Substitua o seguinte:

      • my-project: o ID do projeto do Google Cloud.
      • us-central1: a região em que a conexão e os gateways serão implantados.
      • my-connector: o nome do conector.

    7. Registre o conector usando um dos seguintes tipos de credenciais:

    Conta de serviço

    1. Registre o conector executando o seguinte comando na CLI bce-connctl: 

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

    2. Siga as instruções na tela para copiar e colar o script de registro nos projetos do Google Cloud usando o Cloud Shell ou a CLI gcloud e concluir a inscrição do conector. Para executar o script de inscrição, você precisa ter permissões Owner no projeto.

      Quando o script de registro for concluído, o ambiente de execução sincronizará a configuração do conector automaticamente.

    Identidade federada

    1. Siga o guia de federação de identidade da carga de trabalho para conceder à sua identidade externa acesso ao Google Cloud usando a representação de conta de serviço.
    2. Faça o download da configuração da biblioteca de cliente e coloque o arquivo na VM do agente remoto em /var/beyondcorp/credentials/credentials.json.
      1. Se você estiver usando uma instância do AWS EC2 como VM do agente remoto, siga um destes procedimentos:
        1. Torne o IMDSv2 opcional na instância do EC2.
        2. Adicione a seguinte linha ao objeto credential_source no arquivo de configuração da biblioteca de cliente: 
          "imdsv2_session_token_url": "http://169.254.169.254/latest/api/token"
    3. Na VM do agente remoto, execute os seguintes comandos na CLI bce-connctl: 
      bce-connctl config set project $PROJECT_ID
bce-connctl config set region $REGION
bce-connctl config set connector $CONNECTOR_NAME
    4. Execute o seguinte comando para reiniciar o agente e selecionar as credenciais: 
      sudo systemctl restart beyondcorp
    5. No endpoint do Cloud Shell ou da CLI gcloud, defina a variável de ambiente necessária executando o seguinte comando: 
      SERVICE_ACCOUNT=my-service-account
      Substitua o seguinte:
      • my-service-account: a conta de serviço do Google Cloud associada à identidade externa.

    6. Conceda o papel BeyondCorp Connection Agent à conta de serviço do Google Cloud executando o seguinte comando:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:$SERVICE_ACCOUNT" \
    --role="roles/beyondcorp.connectionAgent"

    7. Execute o comando a seguir para criar o recurso do conector de app do Google Cloud.

      gcloud alpha beyondcorp app connectors create $CONNECTOR_NAME \
    --project=$PROJECT_ID \
    --location=$REGION \
    --member="serviceAccount:$SERVICE_ACCOUNT" \
    --display-name=$CONNECTOR_NAME

      Depois que o recurso do conector de app é criado, o ambiente de execução do agente remoto sincroniza a configuração do conector automaticamente.

  3. Verifique a instalação do agente remoto:

    1. Execute o seguinte comando para garantir que o serviço esteja em execução: 
      sudo systemctl status beyondcorp
    2. O agente remoto consiste em três contêineres do Docker: bce-control-runtime, bce-logagent e bce-connector. Para verificar se os três contêineres estão em execução, use o seguinte comando:
      docker ps --filter name=bce
    3. Opcional: verifique os arquivos de registro dos contêineres do Docker executando o seguinte comando: 
      docker logs -f CONTAINER_NAME
      Substitua CONTAINER_NAME pelo nome do contêiner do Docker.

Como conectar um aplicativo remoto a uma VPC

CLI da gcloud

Antes de concluir as etapas a seguir, verifique se você tem o SDK da CLI gcloud instalado e se fez login com uma conta que tenha o papel beyondcorp.admin.

  1. Defina as variáveis de ambiente necessárias executando os seguintes comandos:

    CONNECTOR_NAME=my-connector
CONNECTION_NAME=my-connection
PROJECT_ID=my-project
REGION=us-central1
APP_ENDPOINT=APP_HOST:APP_PORT

    Substitua:

    • my-connector: o nome do conector, definido em uma etapa anterior.
    • my-connection: um nome exclusivo para a conexão.
    • my-project: o ID do projeto do Google Cloud.
    • us-central1: a região em que a conexão e os gateways serão implantados.
    • APP_HOST: o endereço IP local ou um FQDN que hospeda o aplicativo.
    • APP_PORT: o número da porta para se conectar ao aplicativo.

  2. Para criar uma conexão entre o aplicativo e a VPC, execute o seguinte comando:

    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

    Essa etapa pode levar vários minutos para ser concluída.

  3. Depois de criar a conexão, execute os seguintes comandos para recuperar os URIs do gateway: 

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

    O GATEWAY_URI_L7 é usado para criar uma regra de encaminhamento. O conector de apps do Chrome Enterprise Premium usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados em projetos gerenciados pelo Google.

API

  1. Defina as variáveis de ambiente necessárias executando os seguintes comandos:

    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

    Substitua:

    • my-connector: o nome do conector, definido em uma etapa anterior.
    • my-connection: um nome exclusivo para a conexão.
    • my-project: o ID do projeto do Google Cloud.
    • us-central1: a região em que a conexão e os gateways serão implantados.
    • my-app-host: o endereço IP local ou um FQDN que hospeda o aplicativo.
    • my-app-port: o número da porta para se conectar ao aplicativo.

  2. Para criar uma conexão entre o aplicativo e a VPC, execute o seguinte comando:

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

    Essa etapa pode levar vários minutos para ser concluída.

  3. Depois de criar a conexão, execute os seguintes comandos para recuperar os URIs do gateway: 

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

    O GATEWAY_URI_L7 é usado para criar uma regra de encaminhamento. O conector de apps do Chrome Enterprise Premium usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados em projetos gerenciados pelo Google.

Como configurar um balanceador de carga de aplicativo externo

Só é possível conectar aplicativos HTTPS a um balanceador de carga de aplicativo externo. Não há suporte para aplicativos HTTP.

CLI da gcloud

Antes de concluir as etapas a seguir, verifique se você tem o SDK da CLI gcloud instalado e se fez login com uma conta que tenha o papel beyondcorp.admin.

  1. Defina as variáveis de ambiente necessárias executando os seguintes comandos: 

    LB_PREFIX=web-app
PROJECT_ID=my-project
REGION=us-central1
DOMAIN_NAME=app.example.com
    Substitua o seguinte:

    • web-app: o prefixo anexado aos nomes de todos os recursos do balanceador de carga.
    • my-project: o ID do projeto do Google Cloud.
    • us-central1: a região em que a conexão e os gateways serão implantados.
    • app.example.com: o nome de domínio do aplicativo.

  2. Crie um grupo de endpoints de rede (NEG, na sigla em inglês) usando o seguinte comando:

    gcloud beta compute network-endpoint-groups create $LB_PREFIX-neg \
    --region=$REGION \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=$GATEWAY_URI_L7

    Sinalizações opcionais:

    • Defina a flag --network para especificar o nome da rede para os endpoints de rede no NEG. Se não for especificada, a rede de projeto padrão será usada.
    • Defina a flag --subnet para especificar o nome da sub-rede para os endpoints de rede no NEG. Se não for especificado, o endpoint de rede poderá pertencer a qualquer sub-rede na região em que o grupo de endpoints de rede foi criado.

  3. Execute os comandos a seguir para criar um serviço de back-end baseado em NEG e conectá-lo a um anexo do serviço do Private Service Connect:

    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. Crie um certificado gerenciado pelo Google para seu domínio executando os seguintes comandos:

    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. Execute os comandos a seguir para criar um balanceador de carga de aplicativo externo com base no back-end da etapa anterior:

    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

    Após a criação do balanceador de carga de aplicativo externo, seu aplicativo poderá ser acessado pela Internet por esse endereço IP.

  6. Depois que o balanceador de carga de aplicativo externo for criado, associe o endereço IP ao nome de domínio para que o Google Cloud possa provisionar um certificado SSL. Use as instruções do seu provedor de DNS para saber como associar o endereço IP ao nome do DNS. Execute o seguinte comando para verificar o status do provisionamento:

    1. Mostre o endereço IP a ser configurado no provedor de DNS: 
      echo "Load Balancer ip address - $LB_IP"
    2. Depois de definir o DNS, verifique se o nome de domínio é resolvido ou não para o endereço IP executando o seguinte comando:
      dig $DOMAIN_NAME
    3. Para receber o status do provisionamento, execute o seguinte comando:
    gcloud compute ssl-certificates describe $LB_PREFIX-ssl-cert \
    --global \
    --format="get(name,managed.status, managed.domainStatus)"

    Depois que o certificado SSL for provisionado, você poderá acessar seu aplicativo usando o nome DNS.

API

  1. Defina as variáveis de ambiente necessárias executando os seguintes comandos: 

    LB_PREFIX=web-app
PROJECT_ID=my-project
REGION=us-central1
DOMAIN_NAME=app.example.com
    Substitua o seguinte:

    • web-app: o prefixo anexado aos nomes de todos os recursos do balanceador de carga.
    • my-project: o ID do projeto do Google Cloud.
    • us-central1: a região em que a conexão e os gateways serão implantados.
    • app.example.com: o nome de domínio do aplicativo.

  2. Crie um grupo de endpoints de rede (NEG, na sigla em inglês) usando o seguinte comando:

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

    Campos opcionais:

    • Defina o campo network para especificar o URL da rede para os endpoints de rede no NEG. Se não for especificada, a rede de projeto padrão será usada.
    • Defina o campo subnetwork para especificar o URL da sub-rede para os endpoints de rede no NEG. Se não for especificado, o endpoint de rede poderá pertencer a qualquer sub-rede na região em que o grupo de endpoints de rede foi criado.

  3. Execute os comandos a seguir para criar um serviço de back-end baseado em NEG e conectá-lo a um anexo do serviço do Private Service Connect:

    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. Crie um certificado gerenciado pelo Google para seu domínio executando os seguintes comandos:

    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. Execute os comandos a seguir para criar um balanceador de carga de aplicativo externo com base no back-end da etapa anterior:

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

    Após a criação do balanceador de carga de aplicativo externo, seu aplicativo poderá ser acessado pela Internet por esse endereço IP.

  6. Depois que o balanceador de carga de aplicativo externo for criado, associe o endereço IP ao nome de domínio para que o Google Cloud possa provisionar um certificado SSL. Use as instruções do seu provedor de DNS para saber como associar o endereço IP ao nome do DNS. Execute o seguinte comando para verificar o status do provisionamento:

    1. Mostre o endereço IP a ser configurado no provedor de DNS: 
      echo "Load Balancer ip address - $LB_IP"
    2. Depois de definir o DNS, verifique se o nome de domínio é resolvido ou não para o endereço IP executando o seguinte comando:
      dig $DOMAIN_NAME
    3. Para receber o status do provisionamento, execute o seguinte comando:
    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[]')

    Depois que o certificado SSL for provisionado, você poderá acessar seu aplicativo usando o nome DNS.

Como ativar o Identity-Aware Proxy

Siga a documentação do Identity-Aware Proxy (IAP) para configurar o Identity-Aware Proxy. Depois de configurar o IAP, ative-o para o serviço de back-end concluindo as seguintes etapas:

  1. Acessar a página do IAP:
    IAP

  2. Em RECURSOS HTTPS, localize $LB_PREFIX-backend-service. Para ativar o IAP para este recurso, clique no botão de alternância na coluna IAP. Na janela Ativar IAP, marque a caixa de seleção para confirmar os requisitos de configuração desse recurso e clique em ATIVAR para confirmar que você quer que o IAP proteja o recurso.

  3. Para permitir que os usuários acessem seu aplicativo, conceda a eles o papel Usuário do app da Web protegido pelo IAP no projeto. Para isso, conclua as seguintes etapas:

    1. Marque a caixa de seleção $LB_PREFIX-backend-service.
    2. No Painel de informações, selecione ADICIONAR PRINCIPAL e insira os endereços de e-mail dos grupos ou indivíduos que devem ter acesso ao seu aplicativo.
    3. Na lista suspensa Selecionar um papel, escolha Cloud IAP > Usuário do app da Web protegido pelo IAP e clique em Salvar.

Seu aplicativo local deve estar publicado na Internet e protegido pelo Chrome Enterprise Premium.

Configurar o conector de app usando o console do Google Cloud

Conclua os procedimentos desta seção para implantar o conector de apps do Chrome Enterprise Premium usando o console do Google Cloud.

Insira os detalhes da sua inscrição

Adicione os detalhes do seu aplicativo concluindo as seguintes etapas:

  1. No console do Google Cloud, acesse a página do IAP.
    Acessar o IAP

  2. Clique no botão CONECTAR NOVO APLICATIVO e selecione Conectar via Conector de apps.

  3. Em Nome do aplicativo, insira o nome do aplicativo que você quer proteger.

  4. Em URL do aplicativo externo, insira um URL público para que os usuários acessem o aplicativo.

  5. Clique em Próxima.

Configurar a conexão com o Google Cloud

Conclua as etapas a seguir para estabelecer a conectividade entre o Google Cloud e o ambiente que não é do Google Cloud.

  1. Clique no botão CRIAR CONEXÃO DE APP e insira as seguintes informações:

    • Nome do conector de app: inclua um nome para o conector.
    • Região: a região em que os gateways e o conector de conexão serão implantados.

  2. Clique no botão CRIAR.

  3. Siga as instruções no painel Provisionar uma máquina virtual para implantar o agente remoto na sua VM.

  4. Clique no botão TESTAR STATUS DA CONEXÃO para testar a conexão.

  5. Configure o conector que você criou na etapa anterior inserindo as seguintes informações em Onde o Google Cloud pode encontrar seu aplicativo?:

    • Nome do host interno: o endereço IP local ou o FQDN que hospeda o aplicativo.
    • Porta: o número da porta para se conectar ao aplicativo.

Conceder acesso ao aplicativo (opcional)

  1. Em Novos principais, insira um ou mais dos itens a seguir:

    • e-mail da conta do Google: user@gmail.com
    • grupo do Google: admins@googlegroups.com
    • Conta de serviço: server@example.gserviceaccount.com
    • Domínio do Google Workspace: example.com
    • qualquer pessoa: digite allUsers para conceder acesso a todos os usuários.
    • Todas as Contas do Google: allAuthenticatedUsers para conceder acesso a qualquer usuário conectado a uma Conta do Google

  2. Selecione um ou mais níveis de acesso e clique em PRÓXIMA.

Publicar seu aplicativo

  1. Para publicar o aplicativo, clique no botão PUBLICAR APLICATIVO COM SEGURANÇA.

  2. Depois de publicar o aplicativo e receber a confirmação Aplicativo publicado com segurança, crie um registro DNS para apontar o URL do aplicativo externo para o endereço IP do proxy. Conclua as etapas a seguir:

    • Na seção ETAPA 2: atualizar DNS, copie o endereço IP do campo Endereço IP. Use o endereço para criar um registro DNS seguindo as instruções do provedor de DNS sobre como associar o endereço IP ao nome do DNS.

  3. Depois de criar o registro DNS, teste-o clicando no botão TESTAR. Você vai receber a confirmação DNS test failed..

  4. Clique em CONCLUÍDO.

Ativar o IAP

  1. Acesse a página do IAP.
    Acessar o IAP

  2. Na lista de recursos, localize seu aplicativo e selecione o botão na coluna IAP.

  3. Na caixa de diálogo Ativar IAP, marque a caixa de seleção Li os requisitos de configuração e configurei meu serviço de back-end de acordo com a documentação e clique em ATIVAR.

Seu aplicativo local deve estar publicado na Internet e protegido pelo Chrome Enterprise Premium.

Criar um gateway de app (opcional)

Os gateways de aplicativos são criados e gerenciados implicitamente quando você conecta um aplicativo usando o conector de app. Você também pode criar seus próprios gateways de aplicativos para organizar recursos de conexões de aplicativos em grupos. O tráfego para conexões de apps hospedadas em diferentes gateways de apps é roteado por uma infraestrutura virtual separada.

Para criar e especificar um gateway de app, conclua as etapas a seguir.

CLI da gcloud

  1. Defina as variáveis de ambiente necessárias executando o seguinte comando:

    CONNECTOR_NAME=CONNECTOR_NAME
CONNECTION_NAME=CONNECTION_NAME
GATEWAY_NAME=GATEWAY_NAME
PROJECT_ID=PROJECT_ID
REGION=REGION
APP_ENDPOINT=APP_HOST:APP_PORT

    Substitua:

    • CONNECTOR_NAME: o nome do conector, definido em uma etapa anterior.
    • CONNECTION_NAME: um nome exclusivo para a conexão.
    • GATEWAY_NAME: o nome do gateway do app.
    • PROJECT_ID: o ID do projeto do Google Cloud.
    • REGION: a região em que o gateway do app será implantado, como us-central1.
    • APP_HOST: o endereço IP local ou um FQDN que hospeda o aplicativo.
    • APP_PORT: o número da porta para se conectar ao aplicativo.

  2. Crie um gateway de aplicativo executando o seguinte comando:

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

  3. Especifique um gateway de app em uma chamada de conexão de criação executando o seguinte comando:

    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. Defina as variáveis de ambiente necessárias executando o seguinte comando:

    CONNECTOR_NAME=CONNECTOR_NAME
CONNECTION_NAME=CONNECTION_NAME
GATEWAY_NAME=GATEWAY_NAME
PROJECT_ID=PROJECT_ID
REGION=REGION
APP_ENDPOINT=APP_HOST:APP_PORT

    Substitua:

    • CONNECTOR_NAME: o nome do conector, definido em uma etapa anterior.
    • CONNECTION_NAME: um nome exclusivo para a conexão.
    • GATEWAY_NAME: o nome do gateway do app.
    • PROJECT_ID: o ID do projeto do Google Cloud.
    • REGION: a região em que o gateway do app será implantado, como us-central1.
    • APP_HOST: o endereço IP local ou um FQDN que hospeda o aplicativo.
    • APP_PORT: o número da porta para se conectar ao aplicativo.

  2. Crie um gateway de aplicativo executando o seguinte comando:

    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. Especifique um gateway de app em uma chamada de conexão de criação executando o seguinte comando:

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

Próximas etapas

Solução de problemas

Não foi possível encontrar recursos criados anteriormente

Ao usar CLI gcloud versão 392.0.0 ou mais recente, use os novos recursos padrão do conector de app AppConnector e AppConnection. Por exemplo, gcloud alpha beyondcorp app connectors e gcloud alpha beyondcorp app connections se referem aos novos recursos.

Para acessar os recursos legados criados com uma versão da CLI gcloud anterior à versão 392.0.0, use a palavra-chave legacy. Por exemplo, gcloud alpha beyondcorp app legacy connectors e gcloud alpha beyondcorp app legacy connections se referem aos recursos legados.

As configurações que usam recursos legados continuam funcionando, mas serão descontinuadas.

  • Siga os procedimentos neste guia para configurar novos recursos.
  • Se a configuração usa recursos legados, use a palavra-chave legacy para localizar e remover esses recursos. Recrie os recursos seguindo os procedimentos neste documento.
  • Se você tiver uma configuração incompleta que usa recursos legados, use a palavra-chave legacy para localizar e remover esses recursos. Recrie os recursos seguindo os procedimentos neste documento.

Erros de TLS/SSL

ERR_SSL_VERSION_OR_CIPHER_MISMATCH

O navegador mostra o erro ERR_SSL_VERSION_OR_CIPHER_MISMATCH ou erros semelhantes de TLS/SSL e não redireciona para a página de login.

  • Verifique o status dos certificados na página de detalhes do balanceador de carga do Google Cloud.

    OBSERVAÇÃO: o provisionamento de um certificado gerenciado pelo Google pode levar até 60 minutos.

TLS error

O navegador mostra o erro upstream connect error or disconnect/reset before headers. retried and the latest reset reason: connection failure, transport failure reason: TLS error ou erros semelhantes de TLS/SSL depois de redirecionar para a página de login.

  • Verifique se o endpoint do aplicativo usado na conexão é HTTPS.

  • Verifique se o endpoint do app pode ser acessado pela VM do agente remoto usando curl:

    curl https://$APP_ENDPOINT

    Pode ser necessário usar a sinalização -k se o certificado do aplicativo for autoassinado.

Verificar a configuração do firewall

Verifique se os firewalls entre o agente remoto e a Internet permitem conexões de saída com os seguintes domínios:

Tipo de conexão Domínio 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

Alterar os conectores associados a uma conexão

gcloud

  1. Defina as variáveis de ambiente necessárias executando o seguinte comando:

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

    Substitua:

    • my-connector: o nome do conector. Também pode ser uma lista separada por vírgulas, como connector1,connector2.
    • my-connection: o nome da conexão a ser atualizada.
    • us-central1: a região em que a conexão é implantada.
    • my-project: o ID do projeto do Google Cloud.

  2. Para alterar os conectores associados a uma conexão, execute o seguinte comando:

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

API

  1. Defina as variáveis de ambiente necessárias executando o seguinte comando:

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

    Substitua:

    • my-connector: o nome do conector.
    • my-connection: o nome da conexão a ser atualizada.
    • us-central1: a região em que a conexão é implantada.
    • my-project: o ID do projeto do Google Cloud.

  2. Para alterar os conectores associados a uma conexão, execute o seguinte comando:

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

    Para verificar a atualização, execute o comando a seguir e verifique o campo connectors da saída:

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

Proxy

O suporte a proxies foi introduzido no início de 2024 e requer mudanças no arquivo systemd do BeyondCorp. Se você instalou o agente remoto antes desse período e quer usar um proxy, reinstale-o.

  • Verifique se o daemon do Docker está configurado corretamente para funcionar com proxies.

  • Verifique se as variáveis de ambiente do proxy HTTP e HTTPS estão definidas e se ambas estão usando o esquema http://. O esquema https:// e outros esquemas não são compatíveis.

  • Execute o comando env para verificar se as variáveis de ambiente do proxy são exportadas para subprocessos.

  • Somente HTTP_PROXY, HTTPS_PROXY, NO_PROXY e as letras minúsculas equivalentes são aceitos.

  • Se você precisar atualizar as configurações de proxy após a instalação, atualize as variáveis de ambiente em /var/beyondcorp/env/PROXY se estiver usando o usuário beyondcorp padrão. Se estiver usando um usuário personalizado, atualize /home/$USER/.docker/config.json de acordo com as instruções para configurar o cliente Docker. Para aplicar as alterações de proxy, reinicie o agente remoto usando o seguinte comando: 

    sudo systemctl restart beyondcorp

Ferramentas de diagnóstico

run-post-install-checks

O run-post-install-checks é um script instalado no /var/beyondcorp/scripts/ que verifica se o agente remoto está instalado, registrado e íntegro corretamente. Depois de criar um app connection e atribuí-lo a um agente remoto (conector), acesse a VM do agente remoto e execute run-post-install-checks com o seguinte comando:

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

O script imprime uma mensagem de sucesso se tudo estiver em ordem.

run-diagnostics

O run-diagnostics é um script instalado no /var/beyondcorp/scripts/ que diagnostica problemas comuns na VM do agente remoto e imprime um relatório que pode ser compartilhado com a equipe de suporte do Chrome Enterprise Premium. Para executar esse script de diagnóstico, execute o seguinte comando:

sudo /var/beyondcorp/scripts/run-diagnostics

O relatório de diagnóstico é gravado no console e em ./diagnostics-report.txt

CLI do agente remoto

bce-connctl é a interface de linha de comando (CLI) do administrador do agente remoto para interagir localmente com o agente remoto. Essa CLI é compatível com vários comandos, por exemplo, para registrar o agente remoto, verificar o status e definir valores de configuração.

Comando de inicialização

É possível usar o comando Init para inicializar o agente remoto e gerar um script para registrar o agente.

Exemplo: 

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

Comandos de status

Use os comandos Status para gerenciar o status do agente remoto.

  • List: use esse comando para listar o status geral do agente remoto, bem como o status de todas as conexões compatíveis com ele. Exemplo: bce-connctl status list

Comandos "config"

É possível usar os comandos Config para gerenciar os valores de configuração do agente remoto.

  • List: use este comando para listar os valores de configuração do agente remoto. Exemplo: bce-connctl config list
  • Set: use este comando para definir um valor de configuração do agente remoto. Exemplo: bce-connctl config set <key> <value>

Comandos de registro

Use os comandos de registro para gerenciar o registro do agente remoto.

  • Descrever: use esse comando para ver o status de registro do agente remoto. Exemplo: bce-connctl enrollment describe

    Quando o script de registro de bce-connctl init for concluído e o upload da chave pública for concluído, o status será ENROLLED.

Ajuda

É possível anexar a sinalização -h ou --help a qualquer comando bce-connctl para exibir informações de uso.

bce-connctl init -h