As instâncias são a base do App Engine e incluem todos os recursos necessários para hospedar o aplicativo com êxito. Em qualquer momento, o aplicativo pode estar em execução em uma ou várias instâncias, com solicitações espalhadas por todas elas. Cada instância inclui uma camada de segurança para garantir que elas não afetem umas às outras de maneira inadvertida.
O App Engine pode criar e encerrar instâncias automaticamente à medida que o tráfego flutua. Também é possível especificar um número de instâncias para executar, independentemente da quantidade de tráfego. Para determinar como e quando novas instâncias são criadas, especifique um tipo de escalonamento para o aplicativo. As configurações de escalonamento são aplicadas no nível da versão do App Engine como parte do arquivo app.yaml.
Tipos de escalonamento
O App Engine é compatível com os seguintes tipos de escalonamento, que controlam como e quando as instâncias são criadas:
- Automático (padrão)
- Basic
- Manual
Você especifica o tipo de escalonamento no
appengine-web.xml do app.
Por padrão, o aplicativo usa o escalonamento automático, o que significa que o App Engine
gerenciará o número de instâncias inativas.
- Escalonamento automático
- O escalonamento automático cria instâncias baseadas na taxa de solicitação, nas latências de resposta
e em outras métricas do aplicativo. É possível especificar limites para cada uma dessas
métricas, além de um número mínimo de instâncias para continuar em execução o tempo todo,
configurando o elemento
automatic_scaling.
- Escalonamento básico
- O escalonamento básico cria instâncias quando seu aplicativo recebe solicitações. Cada instância será encerrada quando o aplicativo ficar inativo. O escalonamento básico é ideal para trabalhos intermitentes ou determinados pela atividade dos usuários.
- Escalonamento manual
- O escalonamento manual especifica o número de instâncias que são executadas continuamente, seja qual for o nível de carga. Isso permite a realização de tarefas como inicializações complexas e a execução de aplicativos que dependem do estado da memória ao longo do tempo.
| Recurso | Escalonamento automático | Escalonamento básico | Escalonamento manual |
|---|---|---|---|
| Tempo limite da solicitação |
10 minutos para solicitações HTTP e tarefas da fila de tarefas. Se o aplicativo não
retornar uma solicitação dentro desse limite, o App Engine interromperá o
gerenciador de solicitações e
emitirá
um erro para o código processar.
Para ambientes de execução legados (Java 8, PHP 5 e Python 2):
|
24 horas para solicitações HTTP e tarefas da fila. Se o aplicativo não
retornar uma solicitação dentro desse limite de tempo, o App Engine interromperá o
gerenciador de solicitações e
emitirá
um erro para o código processar.
Uma instância com escalonamento básico pode processar |
Igual ao escalonamento básico. |
| Linhas de execução em segundo plano | Não permitido | Permitido | Permitido |
| Residência | As instâncias são encerradas com base nos padrões de uso. |
As instâncias são encerradas com base no parâmetro
idle-timeout. Por exemplo, se uma instância estiver ociosa e não receber
uma solicitação para mais de idle-timeout, ela
será encerrada.
|
As instâncias permanecem na memória e o estado é preservado em todas as solicitações. Quando
as instâncias são interrompidas, uma solicitação /_ah/stop aparece
nos registros.
Se houver um gerenciador /_ah/stop ou um
gancho de encerramento registrado, terá 30 segundos para
concluir antes que o encerramento ocorra.
|
| Inicialização e encerramento | As instâncias são criadas sob demanda para manipular solicitações e são desativadas automaticamente quando ficam ociosas. |
As instâncias são criadas sob demanda para processar solicitações e
encerradas automaticamente quando inativas, com base no
parâmetro de configuração idle-timeout. Uma instância que é
parada manualmente
tem 30 segundos para terminar de processar as solicitações antes de ser encerrada
à força.
|
As instâncias recebem uma solicitação de início automaticamente pelo App Engine na
forma de uma solicitação GET vazia para /_ah/start. Assim como o
escalonamento básico, uma instância
interrompida manualmente
tem 30 segundos para concluir o processamento de solicitações antes de ser
encerrada à força.
|
| Endereçabilidade de instâncias | As instâncias são anônimas. |
A instância "i" da versão "v" do serviço "s" é endereçável no URL:
https://i-dot-v-dot-s-dot-app_id.REGION_ID.r.appspot.com.
Se você configurou um
mapeamento de subdomínio de caractere curinga para um domínio personalizado, também poderá endereçar
um serviço ou qualquer instância por meio de um URL no formato
https://s.domain.com ou https://i.s.domain.com.
É possível armazenar em cache o estado em cada instância com segurança e recuperá-lo nas
solicitações subsequentes.
|
Igual ao escalonamento básico. |
| Escalonamento |
O App Engine escalona o número de instâncias automaticamente em resposta ao volume de processamento. Esse fator de escalonamento considera as
configurações de automatic_scaling fornecidas
por versão no arquivo de configuração.
|
Um serviço com escalonamento básico é configurado definindo o número máximo
de instâncias no parâmetro max_instances da
configuração basic_scaling. O número de instâncias ativas é escalonado com o volume de processamento.
|
Você configura o número de instâncias de cada versão no arquivo de configuração desse serviço. O número de instâncias geralmente corresponde ao tamanho de um conjunto de dados mantido na memória ou à capacidade esperada para trabalho off-line. |
Como escalonar instâncias dinâmicas
Os aplicativos do App Engine que usam escalonamento básico ou automático são alimentados por qualquer número de instâncias dinâmicas em um determinado momento, dependendo do volume de solicitações recebidas. À medida que as solicitações para o aplicativo aumentam, o número de instâncias dinâmicas também pode aumentar.
Aplicativos com escalonamento básico
Se você usar o escalonamento básico, o App Engine tentará manter o custo baixo, mesmo que isso possa resultar em maior latência à medida que o volume de solicitações recebidas aumenta.
Quando nenhuma das instâncias atuais estiver disponível para atender a uma solicitação recebida, o App Engine iniciará uma nova instância. Mesmo depois de iniciar uma nova instância, algumas solicitações precisam ser colocadas na fila até que a nova instância conclua o processo de inicialização. Se você precisar da menor latência possível, considere usar o escalonamento automático, que cria novas instâncias preventivamente para minimizar a latência.
Aplicativos com escalonamento automático
Se você usar o escalonamento automático, cada instância no aplicativo terá sua própria fila para solicitações recebidas. Antes que as filas se tornem longas o suficiente para causar um efeito perceptível na latência do app, o App Engine cria automaticamente uma ou mais instâncias novas para processar o aumento da carga.
É possível definir as configurações do escalonamento automático para alcançar um melhor equilíbrio entre o desempenho pretendido e o custo incorrido. Na tabela a seguir, descrevemos essas configurações.
| Configurações de escalonamento automático | Descrição |
|---|---|
| Meta de uso da CPU | Define o limite da taxa de utilização da CPU para especificar o ponto de uso de CPU em que mais instâncias serão iniciadas para processar o tráfego. |
| Meta de uso da capacidade | Define o ponto de capacidade para o número de solicitações simultâneas a partir do qual mais instâncias serão iniciadas para processar o tráfego. |
| Max Concurrent Requests | Define o máximo de solicitações simultâneas que uma instância pode aceitar antes que o programador gere uma nova instância. |
Assista ao vídeo Configurações do programador do App Engine para ver os efeitos dessas configurações.
Como reduzir
Quando os volumes de solicitações diminuem, o App Engine reduz o número de instâncias. Essa redução no escalonamento ajuda a garantir que todas as instâncias atuais do aplicativo estejam sendo usadas com eficiência e custo-benefício ideais.
Quando um aplicativo não está sendo usado, o App Engine desativa as instâncias dinâmicas associadas dele, mas as recarregará prontamente assim que elas forem necessárias. O recarregamento das instâncias pode resultar no carregamento de solicitações e na latência adicional para usuários.
É possível especificar um número mínimo de instâncias ociosas. A definição de um número apropriado de instâncias ociosas para o aplicativo com base no volume de solicitações permite que o aplicativo atenda a todas as solicitações com pouca latência, a menos que você esteja processando um volume de solicitações alto anormal.
Como fazer reduções no escalonamento automático
Se o app usar escalonamento automático, levará cerca de 15 minutos de
inatividade para que as instâncias ociosas comecem a ser encerradas. Para manter uma ou mais
instâncias inativas em execução, defina o valor de min_idle_instances
como 1 ou mais.
Escalonamento e lotes de solicitações
Se você estiver enviando lotes de solicitações para os serviços, por exemplo, para uma fila de tarefas para processamento, um grande número de instâncias será criado rapidamente. Recomendamos controlar isso por meio da limitação de taxa do número de solicitações enviadas por segundo, se possível. Por exemplo, se você usa o Google Tarefas, é possível controlar a taxa em que as tarefas são enviadas.
Ciclo de vida da instância
Estados de instância
Uma instância de um serviço com escalonamento automático está sempre em execução. No entanto, uma instância de um serviço com escalonamento manual ou básico pode estar em execução ou parada. Todas as instâncias do mesmo serviço e versão têm estados iguais. Você altera o estado das instâncias gerenciando as versões. Você pode:
- Usar a página "Versões" no Console do Google Cloud
- usar os comandos
gcloud app versions startegcloud app versions stop - usar o serviço Modules;
Inicialização
Cada instância de serviço é criada em resposta a uma solicitação de inicialização, que é uma
solicitação HTTP GET vazia para /_ah/start. O App Engine envia essa solicitação
para criar uma instância. Os usuários não podem enviar uma solicitação para
/_ah/start. As instâncias com escalonamento manual e básico precisam responder à solicitação de inicialização
antes de processar outra solicitação. A solicitação de inicialização pode ser usada
para dois objetivos:
- Iniciar um programa executado indefinidamente, sem aceitar outras solicitações.
- Inicializar uma instância antes que ela receba mais tráfego.
As instâncias de escalonamento automático, manual e básico são inicializadas de maneira diferente. Quando você
inicia uma instância com escalonamento manual, o App Engine envia imediatamente uma solicitação
/_ah/start para cada instância. Quando você inicia uma instância de um serviço de escalonamento básico,
o App Engine permite que ele aceite o tráfego, mas a solicitação
/_ah/start não é enviada a uma instância até receber a primeira solicitação de
usuário. Várias instâncias básicas de escalonamento só são iniciadas conforme o necessário, para
processar o aumento do tráfego. As instâncias com escalonamento automático não
recebem nenhuma solicitação /_ah/start.
Quando uma instância responde à solicitação /_ah/start com um código de status HTTP de
200–299 ou 404, ela é considerada bem-sucedida na inicialização e pode
processar outras solicitações. Do contrário, o App Engine encerra a instância. As instâncias de escalonamento manual são reiniciadas imediatamente, e as de escalonamento básico só são reiniciadas quando necessário para veicular o tráfego.
Encerramento
O processo de encerramento pode ser acionado por uma variedade de eventos planejados e não planejados, como estes:
- Há muitas instâncias e não há solicitações suficientes (tráfego).
- Você para manualmente uma instância.
- Implante uma versão atualizada no serviço.
- A instância excede a memória máxima do
instance_classconfigurado. - O aplicativo esgotou a cota de instância/horas.
- A instância é transferida para uma máquina diferente, porque a máquina em que ela está sendo executada foi reiniciada ou o App Engine moveu a instância para melhorar a distribuição de carga.
Uma das vantagens da plataforma "pague somente pelo que você usa" do ambiente padrão do App Engine, conforme descrito anteriormente em Como escalonar verticalmente, é que o sistema faz o escalonamento automático do número de instâncias para zero quando não há tráfego. Isso ajuda a tornar o App Engine uma solução econômica para pequenos aplicativos que não recebem solicitações contínuas. Quando uma instância precisar ser encerrada, novas solicitações recebidas serão roteadas para outras instâncias (se houver) e as solicitações que estiverem sendo processadas terão tempo para serem concluídas.
Quando uma instância precisa ser encerrada, o App Engine envia um sinalKILL (SIGKILL), encerrando a instância.
Como carregar solicitações
Quando o App Engine cria uma nova instância para o aplicativo, ela precisa primeiro carregar todas as bibliotecas e os recursos necessários para processar a solicitação. Isso acontece durante a primeira solicitação para a instância, chamada de solicitação de carregamento. Durante esse processo, o aplicativo passa pela inicialização, o que faz a solicitação demorar mais.
As práticas recomendadas a seguir permitem reduzir a duração das solicitações de carregamento:
- Carregue apenas o código necessário para a inicialização.
- Acesse o disco o mínimo possível.
- Em alguns casos, o carregamento do código a partir de um arquivo zip ou jar é mais rápido do que o carregamento de muitos arquivos separados.
Solicitações de aquecimento
Solicitações de aquecimento são um tipo específico de solicitação que carrega o código do aplicativo em uma instância com antecedência, antes que solicitações ativas sejam realizadas.
As instâncias de escalonamento manual ou básico não recebem uma solicitação /_ah/warmup.
Tempo de atividade da instância
O App Engine tenta manter as instâncias de escalonamento manual e básico em execução indefinidamente. No entanto, neste momento, não há tempo de atividade garantido para instâncias de escalonamento manual e básico. As falhas de hardware e software que causam o encerramento prematuro ou reinicializações frequentes podem ocorrer sem aviso prévio e levar um tempo considerável para serem resolvidas. Assim, você precisa criar seu aplicativo de um modo que tolere essas falhas.
Veja a seguir algumas boas estratégias para evitar a inatividade devido a reinícios da instância:
- Reduza o tempo necessário para a reinicialização das instâncias ou para que novas instâncias sejam inicializadas.
- Para cálculos de longa duração, crie checkpoints periodicamente para que seja possível retomar a partir desse estado.
- O aplicativo precisa ser "sem estado" para que nada seja armazenado na instância.
- Use filas para executar tarefas assíncronas.
- Se você configurar as instâncias para escalonamento manual:
- Use o balanceamento de carga em várias instâncias.
- configure mais instâncias do que o necessário para processar o tráfego normal;
- escreva a lógica de fallback que usa resultados em cache quando uma instância de escalonamento manual não está disponível.
NTP com ambiente padrão do App Engine
O ambiente padrão do App Engine tem serviços de protocolo de tempo de rede (NTP, na sigla em inglês) que usam servidores NTP do Google. No entanto, o serviço NTP não é editável.