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

Visão geral

É possível usar o conector de app do BeyondCorp Enterprise para fornecer acesso baseado em identidade e contexto aos aplicativos HTTPS em execução em ambientes que não são 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 executados em outras nuvens e ambientes locais.

Um benefício de usar o conector de apps do BeyondCorp Enterprise é que você não precisa abrir firewalls ou configurar conexões do Cloud VPN site a site.

Arquitetura

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

Os componentes do conector de app do BeyondCorp Enterprise são regidos por dois principais recursos, conectores e conexões da API:

• Conectores: um recurso de conector define um agente remoto exclusivo do conector de apps. Os agentes remotos do conector de app são implantados em ambientes corporativos remotos, como outras 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 redirecionam o tráfego para endpoints de aplicativos remotos no mesmo ambiente dos agentes.
• Conexões: um recurso de conexão define uma conexão lógica do Google Cloud para um endpoint de aplicativo específico identificado usando o endereço IP:Porta ou FQDN:Porta. Um recurso de conexão organiza um conjunto de gateways de conector de app gerenciados alocados para um endpoint de aplicativo específico. Os gateways são gerenciados no Google Cloud e encerram as sessões de agente dos agentes remotos quando não são mais necessárias.

O conector e os recursos de conexão são regionais e só podem ser usados em um contexto regional. Por exemplo, um conector associado à região A não pode ser atribuído a uma conexão criada para a região B.

Antes de começar

No momento, só é possível usar o conector de apps do BeyondCorp Enterprise com aplicativos HTTPS. Além disso, os balanceadores de carga HTTPS não usam a extensão Indicação de nome do servidor (SNI, na sigla em inglês) para conexões com o back-end. Para mais detalhes, consulte Criptografia do balanceador de carga para os back-ends.

Para usar o conector de app do BeyondCorp Enterprise, você precisa do seguinte:

• Uma licença do BeyondCorp Enterprise.
• Versão 392 ou mais recente do Google Cloud CLI.

Cada agente do conector de app do BeyondCorp Enterprise 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 de VM do Linux, recomendamos no mínimo 2 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 apps usando o console do Google Cloud.

Como configurar o projeto do Google Cloud

Para configurar um projeto do Google Cloud a ser usado com o conector de apps do BeyondCorp Enterprise, ative a API BeyondCorp Enterprise. Ative a API concluindo as seguintes etapas:

gcloud

Antes de concluir estas etapas, instale o SDK da CLI gcloud.

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. Consiga um token de acesso e defina os aliases e variáveis de ambiente necessários executando os comandos abaixo:

   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

Implante uma VM de agente remoto do conector de app para cada ambiente de rede que hospeda um aplicativo que você quer proteger com o BeyondCorp Enterprise. É preciso 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 da 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 do intervalo 35.235.240.0/20.

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.
   3. Execute o seguinte comando na VM do agente remoto:

      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
      

   4. Para adicionar o alias bce-connctl ao shell, execute o seguinte comando:

       source ~/.bce_alias
       

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

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

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

      Siga as instruções na tela para copiar e colar o script de inscrição e concluir o registro do seu conector. Para executar o script de inscrição, você precisa ter permissões OWNER no projeto.

      Quando o script de inscrição é concluído, o ambiente de execução sincroniza automaticamente a configuração do conector.

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

   1. Execute este comando para verificar se o serviço está 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, execute este comando:

      docker ps --filter name=bce
      

   3. (Opcional) Para verificar os arquivos de registro de contêineres do Docker, execute 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

gcloud

Antes de concluir as etapas a seguir, verifique se o SDK da CLI gcloud está instalado e se você 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 no local ou um FQDN que hospeda seu aplicativo.
   • APP_PORT: o número da porta a ser conectada 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 BeyondCorp Enterprise usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados nos projetos gerenciados do 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 no local ou um FQDN que hospeda seu aplicativo.
   • my-app-port: o número da porta a ser conectada 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 BeyondCorp Enterprise usa o Private Service Connect para vincular o projeto do consumidor aos recursos gerenciados nos projetos gerenciados do Google.

Como configurar um balanceador de carga HTTP(S) externo

Só é possível conectar aplicativos HTTPS a um balanceador de carga HTTP(S) externo. Aplicativos HTTP não são suportados.

gcloud

Antes de concluir as etapas a seguir, verifique se o SDK da CLI gcloud está instalado e se você 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:
   • 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 sinalização --network para especificar o nome da rede para os endpoints da rede no NEG. Se não for especificada, a rede padrão do projeto 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 da rede poderá pertencer a qualquer sub-rede na região em que o grupo de endpoints da rede será 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 HTTP(S) 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 HTTP(S) externo é criado, seu aplicativo pode ser acessado pela Internet por esse endereço IP.

