> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Visão geral de funções de backend

> Escreva lógica customizada de backend com funções serverless alimentadas por Deno

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Você está vendo a documentação para desenvolvedores
    </div>

    <div className="dev-docs-banner-text">
      Esta documentação é para desenvolvedores que trabalham com a plataforma para desenvolvedores
      Base44. Para informações sobre funções de backend no editor de apps, veja{" "}

      <a href="/Integrations/Using-integrations#activating-backend-functions">
        Usando integrações
      </a>

      .
    </div>
  </div>
</div>

As funções de backend permitem que você execute código customizado de backend em um ambiente seguro e isolado. Use funções para implementar lógica de negócio que não deve rodar no navegador, conectar a APIs de terceiros com credenciais protegidas, processar webhooks ou estender seu app com endpoints customizados.

As funções de backend rodam no [Deno](https://docs.deno.com/runtime/), um runtime moderno de TypeScript. Chame funções do seu frontend [usando o SDK](/developers/references/sdk/docs/interfaces/functions), que cuida da autenticação automaticamente. Cada função também recebe seu próprio endpoint HTTP para webhooks e integrações externas.

As funções também podem rodar automaticamente usando [automations](/developers/backend/resources/backend-functions/automations). Agende funções para rodar em horários específicos ou dispare-as em resposta a eventos do banco de dados como criar, atualizar ou excluir registros.

<Note>Cada projeto suporta no máximo 50 funções de backend.</Note>

## Criar funções

Crie funções de backend como arquivos TypeScript no diretório de funções do seu projeto. Por padrão o diretório de funções é `base44/functions/`, mas você pode personalizar o caminho na [configuração do seu projeto](/developers/backend/overview/project-structure#config-jsonc).

Cada função fica em seu próprio subdiretório com um arquivo `entry.ts` ou `entry.js`:

<Tree>
  <Tree.Folder name="functions" defaultOpen>
    <Tree.Folder name="<function-name>" defaultOpen>
      <Tree.File name="entry.ts" />
    </Tree.Folder>
  </Tree.Folder>
</Tree>

A CLI usa o caminho do diretório relativo à raiz de funções como o nome da função. Por exemplo, `functions/sendWelcomeEmail/entry.ts` cria uma função chamada `sendWelcomeEmail`. Você também pode aninhar funções em subdiretórios para organização. `functions/email/send/entry.ts` cria uma função chamada `email/send`.

### Adicionando um arquivo de configuração

Para necessidades avançadas como nomes customizados de função ou [automations](/developers/backend/resources/backend-functions/automations), adicione um arquivo `function.jsonc`:

<Tree>
  <Tree.Folder name="functions" defaultOpen>
    <Tree.Folder name="<function-name>" defaultOpen>
      <Tree.File name="entry.ts" />

      <Tree.File name="function.jsonc" />
    </Tree.Folder>
  </Tree.Folder>
</Tree>

O arquivo de configuração define o nome e o entry point da função:

```jsonc theme={null}
{
  "name": "sendWelcomeEmail",
  "entry": "entry.ts",
}
```

| Propriedade   | Descrição                                                                                                                                                                                                                         |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`        | Opcional. Identificador único da função. Usado ao invocar pelo SDK ou HTTP. O padrão é o caminho do diretório relativo à raiz de funções.                                                                                         |
| `entry`       | O arquivo contendo o código da função.                                                                                                                                                                                            |
| `automations` | Opcional. Array de configurações de automation para executar a função em um cronograma ou em resposta a eventos do banco de dados. Veja [Automations](/developers/backend/resources/backend-functions/automations) para detalhes. |

### entry.ts

O arquivo de código contém a lógica da sua função. As funções devem usar o wrapper `Deno.serve()` e retornar objetos `Response`:

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  try {
    const base44 = createClientFromRequest(req);
    const user = await base44.auth.me();

    if (!user) {
      return Response.json({ error: "Unauthorized" }, { status: 401 });
    }

    const { name } = await req.json();

    return Response.json({
      message: `Hello, ${name || user.full_name}!`,
    });
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 });
  }
});
```

## Teste localmente

Execute suas funções localmente com [`base44 dev`](/developers/references/cli/commands/dev) para testar mudanças sem fazer deploy. Veja [Desenvolvimento local](/developers/backend/overview/local-dev/local-development-overview) para detalhes.

## Implante funções

Implante funções com [`functions deploy`](/developers/references/cli/commands/functions-deploy) ou [`deploy`](/developers/references/cli/commands/deploy) para enviar todos os recursos do projeto de uma vez. Você pode implantar funções específicas pelo nome com `functions deploy <names...>`, ou usar `--force` para remover funções remotas não encontradas localmente.

Para baixar funções implantadas para seu projeto local, use [`functions pull`](/developers/references/cli/commands/functions-pull). Para ver o que está implantado atualmente, use [`functions list`](/developers/references/cli/commands/functions-list).

## Chamar funções

Chame funções de backend do seu frontend usando o SDK, ou via HTTP para webhooks e integrações externas.

### Pelo SDK

Use [`base44.functions.invoke()`](/developers/references/sdk/docs/interfaces/functions) para chamar funções do seu frontend. O SDK cuida da autenticação automaticamente, passando as credenciais do usuário atual para sua função.

```javascript theme={null}
import { base44 } from "@/api/base44Client";

const response = await base44.functions.invoke("sendWelcomeEmail", {
  name: "Alice",
});
```

### Via HTTP

Cada função implantada recebe um endpoint HTTP em:

```
https://<your-app-domain>/functions/<function-name>
```

Isso é útil para:

* **Webhooks:** Receba callbacks de serviços externos como Stripe ou GitHub.
* **Integrações externas:** Permita que outros sistemas interajam com seu app.
* **Testes:** Chame funções diretamente com ferramentas como cURL ou Postman.

**Exemplo de uso**

```bash theme={null}
curl -X POST https://your-app.base44.app/functions/sendWelcomeEmail \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice"}'
```

<Note>
  Ao chamar funções via HTTP direto (como cURL ou webhooks), não há
  contexto de usuário autenticado. Use `asServiceRole` para todas as operações nesses
  casos.
</Note>

## Use o SDK em funções

Dentro das suas funções de backend, você pode acessar os dados, autenticação e integrações do seu app através do SDK da Base44. Use [`createClientFromRequest()`](/developers/references/sdk/docs/functions/createClientFromRequest) para criar um cliente a partir da requisição recebida.

O contexto de autenticação depende de como a função foi chamada:

* **Quando chamada pelo SDK do seu frontend:** A autenticação do usuário é passada automaticamente. Você pode acessar o usuário atual com `base44.auth.me()` e realizar operações com suas permissões. Para operações de nível admin, use [`asServiceRole`](/developers/references/sdk/docs/functions/createClientFromRequest#asservicerole).

* **Quando chamada via HTTP direto (cURL, webhooks, serviços externos):** Não há usuário autenticado, então use `asServiceRole` para todas as operações.

## Conectar a APIs de terceiros

As funções de backend são uma das várias formas de [conectar a APIs de terceiros](/developers/references/sdk/getting-started/third-party-apis). Elas são ideais quando você precisa de controle total sobre as requisições ou quer armazenar API keys com segurança como variáveis de ambiente. Use [`secrets set`](/developers/references/cli/commands/secrets-set) para configurar variáveis de ambiente pela CLI.

## Veja logs

Durante o [desenvolvimento local](/developers/backend/overview/local-dev/local-development-overview), a saída da função é impressa diretamente no seu terminal sem precisar do comando `logs`.

Para funções implantadas, veja logs com o comando [`logs`](/developers/references/cli/commands/logs). Os logs incluem saída do console, erros e informações de tempo. Você pode filtrar por nome da função ou intervalo de tempo. Se você está usando um agente de codificação de IA, a skill [base44-troubleshooter](/developers/backend/overview/skills#base44-troubleshooter) pode buscar e analisar esses logs automaticamente.

## Tipos TypeScript

Gere tipos TypeScript a partir das configurações das suas funções para obter segurança de tipo e autocomplete para nomes de função no seu código do SDK. Saiba mais sobre [tipos dinâmicos](/developers/references/sdk/getting-started/dynamic-types).

## Veja também

* [Automations](/developers/backend/resources/backend-functions/automations): Agende funções ou dispare-as em eventos do banco de dados
* [Módulo `functions`](/developers/references/sdk/docs/interfaces/functions): Referência do SDK para invocar funções
* [`createClientFromRequest`](/developers/references/sdk/docs/functions/createClientFromRequest): Criando um cliente em funções de backend
* [`functions deploy`](/developers/references/cli/commands/functions-deploy): Implante funções locais na Base44
* [`functions pull`](/developers/references/cli/commands/functions-pull): Baixe funções implantadas para seu projeto local
* [`functions list`](/developers/references/cli/commands/functions-list): Liste todas as funções implantadas
* [`functions delete`](/developers/references/cli/commands/functions-delete): Delete funções implantadas
* [`logs`](/developers/references/cli/commands/logs): Veja logs de função
* [`exec`](/developers/references/cli/commands/exec): Teste funções de forma isolada a partir de scripts autônomos

<Note>Esta página foi traduzida usando IA. Para informações mais precisas e atualizadas, consulte a [versão em inglês](/). </Note>