API Maps Static: acessar uma chave de API e uma assinatura

Observação: o plano Premium da Plataforma Google Maps não está mais disponível para inscrições ou novos clientes.

Escolher um método de autenticação

Para utilizar a Plataforma Google Maps, é preciso autenticar solicitações com uma chave de API e uma assinatura digital OU um ID do cliente e uma assinatura digital. Para minimizar o uso de IDs do cliente no seu código, utilize uma chave de API e uma assinatura digital, se possível.

Os métodos de autenticação disponíveis são definidos com base na sua licença:

  • Os clientes com o plano Premium podem usar uma chave de API e uma assinatura digital OU um ID do cliente e uma assinatura digital.
  • Os clientes com uma licença anterior precisam usar um ID do cliente e uma assinatura digital.

Para escolher o método de autenticação a ser usado, considere o seguinte:

  • Chave de API (plano Premium, preferencial) – usando uma chave de API para autenticar as solicitações, você fazer o seguinte:
    • Gerenciar todas as suas APIs na página APIs no Console do Google Cloud
    • Acessar dados de uso em tempo real e dados históricos dos últimos 30 dias no Console do Cloud
    • Adicionar o parâmetro channel às solicitações para ver relatórios de uso mais detalhados
    • Ver relatórios de uso com mais de 30 dias de dados no Console do Google Cloud
    • Restringir sua chave de API para evitar uso indevido
  • ID do cliente (plano Premium ou licença anterior) – usando o ID do cliente para autenticar as solicitações, você pode fazer o seguinte:
    • Adicionar o parâmetro channel às solicitações para ver relatórios de uso mais detalhados
    • Ver relatórios de uso com mais de 30 dias de dados no Console do Google Cloud
    • Usar as ferramentas de análise do Google Maps para a API Maps JavaScript

Autenticação usando uma chave de API e uma assinatura digital

Criar chaves de API

Você precisa ter pelo menos uma chave de API associada ao projeto.

Para acessar uma chave de API, faça o seguinte:

  1. Acesse o Console do Cloud.
  2. Abra a lista suspensa e selecione o projeto criado quando você adquiriu o plano Premium. O nome do projeto começa com APIs Google Maps for Business, Google Maps for Work ou Google Maps.
  3. Observação: para ter acesso total aos recursos do plano, os clientes Premium precisam usar o projeto associado a essa conta. Ao comprar sua licença, você recebeu o nome do recurso Premium no seguinte formato: gme-[company] > proj-[number] ([type]). Para garantir que você esteja acessando o projeto correto, faça login no Console como proprietário usando o link console.cloud.google.com/project/number (substitua number pelo número do seu projeto). Você encontrará o proprietário do projeto na mensagem de boas-vindas.

  4. Clique no botão de menu e escolha Plataforma Google Maps > Credenciais.
  5. Na página Credenciais, clique em Criar credenciais > Chave de API.
    A caixa de diálogo Chave de API criada exibe sua nova chave (uma string criptografada).
  6. Clique em Fechar.
    A nova chave aparecerá na página Credenciais, em Chaves de API.

Adicionar a chave de API à solicitação

Você precisa incluir uma chave de API em todas as solicitações da Plataforma Google Maps. No exemplo a seguir, substitua YOUR_API_KEY pela sua chave.

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

O HTTPS é obrigatório e recomendado, respectivamente, para solicitações que usam uma chave de API e que usam um ID do cliente. Este protocolo também é necessário para aplicativos que incluem dados confidenciais de usuários nas solicitações, como a localização.

Restringir chaves de API

Essa ação aumenta a segurança do aplicativo, garantindo que somente solicitações autorizadas sejam feitas com sua chave de API. Recomendamos que você siga as instruções para definir restrições nessas chaves. Para mais informações, consulte Práticas recomendadas de segurança da API.

