Databasetriggere: Reaktion på CRUD-hændelser
De lærende vil oprette en databasetrigger, der udløses ved indsættelse eller opdatering og kører en Atlas Function for at synkronisere data eller sende en notifikation.
Databasetriggere: Reaktion på CRUD-hændelser er en gratis MongoDB Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i MongoDB Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. MongoDB Academy-kurset indeholder 4 lektioner i alt.
Hvad er Atlas Database Triggers?
Atlas Database Triggers er serverløse hændelseshåndteringer, der automatisk udfører en Atlas Function, når en bestemt CRUD-hændelse (indsættelse, opdatering, erstatning, sletning) sker i en samling. De er bygget oven på MongoDB Change Streams og fjerner behovet for at køre en pollingproces eller administrere infrastruktur til hændelsesdrevne arbejdsgange.
Sådan fungerer triggers internt
Internt bruger Atlas-triggers en ændringsstrøm, som MongoDB åbner på målsamlingen. Hver matchende ændringshændelse videresendes til triggeren, som kalder den tilknyttede Atlas Function med hændelsesdokumentet som argument. Funktionen kører i Atlas' administrerede JavaScript-runtime — du skal ikke klargøre eller skalere servere. Triggers kan håndtere op til hundredvis af hændelser pr. sekund med automatisk skalering.
Oprettelse af en trigger: Vigtig konfiguration
Når du konfigurerer en databasetrigger, angiver du: klyngenavn og den samling, der skal overvåges. Handlingstyper, der skal udløse en reaktion: insert, update, replace, delete eller en kombination af disse. Indstillingen Full Document — når den er aktiveret, henter MongoDB hele dokumentet efter ændringen og inkluderer det i hændelsesnyttelasten. Linked Function — den Atlas Function, der skal kaldes.
// 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'
// }Dokumentet med ændringshændelsen
Hændelsesdokumentet, der sendes til triggerfunktionen, har disse vigtige felter: operationType ('insert', 'update', 'replace', 'delete'), fullDocument (dokumentet efter ændringen, hvis det er aktiveret), documentKey (_id for det ændrede dokument), updateDescription (ved opdateringer: hvilke felter der blev sat eller fjernet) og ns (database- og samlingsnavneområde).
// 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(...)
// }Skrivning af en triggerfunktion: Håndtering af nye ordrer
En triggerfunktion er en Atlas Function — JavaScript på serversiden, som har adgang til objektet context (MongoDB-klient, tjenester og brugeroplysninger) og modtager ændringshændelsen som sit første argument. Her er et mønster til håndtering af nye ordrer: send en e-mailnotifikation, og opdatér en analysetæller.
// 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
})
}Filtrering af triggerhændelser
Du kan føje et match-udtryk til en trigger, så den kun udløses for et udsnit af hændelserne. Det implementeres som en aggregeringspipeline på ændringsstrømmen. Du kan for eksempel kun udløse triggeren for ordrer over et bestemt beløb, kun reagere på opdateringer, hvor statusfeltet blev ændret, eller kun reagere på dokumenter fra en bestemt lejer.
// 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 }
// }
// }Fuldt dokument kontra opslag ved opdatering
Ved handlingerne INSERT og REPLACE er fullDocument altid tilgængeligt i ændringshændelsen. Ved UPDATE-hændelser er fullDocument kun tilgængeligt, hvis du aktiverer indstillingen Full Document i triggerkonfigurationen. Det får Atlas til at udføre et ekstra dokumentopslag (en ekstra læsning). Uden denne indstilling er kun updateDescription (de ændrede felter) tilgængeligt.
// 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
}
}
}Fejlhåndtering og gentagelse i triggers
Hvis en triggerfunktion udløser en fejl eller får timeout (maksimalt 90 sekunder), forsøger Atlas automatisk igen op til 3 gange med eksponentiel backoff. Hvis alle forsøg mislykkes, logges hændelsen som mislykket i Atlas' fejllog for triggers. Du bør skrive triggerfunktioner, så de er idempotente — hvis funktionen anvendes flere gange på den samme hændelse, giver det samme resultat — så gentagelser håndteres sikkert.
// 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 }
)
}Kaskadetriggers: Mønster til datasynkronisering
Et almindeligt anvendelsesområde er datasynkronisering: Når et dokument ændres i én samling, viderefører en trigger ændringen til en denormaliseret kopi i en anden samling. Når en brugers e-mailadresse f.eks. ændres i samlingen users, opdaterer en trigger det denormaliserede e-mailfelt i hvert dokument i samlingen orders, der refererer til brugeren.
// 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 } }
)
}Triggernes rækkefølge og samtidighed
Som standard behandler Atlas-triggers hændelser sekventielt i den rækkefølge, de ankommer. Hvis du aktiverer event ordering off (i triggerindstillingerne), kan flere funktionskald køre parallelt for at opnå større gennemløb — men så skal din funktion kunne håndtere samtidige kørsler sikkert. Sekventiel tilstand er mere sikker; parallel tilstand er hurtigere for samlinger med mange hændelser.
Deaktivering og overvågning af triggers
Du kan til enhver tid aktivere eller deaktivere triggers fra Atlas' brugergrænseflade uden at slette dem. Trigger Execution Log i Atlas viser hvert funktionskald: status (succes/fejl/timeout), varighed og fejloplysninger. Brug denne log til at fejlfinde triggers, der mislykkes, og overvåge udviklingen i udførelsen. Atlas viser også trigger-metrikker i Atlas Monitoring-dashboardet.
Hurtigt tjek
Test din forståelse af begreberne inden for MongoDB og NoSQL-databaser fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du, at Atlas Database Triggers udløser en Atlas Function ved insert/update/replace/delete-hændelser og internt bruger en ændringsstrøm, at match-udtryk filtrerer, hvilke hændelser der kalder funktionen, og at funktioner skal være idempotente, fordi Atlas automatisk gentager mislykkede funktionskald. Næste emne er planlagte triggers og cron-job.
Lær JavaScript med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Databasetriggere: Reaktion på CRUD-hændelser” gratis?
Ja — hele teksten til “Databasetriggere: Reaktion på CRUD-hændelser” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af MongoDB Academy-kurset, skal du opgradere til CoddyKit PRO. MongoDB Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Databasetriggere: Reaktion på CRUD-hændelser”?
De lærende vil oprette en databasetrigger, der udløses ved indsættelse eller opdatering og kører en Atlas Function for at synkronisere data eller sende en notifikation. Du øver dig i MongoDB Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på MongoDB Academy?
Der kræves ingen tidligere erfaring. MongoDB Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Databasetriggere: Reaktion på CRUD-hændelser”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne MongoDB Academy-lektion?
Ja. Alle MongoDB Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Databasetriggere: Reaktion på CRUD-hændelser
- Planlagte triggere og cron-jobs
- Skrivning af Atlas Functions i JavaScript
- HTTPS-endpoints som lette webhooks