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

# Présentation des fonctions backend

> Écrivez une logique backend personnalisée avec des fonctions serverless propulsées par Deno

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Vous consultez la documentation pour développeurs
    </div>

    <div className="dev-docs-banner-text">
      Cette documentation est destinée aux développeurs travaillant avec la plateforme
      développeur Base44. Pour des informations sur les fonctions backend dans l'éditeur d'applications, consultez{" "}

      <a href="/Integrations/Using-integrations#activating-backend-functions">
        Utilisation des intégrations
      </a>

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

Les fonctions backend vous permettent d'exécuter du code backend personnalisé dans un environnement sécurisé et isolé. Utilisez les fonctions pour implémenter une logique métier qui ne devrait pas s'exécuter dans le navigateur, se connecter à des API tierces avec des identifiants protégés, traiter des webhooks ou étendre votre application avec des endpoints personnalisés.

Les fonctions backend s'exécutent sur [Deno](https://docs.deno.com/runtime/), un runtime TypeScript moderne. Appelez les fonctions depuis votre frontend [en utilisant le SDK](/developers/references/sdk/docs/interfaces/functions), qui gère l'authentification automatiquement. Chaque fonction obtient également son propre endpoint HTTP pour les webhooks et les intégrations externes.

Les fonctions peuvent également s'exécuter automatiquement en utilisant des [automatisations](/developers/backend/resources/backend-functions/automations). Planifiez l'exécution des fonctions à des heures spécifiques ou déclenchez-les en réponse à des événements de base de données comme la création, la mise à jour ou la suppression d'enregistrements.

<Note>Chaque projet prend en charge un maximum de 50 fonctions backend.</Note>

## Créer des fonctions

