MongoDB Academy · Lección

Triggers de base de datos: reacción a eventos CRUD

Creará un trigger de base de datos que se active con eventos de inserción o actualización y ejecute una Atlas Function para sincronizar datos o enviar una notificación.

Lección 1 de 413 pasos

Triggers de base de datos: reacción a eventos CRUD es una lección gratuita de MongoDB Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de MongoDB Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de MongoDB Academy incluye 4 lecciones en total.

¿Qué son los Atlas Database Triggers?

Los Atlas Database Triggers son gestores de eventos sin servidor que ejecutan automáticamente una Atlas Function cada vez que ocurre un evento CRUD específico (insertar, actualizar, reemplazar o eliminar) en una colección. Se basan en MongoDB Change Streams y eliminan la necesidad de ejecutar un proceso de sondeo o administrar infraestructura para flujos de trabajo basados en eventos.

Cómo funcionan los Triggers internamente

Internamente, los Atlas triggers usan un change stream que MongoDB abre en la colección de destino. Cada evento de cambio que coincide se reenvía al trigger, que invoca la Atlas Function asociada y le proporciona el documento del evento como argumento. La función se ejecuta en el entorno de ejecución de JavaScript administrado por Atlas; no es necesario aprovisionar ni escalar servidores. Los triggers pueden gestionar hasta cientos de eventos por segundo mediante el escalado automático.

Creación de un Trigger: configuración clave

Al configurar un database trigger, debe especificar: el Cluster name y la collection que se supervisarán. Los Operation types a los que reaccionará: insert, update, replace, delete o cualquier combinación. La opción Full Document: cuando está habilitada, MongoDB obtiene el documento completo después del cambio y lo incluye en la carga útil del evento. Linked Function: la Atlas Function que se invocará.

// Trigger configuration (set in Atlas UI or App Services API)
// {
//   name: 'onOrderInsert',
//   type: 'DATABASE',
//   config: {
//     serviceId: '...',
//     database: 'mydb',
//     collection: 'orders',
//     operationTypes: ['INSERT'],
//     fullDocument: true
//   },
//   functionName: 'handleNewOrder'
// }

El documento del evento de cambio

El documento del evento que se pasa a la función del trigger contiene estos campos principales: operationType ('insert', 'update', 'replace', 'delete'), fullDocument (el documento después del cambio, si está habilitado), documentKey (el _id del documento modificado), updateDescription (en las actualizaciones: qué campos se establecieron o eliminaron) y ns (el espacio de nombres de la base de datos y la colección).

// Example change event passed to the trigger function:
// {
//   operationType: 'INSERT',
//   fullDocument: { _id: ObjectId('...'), item: 'laptop', qty: 1, status: 'pending' },
//   documentKey: { _id: ObjectId('...') },
//   ns: { db: 'mydb', coll: 'orders' },
//   clusterTime: Timestamp(...)
// }

Escritura de una función Trigger: gestor de nuevos pedidos

Una función trigger es una Atlas Function: JavaScript del lado del servidor que tiene acceso al objeto context (cliente de MongoDB, servicios e información del usuario) y recibe el evento de cambio como primer argumento. Este es un patrón para gestionar nuevos pedidos: enviar un correo electrónico de notificación y actualizar un contador de análisis.

// Atlas Function: handleNewOrder
exports = async function(changeEvent) {
  const order = changeEvent.fullDocument
  if (!order) return  // safeguard if fullDocument is null

  const db = context.services.get('mongodb-atlas').db('mydb')

  // Update daily order count
  await db.collection('daily_stats').updateOne(
    { date: new Date().toISOString().split('T')[0] },
    { $inc: { orderCount: 1, revenue: order.amount || 0 } },
    { upsert: true }
  )

  // Send notification (using a linked email service)
  await context.services.get('myEmailService').send({
    to: 'ops@company.com',
    subject: 'New order: ' + order._id,
    body: 'Amount: ' + order.amount
  })
}

Filtrado de eventos de Trigger

Puede añadir una match expression a un trigger para que solo se active para un subconjunto de eventos. Esto se implementa como una canalización de agregación en el change stream. Por ejemplo, puede activar el trigger solo para pedidos que superen un importe determinado, solo para actualizaciones en las que haya cambiado el campo de estado o solo para reaccionar a documentos de un tenant específico.

// Trigger match filter (aggregation pipeline on the change stream)
// Only fire the trigger when order amount > 500
// {
//   'match': {
//     'fullDocument.amount': { '$gt': 500 },
//     'operationType': 'INSERT'
//   }
// }

// Only fire when 'status' field is part of the update
// {
//   'match': {
//     'updateDescription.updatedFields.status': { '$exists': true }
//   }
// }

Full Document frente a Update Lookup

En las operaciones INSERT y REPLACE, fullDocument siempre está disponible en el evento de cambio. En los eventos UPDATE, fullDocument solo está disponible si habilita la opción Full Document en la configuración del trigger, lo que hace que Atlas realice una búsqueda adicional del documento (una segunda lectura). Sin esta opción, solo está disponible updateDescription (los campos modificados).

