---
name: azion-crie-uma-funcao-com-webassembly
description: >-
  Compile e instancie um módulo WebAssembly dentro de uma função, a partir de um array de bytes no código ou de um arquivo .wasm que o handler busca.
---

# Crie uma função com WebAssembly

Uma [função](/pt-br/documentacao/plataforma/functions/) compila e instancia um módulo [WebAssembly](https://webassembly.org/getting-started/developers-guide/) com a WebAssembly API, dentro do handler. Azion Runtime fornece essa API com a interface que a MDN define. Para conhecer os métodos estáticos e os construtores que ela carrega, consulte [WebAssembly](/pt-br/documentacao/devtools/runtime/api-reference/webassembly/).

Os passos abaixo usam Azion Console. O módulo desta página exporta uma operação, `increment`, e o handler retorna o resultado dela no corpo da resposta. Os bytes do módulo chegam ao handler de duas formas: como um array de bytes no código da função ou como um arquivo `.wasm` que o handler busca por HTTP.

---

## Pré-requisitos

- Uma conta Azion. Para criar uma, consulte [Como criar uma conta na Azion](/pt-br/documentacao/fundamentos/criar-uma-conta/).
- A permissão **Edit Functions** na conta. Ela concede permissão para criar, editar e remover funções, e também requer a permissão **View Functions**. Consulte [Teams Permissions](/pt-br/documentacao/fundamentos/teams-permissions/).

---

## Crie a função com um módulo embutido

O array `wasmCode` contém o módulo, então o handler o compila sem uma requisição de rede. Para criar a função:

1. **Abra a página Functions**

   Acesse [Azion Console](https://console.azion.com/) > **Products Menu** > **Libraries** > **Functions**.

2. **Selecione + Function**

3. **Nomeie a função**

   Digite um nome para a função. Por exemplo: `wasm-increment`.

4. **Cole o código na aba Code**

   Na aba **Code**, cole o código a seguir:

   ```javascript
   export default {
     fetch: async (request, env, ctx) => {
       const wasmCode = new Uint8Array([
         0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 7, 13, 1, 9, 105, 110, 99, 114, 101,
         109, 101, 110, 116, 0, 0, 10, 9, 1, 7, 0, 32, 0, 65, 1, 106, 11,
       ]);

       const wasmModule = new WebAssembly.Module(wasmCode);
       const wasmInstance = new WebAssembly.Instance(wasmModule);
       const increment = wasmInstance.exports.increment;
       let value = 0;

       if (request.headers.has("value")) {
         let number = request.headers.get("value");
         if (!isNaN(number)) {
           value = parseInt(number);
         }
       }

       let incremented = increment(value);
       return new Response("incrementing " + value + " we have " + incremented);
     },
   };
   ```

5. **Selecione Save**

A função fica salva e disponível para ser instanciada em uma aplicação.

O array `wasmCode` é a forma binária do seguinte módulo [WAT](https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format), que soma 1 ao parâmetro `i32` e retorna o resultado:

```text
(module
  (type (;0;) (func (param i32) (result i32)))
  (func (;0;) (type 0) (param i32) (result i32)
    local.get 0
    i32.const 1
    i32.add)
  (export "increment" (func 0)))
```

> **nota**
>
> WAT é a representação textual do formato binário do WebAssembly. Ele existe para que uma pessoa consiga ler e editar um módulo.

Um array de bytes faz parte do código-fonte da função, então o módulo conta para o limite de tamanho de código: 6 MB no Azion Console e 20 MB pela Azion API. Consulte [Limites de Functions](/pt-br/documentacao/plataforma/functions/limites/).

---

## Carregue o módulo a partir de uma URL

Um handler lê os bytes do módulo por HTTP em vez de carregá-los. Substitua o array de bytes por uma chamada `fetch` e passe o corpo da resposta para `WebAssembly.instantiate()`:

```javascript
export default {
  fetch: async (request, env, ctx) => {
    const wasmResponse = await fetch("https://example.com/increment.wasm");
    const wasmCode = await wasmResponse.arrayBuffer();

    const { instance } = await WebAssembly.instantiate(wasmCode);
    const increment = instance.exports.increment;
    let value = 0;

    if (request.headers.has("value")) {
      let number = request.headers.get("value");
      if (!isNaN(number)) {
        value = parseInt(number);
      }
    }

    let incremented = increment(value);
    return new Response("incrementing " + value + " we have " + incremented);
  },
};
```

O handler compila o que a URL retornar, então uma nova versão do módulo chega à função sem alteração de código. Cada chamada `fetch` conta como uma sub-requisição e uma invocação faz no máximo 50 delas. Consulte [Limites de Functions](/pt-br/documentacao/plataforma/functions/limites/).

---

## Verifique a resposta

Uma função só é executada depois que uma [instância de função](/pt-br/documentacao/plataforma/applications/functions-instances/) a vincula a uma aplicação e uma regra do Rules Engine seleciona essa instância. Para montar essa cadeia, consulte [Primeiros passos com Functions](/pt-br/documentacao/plataforma/functions/primeiros-passos/).

Para ler a resposta, requisite a URI definida na regra:

```bash
curl https://<your-azion-domain>/<your-uri>
```

O módulo incrementa o valor padrão, `0`:

```
incrementing 0 we have 1
```

O handler lê o header `value` da requisição quando ela o carrega. Para incrementar outro inteiro, envie-o nesse header:

```bash
curl -H "value: 41" https://<your-azion-domain>/<your-uri>
```

```
incrementing 41 we have 42
```

O corpo da resposta carrega o resultado que o módulo WebAssembly calculou.

---

## Próximos passos

- [Primeiros passos com Functions](/pt-br/documentacao/plataforma/functions/primeiros-passos.md): Instancie a função em uma aplicação e adicione a regra do Rules Engine que a executa.
- [WebAssembly API](/pt-br/documentacao/devtools/runtime/api-reference/webassembly.md): Todos os métodos estáticos e construtores que Azion Runtime carrega, com sintaxe e parâmetros.
- [Migre padrões de handler em Functions](/pt-br/documentacao/guias/desenvolvimento-de-aplicacoes/functions-e-runtime/migrar-padroes-de-handler.md): Os formatos de handler ES Modules e Service Worker e como mover código entre eles.
- [Limites de Functions](/pt-br/documentacao/plataforma/functions/limites.md): Os limites de tamanho de código, sub-requisições e tempo de CPU dentro dos quais uma função é executada.
