Java 8 Runtime Environment

Com o App Engine, é possível criar aplicativos da Web para usar a infraestrutura e os serviços escalonáveis do Google. O App Engine executa seu aplicativo da Web usando uma JVM Java 8. Ele também invoca as classes de servlet do aplicativo para processar solicitações e preparar respostas nesse ambiente.

A plataforma do App Engine oferece muitos serviços de API integrados que podem ser chamados por seu código. Por meio de seu aplicativo, também é possível configurar tarefas agendadas que são executadas em intervalos especificados.

Como especificar o tempo de execução do Java 8 para seu aplicativo

Para que o aplicativo use o ambiente de execução do Java 8, adicione a seguinte linha ao arquivo appengine-web.xml:

<runtime>java8</runtime>

Os aplicativos existentes do App Engine que usam atualmente o ambiente de execução do Java 7 serão executados no ambiente de execução do Java 8 com essa simples alteração.

Melhorias e upgrades no ambiente de execução do Java 8

O ambiente de execução do Java 8 do App Engine, baseado no OpenJDK 8, é compatível com todos os recursos existentes e disponíveis no ambiente de execução atual do Java 7, que é baseado no OpenJDK 7, mas com os upgrades e melhorias abaixo:

  • Não impõe um gerenciador de segurança como o ambiente de execução do Java 7 faz, o que significa que seu código não será restringido por problemas de permissões do Java.
  • Oferece suporte a todas as bibliotecas públicas padrão do Java.
  • Usa o Jetty 9.
  • É compatível com as especificações Java Servlet 3.1 e Java Servlet 2.5 (ambos em inglês).
  • É compatível com todas as APIs do Google Cloud, acessadas por meio da Biblioteca de cliente do Google Cloud para Java.

Introdução

Como selecionar o ambiente de execução do Java 8

A API App Engine para Java é representada pelo appengine-api-*.jar incluído no SDK do App Engine como parte do SDK do Cloud, em que * representa a versão da API e do SDK do App Engine.

Selecione a versão da API usada pelo aplicativo incluindo esse JAR no diretório WEB-INF/lib/ do aplicativo. Se preferir, use o Maven para processar as dependências. Se uma nova versão do ambiente de execução do Java for lançada, que inclua mudanças incompatíveis com os aplicativos atuais, esse ambiente terá um novo número de versão principal.

Como usar o Maven para lidar com dependências

Você pode usar o Maven para gerenciar todas as dependências. Por exemplo, a entrada pom.xml inclui a mais recente API App Engine (Rappengine-api-1.0-sdk) disponível na central do Maven:

<dependency>
    <groupId>com.google.appengine</groupId>
    <artifactId>appengine-api-1.0-sdk</artifactId>
    <version><span class="notranslate exporttrans-dynamic">print setvar.appengine_java_version</span></version>
</dependency>

O sandbox

O ambiente de execução do Java App Engine distribui pedidos de aplicativos em vários servidores da Web e impede que um aplicativo interfira com outro. Um aplicativo do App Engine não pode responder lentamente. Uma solicitação da Web para um aplicativo precisa ser processada em 60 segundos (10 minutos para solicitações do TaskQueue). Os processos que excedem esse limite são finalizados para evitar a sobrecarga do servidor da web.

Observe que o único lugar em que os usuários podem gravar arquivos é no diretório /tmp. Arquivos em /tmp consumirão a memória alocada para sua instância. Os arquivos armazenados nesse local estão disponíveis somente para essa instância durante a vida útil dela.

A maneira usual de o aplicativo receber arquivos de recursos é empacotar os arquivos de que você depende com seu aplicativo em WEB-INF e, em seguida, carregá-los do aplicativo usando Class.getResource(), ServletContext.getResource() ou métodos semelhantes. Por padrão, todos os arquivos no WAR são "arquivos de recursos". Você pode excluir arquivos desse conjunto usando o arquivo appengine-web.xml.

Ordenação de JAR do carregador de classe

Às vezes, pode ser necessário redefinir a ordem em que as classes são verificadas nos arquivos JAR para resolver conflitos entre os nomes das classes. Nesses casos, a prioridade de carregamento pode ser concedida a arquivos JAR específicos adicionando um elemento <class-loader-config> que contém elementos <priority-specifier> no arquivo appengine-web.xml. Exemplo:

<class-loader-config>
  <priority-specifier filename="mailapi.jar"/>
</class-loader-config>

Isso coloca "mailapi.jar" como o primeiro arquivo JAR em que as classes serão pesquisadas, excluindo os arquivos no diretório war/WEB-INF/classes/.

