> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# Deployer

Le Deployer gère le déploiement des applications Mastra autonomes en regroupant le code, en gérant les fichiers d’environnement et en servant les applications au moyen du framework Hono. Les implémentations concrètes doivent définir la méthode deploy pour des cibles de déploiement précises.

## Exemple d’utilisation

Pour créer un Deployer personnalisé, étendez la classe abstraite `Deployer` et implémentez la méthode `deploy` avec votre propre logique de déploiement. Exemple :

```typescript
import { Deployer } from '@mastra/deployer'

class CustomDeployer extends Deployer {
  constructor() {
    super({ name: 'custom-deployer' })
  }

  async deploy(outputDirectory: string): Promise<void> {
    // Prepare the output directory
    await this.prepare(outputDirectory)

    // Bundle the application
    await this._bundle('server.ts', 'mastra.ts', outputDirectory)

    // Custom deployment logic
  }
}
```

## Paramètres

### Paramètres du constructeur

**args** (`object`): Options de configuration du Deployer.

**args.name** (`string`): Nom unique de l’instance du Deployer.

### Paramètres de deploy

**outputDirectory** (`string`): Répertoire dans lequel sera générée l’application regroupée et prête au déploiement.

## Méthodes

**getEnvFiles** (`() => Promise<string[]>`): Renvoie la liste des fichiers d’environnement à utiliser pendant le déploiement. Par défaut, recherche les fichiers '.env.production' et '.env'.

**deploy** (`(outputDirectory: string) => Promise<void>`): Méthode abstraite que les sous-classes doivent implémenter. Gère le processus de déploiement vers le répertoire de sortie indiqué.

## Méthodes héritées de Bundler

La classe Deployer hérite des méthodes principales suivantes de la classe Bundler :

**prepare** (`(outputDirectory: string) => Promise<void>`): Prépare le répertoire de sortie en le nettoyant et en créant les sous-répertoires nécessaires.

**writePackageJson** (`(outputDirectory: string, dependencies: Map<string, string>) => Promise<void>`): Génère un fichier package.json dans le répertoire de sortie avec les dépendances indiquées.

**\_bundle** (`(serverFile: string, mastraEntryFile: string, outputDirectory: string, bundleLocation?: string) => Promise<void>`): Regroupe l’application au moyen des fichiers d’entrée du serveur et de Mastra indiqués.

## Concepts fondamentaux

### Cycle de vie du déploiement

La classe abstraite Deployer implémente un cycle de vie de déploiement structuré :

1. **Initialisation :** le Deployer est initialisé avec un nom et crée une instance de Deps pour gérer les dépendances.
2. **Configuration de l’environnement :** la méthode `getEnvFiles` identifie les fichiers d’environnement (.env.production, .env) à utiliser pendant le déploiement.
3. **Préparation :** la méthode `prepare`, héritée de Bundler, nettoie le répertoire de sortie et crée les sous-répertoires nécessaires.
4. **Regroupement :** la méthode `_bundle`, héritée de Bundler, regroupe le code de l’application et ses dépendances.
5. **Déploiement :** les sous-classes implémentent la méthode abstraite `deploy` afin de gérer le processus de déploiement réel.

### Gestion des fichiers d’environnement

La classe Deployer prend nativement en charge la gestion des fichiers d’environnement au moyen de la méthode `getEnvFiles`. Cette méthode :

- Recherche les fichiers d’environnement dans un ordre prédéfini (.env.production, .env)
- Utilise FileService pour trouver le premier fichier existant
- Renvoie un tableau des fichiers d’environnement trouvés
- Renvoie un tableau vide si aucun fichier d’environnement n’est trouvé

```typescript
getEnvFiles(): Promise<string[]> {
  const possibleFiles = ['.env.production', '.env.local', '.env'];

  try {
    const fileService = new FileService();
    const envFile = fileService.getFirstExistingFile(possibleFiles);

    return Promise.resolve([envFile]);
  } catch {}

  return Promise.resolve([]);
}
```

### Relation entre le regroupement et le déploiement

La classe Deployer étend la classe Bundler, établissant une relation claire entre le regroupement et le déploiement :

1. **Regroupement comme prérequis :** le regroupement est une étape préalable au déploiement, durant laquelle le code de l’application est conditionné dans un format déployable.
2. **Infrastructure partagée :** le regroupement et le déploiement partagent une infrastructure commune, comme la gestion des dépendances et les opérations sur le système de fichiers.
3. **Logique de déploiement spécialisée :** le regroupement se concentre sur le packaging du code, tandis que le déploiement ajoute une logique propre à l’environnement pour déployer le code regroupé.
4. **Extensibilité :** la méthode abstraite `deploy` permet de créer des Deployers spécialisés pour différentes cibles d’environnement.