Como o idioma, a memória e o tamanho do pacote afetam os arranques a frio da AWS Lambda?

Comparando os tempos de início frio da AWS Lambda usando diferentes idiomas, alocação de memória e tamanhos de pacote de implantação

esta publicação analisa o tempo de tempo frio entre C #, Java, Python e Nodejs em AWS Lambda

Em um blog recente, examinamos a diferença de desempenho entre os tempos de execução de idiomas que a AWS Lambda suporta de forma nativa. Uma vez que esse experimento estava especificamente interessado nas diferenças de tempo de execução de uma função "quente", os tempos de "início frio" foram intencionalmente omitidos.

Um início a frio ocorre quando uma função Lambda de AWS é invocada depois de não ser usada por um longo período de tempo, resultando em latência de invocação aumentada.

Uma vez que os tempos de início frio da AWS Lambda são uma consideração de desempenho importante, vejamos mais de perto alguns experimentos projetados para isolar as variáveis ??que podem afetar as primeiras invocações de funções.

Metodologia de teste

A partir da minha experiência de funcionamento das funções da Lambda em ambientes de produção, os arranques a frio geralmente ocorrem quando uma função Lambda AWS está ociosa por mais de cinco minutos. Mais recentemente, algumas das minhas funções não experimentaram um início a frio até após 30 minutos de tempo ocioso. Mesmo que você mantenha sua função quente, um começo frio ocorrerá aproximadamente a cada 4 horas quando a máquina virtual do host for reciclada – basta verificar as métricas da IO Pipe .

Para fins de teste, eu precisava de um método confiável para garantir consistentemente um início a frio de uma função AWS Lambda. A única maneira infalível de criar um início a frio é implementando uma nova versão de uma função antes da invocação.

Para o experimento, criei 45 variações da função AWS Lambda. Usando a configuração da estrutura sem servidor abaixo, foi fácil criar variantes da mesma função com diferentes tamanhos de memória.

Eu instalei recursivamente todas as 45 funções e invoquei cada uma delas programaticamente usando o script simples abaixo.

O loop de implantação e invocação demorou cerca de três minutos. Para coletar uma quantidade significativa de pontos de dados, executei o experimento por mais de 24 horas.

Minha hipótese inicial

Basei a hipótese de que a quantidade de recursos da CPU é proporcional à quantidade de memória alocada a uma função Lambda AWS.

  1. C # e Java teriam uma hora de início mais frio
  2. O tamanho da memória afeta o tempo de início frio linearmente
  3. O tamanho do código afeta o tempo de início frio linearmente

Agora era hora de ver se as experiências apoiaram minha hipótese.

Experiência # 1 – Hora de início a frio por tempo de execução e memória

Para avaliar o impacto da memória nos arranques a frio, criei 20 funções com 5 variantes – usando diferentes tamanhos de memória para cada tempo de execução do idioma. Os idiomas suportados são C #, Java, Node.js e Python.

Criei 5 variantes da mesma função mundial de Olá (usando diferentes tamanhos de memória) para cada tempo de execução de idioma

Depois de executar o experimento um pouco mais de 24 horas, colecionei os seguintes dados – aqui estão os resultados:

Observação: C # e Java têm tempo de início frio muito maior

A tendência mais óbvia é que as linguagens digitadas estaticamente (C # e Java) têm mais de 100 vezes o tempo de início frio. Isso claramente apoia nossa hipótese, embora em uma extensão muito maior do que eu inicialmente antecipa.

Sinta-se livre jogo ao redor com o gráfico plot.ly interativo aqui

Observação: Python tem uma hora de início fria ridiculamente baixa

Fico agradavelmente surpreendido com o pouco tempo de início do tempo de execução do Python. OK, houve alguns pontos de dados anormais que influenciaram fortemente alguns percentil e desvios padrão – mas você não pode argumentar com uma hora de início frio de 0,41 ms no percentil 95 de uma função de 128MB.

Observação: o tamanho da memória melhora o tempo de início frio linearmente

Quanto mais memória alocar a sua função, menor é o tempo de início frio – e menor desvio padrão. Isso é mais óbvio com os tempos de execução C # e Java, já que o tempo de início frio da linha de base (128MB) para ambos são muito significativos.

Até agora, os dados do primeiro experimento suportam a hipótese inicial.

Experiência # 2 – tempo de início frio pelo tamanho do código e memória

Para avaliar o impacto da memória e o tamanho do pacote em arranques a frio, criei 25 funções com vários tamanhos de código e memória. Node.js foi o idioma constante para esta experiência.

Aqui estão os resultados dessa experiência:

Observação: o tamanho da memória melhora o tempo de início frio linearmente

Tal como acontece com o primeiro experimento, o tamanho da memória melhora a hora de início a frio e o desvio padrão de forma mais ou menos linear.

Observação # 2: o tamanho do código melhora a hora de início a frio

Curiosamente, o tamanho do pacote de implantação não aumenta a hora de início a frio. Eu teria assumido que o pacote maior equivaleria a mais tempo para baixar e descompactar. Em vez disso, um pacote de implantação maior parece ter um efeito positivo na redução do tempo de início frio em geral.

Para ver se o comportamento é consistente, eu adoraria que outra pessoa repita essa experiência usando um tempo de execução de linguagem diferente. O código-fonte usado para essas experiências pode ser encontrado aqui , incluindo os scripts usados ??para calcular as estatísticas e gerar os gráficos da caixa plot.ly.

theburningmonk / lambda-coldstart-comparison
comparação de lambda-coldstart – Comparando o tempo do coldstart das funções da AWS Lambda usando uma variedade de tempo de execução do idioma … github.com

Conclusões

Aqui estão algumas coisas que aprendi com estas experiências:

  • as funções não são mais recicladas após ~ 5 minutos de ociosidade, o que faz o frio começar muito menos punido do que antes
  • O tamanho da memória melhora o tempo de início frio linearmente
  • C # e Java Runtimes experiência ~ 100 vezes o tempo de início frio de Python e também sofrem de desvio padrão muito maior
  • você deve considerar executar suas funções C # / Java Lambda com uma alocação de memória maior do que as funções Node.js / Python
  • O tamanho do pacote de implantação maior não aumenta a hora de início a frio

atualização 04/07/2017 : postei um experimento de acompanhamento para descobrir quanto tempo Lambda mantém funções ociosas antes de reciclá-las.

Há quanto tempo AWS Lambda mantém suas funções inativas antes de um arranque a frio?
Usando AWS Step Function para encontrar o tempo mais longo, sua função AWS Lambda pode ser ociosa antes que os recursos sejam recuperados read.acloud.guru

Texto original em inglês.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *