Skip to main content
Les applications Replit sont configurées avec deux fichiers : .replit et replit.nix. Ils affectent le comportement de votre application Replit, de l’exécution du code aux outils de développement et aux langages. Ces fichiers de configuration sont masqués par défaut. Affichez-les dans votre application Replit en sélectionnant “Afficher les fichiers cachés” dans le menu de l’arborescence de fichiers.
image

Fichier replit.nix

Replit utilise Nix pour gérer les packages et les environnements. Le fichier replit.nix est utilisé pour : Spécifier les dépendances système : Définissez exactement quels packages logiciels votre application Replit nécessite, gérés via Nix, un gestionnaire de packages. Créer des environnements reproductibles : Assurez-vous que votre environnement de développement est cohérent et reproductible, idéal pour les projets collaboratifs et les tests sur plusieurs systèmes. Vous pouvez gérer les packages Nix visuellement via l’outil Dépendances. Apprenez-en plus dans le guide Dépendances système. Pour configurer des packages avec le fichier replit.nix, vous pouvez lister les packages Nix dans le tableau deps, préfixés par pkgs.. Toutes les modifications seront synchronisées après le rechargement de votre shell.
{ pkgs }: {
  deps = [
    pkgs.nodejs-19_x
    pkgs.nodePackages.typescript-language-server
    pkgs.yarn
    pkgs.replitPackages.jest
  ];
}

Fichier .replit

Le fichier .replit contrôle le comportement de votre application Replit. Il utilise le format de configuration toml. Voici quelques aspects clés qui peuvent être configurés : Commande d’exécution : Spécifiez la commande qui s’exécute lorsque le bouton Exécuter est sélectionné. Chaque modèle dispose d’une commande d’exécution par défaut pour permettre l’exécution immédiate du code. Pour des applications plus personnalisées et complexes, utilisez les Workflows. Language Server Protocol (LSP) : Fournit des fonctionnalités comme la complétion automatique, la navigation dans le code, la coloration syntaxique et le linting en temps réel. Variables d’environnement : Définissez et gérez les variables d’environnement essentielles au bon fonctionnement de vos applications. Dépendances et packages : Gérez les installations de packages et les configurations directement via le fichier .replit, en vous assurant que votre application Replit dispose de tous les outils nécessaires au démarrage. Vous pouvez gérer les dépendances visuellement via l’outil Dépendances. Apprenez-en plus dans le guide Modules système. Pour les applications Python, le fichier .replit par défaut ressemble à ceci :
entrypoint = "main.py"
modules = ["python-3.10:v18-20230807-322e88b"]

[nix]
channel = "stable-23_05"

[unitTest]
language = "python3"

[gitHubImport]
requiredFiles = [".replit", "replit.nix"]

[deployment]
run = ["python3", "main.py"]
deploymentTarget = "cloudrun"
Le tableau suivant fournit une vue de chaque paramètre dans le fichier .replit, expliquant ce que fait chaque configuration et son impact sur l’environnement de l’application Replit.
Clé de configurationValeur/ExempleDescription
entrypointmain.pySpécifie le fichier principal à exécuter et afficher par défaut à l’ouverture de l’éditeur. Vous pouvez renommer le fichier en fonction de votre application.
modules["python-3.10:v18-20230807-322e88b"]Définit des versions spécifiques de langages de programmation ou d’autres dépendances majeures prises en charge par Replit.
[nix]Spécifie les paramètres d’utilisation de Nix, un gestionnaire de packages, pour gérer les dépendances système. Consultez le document Gestion des dépendances pour plus d’informations.
channelstable-23_05Indique le canal Nix à utiliser, ce qui affecte les versions des dépendances système disponibles.
packages["cowsay", "htop"]Spécifie certains packages Nix à installer. Pour un contrôle plus précis, vous pouvez également utiliser replit.nix.
[unitTest]Configure les paramètres liés aux tests unitaires dans l’application Replit.
languagepython3Spécifie le langage utilisé pour les tests unitaires, indiquant que Python 3 est utilisé pour écrire les tests.
[gitHubImport]Paramètres qui affectent la façon dont les projets sont importés depuis GitHub, notamment quels fichiers doivent être inclus.
requiredFiles[".replit", "replit.nix"]Liste les fichiers qui doivent être présents lors de l’importation du projet pour s’assurer qu’il fonctionne correctement.
[deployment]Contient les paramètres de déploiement de l’application depuis l’application Replit vers un environnement en ligne.
run["python3", "main.py"]Commande exécutée pour démarrer l’application lors du déploiement.
deploymentTargetcloudrunSpécifie la plateforme cible de déploiement pour l’hébergement de l’application.
Maintenant que vous avez une idée des configurations par défaut du fichier .replit, utilisez les sections suivantes pour comprendre comment configurer les paramètres de base et avancés de votre application Replit.

Configurer les paramètres de base

Point d’entrée

Il s’agit du fichier principal de votre projet. Si vous ne définissez pas de propriété run, entrypoint est le fichier exécuté par le runtime.
entrypoint = "<nom-du-fichier>.py"

Commande Run