Para restringir uma chave de API, faça o seguinte:

  1. Acesse a página Plataforma Google Maps > Credenciais.

    Acessar a página "Credenciais"

  2. Selecione a chave de API em que você quer definir uma restrição. A página de propriedades será exibida.
  3. Em Restrições de chave, defina as seguintes opções:
    • Restrições do aplicativo:
      1. Para aceitar as solicitações da lista de sites que você informou, selecione Referenciadores HTTP (sites da Web) na lista de Restrições do aplicativo.
      2. Especifique um ou mais sites de referenciadores. Por exemplo, *.google.com aceita todos os sites que terminam em google.com, como https://developers.google.com.

        Observação: os referenciadores de file:// precisam de uma representação especial para serem adicionados à restrição de chave. A parte "file://" precisa ser substituída por "__file_url__" antes de ser incluída. Por exemplo, "file:///path/to/" precisa ser formatado como "__file_url__//path/to/*". Depois de ativar os referenciadores de file://, é recomendável verificá-los regularmente para garantir que eles atendam às suas expectativas.

    • Restrições de API:
      1. Clique em Restringir chave.
      2. Escolha Plataforma Google Maps no menu suspenso Selecionar APIs. Se a Plataforma Google Maps não aparecer na lista, será preciso ativá-la.
  4. Para concluir as mudanças, clique em Salvar.

Gerar uma assinatura digital

As solicitações para a Plataforma Google Maps que usam um parâmetro key com uma chave de API também precisam incluir um parâmetro signature, contendo uma assinatura digital gerada com uma Chave secreta de assinatura do URL compartilhada. Sua chave secreta compartilhada está disponível no Console do Google Cloud.

O processo de assinatura usa um algoritmo de criptografia para combinar o URL e a chave secreta compartilhada. A assinatura exclusiva resultante permite que nossos servidores confirmem que qualquer site que gere solicitações usando sua chave de API tenha autorização para fazê-lo.

Criar uma assinatura digital é um processo de duas etapas:

Etapa 1: gerar a Chave secreta de assinatura do URL

Sua Chave secreta de assinatura do URL criptográfica está disponível no Console do Cloud. Essa chave, também conhecida como chave privada, é codificada no formato Base64 modificado para URLs. Ela é compartilhada entre você e o Google e é exclusiva para a chave de API. Mantenha a chave secreta de assinatura do URL em segurança. Não a inclua em solicitações, armazene em sites nem publique em fóruns públicos. Qualquer pessoa que tenha acesso a essa chave pode falsificar solicitações usando sua identidade.

Confira sua Chave secreta de assinatura do URL nesta página no Console do Cloud. Importante: selecione o projeto criado quando você adquiriu o plano Premium.

Como alternativa, siga estas etapas para acessar sua Chave secreta de assinatura do URL:

  1. Acesse o Console do Cloud.
  2. Clique na lista suspensa e selecione o projeto criado quando você adquiriu o plano Premium. O nome do projeto começa com APIs Google Maps for Business, Google Maps for Work ou Google Maps.
  3. Na lista de APIs da página do painel, clique no nome da Plataforma Google Maps. Os detalhes da API serão exibidos na guia Visão geral.
  4. Clique na guia Chave secreta de assinatura do URL.

Para gerar um nova chave secreta de assinatura do URL, clique em Gerar chave secreta novamente. A chave anterior expira 24 horas após a criação de uma nova. Após esse período, as solicitações que contiverem a chave antiga deixarão de funcionar.

Etapa 2: gerar uma assinatura digital

Para criar uma assinatura digital a ser usada na sua solicitação, consulte Gerar uma assinatura digital com uma chave de API.

Autenticação usando um ID do cliente e uma assinatura digital

Noções básicas sobre o ID do cliente e a chave criptográfica

Após adquirir sua licença do plano Premium da Plataforma Google Maps, você receberá um e-mail de boas-vindas do Google que inclui o ID do cliente e sua chave criptográfica privada.

  • O ID do cliente é usado para acessar os recursos especiais do plano Premium da Plataforma Google Maps. No exemplo abaixo, substitua YOUR_CLIENT_ID pelo ID do cliente que você recebeu por e-mail. Todos os IDs de cliente começam com o prefixo gme-.

  • Sua chave criptográfica privada é usada para gerar uma assinatura digital exclusiva. No exemplo de código abaixo, substitua SIGNATURE pela assinatura digital exclusiva. Para mais informações, consulte Como gerar uma assinatura digital com um ID do cliente.

    <img src="https://maps.googleapis.com/maps/api/staticmap
      ?center=-15.800513,-47.91378
      &zoom=11
      &size=300x300
      &client=YOUR_CLIENT_ID
      &signature=SIGNATURE">

