Como funciona uma invocação

your code ── invoke('hello') ──▶ gateway (data plane)
                                   • checks the key and the user's token
                                   • finds the project from the host
                                   • adds x-aura-role, x-aura-user-id, x-aura-project-id
                                   │  message bus (request / reply)
                                   ▼
                           functions service
                                   • access policy: only invoke is public
                                   • reads the function, reserves one invocation of the plan quota
                                   │  HTTP
                                   ▼
                            edge runtime
                                   • loads code, limits and variables
                                   • starts an isolated V8 worker
                                   • rebuilds the request you described
                                   ▼
                             your function ── Response ──▶ back along the same path

O gateway e o serviço de funções comunicam-se através de um barramento de mensagens. Uma mensagem nesse barramento tem um limite de tamanho, e é por isso que uma solicitação ou resposta acima de 256 KiB não passa: consulte limites.

• Um trabalhador por chamada. O edge runtime inicia um novo trabalhador V8 isolado para cada invocação, com o limite de memória e o tempo limite da função. Nada na memória sobrevive de uma chamada para a próxima: não mantenha o estado em uma variável. Use seu banco de dados ou armazenamento.
• O código é armazenado em cache por alguns segundos. O tempo de execução mantém o código e os limites de uma função por 5 segundos e os descarta quando você implanta. As variáveis ​​são lidas em cada chamada.
• Sua solicitação foi reconstruída. O tempo de execução cria a solicitação que você descreveu (method, path, headers, body) e a entrega ao seu manipulador Deno.serve. Uma função, portanto, se comporta como qualquer servidor HTTP.
• O tempo de execução impõe o tempo limite. Quando timeout_secs decorre, cancela o trabalhador; o chamador vê um erro após esse atraso.
• WASM funções são executadas dentro do próprio serviço, com limites de memória, tempo e instruções. Uma função WASM pode relatar linhas de log, que aparecem no campo logs da resposta; uma função Deno não pode.

O serviço possui duas formas de retornar a resposta da sua função, escolhidas pelo cabeçalho da solicitação X-Aurabase-Invoke-Mode.

O envelope existe para que uma resposta JSON possa conter o status, os cabeçalhos e a duração da chamada. Seu limite é que os bytes não podem viajar em JSON: é por isso que uma resposta binária precisa do modo bruto. O SDK escolhe o modo de responseType.

No modo bruto, o serviço adiciona x-aurabase-invoke-origin: function às respostas da sua função. Um erro que vem do gateway ou do tempo de execução não o carrega. É assim que o SDK separa FunctionsHttpError (sua função respondida) de FunctionsRelayError (a plataforma falhou).

Três tempos limite são aninhados para que nenhum termine antes do que está dentro dele:

gateway 380 s  ⊃  message bus 370 s  ⊃  function timeout_secs (≤ 300 s) + margin

O serviço aguarda o tempo de execução de timeout_secs mais uma margem. Como o tempo de execução cancela o trabalhador em timeout_secs, você normalmente verá um erro da função naquele momento e um 504 TIMEOUT somente se o próprio tempo de execução parar de responder. Um 504 significa, portanto, que a função foi iniciada e pode ter tido efeitos: não repita cegamente uma chamada não idempotente.

Medição e cota:

1. Antes da chamada, o serviço reserva uma chamada da cota do plano. Se a cota se esgotar, a chamada para aqui com 403.
2. Após a chamada, registra a invocação e sua duração em milissegundos.
3. Se a chamada falhar antes de sua função atender, a reserva será liberada e nada será contado.

• Mantenha cada chamada curta e sem estado. Para trabalhos longos, enfileira um trabalho.
• Mantenha as solicitações e respostas pequenas; coloque os arquivos no armazenamento e passe uma referência.
• Torne as funções idempotentes: uma nova tentativa de trabalho, uma nova tentativa de cliente após um erro de rede ou uma entrega cron duplicada podem executar seu código duas vezes.
• Autorize nos cabeçalhos de identidade da plataforma, porque são os únicos valores que o chamador não pode falsificar. Consulte segurança.
• Meça sua própria latência: cada chamada paga pelo início de um trabalhador. Uma função mínima relatada duration_ms: 74 em uma pilha local.