Gatilhos de banco de dados: reagindo a eventos CRUD
Você criará um gatilho de banco de dados que será acionado em eventos de inserção ou atualização e executará uma Atlas Function para sincronizar dados ou enviar uma notificação.
Gatilhos de banco de dados: reagindo a eventos CRUD é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 1 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.
O que são Atlas Database Triggers?
Os Atlas Database Triggers são manipuladores de eventos sem servidor que executam automaticamente uma Atlas Function sempre que ocorre um evento CRUD específico (inserção, atualização, substituição ou exclusão) em uma coleção. Eles são baseados no MongoDB Change Streams e eliminam a necessidade de executar um processo de consulta periódica ou gerenciar uma infraestrutura para fluxos de trabalho orientados a eventos.
Como os Triggers funcionam internamente
Internamente, os Atlas Triggers usam um fluxo de alterações que o MongoDB abre na coleção de destino. Cada evento de alteração correspondente é encaminhado ao trigger, que invoca a Atlas Function associada, passando o documento do evento como argumento. A função é executada no ambiente gerenciado de JavaScript do Atlas — não é necessário provisionar nem dimensionar servidores. Os Triggers podem processar até centenas de eventos por segundo com dimensionamento automático.
Criando um Trigger: configuração principal
Ao configurar um trigger de banco de dados, você especifica: nome do cluster e coleção a serem monitorados. Tipos de operação aos quais reagir: inserção, atualização, substituição, exclusão ou qualquer combinação. Opção Full Document — quando ativada, o MongoDB busca o documento completo após a alteração e o inclui na carga do evento. Linked Function — a Atlas Function a ser invocada.
// 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'
// }O documento do evento de alteração
O documento do evento passado à função do trigger tem estes campos principais: operationType ('insert', 'update', 'replace', 'delete'), fullDocument (o documento após a alteração, se ativado), documentKey (o _id do documento alterado), updateDescription (nas atualizações: quais campos foram definidos ou removidos) e ns (namespace do banco de dados e da coleção).
// 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(...)
// }Escrevendo uma função de Trigger: manipulador de novos pedidos
Uma função de trigger é uma Atlas Function — JavaScript no lado do servidor que tem acesso ao objeto context (cliente do MongoDB, serviços e informações do usuário) e recebe o evento de alteração como primeiro argumento. Este é um padrão para processar novos pedidos: enviar uma notificação por e-mail e atualizar um contador de análise.
// 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
})
}Filtrando eventos de Trigger
Você pode adicionar uma expressão de correspondência a um trigger para que ele seja acionado somente por um subconjunto de eventos. Isso é implementado como um fluxo de agregação no fluxo de alterações. Por exemplo, você pode acioná-lo somente para pedidos acima de determinado valor, somente para atualizações em que o campo de status foi alterado ou somente para reagir a documentos de um locatário 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 }
// }
// }Documento completo versus consulta de atualização
Nas operações INSERT e REPLACE, fullDocument está sempre disponível no evento de alteração. Nos eventos UPDATE, fullDocument só estará disponível se você ativar a opção Full Document na configuração do trigger, o que faz o Atlas realizar uma consulta adicional ao documento (uma segunda leitura). Sem essa opção, somente updateDescription (os campos alterados) estará disponível.
// 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
}
}
}Tratamento de erros e novas tentativas em Triggers
Se uma função de trigger lançar um erro ou exceder o tempo limite (máximo de 90 segundos), o Atlas tentará executá-la novamente até 3 vezes, usando um retrocesso exponencial. Se todas as tentativas falharem, o evento será registrado como falha no registro de erros do Atlas Trigger. Você deve escrever funções de trigger idempotentes — aplicar a função várias vezes ao mesmo evento produz o mesmo resultado — para lidar com novas tentativas com segurança.
// 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 em cascata: padrão de sincronização de dados
Um caso de uso comum é a sincronização de dados: quando um documento muda em uma coleção, um trigger propaga a alteração para uma cópia desnormalizada em outra coleção. Por exemplo, quando o e-mail de um usuário muda na coleção users, um trigger atualiza o campo de e-mail desnormalizado em todos os documentos da coleção orders que fazem referência a esse usuário.
// 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 } }
)
}Ordenação de Triggers e simultaneidade
Por padrão, os Atlas Triggers processam os eventos sequencialmente, na ordem em que chegam. Se você ativar ordenação de eventos desativada (nas configurações do trigger), várias invocações de funções poderão ser executadas em paralelo para aumentar a vazão — mas sua função deverá ser segura para execução simultânea. O modo sequencial é mais seguro; o modo paralelo é mais rápido para coleções com alta taxa de eventos.
Desativando e monitorando Triggers
Você pode ativar ou desativar os triggers a qualquer momento na interface do Atlas, sem excluí-los. O Trigger Execution Log no Atlas mostra cada invocação: status (sucesso/falha/tempo limite), duração e detalhes do erro. Use esse registro para depurar triggers com falha e monitorar tendências de execução. O Atlas também disponibiliza métricas de triggers no painel Atlas Monitoring.
Verificaçã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: os Atlas Database Triggers acionam uma Atlas Function em eventos de inserção/atualização/substituição/exclusão, usando internamente um fluxo de alterações, as expressões de correspondência filtram quais eventos invocam a função e as funções devem ser idempotentes porque o Atlas tenta automaticamente novamente as invocações que falharam. A seguir, exploraremos os triggers agendados e as tarefas cron.
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 “Gatilhos de banco de dados: reagindo a eventos CRUD” é grátis?
Sim — o texto completo de “Gatilhos de banco de dados: reagindo a eventos CRUD” é 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 “Gatilhos de banco de dados: reagindo a eventos CRUD”?
Você criará um gatilho de banco de dados que será acionado em eventos de inserção ou atualização e executará uma Atlas Function para sincronizar dados ou enviar uma notificação. 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 1 de 4.
Quanto tempo leva a aula “Gatilhos de banco de dados: reagindo a eventos CRUD”?
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
- Gatilhos de banco de dados: reagindo a eventos CRUD
- Gatilhos programados e tarefas do Cron
- Escrevendo Atlas Functions em JavaScript
- Endpoints HTTPS como webhooks leves