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 app BeyondCorp Enterprise para proteger aplicativos que não são do Google Cloud.

Visão geral

É possível usar o conector de app BeyondCorp Enterprise para fornecer identidade e acesso baseado no contexto a aplicativos HTTPS em execução em ambientes que não sejam do Google Cloud. O conector de app do BeyondCorp Enterprise é uma interface segura e autenticada entre o plano de aplicação do BeyondCorp Enterprise e os aplicativos em execução em outras nuvens e ambientes locais.

Uma vantagem de usar o conector de app BeyondCorp Enterprise é que você não precisa abrir firewalls ou configurar conexões do Cloud VPN site a site.

Arquitetura

Veja a seguir um diagrama de arquitetura de alto nível que descreve os principais componentes do conector de app do BeyondCorp Enterprise.

Componentes do conector de app do BeyondCorp Enterprise

Os componentes do conector de app do BeyondCorp Enterprise são controlados por três recursos principais de API: conectores, conexões e gateways de apps.

Conectores de apps
Um recurso de conector define um agente remoto exclusivo do conector de app. Os agentes remotos do conector de apps são implantados em ambientes corporativos remotos, como em outras nuvens e ambientes locais. Os 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 de apps
Um recurso de conexão define uma conexão lógica do Google Cloud para 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 do 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 pelo Google. Os agentes remotos do conector de apps se conectam a um ou mais gateways que permitem que esses conectores redirecionem o tráfego de usuários finais para agentes remotos. O tráfego de conexões de apps hospedadas no mesmo gateway de app é roteado por uma infraestrutura virtual comum.

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

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

Para oferecer suporte a até 200.000 conexões simultâneas e até 1 Gbps em capacidade 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 oferecer suporte a uma combinação de 10 apps de baixo uso com outro gateway de app dedicado (app_gateway2).

Os recursos de conector, conexão de app e gateway de app são regionais. Só é possível usá-los em um contexto regional. Por exemplo, não é possível atribuir um conector de app da 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 app BeyondCorp Enterprise 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. Saiba mais em Criptografia do balanceador de carga nos back-ends.

Para usar o conector de app do BeyondCorp Enterprise, é necessário ter o seguinte:

Cada agente de conector de app do BeyondCorp Enterprise requer uma VM do Linux que execute 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 de VM do Linux, recomendamos um mínimo de duas CPUs com 2 GB de RAM.

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

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. Ative a API executando o seguinte comando: 

    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. 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 do agente remoto do conector de app em cada ambiente de rede que hospeda um aplicativo que você queira proteger com o BeyondCorp Enterprise. É 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, siga estas etapas:

  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 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 deve permitir o tráfego de saída.

  2. Instale o agente remoto:

    1. Verifique se o DNS está configurado corretamente e se você pode 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 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. Execute os comandos a seguir para definir as variáveis de ambiente necessárias: 

      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. Inscreva 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 inscrição 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 as permissões Owner no projeto.

      Quando o script de inscrição 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 acesso de identidade externa 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 estiver usando uma instância do AWS EC2 como a 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 comando a seguir para reiniciar o agente e para 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 de 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 de conector de app for criado, o ambiente de execução do agente remoto vai sincronizar 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 sendo executado: 
      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, execute o seguinte comando: 
      docker ps --filter name=bce
    3. Opcional: é possível verificar 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. 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 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 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 apps do BeyondCorp Enterprise usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados em projetos gerenciados do 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 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 apps do BeyondCorp Enterprise usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados em projetos gerenciados do Google.

Como configurar um balanceador de carga de aplicativo externo

Só é possível conectar aplicativos HTTPS a um balanceador de carga de aplicativo externo. Os aplicativos HTTP não são compatíveis.

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 nos endpoints da rede no NEG. Se não for especificada, a rede de projeto padrão será usada.
    • Defina a sinalização --subnet para especificar o nome da sub-rede dos 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. 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. 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. 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

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

  6. Após a criação do balanceador de carga de aplicativo externo, é preciso associar 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 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 com o endereço IP executando o seguinte comando: 
      dig $DOMAIN_NAME
    3. Receba o status de provisionamento executando o seguinte comando:
    gcloud compute ssl-certificates describe $LB_PREFIX-ssl-cert \
    --global \
    --format="get(name,managed.status, managed.domainStatus)"

    Após o certificado SSL ser provisionado, você poderá acessar seu aplicativo usando o nome DNS.

