> ## 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.

# Panoramica delle funzioni backend

> Scrivi logica backend personalizzata con funzioni serverless basate su Deno

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Stai visualizzando la documentazione per sviluppatori
    </div>

    <div className="dev-docs-banner-text">
      Questa documentazione è per sviluppatori che lavorano con la piattaforma di sviluppo Base44. Per informazioni sulle funzioni backend nell'editor di app, consulta{" "}

      <a href="/Integrations/Using-integrations#activating-backend-functions">
        Usare le integrazioni
      </a>

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

Le funzioni backend ti permettono di eseguire codice backend personalizzato in un ambiente sicuro e isolato. Usa le funzioni per implementare logica di business che non dovrebbe essere eseguita nel browser, connetterti ad API di terze parti con credenziali protette, elaborare webhook o estendere la tua app con endpoint personalizzati.

Le funzioni backend vengono eseguite su [Deno](https://docs.deno.com/runtime/), un runtime TypeScript moderno. Chiama le funzioni dal tuo frontend [usando l'SDK](/developers/references/sdk/docs/interfaces/functions), che gestisce automaticamente l'autenticazione. Ogni funzione ottiene anche un proprio endpoint HTTP per webhook e integrazioni esterne.

Le funzioni possono anche essere eseguite automaticamente usando le [automazioni](/developers/backend/resources/backend-functions/automations). Pianifica funzioni per essere eseguite in momenti specifici o attivarle in risposta a eventi del database come la creazione, l'aggiornamento o l'eliminazione di record.

<Note>Ogni progetto supporta un massimo di 50 funzioni backend.</Note>

## Crea funzioni

Crea funzioni backend come file TypeScript nella directory delle funzioni del tuo progetto. Per impostazione predefinita la directory delle funzioni è `base44/functions/`, ma puoi personalizzare il percorso nella tua [configurazione del progetto](/developers/backend/overview/project-structure#config-jsonc).

Ogni funzione vive in una propria sottodirectory con un file `entry.ts` o `entry.js`:

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

La CLI usa il percorso della directory relativo alla root delle funzioni come nome della funzione. Ad esempio, `functions/sendWelcomeEmail/entry.ts` crea una funzione chiamata `sendWelcomeEmail`. Puoi anche annidare le funzioni in sottodirectory per organizzazione. `functions/email/send/entry.ts` crea una funzione chiamata `email/send`.

### Aggiungere un file di configurazione

Per esigenze avanzate come nomi di funzione personalizzati o [automazioni](/developers/backend/resources/backend-functions/automations), aggiungi un file `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>

Il file di configurazione definisce il nome della funzione e il punto di ingresso:

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

| Proprietà     | Descrizione                                                                                                                                                                                                                                      |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name`        | Opzionale. Identificatore univoco per la funzione. Usato quando viene invocata tramite SDK o HTTP. Valore predefinito il percorso della directory relativo alla root delle funzioni.                                                             |
| `entry`       | Il file che contiene il codice della funzione.                                                                                                                                                                                                   |
| `automations` | Opzionale. Array di configurazioni di automazione per eseguire la funzione in base a una pianificazione o in risposta a eventi del database. Consulta [Automazioni](/developers/backend/resources/backend-functions/automations) per i dettagli. |

### entry.ts

Il file di codice contiene la logica della tua funzione. Le funzioni devono usare il wrapper `Deno.serve()` e restituire oggetti `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 });
  }
});
```

## Testa in locale

Esegui le tue funzioni in locale con [`base44 dev`](/developers/references/cli/commands/dev) per testare le modifiche senza distribuire. Consulta [Sviluppo locale](/developers/backend/overview/local-dev/local-development-overview) per i dettagli.

## Distribuisci le funzioni

Distribuisci le funzioni con [`functions deploy`](/developers/references/cli/commands/functions-deploy) o [`deploy`](/developers/references/cli/commands/deploy) per inviare tutte le risorse del progetto in una volta. Puoi distribuire funzioni specifiche per nome con `functions deploy <names...>`, oppure usare `--force` per rimuovere le funzioni remote non trovate in locale.

Per scaricare le funzioni distribuite nel tuo progetto locale, usa [`functions pull`](/developers/references/cli/commands/functions-pull). Per vedere cosa è attualmente distribuito, usa [`functions list`](/developers/references/cli/commands/functions-list).

## Chiama le funzioni

Chiama le funzioni backend dal tuo frontend usando l'SDK, o tramite HTTP per webhook e integrazioni esterne.

### Tramite l'SDK

Usa [`base44.functions.invoke()`](/developers/references/sdk/docs/interfaces/functions) per chiamare le funzioni dal tuo frontend. L'SDK gestisce automaticamente l'autenticazione, passando le credenziali dell'utente corrente alla tua funzione.

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

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

### Tramite HTTP

Ogni funzione distribuita ottiene un endpoint HTTP a:

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

Questo è utile per:

* **Webhook:** ricevere callback da servizi esterni come Stripe o GitHub.
* **Integrazioni esterne:** consentire ad altri sistemi di interagire con la tua app.
* **Test:** chiamare funzioni direttamente con strumenti come cURL o Postman.

**Esempio d'uso**

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

<Note>
  Quando chiami funzioni tramite HTTP diretto (come cURL o webhook), non c'è
  un contesto utente autenticato. Usa `asServiceRole` per tutte le operazioni in questi
  casi.
</Note>

## Usa l'SDK nelle funzioni

All'interno delle tue funzioni backend, puoi accedere ai dati, all'autenticazione e alle integrazioni della tua app tramite l'SDK di Base44. Usa [`createClientFromRequest()`](/developers/references/sdk/docs/functions/createClientFromRequest) per creare un client dalla richiesta in arrivo.

Il contesto di autenticazione dipende da come è stata chiamata la funzione:

* **Quando viene chiamata tramite l'SDK dal tuo frontend:** l'autenticazione dell'utente viene passata automaticamente. Puoi accedere all'utente corrente con `base44.auth.me()` ed eseguire operazioni con i suoi permessi. Per leggere o scrivere dati senza che vengano applicate le regole di accesso alle entità, usa [`asServiceRole`](/developers/references/sdk/docs/functions/createClientFromRequest#asservicerole).

* **Quando viene chiamata tramite HTTP diretto (cURL, webhook, servizi esterni):** non c'è un utente autenticato, quindi usa `asServiceRole` per tutte le operazioni.

## Connettiti ad API di terze parti

Le funzioni backend sono uno dei diversi modi per [connettersi ad API di terze parti](/developers/references/sdk/getting-started/third-party-apis). Sono ideali quando hai bisogno di pieno controllo sulle richieste o vuoi memorizzare in modo sicuro le chiavi API come variabili d'ambiente. Usa [`secrets set`](/developers/references/cli/commands/secrets-set) per configurare le variabili d'ambiente dalla CLI.

## Visualizza i log

Durante lo [sviluppo locale](/developers/backend/overview/local-dev/local-development-overview), l'output delle funzioni viene stampato direttamente nel tuo terminale senza bisogno del comando `logs`.

Per le funzioni distribuite, visualizza i log con il comando [`logs`](/developers/references/cli/commands/logs). I log includono output della console, errori e informazioni di timing. Puoi filtrare per nome della funzione o intervallo di tempo. Se stai usando un agente IA di programmazione, la skill [base44-troubleshooter](/developers/backend/overview/skills#base44-troubleshooter) può recuperare e analizzare automaticamente questi log.

## Tipi TypeScript

Genera tipi TypeScript dalle configurazioni delle tue funzioni per ottenere sicurezza dei tipi e autocompletamento per i nomi delle funzioni nel tuo codice SDK. Scopri di più sui [tipi dinamici](/developers/references/sdk/getting-started/dynamic-types).

## Vedi anche

* [Automazioni](/developers/backend/resources/backend-functions/automations): pianifica le funzioni o attivale su eventi del database
* [Modulo `functions`](/developers/references/sdk/docs/interfaces/functions): riferimento SDK per invocare le funzioni
* [`createClientFromRequest`](/developers/references/sdk/docs/functions/createClientFromRequest): creazione di un client nelle funzioni backend
* [`functions deploy`](/developers/references/cli/commands/functions-deploy): distribuisci le funzioni locali su Base44
* [`functions pull`](/developers/references/cli/commands/functions-pull): scarica le funzioni distribuite nel tuo progetto locale
* [`functions list`](/developers/references/cli/commands/functions-list): elenca tutte le funzioni distribuite
* [`functions delete`](/developers/references/cli/commands/functions-delete): elimina le funzioni distribuite
* [`logs`](/developers/references/cli/commands/logs): visualizza i log delle funzioni
* [`exec`](/developers/references/cli/commands/exec): testa le funzioni in isolamento da script standalone

<Note>Questa pagina è stata tradotta utilizzando l'IA. Per informazioni più accurate e aggiornate, consulta la [versione inglese](/). </Note>