Nesta página, você aprenderá como fazer a autenticação em um recurso protegido pelo Identity-Aware Proxy (IAP) usando uma conta de usuário ou uma conta de serviço.
- A conta de usuário pertence a um usuário individual. Ela é usada na autenticação quando o aplicativo precisa acessar recursos protegidos pelo IAP em nome de um usuário. Leia sobre as credenciais de conta de usuário.
- A conta de serviço pertence a um aplicativo, e não a um usuário individual. Ela é usada na autenticação quando você quer permitir que um aplicativo acesse seus recursos protegidos pelo IAP. Conheça as noções básicas sobre contas de serviço.
Antes de começar
Antes de começar, você precisará de:
- um aplicativo protegido pelo IAP a que você quer se conectar de maneira programática usando uma conta de desenvolvedor, uma conta de serviço ou credenciais de app para dispositivos móveis.
Como autenticar uma conta de usuário
É possível liberar o acesso de usuários a seu aplicativo por meio de um app para computador ou dispositivos móveis para permitir que um programa interaja com um recurso protegido pelo IAP.
Como autenticar usando um app para dispositivos móveis
- Crie um ID do cliente OAuth 2.0 para seu app para dispositivos móveis no mesmo projeto que
o recurso protegido pelo IAP:
- Acesse a página Credenciais.
Acessar a página "Credenciais" - Selecione o projeto com o recurso protegido pelo IAP.
- Clique em Criar credenciais e selecione ID do cliente OAuth.
- Selecione o Tipo de aplicativo para que você quer criar credenciais.
- Inclua as informações de Nome e Restrições, se apropriado, e clique em Criar.
- Acesse a página Credenciais.
- Uma janela Cliente OAuth será exibida. Anote o ID do cliente do recurso protegido pelo IAP a que você quer se conectar.
- Receba um token para o ID do cliente protegido pelo IAP:
- Android: use a API Google Sign-in para solicitar um token do OpenID Connect (OIDC). Defina o ID do cliente
requestIdToken
como o do recurso a que você está se conectando. - iOS: use o Login do Google para receber um token de ID. Defina
serverClientID
como o ID do cliente do recurso a que você está se conectando.
- Android: use a API Google Sign-in para solicitar um token do OpenID Connect (OIDC). Defina o ID do cliente
- Inclua o token de ID em um cabeçalho
Authorization: Bearer
para fazer a solicitação autenticada ao recurso protegido pelo IAP.
Como autenticar usando um app para computador
Esta seção descreve como autenticar uma conta de usuário de uma linha de comando de um desktop.
Como configurar o ID do cliente
Para permitir que os desenvolvedores acessem seu aplicativo a partir da linha de comando, primeiro é necessário criar credenciais de ID do cliente OAuth do tipo app para computador:
- Acesse a página Credenciais.
Acessar a página "Credenciais" - Selecione o projeto com o recurso protegido pelo IAP.
- Clique em Criar credenciais e selecione ID do cliente OAuth.
- Em Tipo de aplicativo, selecione app para computador, adicione um Nome e clique em Criar.
- Na janela Cliente OAuth que é exibida, anote o ID do cliente e a chave secreta do cliente. Você precisará usá-los em um script para gerenciar credenciais ou compartilhar com seus desenvolvedores.
- Na janela Credenciais, as novas credenciais app para computador aparecem junto com o ID do cliente principal que é usado para acessar o aplicativo.
Como fazer login no aplicativo
Cada desenvolvedor que quiser acessar um app protegido pelo IAP precisará fazer login nele. Você pode empacotar o processo em um script, como usando a CLI gcloud. Veja abaixo um exemplo que usa a curl para fazer login e gerar um token que pode ser usado para acessar o aplicativo:
- Faça login na sua conta que tem acesso ao recurso do Google Cloud.
-
Iniciar um servidor local que possa ecoar as solicitações recebidas.
$ nc -k -l 4444
OBSERVAÇÃO: o comando usa o utilitário NetCat. Você pode usar o utilitário que preferir. -
Acesse o seguinte URI, em que
DESKTOP_CLIENT_ID
é o ID do cliente do app para computador criado acima:https://accounts.google.com/o/oauth2/v2/auth?client_id=DESKTOP_CLIENT_ID&response_type=code&scope=openid%20email&access_type=offline&redirect_uri=http://localhost:4444&cred_ref=true
-
Na saída do servidor local, procure os parâmetros de solicitação. Você verá
uma tela como esta:
GET /?code=$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1
copie o CODE para substituirAUTH_CODE
abaixo pelo ID do cliente do app para computador e a chave secreta que você criou acima.IAP_CLIENT_ID
é o principal ID do cliente usado para acessar seu aplicativo:curl --verbose \ --data client_id=DESKTOP_CLIENT_ID \ --data client_secret=DESKTOP_CLIENT_SECRET \ --data code=AUTH_CODE \ --data audience=IAP_CLIENT_ID \ --data redirect_uri=http://localhost:4444 \ --data grant_type=authorization_code \ https://oauth2.googleapis.com/token
Esse código retorna um objeto JSON com um campo
id_token
que pode ser usado para acessar o aplicativo.
Como acessar o aplicativo
Para acessar o app, use o
id_token
desta maneira:
curl --verbose --header 'Authorization: Bearer ID_TOKEN' URL
Token de atualização
É possível usar o token de atualização gerado durante o fluxo de login para receber novos tokens de ID. Isso é útil quando o token de ID original expira. Cada token de ID é válido por aproximadamente uma hora e, nesse período, é possível fazer várias solicitações a um app específico.
Veja a seguir um exemplo que usa curl para utilizar o token de atualização e receber um novo token de ID. No exemplo a seguir,
REFRESH_TOKEN
é o token
do fluxo de login.
IAP_CLIENT_ID
,
DESKTOP_CLIENT_ID
e
DESKTOP_CLIENT_SECRET
são os
mesmos usados no fluxo de login:
curl --verbose \ --data client_id=DESKTOP_CLIENT_ID \ --data client_secret=DESKTOP_CLIENT_SECRET \ --data refresh_token=REFRESH_TOKEN \ --data grant_type=refresh_token \ --data audience=IAP_CLIENT_ID \ https://oauth2.googleapis.com/token
Esse código retorna um objeto JSON com um novo
campo id_token
que pode ser
usado para acessar o app.
Como autenticar uma conta de serviço
Use um token do OpenID Connect (OIDC) para autenticar uma conta de serviço em um recurso protegido pelo IAP. Siga estas etapas para encontrar seu ID do cliente:
- Acesse a página do IAP.
Encontre o recurso que você quer acessar e clique em > Ir para a configuração do OAuth.
Na página exibida, anote o ID do cliente.
Você também precisa adicionar a conta de serviço à lista de acesso
do projeto protegido pelo IAP. Nas amostras de código a seguir, mostramos como receber um token OIDC. Independentemente da opção escolhida, inclua
o token em um cabeçalho Authorization: Bearer
para fazer a solicitação autenticada
ao recurso protegido pelo IAP.
Como conseguir um token OIDC para a conta de serviço padrão
Se você quiser receber um token do OIDC para a conta de serviço padrão do Compute Engine, do App Engine ou do Cloud Run, use a amostra de código a seguir para gerar o token e acessar um recurso protegido pelo IAP:
C#
Go
Java
Node.js
PHP
Python
Ruby
Como conseguir um token OIDC de um arquivo de chave de conta de serviço local
Se você tiver um arquivo de chave da conta de serviço, poderá adaptar as amostras de código anteriores para fornecer o arquivo de chave da conta de serviço.
Bash
#!/usr/bin/env bash
set -euo pipefail
get_token() {
# Get the bearer token in exchange for the service account credentials.
local service_account_key_file_path="${1}"
local iap_client_id="${2}"
local iam_scope="https://www.googleapis.com/auth/iam"
local oauth_token_uri="https://www.googleapis.com/oauth2/v4/token"
local private_key_id="$(cat "${service_account_key_file_path}" | jq -r '.private_key_id')"
local client_email="$(cat "${service_account_key_file_path}" | jq -r '.client_email')"
local private_key="$(cat "${service_account_key_file_path}" | jq -r '.private_key')"
local issued_at="$(date +%s)"
local expires_at="$((issued_at + 3600))"
local header="{'alg':'RS256','typ':'JWT','kid':'${private_key_id}'}"
local header_base64="$(echo "${header}" | base64)"
local payload="{'iss':'${client_email}','aud':'${oauth_token_uri}','exp':${expires_at},'iat':${issued_at},'sub':'${client_email}','target_audience':'${iap_client_id}'}"
local payload_base64="$(echo "${payload}" | base64)"
local signature_base64="$(printf %s "${header_base64}.${payload_base64}" | openssl dgst -binary -sha256 -sign <(printf '%s\n' "${private_key}") | base64)"
local assertion="${header_base64}.${payload_base64}.${signature_base64}"
local token_payload="$(curl -s \
--data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer" \
--data-urlencode "assertion=${assertion}" \
https://www.googleapis.com/oauth2/v4/token)"
local bearer_id_token="$(echo "${token_payload}" | jq -r '.id_token')"
echo "${bearer_id_token}"
}
main(){
# TODO: Replace the following variables:
SERVICE_ACCOUNT_KEY="service_account_key_file_path"
IAP_CLIENT_ID="iap_client_id"
URL="application_url"
# Obtain the Bearer ID token.
ID_TOKEN=$(get_token "${SERVICE_ACCOUNT_KEY}" "${IAP_CLIENT_ID}")
# Access the application with the Bearer ID token.
curl --header "Authorization: Bearer ${ID_TOKEN}" "${URL}"
}
main "$@"
Como conseguir um token OIDC em todos os outros casos
Em todos os outros casos, use a API de credenciais do IAM para gerar um token OIDC com base em um token de acesso de outra conta de serviço antes de acessar um recurso protegido pelo IAP:
- Adicione a conta no token de acesso com o papel
service account token creator
na conta de destino. Isso garante que ele tenha a permissão do IAM necessária para criar um token OIDC para a conta de serviço de destino. - Chame generateIdToken
na conta de serviço de destino com o token de acesso.
Preste muita atenção para definir o campo
audience
como o ID do cliente.
Como autenticar do cabeçalho Proxy-Authorization
Se o cabeçalho da solicitação Authorization
estiver ocupado pelo aplicativo, inclua o token de ID em um cabeçalho Proxy-Authorization: Bearer
. Se um
token de ID válido for encontrado em um cabeçalho Proxy-Authorization
,
o IAP vai autorizar a solicitação com ele. Depois de autorizar a
solicitação, o IAP transmite o cabeçalho Authorization
ao
aplicativo sem processar o conteúdo.
Se nenhum token de ID válido for encontrado no cabeçalho Proxy-Authorization
,
o IAP vai processar o cabeçalho Authorization
e
remover o cabeçalho Proxy-Authorization
antes de transmitir a solicitação ao
aplicativo.
A seguir
- Saiba mais sobre Autorização: tokens do portador.
- Tente fazer login no Android ou no iOS.