Écrire des fonctions Atlas en JavaScript
Les apprenants écriront des fonctions Atlas en utilisant l’objet de contexte pour accéder aux services associés, aux variables d’environnement et au client MongoDB intégré.
Écrire des fonctions Atlas en JavaScript est une leçon MongoDB Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage MongoDB Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours MongoDB Academy comprend 4 leçons au total.
Que sont les fonctions Atlas ?
Atlas Functions sont des fonctions JavaScript côté serveur qui s’exécutent dans l’environnement d’exécution géré d’Atlas App Services. Elles constituent l’unité d’exécution des déclencheurs de base de données, des déclencheurs planifiés et des points de terminaison HTTPS. Les fonctions ont un accès complet au client MongoDB, aux variables d’environnement, aux services tiers associés (HTTP, AWS, Twilio, etc.) et peuvent appeler d’autres Atlas Functions.
Anatomie d’une fonction : exports et context
Chaque Atlas Function exporte une unique fonction asynchrone comme point d’entrée via exports = async function(...args) {}. Dans la fonction, l’objet global context donne accès aux services Atlas. La fonction reçoit des arguments qui varient selon le type d’invocation : les déclencheurs de base de données reçoivent un événement de modification, les points de terminaison HTTPS reçoivent une requête HTTP et les fonctions appelées reçoivent les arguments transmis par l’appelant.
// Minimal Atlas Function structure
exports = async function(arg1, arg2) {
// context is globally available
const db = context.services.get('mongodb-atlas').db('mydb')
const result = await db.collection('users').findOne({ _id: arg1 })
return result
}Accéder à MongoDB avec context.services
context.services.get('mongodb-atlas') renvoie un client MongoDB associé à votre cluster Atlas lié. À partir de celui-ci, vous obtenez une référence vers une base de données, puis vers une collection — avec la même API que celle du pilote MongoDB pour Node.js. Les opérations sont asynchrones et doivent être attendues. Le client est préconfiguré avec les identifiants internes d’App Services ; vous n’avez donc pas à gérer les chaînes de connexion dans le code de la fonction.
exports = async function() {
// Get the linked MongoDB service
const mongodb = context.services.get('mongodb-atlas')
const db = mongodb.db('mydb')
const orders = db.collection('orders')
// Full CRUD API available
const pending = await orders.find({ status: 'pending' }).toArray()
await orders.updateMany({ status: 'pending' }, { $set: { notified: true } })
return { processed: pending.length }
}Variables d’environnement : context.values et context.environment
Intégrer des secrets (clés API, mots de passe) en dur dans le code d’une fonction est dangereux. Atlas Functions prennent en charge deux mécanismes de configuration sécurisée : Values — des chaînes statiques ou des secrets stockés dans App Services et accessibles via context.values.get('myValue'). Variables d’environnement — des remplacements propres à chaque environnement, accessibles via context.environment.values.MY_VAR. Utilisez-les pour stocker les clés API, les secrets de webhook et les paramètres propres à chaque environnement.
exports = async function() {
// Retrieve a stored secret (never exposed in function logs)
const apiKey = context.values.get('STRIPE_SECRET_KEY')
// Or use environment-specific values
const webhookUrl = context.environment.values.SLACK_WEBHOOK_URL
// Use in an HTTP call
const http = context.services.get('myHTTP')
await http.post({
url: webhookUrl,
headers: { 'Content-Type': ['application/json'] },
body: JSON.stringify({ text: 'Job complete' })
})
}Effectuer des requêtes HTTP
Atlas Functions peuvent appeler des API REST externes à l’aide d’un service HTTP lié ou du raccourci intégré context.http. Cela permet de s’intégrer à Stripe, SendGrid, Slack, Twilio, GitHub et à toute autre API REST sans déployer d’infrastructure supplémentaire. Stockez toujours les clés API dans Values ou Secrets, jamais dans le code.
exports = async function(orderId, amount) {
// Create a Stripe payment intent via REST API
const stripeKey = context.values.get('STRIPE_SECRET_KEY')
const response = await context.http.post({
url: 'https://api.stripe.com/v1/payment_intents',
headers: {
'Authorization': ['Bearer ' + stripeKey],
'Content-Type': ['application/x-www-form-urlencoded']
},
body: 'amount=' + Math.round(amount * 100) + '¤cy=usd&metadata[orderId]=' + orderId
})
const body = EJSON.parse(response.body.text())
return body.client_secret
}Appeler d’autres Atlas Functions
Atlas Functions peuvent s’appeler entre elles avec context.functions.execute('functionName', arg1, arg2). Cela favorise la réutilisation : vous pouvez écrire une fois des fonctions utilitaires (envoyer un e-mail, consigner un événement, valider un JWT), puis les appeler depuis n’importe quelle fonction de déclencheur ou de point de terminaison. Les appels récursifs sont pris en charge, mais Atlas limite la profondeur des appels afin d’éviter la récursion infinie.
// Main function calls a utility function
exports = async function(userId) {
const db = context.services.get('mongodb-atlas').db('mydb')
const user = await db.collection('users').findOne({ _id: userId })
// Call a reusable 'sendWelcomeEmail' function
await context.functions.execute('sendWelcomeEmail', user.email, user.name)
return { status: 'welcome email sent' }
}Contexte utilisateur : qui appelle ?
Dans les fonctions appelées par des utilisateurs authentifiés (via des points de terminaison HTTPS avec authentification utilisateur), context.user fournit l’identité de l’appelant : son ID utilisateur, son adresse e-mail, ses rôles et ses données personnalisées. Vous pouvez ainsi créer une logique sécurisée limitée à l’utilisateur sans transmettre manuellement les ID utilisateur. Les fonctions invoquées par des déclencheurs ou des tâches planifiées disposent d’un contexte utilisateur au niveau du système.
// HTTPS endpoint function that is user-scoped
exports = async function({ query, body }) {
// context.user is populated when the endpoint uses user auth
const currentUserId = context.user.id
const db = context.services.get('mongodb-atlas').db('mydb')
// Users can only read their own data
const orders = await db.collection('orders')
.find({ ownerId: currentUserId })
.toArray()
return { orders }
}Bonnes pratiques de gestion des erreurs
Encadrez le corps de votre fonction dans un bloc try/catch et relancez toujours les erreurs après les avoir consignées. Atlas marque ainsi l’invocation comme ayant échoué (ce qui permet la logique de nouvelle tentative des déclencheurs) et l’erreur apparaît dans le journal d’exécution avec tout son contexte. Utilisez une journalisation structurée (chaînes JSON) plutôt que du texte brut afin que les journaux puissent être analysés par une machine.
exports = async function(payload) {
const start = Date.now()
try {
const result = await processPayload(payload)
console.log(JSON.stringify({ status: 'ok', result, ms: Date.now() - start }))
return result
} catch (err) {
console.error(JSON.stringify({
status: 'error',
message: err.message,
stack: err.stack,
ms: Date.now() - start
}))
throw err // re-throw so Atlas marks this invocation as FAILED
}
}Limites d’exécution des fonctions
Atlas Functions sont soumises à d’importantes limites d’exécution : Durée maximale : 90 secondes par invocation. Mémoire : 256 MB. Taille du code : 64 KB par fonction. Taille de la réponse : 4 MB pour les points de terminaison HTTPS. Pour les opérations longues ou exigeantes en mémoire, concevez vos fonctions de manière à traiter les données par petits lots et utilisez plusieurs invocations (via des déclencheurs planifiés) pour gérer les grands ensembles de données.
Tester les fonctions localement avec app-services-cli
Vous pouvez développer et tester localement vos Atlas Functions à l’aide de l’interface de ligne de commande Atlas App Services (app-services-cli). Envoyez le code de vos fonctions, les configurations des déclencheurs et les valeurs d’environnement vers App Services à l’aide d’une seule commande. La CLI permet également de récupérer votre configuration existante sous forme de code afin de la gérer dans Git avec le contrôle de version, aux côtés du code de votre application.
// Install the App Services CLI
// npm install -g atlas-app-services-cli
// Pull existing config
// appservices pull --remote=<app_id>
// Push updated functions
// appservices push --include-node-modules
// Run a function locally (using App Services CLI)
// appservices function run --name=myFunction --arg='{"key":"val"}'Nommage et organisation des fonctions
À mesure que votre application App Services s’agrandit, organisez vos fonctions en appliquant des conventions de nommage cohérentes. Utilisez des préfixes ou des dossiers : trigger_onOrderInsert, util_sendEmail, api_getProducts. Gardez les fonctions petites et ciblées : une fonction qui ne fait qu’une seule chose est plus facile à tester, à déboguer et à réutiliser. Extrayez la logique partagée dans des fonctions utilitaires et appelez-les avec context.functions.execute() depuis plusieurs appelants.
// Organised function naming examples:
// trigger_onOrderInsert — database trigger handler
// trigger_dailyArchive — scheduled trigger
// api_getOrders — HTTPS endpoint handler
// util_sendEmail — shared email utility
// util_validatePayload — shared validation utility
// Calling a utility from any other function:
await context.functions.execute('util_sendEmail', {
to: user.email,
subject: 'Your order is confirmed',
body: 'Order ID: ' + orderId
})Vérification rapide
Testez votre compréhension des concepts MongoDB et des bases de données NoSQL présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que les Atlas Functions exportent un unique point d’entrée de fonction asynchrone et accèdent à MongoDB, aux services HTTP et à la configuration de l’environnement via l’objet global context, que les fonctions peuvent s’appeler entre elles avec context.functions.execute() pour réutiliser une logique utilitaire et qu’il faut toujours relancer les erreurs après les avoir consignées afin qu’Atlas marque les invocations comme ayant échoué et relance les déclencheurs de manière appropriée. Ensuite, nous exposerons les Atlas Functions sous forme de points de terminaison HTTPS.
Apprends JavaScript avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Écrire des fonctions Atlas en JavaScript » est-elle gratuite ?
Oui — le texte complet de « Écrire des fonctions Atlas en JavaScript » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours MongoDB Academy, passe à CoddyKit PRO. Le cours MongoDB Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Écrire des fonctions Atlas en JavaScript » ?
Les apprenants écriront des fonctions Atlas en utilisant l’objet de contexte pour accéder aux services associés, aux variables d’environnement et au client MongoDB intégré. Tu pratiques MongoDB Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer MongoDB Academy ?
Aucune expérience préalable n'est requise. MongoDB Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Écrire des fonctions Atlas en JavaScript » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon MongoDB Academy ?
Oui. Chaque leçon MongoDB Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Déclencheurs de base de données : réagir aux événements CRUD
- Déclencheurs planifiés et tâches cron
- Écrire des fonctions Atlas en JavaScript
- Points de terminaison HTTPS comme webhooks légers