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

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

Visão geral

É possível usar o conector de app do Chrome Enterprise Premium para fornecer acesso baseado em identidade e contexto a aplicativos HTTPS executados em ambientes que não são 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 executados em outros ambientes locais e de nuvem.

Uma vantagem de usar o conector de apps do Chrome Enterprise Premium é que você não precisa abrir firewalls ou configurar conexões do 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 governados usando três recursos principais de API: conectores de apps, conexões de apps e gateways de apps.

Conectores de apps
Um recurso do conector define um agente remoto exclusivo do conector de app. Conector de app os agentes remotos são implantados em ambientes corporativos remotos, como em outros nuvens e ambientes locais. Os agentes remotos iniciam e mantêm sessões de túnel no Google Cloud, recebem tráfego do Google Cloud e retransmitem 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 para um endpoint de aplicativo específico que é identificado usando o endereço IP:Port ou FQDN:Port. Um recurso de conexão orquestra um conjunto de gateways de conector de app gerenciado alocadas para um determinado endpoint do aplicativo. Os gateways são gerenciados Google Cloud e encerrar as sessões do túnel a partir do agentes 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 de app e os conectores de app redirecionem o tráfego dos usuários finais para agentes remotos. O tráfego de conexões de app hospedadas no mesmo gateway de app é roteado por uma infraestrutura virtual comum.

Quando você conecta um aplicativo usando o conector de app, os gateways são são criadas e gerenciadas implicitamente para você. Você também pode criar outros gateways de apps se quiser organizar os recursos de conexões de apps em grupos. As gateways de apps oferecem a flexibilidade de agrupar ou segregar conexões de apps para permitir o isolamento de apps.

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

Para dar suporte a até 200.000 conexões simultâneas e até 1 Gbps no total capacidade de processamento, recomendamos uma VM dedicada de 8 núcleos e 8 GB para executar o agente remoto do conector de app. Por exemplo, é possível dedicar dois agentes remotos do conector de app em um cluster HA com 8 núcleos e 8 GB de memória cada para oferecer 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 oito núcleos e 8 GB de memória para oferecer suporte a uma combinação de 10 apps de uso baixo com outro gateway de app dedicado (app_gateway2).

Os recursos do conector, da conexão e do gateway de apps são regionais. Você só podem ser usadas 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

O conector de app do Chrome Enterprise Premium só pode ser usado com aplicativos HTTPS. Além disso, os balanceadores de carga HTTPS não usam Extensão Indication (SNI) para conexões com o back-end. Saiba mais em Criptografia do balanceador de carga para os 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 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 Linux, recomendamos no mínimo duas CPUs com 2 GB de RAM.

É possível configurar e ativar o conector de app usando o gcloud e a API ou o console do Google Cloud. Para usar o gcloud e as APIs, siga estas etapas. 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 app Chrome Enterprise Premium é necessário ativar a API Chrome Enterprise Premium. Para ativar a API, seguindo estas etapas:

CLI da gcloud

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

  1. Execute o comando a seguir para definir a variável de ambiente necessária: 

    PROJECT_ID=my-project

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

  2. Ative a API executando o seguinte comando: 

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

API

  1. Tenha um acesso token e configure as variáveis de ambiente e aliases necessários executando o comando 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. Ative a API executando o seguinte comando: 

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

Como instalar um agente remoto do conector de app

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

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 que todos os tráfego iniciado na porta 443 para o intervalo de IP IAP-TCP 35.235.240.0/20. Consulte Verificar a configuração do firewall. para outros domínios em que o firewall da VM do agente remoto permita a saída para receber o tráfego.

  2. Instale o agente remoto:

    1. Verifique se o DNS está configurado corretamente e se você consegue acessar o aplicativo usando o 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 do 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 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:

      • 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 a inscrição. nos projetos do Google Cloud usando o Cloud Shell ou a CLI gcloud e conclua 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 da federação de identidade da carga de trabalho para conceder acesso ao Google Cloud. usando a representação de uma 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, faça uma das seguintes ações:
        1. Torne o IMDSv2 opcional na instância do EC2.
        2. Adicione a linha a seguir 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 comando a seguir para reiniciar o agente e fazer com que ele colete 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:
      • my-service-account: a conta de serviço do Google Cloud associada à identidade externa.

    6. Conceda à conta de serviço do Google Cloud o papel BeyondCorp Connection Agent 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. Verifique se as três os contêineres estão em execução com o seguinte comando: 
      docker ps --filter name=bce
    3. Opcional: é possível verificar os arquivos de registro dos contêineres do Docker executando 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. Execute os comandos a seguir para definir as variáveis de ambiente necessárias:

    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 seu 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 alguns 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 app Chrome Enterprise Premium usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados em projetos gerenciados pelo Google.

