Gatilhos programados e tarefas do Cron

What Are Scheduled Triggers?

Cron Expression Syntax

// 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, weekdays

Creating a Scheduled Trigger

// 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

// 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

// 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

// 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

// 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

// 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 true

Logging and Monitoring Scheduled Triggers

// 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

// 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 done

Testing Scheduled Triggers

// 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

Lesson Recap