// Trigger function handling UPDATE events
exports = async function(changeEvent) {
  const { operationType, updateDescription, fullDocument, documentKey } = changeEvent

  if (operationType === 'UPDATE') {
    const updatedFields = updateDescription.updatedFields
    // Only process if 'status' was updated to 'shipped'
    if (updatedFields.status === 'shipped') {
      // Notify customer using documentKey._id to fetch full data
      const db = context.services.get('mongodb-atlas').db('mydb')
      const order = fullDocument || await db.collection('orders').findOne({ _id: documentKey._id })
      // ... send shipment notification
    }
  }
}

Gestión de errores y reintentos en Triggers

Si una función trigger genera un error o supera el tiempo de espera (máximo de 90 segundos), Atlas la reintenta automáticamente hasta 3 veces con un retroceso exponencial. Si todos los reintentos fallan, el evento se registra como fallido en el registro de errores de Atlas Trigger. Debe escribir funciones trigger idempotentes: aplicar la función varias veces al mismo evento produce el mismo resultado, lo que permite gestionar los reintentos de forma segura.

// Idempotent trigger: use upsert to avoid duplicate stats on retry
exports = async function(changeEvent) {
  const order = changeEvent.fullDocument
  const db = context.services.get('mongodb-atlas').db('mydb')

  // Upsert is safe to retry: same result whether run once or five times
  await db.collection('order_summaries').updateOne(
    { _id: order._id },       // dedup key = original document _id
    { $set: { status: order.status, amount: order.amount, processedAt: new Date() } },
    { upsert: true }
  )
}

Triggers en cascada: patrón de sincronización de datos

Un caso de uso habitual es la sincronización de datos: cuando cambia un documento en una colección, un trigger propaga el cambio a una copia desnormalizada en otra colección. Por ejemplo, cuando cambia el correo electrónico de un usuario en la colección users, un trigger actualiza el campo de correo desnormalizado en cada documento de la colección orders que hace referencia a ese usuario.

// Sync user email to orders whenever user is updated
exports = async function(changeEvent) {
  const updated = changeEvent.updateDescription.updatedFields
  if (!updated.email) return   // email didn't change, skip

  const userId = changeEvent.documentKey._id
  const db = context.services.get('mongodb-atlas').db('mydb')

  await db.collection('orders').updateMany(
    { userId: userId },
    { $set: { userEmail: updated.email } }
  )
}

Orden y concurrencia de los Triggers

De forma predeterminada, los Atlas triggers procesan los eventos secuencialmente, en el orden en que llegan. Si habilita event ordering off (en la configuración del trigger), varias invocaciones de funciones pueden ejecutarse en paralelo para aumentar el rendimiento, pero la función debe ser segura para la ejecución simultánea. El modo secuencial es más seguro; el modo paralelo es más rápido para colecciones con una alta tasa de eventos.

Desactivación y supervisión de Triggers

Puede activar o desactivar los triggers en cualquier momento desde la interfaz de Atlas sin eliminarlos. El Trigger Execution Log de Atlas muestra cada invocación: estado (éxito, error o tiempo de espera), duración y detalles del error. Use este registro para depurar los triggers que fallen y supervisar las tendencias de ejecución. Atlas también muestra métricas de los triggers en el panel de Atlas Monitoring.

Comprobación rápida

Compruebe su comprensión de los conceptos de MongoDB y las bases de datos NoSQL de esta lección.

Resumen de la lección

En esta lección ha aprendido que: los Atlas Database Triggers activan una Atlas Function en eventos de inserción, actualización, reemplazo o eliminación mediante un change stream interno, las expresiones de coincidencia filtran los eventos que invocan la función y las funciones deben ser idempotentes porque Atlas reintenta automáticamente las invocaciones fallidas. A continuación, exploraremos los triggers programados y los trabajos cron.

Gratis para empezar

Aprende JavaScript con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
30
Lecciones
120

Preguntas frecuentes

¿La lección «Triggers de base de datos: reacción a eventos CRUD» es gratis?

Sí — el texto completo de «Triggers de base de datos: reacción a eventos CRUD» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de MongoDB Academy, actualiza a CoddyKit PRO. El curso de MongoDB Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Triggers de base de datos: reacción a eventos CRUD»?

Creará un trigger de base de datos que se active con eventos de inserción o actualización y ejecute una Atlas Function para sincronizar datos o enviar una notificación. Practicas MongoDB Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar MongoDB Academy?

No se requiere experiencia previa. MongoDB Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Triggers de base de datos: reacción a eventos CRUD»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de MongoDB Academy?

Sí. Cada lección de MongoDB Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Triggers de base de datos: reacción a eventos CRUD
  2. Triggers programados y trabajos de Cron
  3. Escritura de Atlas Functions en JavaScript
  4. Endpoints HTTPS como webhooks ligeros
← Volver a MongoDB Academy