Compatibilidade APIs Node.js - Process

Esta documentação explora o uso e a integração do módulo Process do Node.js dentro do Azion Runtime. O módulo Process é uma parte essencial do Node.js, permitindo interação com o processo Node.js atual, fornecendo informações e controlando sua execução.

Ver como Markdown

O módulo process no Node.js é um objeto global que fornece informações e controle sobre o processo Node.js atual. É essencial para interagir com o ambiente de execução e gerenciar a execução de aplicações Node.js. Este módulo está disponível no Azion Runtime através da compatibilidade com Node.js, onde um caso de uso frequente é ler variáveis de ambiente, como process.env, ou agendar trabalho com nextTick dentro de uma function.

Exemplo: Variáveis de ambiente e nextTick

O exemplo abaixo mostra como usar o módulo process em uma function:

/**
* An example of using the Node.js Process API in an Azion Function.
* Support:
* - Extended by library `process`
* Portions of this file Copyright Roman Shtylman, licensed under the MIT license.
* @module runtime-apis/nodejs/process/main
* @example
* // Execute with Azion Bundler:
* npx edge-functions build
* npx edge-functions dev
*/
import { env, nextTick } from "node:process";
/**
* Example of using the process api
* @param {*} event
*/
const main = async (event) => {
console.log(process.env.NODE_ENV);
nextTick(() => {
console.log("Hello, Next Tick!");
// Hello, Next Tick!
});
return new Response(`NODE_ENV: ${process.env.NODE_ENV}`, { status: 200 });
};
export default main;

Exemplo: Lendo configuração de variáveis de ambiente

Acesse valores de configuração armazenados em variáveis de ambiente:

import process from "node:process";
const main = async (event) => {
// Read environment variables
const nodeEnv = process.env.NODE_ENV || "development";
const apiKey = process.env.API_KEY;
const debug = process.env.DEBUG === "true";
const maxRetries = parseInt(process.env.MAX_RETRIES || "3", 10);
console.log("Environment:", nodeEnv);
console.log("Debug mode:", debug);
console.log("Max retries:", maxRetries);
// Check if required variables are set
if (!apiKey) {
console.warn("API_KEY not configured");
}
// Build configuration object
// Security: Never expose sensitive env vars in responses
// Use boolean flags instead of actual values
const config = {
environment: nodeEnv,
debug,
maxRetries,
hasApiKey: !!apiKey // Boolean only, not the actual key
};
return new Response(JSON.stringify(config), {
headers: { "Content-Type": "application/json" }
});
};
export default main;

Exemplo: Usando nextTick para execução adiada

Agende trabalho para executar após a operação atual ser concluída:

import { nextTick } from "node:process";
import { setTimeout } from "node:timers/promises";
const main = async (event) => {
const executionOrder = [];
executionOrder.push("Start");
// Schedule with nextTick - runs after current code
// Note: nextTick execution order may differ from standard Node.js
// in edge runtime environments
nextTick(() => {
executionOrder.push("NextTick callback");
console.log("Deferred execution completed");
});
executionOrder.push("After nextTick call");
// Multiple nextTick calls execute in order
nextTick(() => {
executionOrder.push("Second nextTick");
});
// Wait for nextTick callbacks to execute
await setTimeout(10);
executionOrder.push("End");
console.log("Execution order:", executionOrder.join(" -> "));
return new Response(JSON.stringify({ executionOrder }), {
headers: { "Content-Type": "application/json" }
});
};
export default main;

Exemplo: Informações do processo e detecção de plataforma

Acesse informações de runtime sobre o processo:

import process from "node:process";
const main = async (event) => {
// Note: In Azion Runtime, some process properties may return
// fixed or environment-specific values:
// - process.pid may always return a fixed value
// - process.arch reflects the edge node architecture
// - process.versions may not include all Node.js version fields
// Platform information
const platform = process.platform;
const arch = process.arch;
const versions = process.versions;
// Process identification
const pid = process.pid;
const ppid = process.ppid;
// Runtime information
const nodeVersion = process.version;
const v8Version = versions.v8;
console.log("Platform:", platform);
console.log("Architecture:", arch);
console.log("Node version:", nodeVersion);
console.log("V8 version:", v8Version);
console.log("Process ID:", pid);
// Build info object with fallbacks for potentially undefined values
const processInfo = {
platform,
arch,
pid,
ppid,
nodeVersion,
v8Version,
versions: {
node: versions.node || "unknown",
v8: versions.v8 || "unknown",
openssl: versions.openssl || "unknown"
}
};
return new Response(JSON.stringify(processInfo, null, 2), {
headers: { "Content-Type": "application/json" }
});
};
export default main;