Se você perdeu seu ID do cliente ou a chave criptográfica privada, é possível recuperá-los fazendo login no Console do Google Cloud e clicando em Maps: gerenciar ID do cliente nos links à esquerda da página.

Parâmetro opcional para relatórios

Ao usar um ID do cliente para autenticação de API, o parâmetro opcional a seguir fica disponível para uso:

Gerar uma assinatura digital

Se quiser criar uma assinatura digital para sua solicitação, consulte Gerar uma assinatura digital com um ID do cliente.

Assinaturas digitais

Como funcionam as assinaturas digitais

As assinaturas digitais são geradas usando uma Chave secreta de assinatura do URL criptográfica, disponível no Console do Google Cloud. Essa chave, também conhecida como chave privada, é codificada no formato Base64 modificado para URLs. Ela é compartilhada entre você e o Google e é exclusiva para a chave de API.

O processo de assinatura usa um algoritmo de criptografia para combinar o URL e a chave secreta compartilhada. Com a assinatura exclusiva resultante, nossos servidores podem confirmar se os sites que geram solicitações usando sua chave de API têm autorização para fazer isso.

Você pode gerar uma assinatura digital usando uma chave de API ou um ID do cliente.

Gerar uma assinatura digital com uma chave de API

Siga as etapas abaixo para criar uma assinatura digital para uso com uma chave de API:

  1. Crie o URL da solicitação sem a assinatura, incluindo sua chave de API no parâmetro key. Todos os caracteres não padrão precisam ser codificados para uso em URL. Exemplo:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

    Observação: todos os Serviços do Google exigem codificação de caracteres UTF-8 (que inclui implicitamente ASCII). Se os seus aplicativos operam usando outros conjuntos de caracteres, gere os URLs usando UTF-8 e codifique-os no formato URL.

  2. Remova a parte do domínio da solicitação, deixando apenas o caminho e a consulta:

    /maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

  3. No Console do Cloud, encontre a Chave secreta de assinatura do URL, que é codificada em Base64 modificado para URLs, e assine o URL acima usando o algoritmo HMAC-SHA1 (consulte Gerar sua Chave secreta de assinatura do URL).

    Talvez seja necessário decodificar a chave secreta para o formato binário original. Na maioria das bibliotecas criptográficas, a assinatura resultante está em formato binário.

    Observação: o padrão Base64 modificado para URLs substitui os caracteres + e / por - e _, respectivamente, para que essas assinaturas Base64 não precisem mais ser codificadas para uso em URLs.

  4. Codifique a assinatura binária resultante usando o Base64 modificado para URLs. Assim, você a converte em um formato que pode ser transmitido por URL.

  5. Adicione a assinatura resultante ao URL de solicitação em um parâmetro signature. Por exemplo:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY&signature=BASE64_SIGNATURE

Para ver exemplos de como implementar a assinatura de URL usando o código do lado do servidor, consulte Exemplo de código para assinatura de URL.

Para assinar um URL agora, insira o URL e a chave secreta de assinatura dele abaixo. O URL precisa ter o formato descrito na etapa 1 acima e ser codificado para uso em URL.

Gerar uma assinatura digital com um ID do cliente

As solicitações para a API Static Maps que usam o parâmetro client também exigem uma signature digital, gerada com a chave criptográfica privada informada a você no e-mail de boas-vindas.

O processo de assinatura combina um URL e a chave usando um algoritmo criptográfico. A assinatura exclusiva resultante permite que nossos servidores verifiquem se qualquer site que gera solicitações usando seu ID do cliente está autorizado a fazer isso. A assinatura também é exclusiva por URL, garantindo que as solicitações que usem seu ID não possam ser modificadas sem que uma nova assinatura seja gerada.

Sua chave criptográfica privada