API

  1. Execute os comandos a seguir para definir as variáveis de ambiente necessárias:

    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 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 alguns 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 app 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. Execute os comandos a seguir para definir as variáveis de ambiente necessárias: 

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

    • 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) 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á usados.
    • 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 é criado.

  3. Crie um serviço de back-end baseado em NEG e conecte-o a um anexo de serviço do Private Service Connect executando os seguintes comandos:

    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. Para criar um certificado gerenciado pelo Google para seu domínio, execute 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. Crie um balanceador de carga de aplicativo externo com base no back-end da etapa anterior executando os seguintes comandos:

    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

    Depois que o balanceador de carga de aplicativo externo for criado, o aplicativo poderá ser acessado pela Internet usando esse endereço IP.

  6. Depois que o balanceador de carga de aplicativo externo for criado, você precisará associar o endereço IP dele ao nome de domínio para que o Google Cloud possa provisionar um certificado SSL. Use as instruções do provedor de DNS para associar o endereço IP ao nome DNS. Execute o comando a seguir para verificar o status de provisionamento:

    1. Mostre o endereço IP a ser configurado no provedor de DNS: 
      echo "Load Balancer ip address - $LB_IP"
    2. Após definir o DNS, verifique se o nome de domínio é resolvido ou não ao 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 o 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:

    • 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 especificado, a rede padrão do projeto 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 for criado.

  3. Crie um serviço de back-end baseado em NEG e conecte-o a um anexo de serviço do Private Service Connect executando os seguintes comandos:

    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. Para criar um certificado gerenciado pelo Google para seu domínio, execute 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. Crie um balanceador de carga de aplicativo externo com base no back-end da etapa anterior executando os seguintes comandos:

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

    Depois que o balanceador de carga de aplicativo externo for criado, o aplicativo poderá ser acessado pela Internet usando esse endereço IP.

  6. Depois que o balanceador de carga de aplicativo externo for criado, você precisará associar o endereço IP dele ao nome de domínio para que o Google Cloud possa provisionar um certificado SSL. Use as instruções do provedor de DNS para associar o endereço IP ao nome DNS. Execute o comando a seguir para verificar o status de provisionamento:

    1. Mostre o endereço IP a ser configurado no provedor de DNS: 
      echo "Load Balancer ip address - $LB_IP"
    2. Após definir o DNS, verifique se o nome de domínio é resolvido ou não ao 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 o 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. Acesse a página do IAP:
    IAP

  2. Em RECURSOS HTTPS, localize $LB_PREFIX-backend-service. Para ativar o IAP para esse recurso, clique na chave na coluna "IAP". Na janela Ativar IAP que aparece, marque a caixa de seleção para confirmar os requisitos de configuração desse recurso e clique em ATIVAR para confirmar que você quer proteger seu recurso com o IAP.

  3. Para permitir que os usuários acessem seu aplicativo, conceda a eles o papel de Usuário do app da Web protegido pelo IAP para o projeto seguindo estas 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 precisam ter acesso ao seu aplicativo.
    3. Na lista suspensa Selecionar 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 app do Chrome Enterprise Premium usando o console do Google Cloud.

Insira os detalhes do seu aplicativo

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, digite o nome do aplicativo que você quer proteger.

  4. Em URL externo do aplicativo, insira um URL acessível publicamente 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 seu ambiente externo.

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

    • Nome do conector do app: 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 criado 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 seu 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
    • todos: insira 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ÓXIMO.

Publicar seu aplicativo

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

  2. Depois de publicar o aplicativo e receber o aviso Publicado com segurança aplicativo, crie um registro DNS para apontar ao seu servidor externo do aplicativo voltado ao endereço IP do proxy. Conclua as etapas a seguir:

    • Na seção ETAPA 2: atualizar o 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 uma confirmação de Teste de DNS aprovado.

  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 que aparece, 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. Também é possível criar suas próprias passerelles de app para organizar os recursos de conexões de app em grupos. O tráfego de conexões de apps hospedadas em diferentes gateways de apps é roteado por uma infraestrutura virtual separada.

Para criar e especificar um gateway de app, siga estas etapas.

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 app executando o seguinte comando:

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

  3. Execute o comando a seguir para especificar um gateway de app em uma chamada de conexão de criação 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 app 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. Execute o comando a seguir para especificar um gateway de app em uma chamada de conexão de criação 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 é possível encontrar recursos criados anteriormente

Ao usar a 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 recursos legados criados usando uma versão da CLI gcloud anterior à 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 usar recursos legados, use a palavra-chave legacy para localizar e remover esses recursos. Recrie os recursos seguindo os procedimentos deste 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 deste documento.

Erros de TLS/SSL

ERR_SSL_VERSION_OR_CIPHER_MISMATCH

O navegador mostra o erro ERR_SSL_VERSION_OR_CIPHER_MISMATCH ou erros TLS/SSL semelhantes 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 TLS/SSL semelhantes após o redirecionamento 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 o curl:

    curl https://$APP_ENDPOINT

    Talvez seja necessário usar a flag -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 mudar 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 mudar 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 agente remoto.

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

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

  • 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 do Docker. Para aplicar as alterações no 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 em /var/beyondcorp/scripts/ que verifica se o agente remoto está instalado, registrado e em bom estado. 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 de status para gerenciar o status do agente remoto.

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

Comandos "config"

Você pode usar os comandos de configuração para gerenciar os valores de configuração do seu agente remoto.

  • List: use esse 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 inscrição para gerenciar a inscrição do agente remoto.

  • Descrever: use este comando para conferir 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 flag -h ou --help a qualquer comando bce-connctl para imprimir informações de uso.

bce-connctl init -h