MongoDB Academy · Lección

Expiración automática de datos con expireAfterSeconds

Configure la opción expireAfterSeconds en una colección de series temporales para purgar automáticamente las mediciones antiguas y controlar los costes de almacenamiento.

Lección 4 de 413 pasos

Expiración automática de datos con expireAfterSeconds es una lección gratuita de MongoDB Academy en CoddyKit. Esta es la lección 4 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.

Por qué es importante la caducidad automática de los datos

El valor de los datos de series temporales casi siempre es limitado: las lecturas de sensores de hace 5 años rara vez sirven para tomar decisiones actuales. Conservar datos obsoletos desperdicia almacenamiento, ralentiza las copias de seguridad y aumenta el tamaño de los índices. La opción expireAfterSeconds de MongoDB le permite declarar un periodo de retención al crear la colección, para que la base de datos gestione la limpieza automáticamente, sin tareas cron ni rutinas de eliminación en la aplicación.

Establecer expireAfterSeconds durante la creación

Pase expireAfterSeconds como una opción de nivel superior junto al objeto timeseries al llamar a db.createCollection(). El valor es un entero que representa el número de segundos durante los que se conservarán los datos. Los documentos cuyo valor de timeField sea anterior a ahora − expireAfterSeconds podrán ser eliminados por el subproceso en segundo plano de TTL.

// Create a collection that retains data for 30 days
db.createCollection('sensorReadings', {
  timeseries: {
    timeField: 'timestamp',
    metaField: 'sensorId',
    granularity: 'seconds'
  },
  expireAfterSeconds: 60 * 60 * 24 * 30  // 2592000 seconds = 30 days
})

Cómo funciona la eliminación mediante TTL en las series temporales

El subproceso TTL de MongoDB se ejecuta aproximadamente cada 60 segundos. En las colecciones de series temporales, elimina documentos bucket completos en lugar de mediciones individuales. Un bucket solo se elimina cuando todas las mediciones que contiene son anteriores al umbral de caducidad. Esto hace que la eliminación mediante TTL sea muy eficiente: eliminar un documento bucket permite borrar cientos de mediciones en una sola operación.

Actualizar expireAfterSeconds en colecciones existentes

Puede modificar en cualquier momento el periodo de retención de una colección de series temporales existente mediante el comando collMod, sin necesidad de tiempo de inactividad. Aumentar el valor permite conservar los datos durante más tiempo; reducirlo hace que los datos que antes no caducaban puedan eliminarse durante la siguiente ejecución de TTL. El cambio surte efecto aproximadamente en 60 segundos.

// Extend retention from 30 days to 90 days
db.runCommand({
  collMod: 'sensorReadings',
  expireAfterSeconds: 60 * 60 * 24 * 90  // 7776000 seconds
})

// Disable expiration entirely
db.runCommand({
  collMod: 'sensorReadings',
  expireAfterSeconds: 0
})

TTL frente a los índices TTL de las colecciones normales

Las colecciones normales de MongoDB utilizan un índice TTL (un índice especial de un solo campo sobre un campo de fecha, con un atributo expireAfterSeconds) para hacer caducar documentos individuales. Las colecciones de series temporales utilizan un mecanismo diferente: hacen caducar documentos bucket completos en lugar de documentos de mediciones individuales. Por este motivo, no puede crear un índice TTL independiente en una colección de series temporales; la caducidad se gestiona exclusivamente mediante la opción expireAfterSeconds de la colección.

// Regular collection TTL index (NOT for time series)
db.logs.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 86400 }  // deletes individual documents after 24h
)

// Time series uses collection-level option, not an index
// (The line below would fail on a time series collection)
// db.sensorReadings.createIndex({ timestamp: 1 }, { expireAfterSeconds: 86400 })

Verificar la configuración de caducidad

Consulte la política de retención actual ejecutando db.getCollectionInfos() y examinando el campo options.expireAfterSeconds. También puede comprobar db.sensorReadings.stats(), que incluye la configuración de TTL en sus resultados. Esto resulta útil durante las auditorías para confirmar que las colecciones de producción tienen establecido el periodo de retención correcto.

// Check collection metadata including TTL
const info = db.getCollectionInfos({ name: 'sensorReadings' })
printjson(info[0].options)
// Output includes: { expireAfterSeconds: 2592000, timeseries: {...} }

// Check via stats
db.sensorReadings.stats()

Retención por niveles con varias colecciones

Un patrón habitual en producción es la retención por niveles: los datos sin procesar y de alta frecuencia se almacenan en una colección de series temporales con un TTL corto (por ejemplo, 7 días), mientras que una tarea de canalización de agregación se ejecuta cada noche para calcular resúmenes por hora y escribirlos en una segunda colección con un TTL más largo (por ejemplo, 2 años). Esto equilibra los costes de almacenamiento con la necesidad de analizar tendencias históricas.

