Como acessar metadados de instância

O Google Cloud Platform fornece um servidor de metadados com detalhes sobre a instância do App Engine, como o ID do projeto, as contas de serviço e os tokens usados pelas contas do serviço. É possível acessar esses dados usando solicitações HTTP simples, visto que nenhuma biblioteca de cliente é necessária.

Nesta página, mostramos como acessar metadados de instância de um aplicativo Java 8 de ambiente de execução implantado, fazendo chamadas HTTP para os devidos endpoints do servidor de metadados.

Observação: no momento, o acesso a metadados é somente leitura. Portanto, não é possível gravar metadados próprios em uma instância.

Uma maneira útil de usar essa API é receber o token da conta de serviço e fornecê-lo como token do portador no cabeçalho de autorização de uma das APIs Google Cloud, visando autenticar o aplicativo no serviço de API específico. Consulte a documentação da Google Cloud Translation API para ver um exemplo de uso desses tokens do portador.

Como identificar qual endpoint de metadados usar

A tabela a seguir lista os endpoints em que é possível fazer solicitações HTTP para metadados específicos. O servidor de metadados está acessível em http://metadata.google.internal.

Endpoint de metadados	Descrição
/computeMetadata/v1/project/numeric-project-id	Número do projeto atribuído ao seu projeto.
/computeMetadata/v1/project/project-id	ID do projeto atribuído ao seu projeto.
/computeMetadata/v1/instance/zone	Zona em que a instância está em execução.
/computeMetadata/v1/instance/service-accounts/default/aliases
/computeMetadata/v1/instance/service-accounts/default/email	E-mail da conta de serviço padrão atribuído ao seu projeto.
/computeMetadata/v1/instance/service-accounts/default/	Lista todas as contas de serviço padrão do seu projeto.
/computeMetadata/v1/instance/service-accounts/default/scopes	Lista todos os escopos compatíveis com as contas de serviço padrão.
/computeMetadata/v1/instance/service-accounts/default/token	Retorna o token de autenticação que pode ser usado para autenticar o aplicativo em outras Google Cloud APIs.

Por exemplo, para recuperar o código do projeto, envie uma solicitação para http://metadata.google.internal/computeMetadata/v1/project/project-id.

Como fazer solicitações de metadados

Importante: o acesso ao servidor de metadados precisa usar soquetes nativos, como aqueles fornecidos pelo java.net.HttpURLConnection ou pelo url-stream-handler nativo. O servidor de metadados não é compatível com o serviço urlfetch.

O código de amostra a seguir recebe todos os metadados disponíveis para a instância e os exibe, exceto o token da conta do serviço.

@SuppressWarnings("serial")
// With @WebServlet annotation the webapp/WEB-INF/web.xml is no longer required.
@WebServlet(name = "Metadata", description = "Metadata: Write info about GAE Standard",
    urlPatterns = "/metadata")
public class MetadataServlet extends HttpServlet {

  private final String[] metaPath = {
      "/computeMetadata/v1/project/numeric-project-id", //  (pending)
      "/computeMetadata/v1/project/project-id",
      "/computeMetadata/v1/instance/zone",
      "/computeMetadata/v1/instance/service-accounts/default/aliases",
      "/computeMetadata/v1/instance/service-accounts/default/email",
      "/computeMetadata/v1/instance/service-accounts/default/",
      "/computeMetadata/v1/instance/service-accounts/default/scopes",
      // Tokens work - but are a security risk to display
      //      "/computeMetadata/v1/instance/service-accounts/default/token"
  };

  final String[] metaServiceAcct = {
      "/computeMetadata/v1/instance/service-accounts/{account}/aliases",
      "/computeMetadata/v1/instance/service-accounts/{account}/email",
      "/computeMetadata/v1/instance/service-accounts/{account}/scopes",
      // Tokens work - but are a security risk to display
      //     "/computeMetadata/v1/instance/service-accounts/{account}/token"
  };

  private final String metadata = "http://metadata.google.internal";
  private TemplateEngine templateEngine;

