node:process

O módulo node:process no Azion Runtime: o objeto process, exemplos de variáveis de ambiente, nextTick e informações do processo, e as APIs suportadas.

Última atualização

Ver como Markdown Configurar agente

O módulo node:process fornece process, o objeto do Node.js que guarda informações sobre o processo atual e controla a execução dele. Em uma function, os usos mais frequentes são ler variáveis de ambiente por meio de process.env e agendar trabalho com process.nextTick(). Após o deploy, process.env contém as variáveis de ambiente da sua conta, que você também pode ler com Azion.env.get().

No Azion Runtime, process também é um global, mas o global e o export padrão de node:process são objetos diferentes. Nos exemplos abaixo, o global process.env.NODE_ENV retorna production, e a mesma propriedade do objeto importado não retorna nenhum valor.

nota — Com azion dev, os callbacks de nextTick do exemplo de execução adiada são executados antes de End, e a resposta lista os dois. Sem um arquivo .env no projeto, process.env contém todo o ambiente de shell da máquina que executa azion dev.

Exemplos

Cada exemplo é uma function completa que importa de node:process. A resposta abaixo de cada exemplo é a que uma function com deploy feito retorna.

Variáveis de ambiente e nextTick

Esta function registra no log o global process.env.NODE_ENV, agenda um callback com nextTick e retorna o valor na resposta:

JavaScript
01/**
02 * An example of using the Node.js Process API in an Azion Function.
03 * Support:
04 * - Extended by library `process`
05 * Portions of this file Copyright Roman Shtylman, licensed under the MIT license.
06 * @module runtime-apis/nodejs/process/main
07 * @example
08 * // Build and run with the Azion CLI:
09 * azion build
10 * azion dev
11 */
12import { env, nextTick } from "node:process";
13
14/**
15 * Example of using the process api
16 * @param {*} event
17 */
18const main = async (event) => {
19 console.log(process.env.NODE_ENV);
20
21 nextTick(() => {
22 console.log("Hello, Next Tick!");
23 // Deployed, this line was not logged before the response was sent
24 });
25
26 return new Response(`NODE_ENV: ${process.env.NODE_ENV}`, { status: 200 });
27};
28
29export default main;

A function registra production no log e responde com este corpo:

NODE_ENV: production

Configuração a partir de variáveis de ambiente

Esta function lê quatro valores de configuração de process.env, usa um valor padrão para cada um deles e informa se uma chave de API está definida sem expor o valor dela:

JavaScript
01import process from "node:process";
02
03const main = async (event) => {
04 // Read environment variables
05 const nodeEnv = process.env.NODE_ENV || "development";
06 const apiKey = process.env.API_KEY;
07 const debug = process.env.DEBUG === "true";
08 const maxRetries = parseInt(process.env.MAX_RETRIES || "3", 10);
09
10 console.log("Environment:", nodeEnv);
11 console.log("Debug mode:", debug);
12 console.log("Max retries:", maxRetries);
13
14 // Check if required variables are set
15 if (!apiKey) {
16 console.warn("API_KEY not configured");
17 }
18
19 // Build configuration object
20 // Security: Never expose sensitive env vars in responses
21 // Use boolean flags instead of actual values
22 const config = {
23 environment: nodeEnv,
24 debug,
25 maxRetries,
26 hasApiKey: !!apiKey // Boolean only, not the actual key
27 };
28
29 return new Response(JSON.stringify(config), {
30 headers: { "Content-Type": "application/json" }
31 });
32};
33
34export default main;

Sem nenhuma das quatro variáveis definidas, a function registra o aviso API_KEY not configured no log e responde com os valores padrão:

{"environment":"development","debug":false,"maxRetries":3,"hasApiKey":false}

Execução adiada com nextTick

Esta function registra a ordem em que o código dela é executado em torno de duas chamadas a nextTick, aguarda 10 ms e retorna essa ordem:

JavaScript
01import { nextTick } from "node:process";
02import { setTimeout } from "node:timers/promises";
03
04const main = async (event) => {
05 const executionOrder = [];
06
07 executionOrder.push("Start");
08
09 // Schedule with nextTick - runs after the current code
10 // Deployed, the callbacks have not run when the response is built
11 nextTick(() => {
12 executionOrder.push("NextTick callback");
13 console.log("Deferred execution completed");
14 });
15
16 executionOrder.push("After nextTick call");
17
18 // Schedule a second callback
19 nextTick(() => {
20 executionOrder.push("Second nextTick");
21 });
22
23 // Wait 10 ms before building the response
24 await setTimeout(10);
25
26 executionOrder.push("End");
27
28 console.log("Execution order:", executionOrder.join(" -> "));
29
30 return new Response(JSON.stringify({ executionOrder }), {
31 headers: { "Content-Type": "application/json" }
32 });
33};
34
35export default main;