// Raw readings — 7-day retention
db.createCollection('rawReadings', {
  timeseries: { timeField: 'ts', metaField: 'deviceId', granularity: 'seconds' },
  expireAfterSeconds: 60 * 60 * 24 * 7
})

// Hourly summaries — 2-year retention
db.createCollection('hourlyStats', {
  timeseries: { timeField: 'hour', metaField: 'deviceId', granularity: 'hours' },
  expireAfterSeconds: 60 * 60 * 24 * 730
})

Temporización y precisión del subproceso TTL

El subproceso TTL en segundo plano se activa cada 60 segundos, por lo que la caducidad no es instantánea: los datos pueden permanecer hasta 60 segundos después de alcanzar el umbral. En clústeres de Atlas sometidos a una carga elevada, las eliminaciones mediante TTL pueden retrasarse aún más. Si los requisitos de cumplimiento exigen una eliminación exacta en un segundo determinado, los scripts de eliminación manual o los Atlas Triggers programados ofrecen un control más determinista que TTL.

Eliminación manual para una limpieza inmediata

Si necesita eliminar inmediatamente un bloque de mediciones —por ejemplo, para purgar los datos de un sensor defectuoso—, utilice deleteMany() con un filtro sobre timeField y metaField. Las colecciones de series temporales admiten eliminaciones por intervalo de tiempo y por valor de metaField desde MongoDB 5.1. Las eliminaciones con filtros complejos sobre campos de medición son compatibles desde MongoDB 6.0.

// Delete all readings from a broken sensor before a cutoff date
db.sensorReadings.deleteMany({
  sensorId: 'sensor-broken-99',
  timestamp: { $lt: new Date('2024-06-01T00:00:00Z') }
})

// Delete readings older than a specific date for all sensors
db.sensorReadings.deleteMany({
  timestamp: { $lt: new Date('2023-01-01T00:00:00Z') }
})

Supervisar la eliminación de datos caducados

MongoDB expone métricas de eliminación mediante TTL en server status, dentro de la sección metrics.ttl. El contador deletedDocuments registra cuántos documentos (documentos bucket en el caso de las series temporales) ha eliminado el subproceso TTL desde que se inició el proceso mongod. Supervisar este contador le ayuda a confirmar que TTL se está ejecutando y eliminando los datos según lo previsto en producción.

// Check TTL deletion metrics in mongosh
const status = db.serverStatus()
printjson(status.metrics.ttl)
// Output:
// {
//   deletedDocuments: NumberLong(12345),
//   passes: NumberLong(500)
// }

Buenas prácticas para planificar la retención

Al planificar la retención, tenga en cuenta tres factores: los requisitos de cumplimiento (algunas normativas exigen conservar los datos durante años), las necesidades analíticas (¿hasta cuánto tiempo atrás abarcan sus consultas?) y el presupuesto de almacenamiento (¿cuánto cuesta conservar N días de datos?). Modele el crecimiento del almacenamiento estimando el volumen diario de documentos × el tamaño medio de los documentos y, a continuación, establezca expireAfterSeconds para equilibrar las tres limitaciones.

// Storage estimation helper
const docsPerDay = 60 * 60 * 24       // one reading per second = 86400
const avgDocBytes = 150                // approximate compressed document size
const retentionDays = 30
const totalBytes = docsPerDay * avgDocBytes * retentionDays
console.log('Estimated storage:', (totalBytes / 1e9).toFixed(2), 'GB')
// Outputs: Estimated storage: 0.37 GB for one sensor, 30 days

Comprobación rápida

Compruebe sus conocimientos sobre 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 lo siguiente: expireAfterSeconds se establece en el nivel de la colección (no mediante un índice) y controla cuándo se purgan los buckets completos; collMod permite actualizar el periodo de retención de una colección activa sin tiempo de inactividad; y la retención por niveles —TTL corto para los datos sin procesar y TTL largo para los resúmenes preagregados— es la práctica recomendada en producción para almacenar series temporales de forma rentable. A continuación, trataremos los mecanismos de autenticación de MongoDB.

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 «Expiración automática de datos con expireAfterSeconds» es gratis?

Sí — el texto completo de «Expiración automática de datos con expireAfterSeconds» 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 «Expiración automática de datos con expireAfterSeconds»?

Configure la opción expireAfterSeconds en una colección de series temporales para purgar automáticamente las mediciones antiguas y controlar los costes de almacenamiento. 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 4 de 4.

¿Cuánto tiempo toma la lección «Expiración automática de datos con expireAfterSeconds»?

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. Creación de una colección de series temporales
  2. Inserción y consulta de datos de series temporales
  3. Agregaciones con ventanas sobre series temporales
  4. Expiración automática de datos con expireAfterSeconds
← Volver a MongoDB Academy