Expiração automática de dados com expireAfterSeconds
Os alunos configurarão a opção expireAfterSeconds em uma coleção de séries temporais para eliminar automaticamente medições antigas e controlar os custos de armazenamento.
Expiração automática de dados com expireAfterSeconds é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.
Por que a expiração automática de dados é importante
Os dados de séries temporais quase sempre têm valor limitado — leituras de sensores de 5 anos atrás raramente orientam decisões atuais. Reter dados obsoletos desperdiça armazenamento, torna os backups mais lentos e aumenta o tamanho dos índices. A opção expireAfterSeconds do MongoDB permite declarar um período de retenção no momento da criação da coleção, para que o banco de dados faça a limpeza automaticamente, sem tarefas cron nem rotinas de exclusão no nível da aplicação.
Configuração de expireAfterSeconds na criação
Transmita expireAfterSeconds como uma opção de nível superior, ao lado do objeto timeseries, ao chamar db.createCollection(). O valor é um número inteiro que representa a quantidade de segundos de retenção dos dados. Documentos cujo valor de timeField seja anterior a agora − expireAfterSeconds tornam-se elegíveis para exclusão pela thread de segundo plano do 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
})Como funciona a exclusão por TTL para séries temporais
A thread de TTL do MongoDB é executada aproximadamente a cada 60 segundos. Para coleções de séries temporais, ela exclui documentos de bucket inteiros, em vez de medições individuais. Um bucket só é excluído quando todas as medições que ele contém são mais antigas que o limite de expiração. Isso torna a exclusão por TTL altamente eficiente — remover um documento de bucket exclui centenas de medições em uma única operação.
Atualização de expireAfterSeconds em coleções existentes
Você pode modificar o período de retenção de uma coleção de séries temporais existente a qualquer momento usando o comando collMod — sem exigir indisponibilidade. Aumentar o valor mantém os dados por mais tempo; diminuí-lo faz com que dados anteriormente não expirados se tornem elegíveis para exclusão na próxima execução do TTL. A alteração entra em vigor em aproximadamente 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 versus índices TTL de coleções comuns
As coleções comuns do MongoDB usam um índice TTL (um índice especial de campo único em um campo de data com um atributo expireAfterSeconds) para expirar documentos individuais. As coleções de séries temporais usam um mecanismo diferente — elas expiram documentos de bucket inteiros, em vez de documentos de medição individuais. Isso significa que não é possível criar um índice TTL separado em uma coleção de séries temporais; a expiração é gerenciada exclusivamente pela opção expireAfterSeconds no nível da coleção.
// 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 })Verificação da configuração de expiração
Inspecione a política de retenção atual executando db.getCollectionInfos() e examinando o campo options.expireAfterSeconds. Você também pode verificar db.sensorReadings.stats(), que informa a configuração de TTL em sua saída. Isso é útil durante auditorias para confirmar que as coleções de produção estão configuradas com o período de retenção correto.
// 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()Retenção em camadas com várias coleções
Um padrão comum em produção é a retenção em camadas: dados brutos de alta frequência são armazenados em uma coleção de séries temporais com TTL curto (por exemplo, 7 dias), enquanto um trabalho de pipeline de agregação é executado todas as noites para calcular resumos por hora e gravá-los em uma segunda coleção com TTL mais longo (por exemplo, 2 anos). Isso equilibra os custos de armazenamento com a necessidade de analisar tendências 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
})Temporização e precisão da thread de TTL
A thread de segundo plano do TTL é ativada a cada 60 segundos, portanto a expiração não é instantânea — os dados podem permanecer por até 60 segundos além do limite. Em clusters do Atlas sob carga intensa, as exclusões por TTL podem sofrer atrasos adicionais. Para requisitos de conformidade que exijam a exclusão exata em um segundo específico, scripts de exclusão manual ou Atlas Triggers agendados oferecem um controle mais determinístico do que o TTL.
Exclusão manual para limpeza imediata
Se precisar remover imediatamente um bloco de medições — por exemplo, para eliminar os dados de um sensor com defeito — use deleteMany() com um filtro nos campos timeField e metaField. As coleções de séries temporais permitem exclusões por intervalo de tempo e valor de metaField desde o MongoDB 5.1. Filtros complexos em campos de medição nas exclusões têm suporte a partir do 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') }
})Monitoramento da exclusão de dados expirados
O MongoDB expõe métricas de exclusão por TTL no status do servidor, na seção metrics.ttl. O contador deletedDocuments registra quantos documentos (documentos de bucket, no caso de séries temporais) a thread de TTL excluiu desde que o processo mongod foi iniciado. Monitorar esse contador ajuda a confirmar que o TTL está realmente sendo executado e excluindo os dados conforme esperado em produção.
// Check TTL deletion metrics in mongosh
const status = db.serverStatus()
printjson(status.metrics.ttl)
// Output:
// {
// deletedDocuments: NumberLong(12345),
// passes: NumberLong(500)
// }Práticas recomendadas para planejar a retenção
Ao planejar a retenção, considere três fatores: requisitos de conformidade (algumas regulamentações exigem a retenção de dados por anos), necessidades analíticas (até que ponto no passado suas consultas analisam os dados?) e orçamento de armazenamento (quanto custa manter N dias de dados?). Modele o crescimento do armazenamento estimando o volume diário de documentos × o tamanho médio dos documentos e, em seguida, defina expireAfterSeconds para equilibrar as três restrições.
// 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 daysVerificação rápida
Teste sua compreensão dos conceitos de MongoDB e bancos de dados NoSQL desta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: expireAfterSeconds é definido no nível da coleção (não por meio de um índice) e controla quando buckets inteiros são eliminados, collMod permite atualizar o período de retenção de uma coleção ativa sem indisponibilidade, e a retenção em camadas — TTL curto para dados brutos e TTL longo para resumos pré-agregados — é a prática recomendada em produção para armazenar séries temporais com boa relação custo-benefício. A seguir, abordaremos os mecanismos de autenticação no MongoDB.
Aprenda JavaScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Expiração automática de dados com expireAfterSeconds” é grátis?
Sim — o texto completo de “Expiração automática de dados com expireAfterSeconds” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.
O que vou aprender em “Expiração automática de dados com expireAfterSeconds”?
Os alunos configurarão a opção expireAfterSeconds em uma coleção de séries temporais para eliminar automaticamente medições antigas e controlar os custos de armazenamento. Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar MongoDB Academy?
Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Expiração automática de dados com expireAfterSeconds”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de MongoDB Academy?
Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Criando uma coleção de séries temporais
- Inserindo e consultando dados de séries temporais
- Agregações em janela sobre séries temporais
- Expiração automática de dados com expireAfterSeconds