1. Introdução
O Visual Studio Code (VS Code) e a extensão Rest Client de Huachao Mao permitem testar o fluxo de consentimento do Google OAuth e a API Google Health. Este codelab mostra como configurar a extensão Rest Client, iniciar o fluxo de autorização e fazer sua primeira chamada para um dos endpoints da API Google Health. Depois, leia a documentação do cliente REST e do Fitbit para criar os outros endpoints no seu projeto HTTP.
Se você não quiser usar o VS Code e o Rest Client, as chamadas de API poderão ser feitas com comandos curl.
O que você vai aprender
- Como configurar o VS Code com a extensão do cliente REST.
- Como configurar um ID do cliente no console do Google Cloud.
- Como passar pelo fluxo de autorização do Google OAuth 2.0 para receber um token de acesso e um token de atualização.
- Como fazer chamadas para endpoints da API Google Health usando o cliente REST.
O que é necessário
- app Fitbit móvel
- Visual Studio Code
- Extensão Rest Client de Huacho Mao.
Para configurar o app Fitbit para dispositivos móveis:
- Na App Store da Apple ou na Google Play Store, pesquise e baixe o app Fitbit móvel.
- Selecione o ícone do app.
- Clique em Fazer login com o Google.
- Selecione sua Conta do Google e pressione o botão Continuar.
Para instalar as ferramentas do Visual Studio:
- Faça o download do VS Code. Normalmente, o download contém o executável.
- Inicie o VS Code.
- Instale a extensão Rest Client de Huachao Mao.
- Clique no ícone de extensão
no lado esquerdo da IDE. - Pesquise REST Client by Huachao Mao e pressione Install.
- Clique no ícone de extensão
2. Configurar um projeto na nuvem do Google Cloud
Você vai usar o console do Google Cloud para criar um ID do cliente e ativar o uso da API Google Health.
- Faça login no console do Google Cloud.
- Para criar um projeto:
- Clique em Selecionar um projeto no seletor de projetos.
- No canto superior direito, selecione Novo projeto.
- Insira o Nome do projeto.
- Insira seu Local (por exemplo, "Sem organização").
- Clique no botão Criar.
- Selecione o projeto.
Ativar a API Google Health
- No canto superior esquerdo, clique no ícone de menu:
- Selecione APIs e serviços > Biblioteca.
- Pesquise "API Google Health" e ative-a.
Configurar suas credenciais do OAuth
Se você não estiver no console do Google Cloud, acesse o console do Google Cloud.
- No canto superior esquerdo, clique no ícone de menu:
- Selecione APIs e serviços > Credenciais.
- Na parte superior central, selecione + Criar credenciais > ID do cliente OAuth.
- Clique no botão Configurar tela de consentimento. Se a mensagem "A plataforma de autenticação do Google ainda não está configurada" aparecer, clique no botão Começar.
- Na seção 1:
- Insira o Nome do app.
- Insira o e-mail para suporte do usuário.
- Clique no botão Próxima.
- Na seção 2:
- Selecione Externo.
- Clique no botão Próxima.
- Na seção 3:
- Insira seu endereço de e-mail no campo Informações de contato.
- Clique no botão Próxima.
- Na seção 4:
- Clique na caixa de seleção para concordar com a Política de dados do usuário dos serviços de API do Google.
- Clique no botão Criar.
- Na seção de métricas, clique no botão Criar cliente OAuth.
- Escolha o tipo de aplicativo Aplicativo da Web.
- Insira o nome do ID do cliente.
- Deixe o campo Origens JavaScript autorizadas vazio.
- Em URIs de redirecionamento autorizados, clique no botão + Adicionar URI. Insira "https://www.google.com" como o URI de redirecionamento.
- Clique no botão Criar.
- O console do Google vai mostrar uma mensagem informando que seu ID do cliente foi criado. Clique no link Fazer o download do JSON para baixar o ID do cliente e a chave secreta do cliente ou anote os valores. Não será possível recuperar a chave secreta do cliente depois.
- Clique em OK. Você vai voltar para a página "IDs do cliente OAuth 2.0".
- O ID do cliente será adicionado ao projeto. Clique no URL do ID do cliente para ver os detalhes.
Adicionar usuários de teste
- No painel à esquerda, selecione Público-alvo. O "Status de publicação" deve estar definido como Teste, e o "Tipo de usuário" como Externo.
- Na seção "Usuários de teste", clique no botão + Adicionar usuários. Insira o endereço de e-mail de qualquer usuário cujos dados você quer recuperar.
- Clique no botão Salvar.
Adicionar escopos ao ID do cliente
- No painel à esquerda, selecione Acesso a dados.
- Clique no botão Adicionar ou remover escopos.
- Na coluna "API", pesquise "API Google Health". Neste codelab, vamos usar o escopo
.../auth/googlehealth.activity_and_fitness.readonly. - Depois de selecionar o escopo, pressione o botão Atualizar para voltar à página "Acesso aos dados".
- Clique no botão Salvar.
Você terminou de configurar o ID do cliente.
3. Criar o fluxo de autorização
- Abra o app VS Code na sua máquina.
- Na tela de boas-vindas, selecione Abrir.
- Selecione uma pasta para criar o projeto e clique em Abrir. A tela será parecida com esta, mostrando o nome da pasta ou do projeto no Explorer.
- No menu principal, escolha Arquivo -> Novo arquivo de texto.
- Salve o arquivo para dar um nome a ele. No menu principal, escolha Arquivo -> Salvar como -> Codelab.http. Isso vai colocar o arquivo no seu projeto. A extensão do arquivo precisa ser .http ou .rest. Neste codelab, vamos usar .http.
Ao longo deste projeto, vamos usar vários valores várias vezes. Esses valores são:
| O valor do ID do cliente do console do Google. |
| O valor secreto do cliente no console do Google. |
| Um endpoint no seu app que processa o código de autorização. Para o codelab, vamos usar https://www.google.com |
| O token de acesso criado para o usuário depois que o fluxo de consentimento é concluído. |
| O token de atualização criado para o usuário quando o fluxo de consentimento é concluído. |
Adicione o código a seguir, que define as variáveis usadas com este projeto. Eles precisam estar na parte de cima do arquivo Codelab.http. Preencha os valores de client_id e secret.
### File Variables for the Codelab
@client_id =
@secret =
@redirect_uri = https://www.google.com
@accessToken={{user.response.body.access_token}}
@refreshToken={{user.response.body.refresh_token}}
O URL de autorização, usado para iniciar o fluxo de consentimento, será enviado a cada usuário cujos dados você quer acessar. Para criar o URL de autorização, precisamos saber qual é o endpoint do Google OAuth e usar os parâmetros de consulta para especificar o ID do cliente, os escopos a que queremos ter acesso e para onde redirecionar o usuário quando ele consentir com os escopos. A documentação completa para criar a string de autorização do Google pode ser encontrada aqui.
O endpoint do OAuth 2.0 do Google está em https://accounts.google.com/o/oauth2/v2/auth. Esse endpoint só pode ser acessado por HTTPS. Conexões HTTP simples são recusadas.
O servidor de autorização do Google aceita muitos parâmetros de string de consulta para que os aplicativos de servidor da Web personalizem o fluxo de autorização. Vamos usar os seguintes parâmetros de consulta obrigatórios: client_id, redirect_uri, response_type e scope. A documentação fornece uma lista de todos os parâmetros de consulta e a descrição deles.
Os valores dos parâmetros de consulta são
| O valor do ID do cliente no console do Google |
| Um endpoint no seu app que processa o código de autorização. Para o codelab, use https://www.google.com |
|
|
| Os escopos vêm do console do Google com a sintaxe https://www.googleapis.com seguida pelo nome do escopo. Por exemplo, https://www.googleapis.com/auth/googlehealth.activity_and_fitness. |
Depois das variáveis, escreva o URL de autorização, conforme mostrado. Os parâmetros definidos na parte de cima do projeto não podem ser usados na string de autorização. Portanto, precisamos incluir os valores de client_id e redirect_uri. Substitua a string client-id pelo ID do cliente.
### Google Health API Rest Client Example
### Authorization String
https://accounts.google.com/o/oauth2/v2/auth?client_id=client-id&redirect_uri=https://www.google.com&response_type=code&access_type=offline&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly
Quando um usuário dá consentimento, o Google fornece um código de autorização que você troca por um token de acesso chamando o endpoint de token do Google. Adicione a seguinte definição para chamar o endpoint de token em Codelab.http abaixo da string de autorização. Na próxima etapa, você vai substituir authorization-code por um código de autorização.
### AUTHORIZATION ENDPOINTS
######################################################################
# @name user
POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded
code=authorization-code&client_id={{clientId}}&client_secret={{secret}}&redirect_uri={{redirect_uri}}&grant_type=authorization_code
@name user se refere ao usuário atual cujos dados você está acessando.
4. Autorizar uma conta e receber tokens
Agora vamos analisar o fluxo de autorização para conseguir tokens de autorização.
A string de autorização em Codelab.http é usada para iniciar o fluxo de consentimento baseado em navegador do Google. A extensão Rest Client pode mostrar um link Enviar solicitação para esse URL. Não use Enviar solicitação para esse URL específico. Em vez disso, copie e cole no navegador ou use Ctrl+clique (Windows/Linux) ou Cmd+clique (Mac) no VS Code para abrir no navegador padrão.
https://accounts.google.com/o/oauth2/v2/auth?client_id=client-id&redirect_uri=https://www.google.com&response_type=code&access_type=offline&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly
- Será necessário fazer login na sua Conta do Google. Faça login usando uma das contas de usuário de teste configuradas na seção Adicionar usuários de teste.
- Talvez apareça uma mensagem informando que o app não foi verificado. Isso acontece porque o app não foi publicado. Pressione "Continuar".
- A página de consentimento lista os escopos que estão sendo solicitados. O usuário pode selecionar os escopos que quer compartilhar com o app. Clique em "Continuar".
Depois de consentir em compartilhar os escopos solicitados, você será redirecionado para o redirect_uri especificado (neste codelab, https://www.google.com). O Google anexa um código de autorização e outros parâmetros ao redirect_uri. Portanto, o URL na barra de endereço do navegador deve ser parecido com este:
https://www.google.com/?code=4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly
O código de autorização é o valor alfanumérico entre "code=" e "&scope". No exemplo acima, o valor é:
4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw
Em um app de produção, o servidor analisaria isso dos parâmetros de URL. Para este codelab, copie o código de autorização do URL no navegador.
Agora, troque esse código de autorização por um access_token e um refresh_token. Em Codelab.http, substitua authorization-code no corpo da solicitação POST /token pelo código de autorização copiado.
POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded
code=authorization-code&client_id={{client_id}}&client_secret={{secret}}&redirect_uri={{redirect_uri}}&grant_type=authorization_code
Clique no link Enviar pedido logo acima da linha POST https://oauth2.googleapis.com/token.
Sua resposta deve ser parecida com esta:
{
"access_token": "ya29.a0ATi6K2uasci7FyyIClNLtQou6z...",
"expires_in": 3599,
"refresh_token": "1//05EuqYpEXjJCHCgYIA...",
"scope": "https://www.googleapis.com/auth/googlehealth.activity_and_fitness",
"token_type": "Bearer",
"refresh_token_expires_in": 604799
}
Quando você recebe essa resposta, o Rest Client preenche automaticamente as variáveis @accessToken e @refreshToken definidas na parte de cima de Codelab.http para uso em solicitações subsequentes.
Sobre tokens de atualização
Ao trocar o código de autorização, a resposta pode incluir um refresh_token além do access_token. Os access_tokens são de curta duração (normalmente uma hora). Quando um access_token expira, você precisa usar o refresh_token para conseguir um novo access_token sem exigir que o usuário faça login ou dê consentimento novamente. Isso é possível porque incluímos access_type=offline na nossa solicitação de autorização.
Se você não receber um refresh_token na resposta, talvez seja porque já concedeu consentimento para esse app e esses escopos. Os tokens de atualização geralmente são emitidos apenas na primeira vez que um usuário concede consentimento ao app ou quando prompt=consent é adicionado ao URL de autorização para forçar a exibição da tela de permissão mesmo em autorizações subsequentes.
O refresh_token é de longa duração, mas pode expirar ou se tornar inválido se não for usado por seis meses, se o usuário revogar o acesso ao seu app ou por outros motivos. Armazene refresh_token com segurança para uso futuro.
Para mais detalhes, consulte Como atualizar um token de acesso (off-line).
5. Adicionar dados ao app Fitbit móvel
Para novos usuários do Fitbit, talvez você não tenha dados na sua conta para consultar. Vamos adicionar manualmente um registro de exercícios que pode ser consultado por um dos endpoints. Para registrar um exercício manualmente, siga estas etapas:
- Abra o app Fitbit móvel no seu dispositivo. Faça login na sua conta do Fitbit, se necessário.
- No canto inferior direito da tela, toque no botão +.
- Na seção "Registrar manualmente", toque em Atividade.
- Pesquise e selecione o tipo de exercício Caminhada.
- Insira um horário de início para hoje.
- Mude a duração para 15 minutos.
- Deixe a distância 1,6 km.
- Toque em Adicionar.
- Pressione e deslize para baixo na tela para sincronizar o app para dispositivos móveis com os servidores da Fitbit. Quando você soltar o dedo, o app para dispositivos móveis será sincronizado.
- Na seção "Atividade", você vai encontrar a entrada de caminhada registrada manualmente.
6. Recuperar dados usando o método "list"
Para chamar o método list, adicione o seguinte código a Codelab.http, logo abaixo do endpoint /token.
### users.dataTypes.dataPoints
#####################################################
### LIST exercise
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints
Authorization: Bearer {{accessToken}}
Accept: application/json
Esse código chama o endpoint list para mostrar as etapas registradas pelo usuário na conta do Fitbit. A contagem de passos de cada minuto será retornada na resposta, assim como no endpoint "Atividade intraday" da API Fitbit Web v1.
Para executar a chamada, pressione o link Enviar solicitação do endpoint GET. Sua resposta deve ser parecida com esta:
{
"dataPoints": [
{
"name": "users/2515055256096816351/dataTypes/exercise/dataPoints/8896720705097069096",
"dataSource": {
"recordingMethod": "MANUAL",
"platform": "FITBIT"
},
"exercise": {
"interval": {
"startTime": "2026-02-23T13:10:00Z",
"startUtcOffset": "-18000s",
"endTime": "2026-02-23T13:25:00Z",
"endUtcOffset": "-18000s"
},
"exerciseType": "WALKING",
"metricsSummary": {
"caloriesKcal": 16,
"distanceMillimiters": 1609344,
"steps": "2038",
"averagePaceSecondsPerMeter": 0.55923407301360051,
"activeZoneMinutes": "0"
},
"exerciseMetadata": {},
"displayName": "Walk",
"activeDuration": "900s",
"exerciseEvents": [
{
"eventTime": "2026-02-23T13:10:00Z",
"eventUtcOffset": "-18000s",
"exerciseEventType": "START"
},
{
"eventTime": "2026-02-23T13:25:00Z",
"eventUtcOffset": "-18000s",
"exerciseEventType": "STOP"
}
],
"updateTime": "2026-02-24T01:19:22.450466Z"
}
},
{
"name": "users/2515055256096816351/dataTypes/exercise/dataPoints/5870930690409355408",
"dataSource": {
"recordingMethod": "MANUAL",
"platform": "FITBIT"
},
"exercise": {
"interval": {
"startTime": "2026-02-23T06:00:00Z",
"startUtcOffset": "-18000s",
"endTime": "2026-02-23T06:15:00Z",
"endUtcOffset": "-18000s"
},
"exerciseType": "WALKING",
"metricsSummary": {
"caloriesKcal": 17,
"distanceMillimiters": 1609344,
"steps": "2038",
"averagePaceSecondsPerMeter": 0.55923407301360051,
"averageHeartRateBeatsPerMinute": "81",
"activeZoneMinutes": "0",
"heartRateZoneDurations": {
"lightTime": "900s"
}
},
"exerciseMetadata": {},
"displayName": "Walk",
"activeDuration": "900s",
"exerciseEvents": [
{
"eventTime": "2026-02-23T06:00:00Z",
"eventUtcOffset": "-18000s",
"exerciseEventType": "START"
},
{
"eventTime": "2026-02-23T06:15:00Z",
"eventUtcOffset": "-18000s",
"exerciseEventType": "STOP"
}
],
"updateTime": "2026-02-23T08:29:39.480437Z"
}
}
],
"nextPageToken": ""
}
Muitos endpoints aceitam parâmetros de consulta para filtragem ou paginação. Por exemplo, o exercício aceita o filtro interval.civil_start_time. Adicione a seguinte solicitação a Codelab.http para listar exercícios em um período específico:
### LIST exercise >= civil start time
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints?filter=exercise.interval.civil_start_time >= "2026-02-22T00:00:00"
Authorization: Bearer {{accessToken}}
Accept: application/json
7. Parabéns
Parabéns!
Você concluiu o codelab básico e aprendeu a usar o Visual Studio Code e a extensão Rest Client para testar a autorização do OAuth 2.0 e fazer chamadas para endpoints da API Google Health. Nesse ponto, você pode adicionar os endpoints extras da mesma forma que fez no início da seção Recuperar dados usando o método "List".
Esperamos que você goste de criar apps que se integram ao ecossistema da API Google Health. Para mais informações, confira outros endpoints da API Google Health na documentação de referência e saiba mais sobre o OAuth 2.0 do Google para aplicativos de servidor da Web.