Em uma function com deploy feito, os callbacks de nextTick ainda não foram executados quando a function monta a resposta, então a ordem termina em End e não lista nenhum dos callbacks:

{"executionOrder":["Start","After nextTick call","End"]}

Informações do processo

Esta function lê a plataforma, a arquitetura, as versões e os IDs de processo, e os retorna como JSON formatado:

JavaScript
01import process from "node:process";
02
03const main = async (event) => {
04 // In Azion Runtime, these process properties return fixed values:
05 // - process.platform and process.arch are empty strings
06 // - process.pid is 200 and process.ppid is 100
07 // - process.versions holds only the node field
08
09 // Platform information
10 const platform = process.platform;
11 const arch = process.arch;
12 const versions = process.versions;
13
14 // Process identification
15 const pid = process.pid;
16 const ppid = process.ppid;
17
18 // Runtime information
19 const nodeVersion = process.version;
20 const v8Version = versions.v8;
21
22 console.log("Platform:", platform);
23 console.log("Architecture:", arch);
24 console.log("Node version:", nodeVersion);
25 console.log("V8 version:", v8Version);
26 console.log("Process ID:", pid);
27
28 // Build info object with fallbacks for potentially undefined values
29 const processInfo = {
30 platform,
31 arch,
32 pid,
33 ppid,
34 nodeVersion,
35 v8Version,
36 versions: {
37 node: versions.node || "unknown",
38 v8: versions.v8 || "unknown",
39 openssl: versions.openssl || "unknown"
40 }
41 };
42
43 return new Response(JSON.stringify(processInfo, null, 2), {
44 headers: { "Content-Type": "application/json" }
45 });
46};
47
48export default main;

A function responde com os valores fixos. v8Version é indefinido, então JSON.stringify o deixa fora do corpo:

JSON
01{
02 "platform": "",
03 "arch": "",
04 "pid": 200,
05 "ppid": 100,
06 "nodeVersion": "v22.14.0",
07 "versions": {
08 "node": "22.14.0",
09 "v8": "unknown",
10 "openssl": "unknown"
11 }
12}

Uso de memória

Esta function lê process.memoryUsage() antes e depois de montar um array, e retorna as duas leituras e a diferença entre elas:

JavaScript
01import process from "node:process";
02
03const main = async (event) => {
04 // Get initial memory usage
05 const initialMemory = process.memoryUsage();
06
07 // Simulate some work
08 const data = [];
09 for (let i = 0; i < 1000; i++) {
10 data.push({ id: i, data: "x".repeat(100) });
11 }
12
13 // Get memory usage after work
14 const finalMemory = process.memoryUsage();
15
16 // Calculate memory delta
17 const memoryDelta = {
18 rss: finalMemory.rss - initialMemory.rss,
19 heapTotal: finalMemory.heapTotal - initialMemory.heapTotal,
20 heapUsed: finalMemory.heapUsed - initialMemory.heapUsed,
21 external: finalMemory.external - initialMemory.external
22 };
23
24 console.log("Initial heap used:", initialMemory.heapUsed, "bytes");
25 console.log("Final heap used:", finalMemory.heapUsed, "bytes");
26 console.log("Memory delta:", memoryDelta.heapUsed, "bytes");
27
28 return new Response(JSON.stringify({
29 initial: {
30 rss: initialMemory.rss,
31 heapTotal: initialMemory.heapTotal,
32 heapUsed: initialMemory.heapUsed
33 },
34 final: {
35 rss: finalMemory.rss,
36 heapTotal: finalMemory.heapTotal,
37 heapUsed: finalMemory.heapUsed
38 },
39 delta: memoryDelta
40 }), {
41 headers: { "Content-Type": "application/json" }
42 });
43};
44
45export default main;

Todos os campos de process.memoryUsage() retornam 0, então as duas leituras e a diferença são 0:

{"initial":{"rss":0,"heapTotal":0,"heapUsed":0},"final":{"rss":0,"heapTotal":0,"heapUsed":0},"delta":{"rss":0,"heapTotal":0,"heapUsed":0,"external":0}}