A chave criptográfica de assinatura de URL privada será emitida com seu ID do cliente e é uma "chave secreta compartilhada" entre você e o Google. Ela é somente sua e é exclusiva para cada ID do cliente. Por isso, mantenha-a em segurança. Essa chave não deve ser informada em solicitações, armazenada em sites nem publicada em fóruns públicos. Qualquer pessoa que tenha essa chave de assinatura pode fazer solicitações usando sua identidade.

Observação: essa chave criptográfica privada de assinatura não é igual às chaves de API emitidas pelo Console do Cloud.

Se você perdeu sua chave, faça login no Console do Cloud e selecione Maps: gerenciar ID do cliente para recuperá-la.

Gerar uma assinatura digital com um ID do cliente

A tentativa de acessar a API Static Maps com uma assinatura inválida resultará em um erro HTTP 403 (proibido). Quando converter seus aplicativos para usar uma assinatura de URL, teste as assinaturas para garantir que elas iniciam uma solicitação válida. Primeiro, você precisa verificar se o URL original é válido e se você gerou as assinaturas corretas.

Siga estas etapas se quiser criar uma assinatura digital para sua solicitação:

  1. Gere o URL da solicitação sem a assinatura, incluindo o parâmetro client. Todos os caracteres que não forem padrão terão que ser codificados para uso em URL:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID

    Observação: todos os Serviços do Google exigem codificação de caracteres UTF-8 (que inclui implicitamente ASCII). Se os seus aplicativos operarem usando outros conjuntos de caracteres, gere os URLs com UTF-8 e codifique-os para uso em URL.

  2. Remova a parte do domínio da solicitação, deixando apenas o caminho e a consulta:

    /maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID

  3. Recupere a chave privada, que é codificada em Base64 modificado para URLs, e assine o URL acima usando o algoritmo HMAC-SHA1. Talvez seja necessário decodificar essa chave no formato binário original dela. Na maioria das bibliotecas criptográficas, a assinatura gerada estará em formato binário.

    Observação: o padrão Base64 modificado para URLs substitui os caracteres + e / por - e _, respectivamente, para que essas assinaturas Base64 não precisem mais ser codificadas para uso em URLs.

  4. Codifique a assinatura binária resultante usando o Base64 modificado para URLs. Assim, você a converte em um formato que pode ser transmitido por URL.

  5. Anexe essa assinatura ao URL dentro de um parâmetro signature:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID&signature=base64signature

Para ver exemplos de como implementar a assinatura de URL usando o código do lado do servidor, consulte Exemplo de código para assinatura de URL.

Para assinar um URL agora, insira o URL e a chave secreta de assinatura dele abaixo. O URL precisa ter o formato descrito na etapa 1 acima e ser codificado para uso em URL.

Exemplo de código para assinatura de URL

As seções a seguir mostram como implementar a assinatura de URL usando o código do lado do servidor. Os URLs precisam ser assinados do lado do servidor para evitar a exposição da sua chave criptográfica aos usuários.

Python

O exemplo abaixo usa bibliotecas Python padrão para assinar um URL. Faça o download do código (link em inglês).

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" Signs a URL using a URL signing secret """

import hashlib
import hmac
import base64
import urllib.parse as urlparse

def sign_url(input_url=None, secret=None):
    """ Sign a request URL with a URL signing secret.
      Usage:
      from urlsigner import sign_url
      signed_url = sign_url(input_url=my_url, secret=SECRET)
      Args:
      input_url - The URL to sign
      secret    - Your URL signing secret
      Returns:
      The signed request URL
  """

    if not input_url or not secret:
        raise Exception("Both input_url and secret are required")

    url = urlparse.urlparse(input_url)

    # We only need to sign the path+query part of the string
    url_to_sign = url.path + "?" + url.query

    # Decode the private key into its binary format
    # We need to decode the URL-encoded private key
    decoded_key = base64.urlsafe_b64decode(secret)

    # Create a signature using the private key and the URL-encoded
    # string using HMAC SHA1. This signature will be binary.
    signature = hmac.new(decoded_key, str.encode(url_to_sign), hashlib.sha1)

    # Encode the binary signature into base64 for use within a URL
    encoded_signature = base64.urlsafe_b64encode(signature.digest())

    original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query

    # Return signed URL
    return original_url + "&signature=" + encoded_signature.decode()

