计划触发器和 Cron 任务
您将使用 Cron 表达式配置计划触发器，以运行定期维护任务，例如归档旧文档。
计划触发器和 Cron 任务 是 CoddyKit 上的免费 MongoDB Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
What Are Scheduled Triggers?
Scheduled Triggers in Atlas App Services execute an Atlas Function on a recurring schedule defined by a cron expression. Unlike database triggers (which fire in response to data changes), scheduled triggers fire based on time — making them ideal for maintenance tasks, periodic reports, data archiving, and cache refreshes that need to run automatically without human intervention.
Cron Expression Syntax
Atlas scheduled triggers use standard five-field cron expressions: minute hour day-of-month month day-of-week. Use * for 'every', */n for 'every n units', comma-separated values for lists, and ranges with -. Examples: 0 * * * * = every hour on the hour; 0 2 * * * = daily at 2 AM; */15 * * * * = every 15 minutes.
// Common cron expressions
'0 * * * *' // Every hour at minute 0
'0 2 * * *' // Daily at 02:00 UTC
'0 0 * * 0' // Every Sunday at midnight
'0 0 1 * *' // First day of every month at midnight
'*/15 * * * *' // Every 15 minutes
'0 9-17 * * 1-5' // Every hour, 9 AM to 5 PM, weekdaysCreating a Scheduled Trigger
You create scheduled triggers in the Atlas UI under App Services > Triggers > Add Trigger > Scheduled. You give it a name, set the schedule (cron expression or preset intervals like 'every 5 minutes'), and link an Atlas Function. The function receives no arguments — it is called with no event payload, unlike a database trigger, so it must know what to do based on the current time.
// Scheduled trigger config (via App Services API)
// {
// name: 'dailyArchiveJob',
// type: 'SCHEDULED',
// config: {
// schedule: '0 3 * * *' // 3 AM UTC daily
// },
// functionName: 'archiveOldOrders'
// }Common Use Case: Data Archiving
A classic scheduled trigger use case is archiving documents that are older than a threshold. The function queries for documents beyond the cutoff, copies them to an archive collection (or exports them to S3), then deletes the originals. This keeps the active collection lean and fast without requiring TTL indexes (which delete permanently without archiving).
// Atlas Function: archiveOldOrders (runs at 3 AM daily)
exports = async function() {
const db = context.services.get('mongodb-atlas').db('mydb')
const cutoff = new Date()
cutoff.setMonth(cutoff.getMonth() - 6) // older than 6 months
const oldOrders = await db.collection('orders').find({
createdAt: { $lt: cutoff },
status: 'completed'
}).toArray()
if (oldOrders.length === 0) return
// Copy to archive, then delete from active collection
await db.collection('orders_archive').insertMany(oldOrders)
await db.collection('orders').deleteMany({
createdAt: { $lt: cutoff }, status: 'completed'
})
console.log('Archived ' + oldOrders.length + ' orders')
}Common Use Case: Aggregating Statistics
Scheduled triggers are perfect for pre-computing expensive aggregations into a summary collection. Instead of running a heavy aggregation on every dashboard request, a scheduled trigger runs the aggregation once per hour (or per day) and stores results in a stats collection. Dashboard queries become instant point-lookups instead of multi-second scans.
// Atlas Function: computeDailyRevenue
exports = async function() {
const db = context.services.get('mongodb-atlas').db('mydb')
const today = new Date().toISOString().split('T')[0] // 'YYYY-MM-DD'
const result = await db.collection('orders').aggregate([
{ $match: { date: today, status: 'completed' } },
{ $group: { _id: '$region', revenue: { $sum: '$amount' }, count: { $sum: 1 } } }
]).toArray()
// Upsert into stats collection
for (const row of result) {
await db.collection('daily_revenue').updateOne(
{ date: today, region: row._id },
{ $set: { revenue: row.revenue, count: row.count } },
{ upsert: true }
)
}
}Common Use Case: Sending Reminders
Scheduled triggers are the right tool for time-triggered notifications: send a reminder email to users who have items in their cart for more than 24 hours, notify users of expiring subscriptions 7 days before renewal, or ping team members about overdue tasks. The trigger runs every hour (or every minute for time-sensitive notifications) and finds documents that meet the threshold.
// Atlas Function: sendCartAbandonmentReminders (runs hourly)
exports = async function() {
const db = context.services.get('mongodb-atlas').db('mydb')
const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000)
const abandonedCarts = await db.collection('carts').find({
updatedAt: { $lt: twentyFourHoursAgo },
reminderSent: { $ne: true },
status: 'active'
}).toArray()
for (const cart of abandonedCarts) {
// Send email via a linked external service
await context.functions.execute('sendEmail', cart.userEmail, 'You left items in your cart!')
// Mark reminder sent to avoid duplicate emails
await db.collection('carts').updateOne(
{ _id: cart._id },
{ $set: { reminderSent: true } }
)
}
}Execution Timeout and Long-Running Jobs
Atlas Functions have a maximum execution time of 90 seconds. For long-running jobs (archiving millions of documents, sending thousands of emails), process data in batches: use limit() to process a manageable chunk per invocation, and run the trigger frequently enough to keep up. Use a state document in MongoDB to track the last processed position between invocations.
// Batch processing with state tracking
exports = async function() {
const db = context.services.get('mongodb-atlas').db('mydb')
const state = await db.collection('_trigger_state').findOne({ _id: 'archiver' })
const lastId = state ? state.lastProcessedId : null
const query = lastId ? { _id: { $gt: lastId }, status: 'completed' } : { status: 'completed' }
const batch = await db.collection('orders').find(query)
.sort({ _id: 1 }).limit(500).toArray()
if (batch.length === 0) return
await db.collection('orders_archive').insertMany(batch)
await db.collection('orders').deleteMany({ _id: { $in: batch.map(d => d._id) } })
await db.collection('_trigger_state').updateOne(
{ _id: 'archiver' },
{ $set: { lastProcessedId: batch[batch.length - 1]._id } },
{ upsert: true }
)
}Disabling Triggers During Maintenance
You can temporarily disable a scheduled trigger without deleting it — useful during database migrations, large data imports, or maintenance windows. Disabled triggers do not execute even when their cron schedule fires. Re-enable them after maintenance completes. All configuration is preserved when disabled.
// Disable a trigger via Atlas Admin API
// PUT /api/admin/v3.0/groups/{groupId}/apps/{appId}/triggers/{triggerId}
// Body: { 'disabled': true }
// Via Atlas CLI:
// atlas functions triggers update --triggerId <id> --disabled trueLogging and Monitoring Scheduled Triggers
Every scheduled trigger invocation is logged in the App Services execution log with the status (success/failure/timeout) and any console output from the function (console.log() calls appear in the log). Use structured logging — log the number of documents processed, any errors, and timing — so you can monitor job health and set up Atlas Alerts when a job fails.
// Good logging practice in a scheduled function
exports = async function() {
const start = Date.now()
try {
const db = context.services.get('mongodb-atlas').db('mydb')
const n = await doWork(db)
console.log(JSON.stringify({ job: 'archive', status: 'success', processed: n, ms: Date.now() - start }))
} catch(err) {
console.error(JSON.stringify({ job: 'archive', status: 'error', error: err.message }))
throw err // re-throw so Atlas marks this invocation as failed
}
}Scheduled Triggers vs TTL Indexes
MongoDB TTL indexes (expireAfterSeconds) also delete old documents automatically but have limitations: they only delete — they cannot archive to another collection or S3. They run approximately every 60 seconds and cannot be paused. Scheduled triggers give you full control: archive instead of delete, run at specific times, batch process, and add custom business logic before removing documents.
// TTL index: simple deletion, no archiving
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 86400 })
// Scheduled trigger: archive before delete, full control
// - Archive to S3 or another collection
// - Run only at low-traffic hours
// - Skip certain document types based on business rules
// - Send a Slack notification when doneTesting Scheduled Triggers
After creating a scheduled trigger, you can test it immediately from the Atlas UI using the 'Run' button — this invokes the function once without waiting for the next cron fire time. Use this to verify the function works before it runs in production. Check the execution log to see console output and confirm the function completed successfully.
// You can also test the underlying function directly
// via the Atlas Functions editor 'Run' button or CLI:
// appservices function run --name=archiveOldOrders
// Add a DRY RUN mode to your function for safe testing:
exports = async function(dryRun) {
const isDry = dryRun || context.environment.values.DRY_RUN === 'true'
const docs = await getDocsToArchive()
if (!isDry) {
await archiveDocs(docs)
}
console.log((isDry ? '[DRY RUN] Would archive' : 'Archived') + ' ' + docs.length + ' docs')
}Quick Check
Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.
Lesson Recap
In this lesson you learned: scheduled triggers run Atlas Functions on a cron schedule for periodic maintenance, reporting, and notifications, processing in batches with state tracking is essential for large jobs that exceed the 90-second function timeout, and scheduled triggers offer more control than TTL indexes by enabling archive-before-delete workflows. Next up we explore writing Atlas Functions in JavaScript.
常见问题解答
「计划触发器和 Cron 任务」课时是免费的吗？
是的 — 「计划触发器和 Cron 任务」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。
「计划触发器和 Cron 任务」这节课中我会学到什么？
您将使用 Cron 表达式配置计划触发器，以运行定期维护任务，例如归档旧文档。 你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 MongoDB Academy 需要有经验吗？
无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。
「计划触发器和 Cron 任务」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 MongoDB Academy 课中编写并运行代码吗？
能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。