API

  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:

    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 da rede poderá pertencer a qualquer sub-rede na região em que o grupo de endpoints de rede foi 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. 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. 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' \
}"

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

  6. Após a criação do balanceador de carga de aplicativo externo, é preciso associar 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 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 com o endereço IP executando o seguinte comando: 
      dig $DOMAIN_NAME
    3. Receba o status de provisionamento executando 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[]')

    Após o certificado SSL ser 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 IAP para o serviço de back-end seguindo estas etapas:

  1. Acesse a página do IAP:
    IAP

  2. Em RECURSOS HTTPS, encontre $LB_PREFIX-backend-service. Para ativar o IAP para esse 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 proteger seu recurso com o IAP.

  3. Para permitir que os usuários acessem o aplicativo, conceda a eles o papel de usuário do app da Web protegido pelo IAP no projeto. Para isso, siga 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 terão acesso à sua inscrição.
    3. Na lista suspensa Selecionar um papel, selecione Cloud IAP > Usuário do app da Web protegido pelo IAP e clique em Salvar.

Agora seu aplicativo local deve ser publicado na Internet e protegido pelo BeyondCorp Enterprise.

Configurar o conector de app usando o console do Google Cloud

Conclua os procedimentos nesta seção para implantar o conector de app do BeyondCorp Enterprise usando o console do Google Cloud.

Insira os detalhes da sua inscrição

Siga estas etapas para adicionar os detalhes do seu aplicativo:

  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 pelo App Connector.

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

  4. Em URL do aplicativo externo, 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 que não é do Google Cloud.

  1. Clique no botão CRIAR CONECTOR DO APP e insira as seguintes informações:

    • Nome do conector de app: um nome para o conector.
    • Região: a região em que os gateways de conexão e o conector 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 TEST CONNECTION STATUS 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 o aplicativo.
    • Porta: o número da porta para se conectar ao aplicativo.

Conceder acesso ao aplicativo (opcional)

  1. Em Novos principais, digite um ou mais dos seguintes valores:

    • 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: 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ÓXIMA.

Publicar seu aplicativo

  1. Para publicar o aplicativo, clique no botão PUBLICAR APLICATIVO SEGURO.

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

    • Na seção STEP 2 - Update DNS, copie o endereço IP do campo IP address. 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 DNS.

  3. Depois de criar o registro DNS, clique no botão TEST para testá-lo. Você receberá a confirmação de aprovação no teste de DNS.

  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 do 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.Em seguida, clique em ATIVAR.

Agora seu aplicativo local deve ser publicado na Internet e protegido pelo BeyondCorp Enterprise.

Criar um gateway de app (opcional)

Os gateways de apps são criados e gerenciados implicitamente quando você conecta um aplicativo usando o conector de apps. Também é possível criar seus próprios gateways de apps para organizar os recursos de conexões de apps 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, 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. Execute o seguinte comando para criar um gateway de app:

    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 criação de conexã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. Execute o seguinte comando para criar um gateway de app:

    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 criação de conexã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 é 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 AppConnector e AppConnection do conector de app. Por exemplo, gcloud alpha beyondcorp app connectors e gcloud alpha beyondcorp app connections se referem aos novos recursos.

Para acessar recursos legados criados com 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 vão ser descontinuadas no futuro.

  • Siga os procedimentos neste guia para configurar novos recursos.
  • Se sua 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 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 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 na VM do agente remoto usando curl:

    curl https://$APP_ENDPOINT

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

Verifique a configuração do firewall

Verifique se os firewalls entre o agente remoto e a Internet permitem conexões de saída para 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 alterações no arquivo systemd do BeyondCorp. Se você instalou o agente remoto antes disso e quer usar um proxy, reinstale-o.

  • Verificar 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 os equivalentes em letra minúscula são compatíveis.

  • 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 padrão beyondcorp. Se estiver usando um usuário personalizado, atualize o /home/$USER/.docker/config.json de acordo com as instruções para configurar o cliente do 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

run-post-install-checks é um script instalado em /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 vai imprimir uma mensagem de sucesso se tudo estiver em ordem.

run-diagnostics

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

sudo /var/beyondcorp/scripts/run-diagnostics

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

CLI do agente remoto

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

Comando init

É possível usar o comando Init para inicializar o agente remoto e gerar um script para inscrevê-lo.

Exemplo: 

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

Comandos de status

É possível usar os comandos "Status" para gerenciar o status do agente remoto.

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

Comandos de configuração

Use os comandos Config para gerenciar os valores de configuração do seu 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 a inscrição do agente remoto.

  • Descrição: use este comando para saber 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 os uploads da chave pública forem concluídos, o status será ENROLLED.

Ajuda

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

bce-connctl init -h