if __name__ == "__main__":
    input_url = input("URL to Sign: ")
    secret = input("URL signing secret: ")
    print("Signed URL: " + sign_url(input_url, secret))

Java

O exemplo abaixo usa a classe java.util.Base64 disponível desde o JDK 1.8. Talvez as versões mais antigas precisem usar o Apache Commons ou similar. Faça o download do código (link em inglês).

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;  // JDK 1.8 only - older versions may need to use Apache Commons or similar.
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class UrlSigner {

  // Note: Generally, you should store your private key someplace safe
  // and read them into your code

  private static String keyString = "YOUR_PRIVATE_KEY";

  // The URL shown in these examples is a static URL which should already
  // be URL-encoded. In practice, you will likely have code
  // which assembles your URL from user or web service input
  // and plugs those values into its parameters.
  private static String urlString = "YOUR_URL_TO_SIGN";

  // This variable stores the binary key, which is computed from the string (Base64) key
  private static byte[] key;

  public static void main(String[] args) throws IOException,
    InvalidKeyException, NoSuchAlgorithmException, URISyntaxException {

    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

    String inputUrl, inputKey = null;

    // For testing purposes, allow user input for the URL.
    // If no input is entered, use the static URL defined above.
    System.out.println("Enter the URL (must be URL-encoded) to sign: ");
    inputUrl = input.readLine();
    if (inputUrl.equals("")) {
      inputUrl = urlString;
    }

    // Convert the string to a URL so we can parse it
    URL url = new URL(inputUrl);

    // For testing purposes, allow user input for the private key.
    // If no input is entered, use the static key defined above.
    System.out.println("Enter the Private key to sign the URL: ");
    inputKey = input.readLine();
    if (inputKey.equals("")) {
      inputKey = keyString;
    }

    UrlSigner signer = new UrlSigner(inputKey);
    String request = signer.signRequest(url.getPath(),url.getQuery());

    System.out.println("Signed URL :" + url.getProtocol() + "://" + url.getHost() + request);
  }

  public UrlSigner(String keyString) throws IOException {
    // Convert the key from 'web safe' base 64 to binary
    keyString = keyString.replace('-', '+');
    keyString = keyString.replace('_', '/');
    System.out.println("Key: " + keyString);
    // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar.
    this.key = Base64.getDecoder().decode(keyString);
  }

  public String signRequest(String path, String query) throws NoSuchAlgorithmException,
    InvalidKeyException, UnsupportedEncodingException, URISyntaxException {

    // Retrieve the proper URL components to sign
    String resource = path + '?' + query;

    // Get an HMAC-SHA1 signing key from the raw key bytes
    SecretKeySpec sha1Key = new SecretKeySpec(key, "HmacSHA1");

    // Get an HMAC-SHA1 Mac instance and initialize it with the HMAC-SHA1 key
    Mac mac = Mac.getInstance("HmacSHA1");
    mac.init(sha1Key);

    // compute the binary signature for the request
    byte[] sigBytes = mac.doFinal(resource.getBytes());

    // base 64 encode the binary signature
    // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar.
    String signature = Base64.getEncoder().encodeToString(sigBytes);

    // convert the signature to 'web safe' base 64
    signature = signature.replace('+', '-');
    signature = signature.replace('/', '_');

    return resource + "&signature=" + signature;
  }
}

Node JS

O exemplo abaixo usa módulos nativos do Node para assinar um URL. Faça o download do código (link em inglês).

'use strict'

const crypto = require('crypto');
const url = require('url');

/**
 * Convert from 'web safe' base64 to true base64.
 *
 * @param  {string} safeEncodedString The code you want to translate
 *                                    from a web safe form.
 * @return {string}
 */
function removeWebSafe(safeEncodedString) {
  return safeEncodedString.replace(/-/g, '+').replace(/_/g, '/');
}

/**
 * Convert from true base64 to 'web safe' base64
 *
 * @param  {string} encodedString The code you want to translate to a
 *                                web safe form.
 * @return {string}
 */
