---
name: azion-use-apis-do-node-js-com-polyfills
description: >-
  Importe uma API do Node.js, como node:buffer, em uma function, faça o build com polyfills pela Azion CLI, execute localmente e faça o deploy.
---

# Use APIs do Node.js com polyfills

Você pode importar uma API do Node.js, como `node:buffer`, em uma [function](/pt-br/documentacao/plataforma/functions/) e deixar o build da [Azion CLI](/pt-br/documentacao/devtools/cli/) resolvê-la por meio de polyfills para o [Azion Runtime](/pt-br/documentacao/devtools/runtime/). O build executa o [Azion Bundler](https://github.com/aziontech/bundler), que adiciona os polyfills quando a configuração do projeto os permite. Projetos dos outros presets que a CLI oferece, como Next.js, React, Vue, Angular e Astro, passam pelo mesmo build, tanto quando começam com `azion init` quanto quando entram com `azion link`. Para verificar quais módulos do Node.js uma function pode usar, consulte [APIs do Node.js](/pt-br/documentacao/devtools/runtime/node/).

---

## Pré-requisitos

- Uma conta Azion. Para criar uma, consulte [Criar uma conta](/pt-br/documentacao/fundamentos/criar-uma-conta/).
- A Azion CLI, instalada e com login feito na sua conta. Para instalá-la, consulte [Primeiros passos com a Azion CLI](/pt-br/documentacao/devtools/cli/primeiros-passos/).
- Node.js 18 ou posterior, com npm.
- Um terminal e um editor de código.

---

## Crie um projeto de function em JavaScript

O comando [azion init](/pt-br/documentacao/devtools/cli/init/) cria o projeto a partir de um preset e de um template. Crie um projeto chamado `polyfills-guide`:

```bash
azion init --name polyfills-guide
```

O comando faz cinco perguntas. Em cada lista, use as setas do teclado ou digite para filtrar as entradas. Responda nesta ordem:

1. **Selecione o preset Javascript**

   Em `? Choose a preset:`, selecione *Javascript*.

2. **Selecione o template Hello World**

   Em `? Choose a template:`, selecione *Hello World*.

3. **Instale as dependências**

   Em `Do you want to install project dependencies?`, digite `Y`.

4. **Pule o servidor de desenvolvimento local**

   Em `Do you want to start a local development server?`, digite `n`.

5. **Pule o deploy**

   Em `Do you want to deploy your project?`, digite `n`.

O comando busca o template, instala as dependências e confirma o projeto:

```text
? Choose a preset: Javascript
? Choose a template: Hello World

Fetching selected template...

Template successfully fetched
Template successfully configured
🤔 Do you want to install project dependencies? This may be required to generate initial configuration file (Y/n) Y
Installing application dependencies
up to date, audited 1 package in 307ms
found 0 vulnerabilities
…
[Azion] [Build] › ℹ  info      Using preset: javascript
[Azion] [Build] › ✔  success   Build completed successfully with only azion.config
[Azion] [IaC] › ✔  success   Manifest generated successfully at <project-dir>/.edge/manifest.json
🤔 Do you want to start a local development server? (y/N) n
If you want to start a local development server later, run 'azion dev'
Make sure to change to the new working directory before running building or deploying your project
🤔 Do you want to deploy your project? (y/N) n
If you want to deploy your application later, run 'azion deploy'
Make sure to change to the new working directory before running building or deploying your project
Your application polyfills-guide was initialized successfully
```

Os comandos seguintes são executados dentro do diretório do projeto. Acesse o diretório:

```bash
cd polyfills-guide
```

O diretório `polyfills-guide` contém o projeto da function, com `index.js` como arquivo de entrada e `azion.config.mjs` como arquivo de configuração.

---

## Verifique a configuração de polyfills

A chave `polyfills` do objeto `build` em `azion.config.mjs` define se o build adiciona polyfills. Ela recebe um booleano: `true` adiciona os polyfills, e `false` os deixa de fora. Os polyfills são permitidos por padrão. O arquivo que o `azion init` gera para o preset Javascript já define a chave como `true`. O trecho mostra o bloco `build` e corta o restante do arquivo em `…`:

```javascript
export default {
  build: {
    preset: 'javascript',
    polyfills: true
  },
  …
}
```

Mantenha o arquivo como está para usar uma API do Node.js na próxima etapa. Para todas as chaves que o arquivo aceita, consulte [azion.config.js](/pt-br/documentacao/devtools/cli/azion-config-js/).

O build do projeto inclui os polyfills.

---

## Importe uma API do Node.js na function

O build usa `index.js` como entrada padrão do preset Javascript. Substitua o conteúdo de `index.js` pela function a seguir. Ela importa `Buffer` de `node:buffer`, codifica uma string em dois formatos e sobrescreve parte dela:

```javascript
/**
 * An example of using the Node.js Buffer API in an Azion Function.
 * Build and run with the Azion CLI:
 * azion build
 * azion dev
 */
// Import the Buffer class from the node:buffer module
import { Buffer } from "node:buffer";

const main = async (event) => {
  // Create a buffer from the string "Hello Edge!" with UTF-8 encoding
  const helloBuffer = Buffer.from("Hello Edge!", "utf8");

  // Log the buffer content as a hexadecimal string
  console.log(helloBuffer.toString("hex"));
  // 48656c6c6f204564676521

  // Log the buffer content as a base64 string
  console.log(helloBuffer.toString("base64"));
  // SGVsbG8gRWRnZSE=

  // Overwrite 5 bytes at offset 6 with the string "World"
  helloBuffer.write("World", 6, 5, "utf8");

  // Log the updated buffer content as a string
  console.log(helloBuffer.toString());
  // Hello World

  // Return the buffer content as a response with a 200 status
  return new Response(helloBuffer.toString(), { status: 200 });
};

export default main;
```

A function registra três valores com `console.log`, como mostram os comentários dela, e responde a cada requisição com a string sobrescrita. Para mais operações de `Buffer`, consulte [node:buffer](/pt-br/documentacao/devtools/runtime/node/buffer/).

---

## Execute a function localmente

O comando [azion dev](/pt-br/documentacao/devtools/cli/dev-comando/) faz o build do projeto com os polyfills dele e serve a function na sua máquina. Inicie o comando:

```bash
azion dev
```

O comando faz o build da function e a serve na porta 3333:

```text
…
[Azion] [Build] › ℹ  info      Using preset: javascript
[Azion] [Pre-Build] › ℹ  info      Starting pre-build...
[Azion] [Pre-Build] › ℹ  info      Pre-build completed successfully
[Azion] [Build] › ℹ  info      Using preset default entry: index.js
[Azion] [Build] › ⚠  warning   DEPRECATED: Migrate handler to → export default { fetch: (request, env, ctx) => {...} }
[Azion] [Build] › ℹ  info      Starting build...
[Azion] [Build] › ✔  success   Build completed successfully
[Azion] [Post-Build] › ℹ  info      Starting post-build...
[Azion] [Post-Build] › ✔  success   Post-build completed successfully
[Azion] [Server] › ✔  success   Function running on port 0.0.0.0:3333, url: http://localhost:3333
[Azion] [Server] › ℹ  info      Initial scan complete. Ready for changes.
```

O aviso `DEPRECATED` se refere ao formato `export default main` da function, que continua passando pelo build e sendo executado. Para o formato que o build recomenda, consulte [Handlers](/pt-br/documentacao/devtools/runtime/api-reference/handlers/).

Abra `http://localhost:3333` em um navegador. A function responde com a string sobrescrita:

```text
Hello World
```

A API `Buffer` é executada localmente por meio dos polyfills. Quando terminar, encerre o servidor no terminal em que ele está sendo executado.

Um módulo que é resolvido no build ainda pode lançar `[unenv] <name> is not implemented yet!` quando uma function chama um dos métodos dele. Antes de usar um módulo, verifique o status dele em [APIs do Node.js](/pt-br/documentacao/devtools/runtime/node/). Para a lista de APIs que o bundler resolve por meio de polyfills, consulte o [repositório do Azion Bundler](https://github.com/aziontech/bundler). O Azion Bundler é open source, e você pode propor presets e implementações no repositório.

---

## Faça o deploy da function

O comando [azion deploy](/pt-br/documentacao/devtools/cli/deploy/) envia o projeto, faz o build dele com a mesma configuração de polyfills e cria a function, a aplicação e o workload. No diretório `polyfills-guide`, faça o deploy do projeto:

```bash
azion deploy
```

O comando imprime o domínio do workload:

```text
Running deploy command
Uploading source files

Upload completed successfully!
Please visit https://console.azion.com/create/deploy/00000000-0000-0000-0000-000000000001 in case it did not open automatically, to follow up the full deploy process
Your Application was deployed successfully

To visualize your application access the Domain: https://xxxxxxxxxx.map.azionedge.net
Your application is being deployed to all Azion Locations and it might take a few minutes.
```

O primeiro deploy pode levar vários minutos para responder em todas as localidades; os deploys seguintes levam cerca de dois minutos. Abra o domínio que o comando imprimiu. Depois do deploy, a function responde com `Hello World`, a mesma string da execução local.

Para as flags que alteram como o comando faz o build e o upload, como `--auto`, `--dry-run` e `--workers`, consulte [azion deploy](/pt-br/documentacao/devtools/cli/deploy/).

---

## Próximos passos

- [APIs do Node.js](/pt-br/documentacao/devtools/runtime/node.md): Verifique quais módulos do Node.js uma function pode usar e como cada um se comporta.
- [node:buffer](/pt-br/documentacao/devtools/runtime/node/buffer.md): Converta codificações, combine buffers e leia corpos de requisição como bytes.
- [azion.config.js](/pt-br/documentacao/devtools/cli/azion-config-js.md): Defina as chaves build, entry e polyfills da configuração do projeto.
- [Handlers](/pt-br/documentacao/devtools/runtime/api-reference/handlers.md): Migre a function para o formato de handler que o build recomenda.