Exemplo: Monitoramento de uso de memória

Monitore o consumo de memória durante a execução:

import process from "node:process";
const main = async (event) => {
// Get initial memory usage
const initialMemory = process.memoryUsage();
// Simulate some work
const data = [];
for (let i = 0; i < 1000; i++) {
data.push({ id: i, data: "x".repeat(100) });
}
// Get memory usage after work
const finalMemory = process.memoryUsage();
// Calculate memory delta
const memoryDelta = {
rss: finalMemory.rss - initialMemory.rss,
heapTotal: finalMemory.heapTotal - initialMemory.heapTotal,
heapUsed: finalMemory.heapUsed - initialMemory.heapUsed,
external: finalMemory.external - initialMemory.external
};
console.log("Initial heap used:", initialMemory.heapUsed, "bytes");
console.log("Final heap used:", finalMemory.heapUsed, "bytes");
console.log("Memory delta:", memoryDelta.heapUsed, "bytes");
return new Response(JSON.stringify({
initial: {
rss: initialMemory.rss,
heapTotal: initialMemory.heapTotal,
heapUsed: initialMemory.heapUsed
},
final: {
rss: finalMemory.rss,
heapTotal: finalMemory.heapTotal,
heapUsed: finalMemory.heapUsed
},
delta: memoryDelta
}), {
headers: { "Content-Type": "application/json" }
});
};
export default main;

Exemplo: Uptime e temporização

Acompanhe o uptime do processo para monitoramento de saúde:

import process from "node:process";
import { setTimeout } from "node:timers/promises";
const main = async (event) => {
// Get process uptime in seconds
const uptime = process.uptime();
// Get high-resolution time
const hrtime = process.hrtime();
const hrtimeBigint = process.hrtime.bigint();
console.log("Process uptime:", uptime, "seconds");
console.log("High-res time:", hrtime);
console.log("High-res time (bigint):", hrtimeBigint.toString(), "nanoseconds");
// Calculate elapsed time for an operation
const start = process.hrtime.bigint();
// Simulate work
await setTimeout(100);
const end = process.hrtime.bigint();
const elapsedNs = Number(end - start);
const elapsedMs = elapsedNs / 1_000_000;
console.log("Operation took:", elapsedMs.toFixed(2), "ms");
return new Response(JSON.stringify({
uptime: {
seconds: uptime,
formatted: formatUptime(uptime)
},
hrtime: {
seconds: hrtime[0],
nanoseconds: hrtime[1]
},
operationTime: {
nanoseconds: elapsedNs,
milliseconds: elapsedMs
}
}), {
headers: { "Content-Type": "application/json" }
});
};
// Helper function defined before export
function formatUptime(seconds) {
const hours = Math.floor(seconds / 3600);
const minutes = Math.floor((seconds % 3600) / 60);
const secs = Math.floor(seconds % 60);
return `${hours}h ${minutes}m ${secs}s`;
}
export default main;

APIs com suporte

APIStatus
process.env🟢 Com suporte
process.nextTick()🟢 Com suporte
process.platform🟢 Com suporte
process.arch🟢 Com suporte
process.version🟢 Com suporte
process.versions🟢 Com suporte
process.pid🟢 Com suporte
process.ppid🟢 Com suporte
process.uptime()🟢 Com suporte
process.hrtime()🟢 Com suporte
process.hrtime.bigint()🟢 Com suporte
process.memoryUsage()🟢 Com suporte
process.cwd()🟡 Parcialmente suportado
process.exit()🟡 Parcialmente suportado
process.on()🟡 Parcialmente suportado
process.argv🟡 Parcialmente suportado
process.title🟡 Parcialmente suportado

APIs marcadas como 🟡 Parcialmente suportado têm funcionalidade limitada em comparação com a implementação completa do Node.js. No Azion Runtime, process.cwd() retorna um caminho fixo em vez do diretório de trabalho atual, process.exit() não termina o processo do runtime, process.argv retorna um array fixo ou vazio, e process.on() tem suporte limitado de eventos. Para configuração de ambiente, prefira process.env que tem suporte completo.

Recursos relacionados