  // Use OkHttp from Square as it's quite easy to use for simple fetches.
  private final OkHttpClient ok = new OkHttpClient.Builder()
      .readTimeout(500, TimeUnit.MILLISECONDS)  // Don't dawdle
      .writeTimeout(500, TimeUnit.MILLISECONDS)
      .build();

  // Setup to pretty print returned json
  private final Gson gson = new GsonBuilder()
      .setPrettyPrinting()
      .create();
  private final JsonParser jp = new JsonParser();

  // Fetch Metadata
  String fetchMetadata(String key) throws IOException {
    Request request = new Request.Builder()
        .url(metadata + key)
        .addHeader("Metadata-Flavor", "Google")
        .get()
        .build();

    Response response = ok.newCall(request).execute();
    return response.body().string();
  }

  String fetchJsonMetadata(String prefix) throws IOException {
    Request request = new Request.Builder()
        .url(metadata + prefix)
        .addHeader("Metadata-Flavor", "Google")
        .get()
        .build();

    Response response = ok.newCall(request).execute();

    // Convert json to prety json
    return gson.toJson(jp.parse(response.body().string()));
  }

  @Override
  public void init() {
    // Setup ThymeLeaf
    ServletContextTemplateResolver templateResolver =
        new ServletContextTemplateResolver(this.getServletContext());

    templateResolver.setPrefix("/WEB-INF/templates/");
    templateResolver.setSuffix(".html");
    templateResolver.setCacheTTLMs(Long.valueOf(1200000L)); // TTL=20m

    // Cache is set to true by default. Set to false if you want templates to
    // be automatically updated when modified.
    templateResolver.setCacheable(true);

    templateEngine = new TemplateEngine();
    templateEngine.setTemplateResolver(templateResolver);
  }

  @Override
  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    String defaultServiceAccount = "";
    WebContext ctx = new WebContext(req, resp, getServletContext(), req.getLocale());

    resp.setContentType("text/html");

    String environment =
        (String) System.getProperties().get("com.google.appengine.runtime.environment");
    ctx.setVariable("production", environment);

    // The metadata server is only on a production system
    if (environment.equals("Production")) {

      TreeMap<String, String> m = new TreeMap<>();

      for (String key : metaPath) {
        m.put(key, fetchMetadata(key));
        if (key.contains("default/email")) {
          defaultServiceAccount = m.get(key);
        }
      }

      ctx.setVariable("Metadata", m.descendingMap());

      m = new TreeMap<>();
      for (String key : metaServiceAcct) {
        // substitute a service account for {account}
        key = key.replace("{account}", defaultServiceAccount);
        m.put(key, fetchMetadata(key));
      }
      ctx.setVariable("sam", m.descendingMap());

      // Recursivly get all info about service accounts -- Note tokens are leftout by default.
      ctx.setVariable("rsa",
          fetchJsonMetadata("/computeMetadata/v1/instance/service-accounts/?recursive=true"));
      // Recursivly get all data on Metadata server.
      ctx.setVariable("ram", fetchJsonMetadata("/?recursive=true"));
    }

    templateEngine.process("index", ctx, resp.getWriter());

  }
}

No código de amostra, observe a verificação para assegurar que o aplicativo está em execução na produção. Se o aplicativo estiver em execução localmente, nenhum metadado será retornado das solicitações.

Além disso, observe o uso do serializador/desserializador Google Gson JSON (em inglês), do cliente HTTP e HTTP2 OkHttp (em inglês) e do sistema de modelos Thymeleaf (em inglês). Essas bibliotecas não são obrigatórias, mas são úteis para os projetos.

Como executar no local

O servidor de metadados está disponível para aplicativos implantados. Portanto, a execução local no servidor de desenvolvimento não é compatível. É possível adicionar ao código uma verificação de ambiente para exibir resultados de metadados somente quando o app estiver em execução na produção, conforme indicado no código de amostra abaixo:

String environment =
      (String) System.getProperties().get("com.google.appengine.runtime.environment");
  ctx.setVariable("production", environment);

  // The metadata server is only on a production system
  if (environment.equals("Production")) {
     ... //show metadata results
   }