Se vários arquivos JAR forem priorizados, a ordem de carregamento original deles (em relação um ao outro) será usada. Em outras palavras, a ordem dos próprios elementos <priority-specifier> não importa.

Segmentos

Com o ambiente de execução do Java 8, é possível criar linhas de execução usando a API ThreadManager do App Engine e as APIs integradas do Java, como new Thread(). Atualmente, se quiser chamar as APIs do App Engine (com.google.appengine.api.*), faça isso a partir de uma linha de execução de solicitação ou de uma linha de execução criada com a API ThreadManager.

Com um aplicativo, é possível

Se você criar um ThreadPoolExecutor com currentRequestThreadFactory(), o shutdown() (em inglês) precisará ser explicitamente chamado para que a solicitação de servlet seja concluída. Do contrário, a solicitação não será concluída e o servidor de aplicativos falhará. Observe que algumas bibliotecas podem criar ThreadPoolExecutors para você.

Com um aplicativo, é possível executar operações em relação ao thread atual, como thread.interrupt().

Cada solicitação é limitada a 50 segmentos de solicitação simultâneos à App Engine API.

Ao usar linhas de execução, utilize objetos de simultaneidade de alto nível, como Executor e Runnable. Eles cuidam de detalhes sutis, mas importantes, da simultaneidade, como interrupções e agendamento e contabilidade (todos em inglês).

O número máximo de threads simultâneos em segundo plano criados pela API App Engine é de 10 por instância. Esse limite não se aplica a segmentos comuns do Java não relacionados à API App Engine.

Ferramentas

IDEs compatíveis

Com o Cloud Tools for Eclipse, novos assistentes de projeto e configurações de depuração são adicionados ao ambiente de desenvolvimento integrado do Eclipse (em inglês) em projetos do App Engine. Você pode implantar seus projetos do App Engine dinamicamente na produção de dentro do Eclipse.

Com o Cloud Tools for IntelliJ, é possível executar e depurar aplicativos do App Engine no IntelliJ IDEA (em inglês). Os projetos do App Engine podem ser implantados dinamicamente no ambiente de produção sem sair do ambiente de desenvolvimento integrado.

Ferramentas de compilação compatíveis

Para acelerar o processo de desenvolvimento, use os plug-ins do App Engine para Apache Maven ou Gradle:

Servidor de desenvolvimento local

O servidor de desenvolvimento executa seu aplicativo no computador local de desenvolvimento e testes. O servidor simula os serviços do Cloud Datastore. O servidor de desenvolvimento também pode gerar configuração para índices do Cloud Datastore com base nas consultas que o aplicativo executa durante os testes.

AppCfg

O AppCfg está incluído no SDK independente do App Engine para Java. Ele é uma ferramenta multifuncional que lida com a interação da linha de comando com seu aplicativo em execução no App Engine. O AppCfg pode fazer o upload do seu aplicativo no App Engine ou simplesmente atualizar a configuração do índice do Cloud Datastore para que você possa criar novos índices antes de atualizar o código. Ele também faz o download dos dados de registro do app para possibilitar a análise do desempenho do aplicativo usando as próprias ferramentas.

Simultaneidade e latência

A latência do seu aplicativo tem o maior impacto no número de instâncias necessárias para disponibilizar o tráfego. Se você processa solicitações rapidamente, uma única instância pode lidar com muitas solicitações.

As instâncias de thread único podem processar uma solicitação simultânea. Portanto, há uma relação direta entre a latência e número de solicitações que podem ser processadas na instância por segundo. Por exemplo, a latência de 10 ms é igual a 100 pedidos/segundo/instância.

As instâncias com vários threads podem processar várias solicitações simultâneas. Portanto, há uma relação direta entre a CPU consumida e o número de solicitações/segundo.

Os aplicativos Java são compatíveis com solicitações simultâneas, portanto, uma única instância pode processar novas solicitações enquanto aguarda que outras sejam concluídas. A simultaneidade reduz significativamente o número de instâncias que seu aplicativo requer, mas você precisa projetar seu aplicativo para vários threads.

Por exemplo, se uma instância B4 (aproximadamente 2,4 GHz) consome 10 milhões de ciclos/solicitação, você pode processar 240 solicitações/segundo/instância. Se ela consome 100 milhões de ciclos/solicitação, você pode processar 24 solicitações/segundo/instância. Esses números são o caso ideal, mas são bem realistas em termos do que é possível realizar em uma instância.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Ambiente padrão do App Engine para Java 8