6. Depois que o balanceador de carga HTTP(S) 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 associar o endereço IP ao nome DNS. Execute o comando a seguir 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, execute o seguinte comando para verificar se o nome de domínio é resolvido para o endereço IP:

      dig $DOMAIN_NAME
      

   3. Veja 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)"
   

   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:
   • 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 da rede no NEG. Se não for especificada, a rede padrão do projeto será usada.
   • Defina o campo subnetwork para especificar o URL da sub-rede dos 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 da 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. 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 HTTP(S) 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 HTTP(S) externo é criado, seu aplicativo pode ser acessado pela Internet por esse endereço IP.

6. Depois que o balanceador de carga HTTP(S) 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 associar o endereço IP ao nome DNS. Execute o comando a seguir 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, execute o seguinte comando para verificar se o nome de domínio é resolvido para o endereço IP:

      dig $DOMAIN_NAME
      

   3. Veja 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[]')
   

   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 seguindo estas 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 no botão na coluna correspondente. Na janela Ativar IAP que é exibida, 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 no projeto, concluindo 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 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 o aplicativo local será publicado na Internet e protegido pelo BeyondCorp Enterprise.

Configurar o conector de apps usando o console do Google Cloud

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

Insira os detalhes da sua inscrição

Adicione os detalhes do seu aplicativo seguindo estas etapas:

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

2. Clique no botão CONECTAR NOVO APP e selecione Conectar pelo conector do app.

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

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 APP CONNECTOR 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 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 em 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 no local ou o FQDN que hospeda o aplicativo.
   • Porta: o número da porta a ser conectada ao aplicativo.

Conceder acesso ao aplicativo (opcional)

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

   • e-mail da conta do Google: [e-mail]
   • grupo do Google: [e-mail]
   • Conta de serviço: [e-mail]
   • 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 INSCRIÇÃO.

2. Depois de publicar o aplicativo e receber a confirmação de aplicativo publicado com segurança, é necessário criar 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 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 seu provedor de DNS sobre como associar o endereço IP ao nome DNS.

3. Depois de criar o registro DNS, clique no botão TESTAR para testá-lo. 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. Localize seu aplicativo na lista de recursos e selecione o botão na coluna "IAP".

3. Na caixa de diálogo Ativar o 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 o aplicativo local será publicado na Internet e protegido pelo BeyondCorp Enterprise.

Próximas etapas

• Consulte VPC Service Controls para informações sobre como proteger uma VPC.
• Defina regras de contexto mais avançadas aplicando níveis de acesso.
• Para as solicitações de acesso, ative os registros de auditoria do Cloud.

Solução de problemas

Não é possível encontrar os recursos criados anteriormente

Ao usar a CLI gcloud versão 392.0.0 ou posterior, use os novos recursos padrão do conector de apps AppConnector e AppConnection. Por exemplo, gcloud alpha beyondcorp app connectors e gcloud alpha beyondcorp app connections fazem referência aos novos recursos.

Para acessar recursos legados criados usando 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 fazem referência aos recursos legados.

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

Ações recomendadas

• Siga os procedimentos deste guia para configurar novos recursos.
• Se a configuração usar recursos legados, use a palavra-chave legacy para localizar esses recursos e removê-los. Recrie os recursos seguindo os procedimentos neste documento.
• Se você tiver uma configuração incompleta que use recursos legados, use a palavra-chave legacy para localizar esses recursos e removê-los. 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.

Ações recomendadas

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

Ações recomendadas

• 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 o curl:

  curl https://$APP_ENDPOINT
  

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

Ferramentas de diagnóstico

verificações-de-instalação-instalação-verificações

run-post-install-checks é um script instalado no /var/beyondcorp/scripts/ que verifica se o agente remoto está instalado corretamente, inscrito e íntegro. Depois de criar um app connection e o atribuir 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 exibir uma mensagem de êxito 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 imprime um relatório que você pode compartilhar com a equipe de suporte do BeyondCorp. 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 no ./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, como para 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

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

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

Comandos de configuração

Use os comandos de configuração para gerenciar os valores de configuração do agente remoto.

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

• Descreva: use este comando para ver o status de inscrição do agente remoto. Exemplo: bce-connctl enrollment describe

  Quando o script de inscrição de bce-connctl init for concluído e a chave pública for enviada, o status será ENROLLED.

Ajuda

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

bce-connctl init -h