La propriété run dans le fichier .replit est une fonctionnalité clé qui détermine la commande initiale ou la série de commandes exécutées lorsque le bouton Exécuter est sélectionné dans un environnement Replit. La commande Run peut être spécifiée soit comme une chaîne représentant la commande à exécuter, soit comme un tableau de chaînes représentant la commande et les arguments individuels de cette commande. Quelques façons courantes de configurer la commande Run :
  • Commande unique : Cet exemple montre comment passer une seule commande à exécuter directement dans l’application Replit. Avec ceci dans votre fichier .replit, appuyer sur le bouton Exécuter affichera un message dans le panneau Console : Exemple : run = "echo 'Hello, Replit!'"
  • Arguments explicites : Dans certaines situations, il peut être bénéfique d’être plus explicite, en évitant le besoin d’analyser les guillemets ou les règles d’interpolation du shell. Vous pouvez réécrire l’exemple ci-dessus pour séparer les arguments. Notez que vous n’avez plus besoin des ' et ", puisque vous passez explicitement le message comme premier et seul argument à echo : Exemple : run = ["echo", "Hello, Replit!"]
  • Commandes multiples : Cet exemple montre comment exécuter plusieurs processus simultanément, comme un frontend et un backend. Cela peut être utile pour développer un backend Python et un frontend TypeScript, où chaque serveur est lié à un port différent : Exemple : run = "python -m app & npm run start & wait"

Gestion des processus

Bien que plusieurs commandes puissent être exécutées simultanément avec &, vous voudrez peut-être une meilleure expérience pour distinguer les journaux entre les services. Vous pouvez ajouter des dépendances système comme process-compose pour mieux orchestrer plusieurs processus.

Phase Build

Pour certains langages ou runtimes, il existe une phase de compilation séparée avant que le code puisse être exécuté. Cela couvre à la fois les langages compilés comme TypeScript, Golang ou Java, ou offre un paramètre que vous pouvez utiliser pour réinitialiser votre environnement, vos données ou votre configuration avant que le prochain run soit invoqué.
  • Compilation : Dans un dépôt TypeScript, vous aurez peut-être besoin d’exécuter tsc avant d’exécuter votre code. Exemple :
build = "tsc app.ts"
run = "node app.js"

Inclure des variables d’environnement

Pour fournir des variables d’environnement à votre service avant l’exécution, vous pouvez développer la propriété run en une table. Il s’agit d’un changement plus impliqué, et nécessite probablement de déplacer l’emplacement de votre propriété run = "..." dans votre fichier .replit. Le diff suivant montre comment fournir la commande via les args de [run], ainsi que la variable NAME fournie dans [run.env] :
-run = ["bash", "-c", "echo \"Hello, $NAME!\""]

 modules = ["nodejs-20"]

 hidden = [".pythonlibs"]

+# We need to move our new [run] down past all the
+# top-level properties that do not start with a `[`!
+[run]
+args = ["bash", "-c", "echo \"Hello, $NAME!\""]
+
+[run.env]
+NAME="Replit"

 [nix]
 channel = "stable-23_11"

Interactivité

Les programmes interactifs peuvent également être lancés via le bouton Exécuter, offrant un moyen de distinguer votre environnement de développement du terminal où votre programme s’exécute. Considérez le script de décompte suivant : Exemple
[run]
args = ["bash", "-c", """
count=0
while read -p "$PROMPT" -r next && [ -n "$next" ]; do
    count=$((count+next))
done
echo "The numbers you entered sum to $count!"
"""]

[run.env]
PROMPT = "Next number ([Enter] to end): "

Options de configuration avancées

Explorez les options de configuration détaillées disponibles pour votre application Replit. Vous pouvez personnaliser votre environnement de développement, gérer les commandes d’exécution, intégrer des services de langage et gérer les dépendances.
ConfigurationCléValeur/ExempleDescription
onBootonBootonBoot = "npm install"Commande qui s’exécute au démarrage de l’application Replit.
compilecompile(Pas d’exemple par défaut)Commande qui s’exécute avant la commande run, utilisée dans les langages compilés comme C++.
languagelanguagelanguage = "javascript"Spécifie le langage lors d’un import GitHub ou de la création d’une application Replit.
entrypointentrypointentrypoint = "index.js"Fichier principal à exécuter et afficher à l’ouverture de l’éditeur.
hiddenhiddenhidden = [".config", "package-lock.json"]Fichiers ou dossiers à masquer par défaut dans l’arborescence de fichiers latérale.
audioaudioaudio = trueActive l’audio système lorsque défini à true.

Notes sur l’audio système

Lorsque vous définissez audio = true dans votre fichier .replit, vous devrez peut-être exécuter kill 1 dans un shell pour forcer la prise en compte du nouveau paramètre. Lors de l’exécution d’une application graphique, vous verrez une paire d’écouteurs avec une case à cocher dans le coin inférieur droit du panneau Sortie. En raison des restrictions du navigateur, cela devra être activé à chaque actualisation.
# Ensure this is at the top of your `.replit` file, outside of any `[`-bracketed section
audio = true