function makeWebSafe(encodedString) {
  return encodedString.replace(/\+/g, '-').replace(/\//g, '_');
}

/**
 * Takes a base64 code and decodes it.
 *
 * @param  {string} code The encoded data.
 * @return {string}
 */
function decodeBase64Hash(code) {
  // "new Buffer(...)" is deprecated. Use Buffer.from if it exists.
  return Buffer.from ? Buffer.from(code, 'base64') : new Buffer(code, 'base64');
}

/**
 * Takes a key and signs the data with it.
 *
 * @param  {string} key  Your unique secret key.
 * @param  {string} data The url to sign.
 * @return {string}
 */
function encodeBase64Hash(key, data) {
  return crypto.createHmac('sha1', key).update(data).digest('base64');
}

/**
 * Sign a URL using a secret key.
 *
 * @param  {string} path   The url you want to sign.
 * @param  {string} secret Your unique secret key.
 * @return {string}
 */
function sign(path, secret) {
  const uri = url.parse(path);
  const safeSecret = decodeBase64Hash(removeWebSafe(secret));
  const hashedSignature = makeWebSafe(encodeBase64Hash(safeSecret, uri.path));
  return url.format(uri) + '&signature=' + hashedSignature;
}

C#

No exemplo abaixo, a biblioteca padrão System.Security.Cryptography é usada para assinar uma solicitação de URL. É preciso converter a codificação Base64 padrão para implementar uma versão compatível com URL. Faça o download do código (link em inglês).

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;

namespace SignUrl {

  public struct GoogleSignedUrl {

    public static string Sign(string url, string keyString) {
      ASCIIEncoding encoding = new ASCIIEncoding();

      // converting key to bytes will throw an exception, need to replace '-' and '_' characters first.
      string usablePrivateKey = keyString.Replace("-", "+").Replace("_", "/");
      byte[] privateKeyBytes = Convert.FromBase64String(usablePrivateKey);

      Uri uri = new Uri(url);
      byte[] encodedPathAndQueryBytes = encoding.GetBytes(uri.LocalPath + uri.Query);

      // compute the hash
      HMACSHA1 algorithm = new HMACSHA1(privateKeyBytes);
      byte[] hash = algorithm.ComputeHash(encodedPathAndQueryBytes);

      // convert the bytes to string and make url-safe by replacing '+' and '/' characters
      string signature = Convert.ToBase64String(hash).Replace("+", "-").Replace("/", "_");

      // Add the signature to the existing URI.
      return uri.Scheme+"://"+uri.Host+uri.LocalPath + uri.Query +"&signature=" + signature;
    }
  }

  class Program {

    static void Main() {

      // Note: Generally, you should store your private key someplace safe
      // and read them into your code

      const string keyString = "YOUR_PRIVATE_KEY";

      // The URL shown in these examples is a static URL which should already
      // be URL-encoded. In practice, you will likely have code
      // which assembles your URL from user or web service input
      // and plugs those values into its parameters.
      const  string urlString = "YOUR_URL_TO_SIGN";

      string inputUrl = null;
      string inputKey = null;

      Console.WriteLine("Enter the URL (must be URL-encoded) to sign: ");
      inputUrl = Console.ReadLine();
      if (inputUrl.Length == 0) {
        inputUrl = urlString;
      }

      Console.WriteLine("Enter the Private key to sign the URL: ");
      inputKey = Console.ReadLine();
      if (inputKey.Length == 0) {
        inputKey = keyString;
      }

      Console.WriteLine(GoogleSignedUrl.Sign(inputUrl,inputKey));
    }
  }
}

Exemplos em outras linguagens

Veja outros exemplos de linguagens no projeto url-signing.

Resolver problemas de autenticação

Se a sua solicitação estiver incorreta ou fornecer uma assinatura inválida, a Plataforma Google Maps retornará um erro HTTP 403 (Forbidden).

Para resolver problemas de URLs específicos, use o depurador de assinaturas de URL. Com ele, você pode validar rapidamente um URL e uma assinatura gerada pelo seu aplicativo.

Os clientes do plano Premium também podem resolver problemas de URLs específicos fazendo login no Console do Cloud e selecionando Recursos > Ferramentas on-line do plano Premium da Plataforma Google Maps > Depurador de assinaturas de URL para as APIs Web Service e Image.