Créez des fonctions backend en tant que fichiers TypeScript dans le répertoire des fonctions de votre projet. Par défaut, le répertoire des fonctions est `base44/functions/`, mais vous pouvez personnaliser le chemin dans votre [configuration de projet](/developers/backend/overview/project-structure#config-jsonc).

Chaque fonction vit dans son propre sous-répertoire avec un fichier `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>

La CLI utilise le chemin du répertoire relatif à la racine des fonctions comme nom de fonction. Par exemple, `functions/sendWelcomeEmail/entry.ts` crée une fonction nommée `sendWelcomeEmail`. Vous pouvez également imbriquer des fonctions dans des sous-répertoires pour l'organisation. `functions/email/send/entry.ts` crée une fonction nommée `email/send`.

### Ajouter un fichier de configuration

Pour des besoins avancés comme des noms de fonction personnalisés ou des [automatisations](/developers/backend/resources/backend-functions/automations), ajoutez un fichier `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>

Le fichier de configuration définit le nom de la fonction et le point d'entrée :

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

| Propriété     | Description                                                                                                                                                                                                                                                                |
| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`        | Facultatif. Identifiant unique pour la fonction. Utilisé lors de l'invocation via SDK ou HTTP. La valeur par défaut est le chemin du répertoire relatif à la racine des fonctions.                                                                                         |
| `entry`       | Le fichier contenant le code de la fonction.                                                                                                                                                                                                                               |
| `automations` | Facultatif. Tableau de configurations d'automatisation pour exécuter la fonction selon une planification ou en réponse à des événements de base de données. Consultez [Automatisations](/developers/backend/resources/backend-functions/automations) pour plus de détails. |

### entry.ts

Le fichier de code contient la logique de votre fonction. Les fonctions doivent utiliser le wrapper `Deno.serve()` et retourner des objets `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 });
  }
});
```

## Tester localement

Exécutez vos fonctions localement avec [`base44 dev`](/developers/references/cli/commands/dev) pour tester les changements sans déployer. Consultez [Développement local](/developers/backend/overview/local-dev/local-development-overview) pour plus de détails.

## Déployer les fonctions

Déployez les fonctions avec [`functions deploy`](/developers/references/cli/commands/functions-deploy) ou [`deploy`](/developers/references/cli/commands/deploy) pour pousser toutes les ressources du projet en une fois. Vous pouvez déployer des fonctions spécifiques par nom avec `functions deploy <names...>`, ou utiliser `--force` pour supprimer les fonctions distantes non trouvées localement.

Pour télécharger les fonctions déployées vers votre projet local, utilisez [`functions pull`](/developers/references/cli/commands/functions-pull). Pour voir ce qui est actuellement déployé, utilisez [`functions list`](/developers/references/cli/commands/functions-list).

## Appeler les fonctions

Appelez les fonctions backend depuis votre frontend en utilisant le SDK, ou via HTTP pour les webhooks et les intégrations externes.

### Via le SDK

Utilisez [`base44.functions.invoke()`](/developers/references/sdk/docs/interfaces/functions) pour appeler les fonctions depuis votre frontend. Le SDK gère l'authentification automatiquement, en passant les identifiants de l'utilisateur actuel à votre fonction.

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

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

### Via HTTP

Chaque fonction déployée obtient un endpoint HTTP à :

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

Ceci est utile pour :

* **Webhooks :** recevoir des rappels de services externes comme Stripe ou GitHub.
* **Intégrations externes :** permettre à d'autres systèmes d'interagir avec votre application.
* **Tests :** appeler les fonctions directement avec des outils comme cURL ou Postman.

**Exemple d'utilisation**

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

<Note>
  Lors de l'appel de fonctions via HTTP direct (comme cURL ou les webhooks), il n'y a pas
  de contexte utilisateur authentifié. Utilisez `asServiceRole` pour toutes les opérations dans ces
  cas.
</Note>

## Utiliser le SDK dans les fonctions

À l'intérieur de vos fonctions backend, vous pouvez accéder aux données, à l'authentification et aux intégrations de votre application via le SDK Base44. Utilisez [`createClientFromRequest()`](/developers/references/sdk/docs/functions/createClientFromRequest) pour créer un client à partir de la requête entrante.

Le contexte d'authentification dépend de la manière dont la fonction a été appelée :

* **Lorsqu'appelée via le SDK depuis votre frontend :** l'authentification de l'utilisateur est passée automatiquement. Vous pouvez accéder à l'utilisateur actuel avec `base44.auth.me()` et effectuer des opérations avec ses permissions. Pour des opérations de niveau admin, utilisez [`asServiceRole`](/developers/references/sdk/docs/functions/createClientFromRequest#asservicerole).

* **Lorsqu'appelée via HTTP direct (cURL, webhooks, services externes) :** il n'y a pas d'utilisateur authentifié, utilisez donc `asServiceRole` pour toutes les opérations.

## Se connecter aux API tierces

Les fonctions backend sont l'une des plusieurs façons de [se connecter aux API tierces](/developers/references/sdk/getting-started/third-party-apis). Elles sont idéales lorsque vous avez besoin d'un contrôle total sur les requêtes ou que vous souhaitez stocker des clés API en toute sécurité en tant que variables d'environnement. Utilisez [`secrets set`](/developers/references/cli/commands/secrets-set) pour configurer les variables d'environnement depuis la CLI.

## Voir les logs

Pendant le [développement local](/developers/backend/overview/local-dev/local-development-overview), la sortie des fonctions est affichée directement dans votre terminal sans avoir besoin de la commande `logs`.

Pour les fonctions déployées, voyez les logs avec la commande [`logs`](/developers/references/cli/commands/logs). Les logs incluent la sortie console, les erreurs et les informations de temporisation. Vous pouvez filtrer par nom de fonction ou plage de temps. Si vous utilisez un agent de codage IA, le skill [base44-troubleshooter](/developers/backend/overview/skills#base44-troubleshooter) peut récupérer et analyser automatiquement ces logs.

## Types TypeScript

Générez des types TypeScript à partir de vos configurations de fonction pour obtenir la sécurité des types et l'autocomplétion des noms de fonctions dans votre code SDK. Apprenez-en plus sur les [types dynamiques](/developers/references/sdk/getting-started/dynamic-types).

## Voir aussi

* [Automatisations](/developers/backend/resources/backend-functions/automations) : planifier des fonctions ou les déclencher sur des événements de base de données
* [Module `functions`](/developers/references/sdk/docs/interfaces/functions) : référence SDK pour invoquer les fonctions
* [`createClientFromRequest`](/developers/references/sdk/docs/functions/createClientFromRequest) : créer un client dans les fonctions backend
* [`functions deploy`](/developers/references/cli/commands/functions-deploy) : déployer les fonctions locales vers Base44
* [`functions pull`](/developers/references/cli/commands/functions-pull) : télécharger les fonctions déployées vers votre projet local
* [`functions list`](/developers/references/cli/commands/functions-list) : lister toutes les fonctions déployées
* [`functions delete`](/developers/references/cli/commands/functions-delete) : supprimer les fonctions déployées
* [`logs`](/developers/references/cli/commands/logs) : voir les logs des fonctions
* [`exec`](/developers/references/cli/commands/exec) : tester les fonctions isolément à partir de scripts autonomes

<Note>Cette page a été traduite à l'aide de l'IA. Pour les informations les plus précises et à jour, consultez la [version anglaise](/). </Note>