Configuration du gestionnaire de packages

ConfigurationCléValeur/ExempleDescription
packagerlanguagepackager.language = "python3"Langage utilisé pour les opérations de packages.
fonctionnalités packagerguessImportspackager.features.guessImports = trueDeviner automatiquement les packages à installer avant l’exécution de l’application Replit.
fonctionnalités packagerpackageSearchpackager.features.packageSearch = trueActive le support du gestionnaire de packages lorsque défini à true.
fonctionnalités packagerenabledForHostingpackager.features.enabledForHosting = falseDéfinit si l’hébergement de l’application Replit nécessite l’exécution d’une installation de package.
packagerafterInstallafterInstall = "echo 'package installed'"Commande exécutée après l’installation d’un nouveau package via le gestionnaire.
packagerignoredPathsignoredPaths = [".git"]Chemins à ignorer lors de la tentative de deviner les packages.
packagerignoredPackagesignoredPackages = ["twitter", "discord"]Modules qui ne doivent jamais tenter de deviner un package lors de l’installation.

Exemple de configuration .replit pour la configuration du gestionnaire de packages

# Define the language for the Replit App
packager.language = "python3"

# Enable features for automatic package management
[packager.features]
guessImports = true
packageSearch = true
enabledForHosting = false

# Command to run after each package installation
packager.afterInstall = "echo 'Package installed successfully'"

# Define paths and packages that should be ignored by the package manager
packager.ignoredPaths = [".git", "node_modules"]
packager.ignoredPackages = ["twitter", "discord"]

# Additional deployment settings
[deployment]
run = ["python3", "app.py"]

Configuration du déploiement

ConfigurationCléValeur/ExempleDescription
deploymentrundeployment.run = "npm start"Commande exécutée au démarrage d’un conteneur de déploiement.
deploymentbuilddeployment.build = "npm run build"Commande exécutée avant l’exécution d’un déploiement.
deploymentignorePortsdeployment.ignorePorts = trueSi true, le succès du déploiement ne nécessite pas de vérification de port ouvert.

Exemple de configuration .replit pour la configuration du déploiement


# Specifies the main entry point for the project
entrypoint = "app.js"

# Configuration settings for deploying the application
[deployment]
run = "npm start"
build = "npm run build"
ignorePorts = true
La configuration de l’interpréteur a été dépréciée et n’est plus disponible dans Replit. Au lieu de cela, il est recommandé d’utiliser les commandes Run pour configurer la façon dont les scripts et les applications sont exécutés dans votre environnement d’application Replit.

Configuration des ports

ConfigurationCléValeur/ExempleDescription
portslocalPortlocalPort = 3000Port que Replit lie à un port externe.
portsexternalPortexternalPort = 80Port accessible publiquement lié au localPort.

Exemple de fichier de configuration .replit pour la gestion des ports

# Networking configuration to expose your application on specific ports
[[ports]]
localPort = 3000
externalPort = 80

Accéder aux métadonnées d’environnement de l’application Replit

Node.js

Pour accéder à toutes les variables d’environnement : console.log(process.env); Pour accéder à une variable unique (REPL_SLUG) : console.log(process.env.REPL_SLUG);

Python

Pour accéder à toutes les variables d’environnement :
import os
print(os.environ)
Pour accéder à une variable unique (REPL_SLUG) :
import os
variable = os.environ.get('REPL_SLUG')
print(variable)

Rust

Pour accéder à toutes les variables d’environnement :
use std::env;
fn main() {
    for (key, value) in env::vars() {
        println!("{}: {}", key, value);
    }
}
Pour accéder à une variable unique (REPL_SLUG) :
use std::env;
fn main() {
    let variable = env::var("REPL_SLUG").unwrap();
    println!("{}", variable);
}

Variables d’environnement

Voici les variables d’environnement accessibles depuis votre application Replit :
clédescription
REPL_OWNERLe nom d’utilisateur du propriétaire de l’application Replit. Si votre application Replit est textuelle et n’a pas de serveur web, REPL_OWNER reflétera la valeur de l’utilisateur actuel accédant à l’application Replit
REPL_IDLa chaîne UUID unique de votre application Replit
HOMELe chemin d’accueil de votre application Replit
systemLe système d’exploitation fonctionnant sur votre application Replit
LANGDéfinit la langue et l’encodage des caractères pour votre application Replit, affectant la façon dont le texte est traité et affiché
REPL_IMAGEL’image docker qui correspond à votre application Replit
REPL_LANGUAGELe langage de programmation configuré pour votre application Replit, utilisé pour déterminer l’environnement d’exécution et les outils
REPL_PUBKEYSUn objet JSON stringifié contenant différentes clés API publiques
REPL_SLUGUne version simplifiée et lisible par machine du nom de l’application Replit, adaptée à une utilisation dans les URL et les noms de fichiers
PRYBAR_FILELe fichier principal/point d’entrée de votre application Replit
REPLIT_DEV_DOMAINFournit l’URL replit.dev pour votre application Replit dans l’Éditeur de projet. Notez que cette variable d’environnement n’est pas disponible dans les déploiements