Uptime e medição de tempo

Esta function lê process.uptime() e process.hrtime() e, em seguida, mede uma espera de 100 ms com process.hrtime.bigint():

JavaScript
01import process from "node:process";
02import { setTimeout } from "node:timers/promises";
03
04const main = async (event) => {
05 // Get process uptime in seconds
06 const uptime = process.uptime();
07
08 // Get high-resolution time
09 const hrtime = process.hrtime();
10 const hrtimeBigint = process.hrtime.bigint();
11
12 console.log("Process uptime:", uptime, "seconds");
13 console.log("High-res time:", hrtime);
14 console.log("High-res time (bigint):", hrtimeBigint.toString(), "nanoseconds");
15
16 // Measure an operation; deployed, the measured time is 0
17 const start = process.hrtime.bigint();
18
19 // Simulate work
20 await setTimeout(100);
21
22 const end = process.hrtime.bigint();
23 const elapsedNs = Number(end - start);
24 const elapsedMs = elapsedNs / 1_000_000;
25
26 console.log("Operation took:", elapsedMs.toFixed(2), "ms");
27
28 return new Response(JSON.stringify({
29 uptime: {
30 seconds: uptime,
31 formatted: formatUptime(uptime)
32 },
33 hrtime: {
34 seconds: hrtime[0],
35 nanoseconds: hrtime[1]
36 },
37 operationTime: {
38 nanoseconds: elapsedNs,
39 milliseconds: elapsedMs
40 }
41 }), {
42 headers: { "Content-Type": "application/json" }
43 });
44};
45
46// Helper function defined before export
47function formatUptime(seconds) {
48 const hours = Math.floor(seconds / 3600);
49 const minutes = Math.floor((seconds % 3600) / 60);
50 const secs = Math.floor(seconds % 60);
51 return `${hours}h ${minutes}m ${secs}s`;
52}
53
54export default main;

Após o deploy, process.uptime() retorna 0, process.hrtime() retorna segundos inteiros com 0 nanossegundos, e o tempo medido durante a espera de 100 ms é 0:

{"uptime":{"seconds":0,"formatted":"0h 0m 0s"},"hrtime":{"seconds":1767268800,"nanoseconds":0},"operationTime":{"nanoseconds":0,"milliseconds":0}}

APIs suportadas

A tabela lista o status de cada API de node:process no Azion Runtime:

APIStatus
process.env🟢 Com suporte
process.nextTick()🟢 Com suporte
process.platform🟡 Suporte parcial (string vazia)
process.arch🟡 Suporte parcial (string vazia)
process.version🟢 Com suporte
process.versions🟡 Suporte parcial (somente node)
process.pid🟡 Suporte parcial (valor fixo)
process.ppid🟡 Suporte parcial (valor fixo)
process.uptime()🟡 Suporte parcial (retorna 0)
process.hrtime()🟡 Suporte parcial
process.hrtime.bigint()🟡 Suporte parcial
process.memoryUsage()🟡 Suporte parcial (retorna 0)
process.cwd()🟡 Suporte parcial
process.exit()🟡 Suporte parcial
process.on()🟡 Suporte parcial
process.argv🟡 Suporte parcial
process.title🟡 Suporte parcial
process.binding()🔴 Sem suporte

As APIs marcadas como 🟡 Suporte parcial têm funcionalidade limitada em comparação com a implementação completa do Node.js. Os valores delas são fixos e não descrevem a máquina que executa o seu código. process.platform, process.arch e process.title são strings vazias, process.pid é 200 e process.ppid é 100. process.version é v22.14.0, e process.versions contém somente node. process.cwd() retorna /, e process.argv é um array vazio. Após o deploy, process.hrtime() e process.hrtime.bigint() retornam segundos inteiros com 0 nanossegundos.

process.exit() não encerra o processo do runtime, e process.on() tem suporte limitado a eventos. process.binding() lança Error: [unenv] process.binding is not implemented yet!. Para a configuração do ambiente, use process.env, que tem suporte completo.

Recursos relacionados

APIs do Node.js

O status de cada módulo do Node.js no Azion Runtime, incluindo process.

API de variáveis de ambiente

Como uma function lê as variáveis de ambiente da sua conta com Azion.env.get().

node:os

O módulo os, cujas funções também retornam valores fixos dentro de uma function.

Documentação de process do Node.js

A referência completa do Node.js para cada API de node:process da tabela.