ACID-garantier i et distribuert dokumentlager
Deltakerne vil knytte de fire ACID-egenskapene til MongoDBs lagringsmotor og forstå hvilke egenskaper som tilbys som standard på enkeltdokumentnivå.
ACID-garantier i et distribuert dokumentlager er en gratis leksjon i MongoDB Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i MongoDB Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i MongoDB Academy inneholder totalt 4 leksjoner.
Hva ACID betyr for databaser
ACID står for Atomicity, Consistency, Isolation og Durability – fire egenskaper som garanterer pålitelig behandling av databaseoperasjoner. Disse egenskapene ble først definert for tradisjonelle relasjonsdatabaser, men er like viktige i dokumentlagre. Når De forstår hvordan MongoDB tilbyr (eller gjør avveininger for) hver egenskap, kan De utforme datamodeller og operasjoner som oppfyller kravene til pålitelighet i applikasjonen.
Atomicitet: Alt eller ingenting
Atomicitet garanterer at et sett med operasjoner enten lykkes i sin helhet eller mislykkes i sin helhet – det finnes ingen delvis tilstand. I MongoDB er operasjoner på ett enkelt dokument alltid atomiske. Når De kaller updateOne med flere oppdateringsoperatorer, utføres hele endringen som én atomisk enhet. Dette er mulig fordi alle dataene for ett dokument vanligvis lagres samlet på disken i BSON-format.
// This entire updateOne is atomic — both fields change together or neither does
db.accounts.updateOne(
{ _id: accountId },
{
$inc: { balance: -100 },
$push: { transactions: { type: 'debit', amount: 100, date: new Date() } }
}
)Atomicitet for ett dokument kontra flere dokumenter
MongoDB garanterer atomicitet som standard på nivået for ett enkelt dokument. Siden et dokument kan inneholde innebygde matriser og nestede objekter, kan De ofte modellere det som ville vært flere SQL-rader, som ett dokument, og dermed få atomiske oppdateringer uten ekstra kostnad. Atomicitet på tvers av flere dokumenter krever eksplisitte transaksjoner for flere dokumenter (tilgjengelig siden MongoDB 4.0 på replikasett). Det er viktig å forstå dette skillet når De utformer datamodeller.
// No transaction needed: order + line items in one document = atomic
db.orders.insertOne({
_id: orderId,
customerId: customerId,
status: 'pending',
items: [
{ productId: 'P1', qty: 2, price: 29.99 },
{ productId: 'P2', qty: 1, price: 49.99 }
],
total: 109.97
})Konsistens: Gyldige tilstandsoverganger
Konsistens betyr at databasen alltid går fra én gyldig tilstand til en annen. I MongoDB håndheves konsistens gjennom JSON Schema-validatorer (felttyper, obligatoriske felt og enum-verdier), unikke indekser (ingen dupliserte verdier) og invarianter på applikasjonsnivå. I motsetning til tradisjonelle RDBMS håndhever ikke MongoDB fremmednøkler innebygd – applikasjonskoden eller skjemautformingen må ivareta referanseintegriteten.
// JSON Schema validator enforces consistency constraints
db.createCollection('users', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['email', 'role'],
properties: {
email: { bsonType: 'string' },
role: { enum: ['admin', 'user', 'guest'] }
}
}
}
})Isolasjon: Samtidige operasjoner
Isolasjon styrer hvordan samtidige operasjoner ser hverandres endringer. MongoDB bruker snapshot-isolasjon for transaksjoner på flere dokumenter: En transaksjon ser et konsistent øyeblikksbilde av dataene slik de var da transaksjonen startet. Utenfor transaksjoner kan enkeltstående lesinger umiddelbart se bekreftede endringer fra andre operasjoner – dette kalles isolasjon med read committed. Lesepreferanser i replikasett påvirker hvilket øyeblikksbilde De leser fra.
// Inside a transaction, a consistent snapshot is maintained
const session = client.startSession();
session.startTransaction();
try {
// These two reads see the SAME snapshot even if other writers commit between them
const inventory = await db.collection('inventory').findOne({ _id: itemId }, { session });
const order = await db.collection('orders').findOne({ _id: orderId }, { session });
// ...
await session.commitTransaction();
} finally {
await session.endSession();
}Varighet: Overleve feil
Varighet garanterer at en operasjon vedvarer etter at den er bekreftet, selv om systemet krasjer. MongoDB oppnår varighet gjennom WiredTiger-journalen – skrivinger registreres i en journal før de brukes på datafilene. Alternativet writeConcern lar Dem styre graden av varighet: w:1 bekrefter etter at én node har skrevet, mens w:majority venter til flertallet av medlemmene i replikasettet har gjort skrivingen varig.
// w:majority ensures write survives even if the primary fails
db.payments.insertOne(
{ orderId: orderId, amount: 99.99, status: 'completed' },
{ writeConcern: { w: 'majority', j: true } }
// j:true = wait for journal flush on disk
)Skrivinger av ett dokument er alltid varige
For operasjoner på ett enkelt dokument i et replikasett med standard skrivebekreftelse venter MongoDB på at primærnoden skal bekrefte skrivingen før den svarer. Hvis operasjonen har j:true, venter den også på at journalen skal tømmes til disken. Det betyr at skrivinger av ett enkelt dokument er beskyttet mot både krasj i primærnoden (failover i replikasettet) og diskfeil (journalen sikrer at data ikke går tapt ved omstart).
// Default write concern on Atlas: {w: 'majority'} — already durable
// Explicitly requesting journal flush:
await db.collection('criticalAuditLog').insertOne(
{ event: 'payment', userId: userId, timestamp: new Date(), amount: 500 },
{ writeConcern: { w: 'majority', j: true } }
);Fordelen med innebygde dokumenter for ACID
En av MongoDBs viktigste designinnsikter er at innbygging av relaterte data i ett enkelt dokument i mange tilfeller eliminerer behovet for transaksjoner på tvers av flere dokumenter. En ordre med ordrelinjene sine, et blogginnlegg med kommentarene sine og en brukerprofil med adressene sine er alle enkeltstående dokumenter og får derfor atomiske, konsistente, isolerte og varige oppdateringer uten ekstra kostnad og uten transaksjonsoverhead.
// Updating shipping address + logging the change:
// One atomic write — no transaction needed
await db.collection('users').updateOne(
{ _id: userId },
{
$set: { 'address.street': '123 Main St', 'address.city': 'Austin' },
$push: {
addressHistory: {
changedAt: new Date(),
previous: oldAddress
}
}
}
)Når De trenger ACID på tvers av flere dokumenter
Det finnes situasjoner der innbygging ikke fungerer, og ACID på tvers av flere dokumenter er nødvendig. Finansielle overføringer mellom to separate kontodokumenter (belaste den ene kontoen og godskrive den andre) krever atomicitet på tvers av to dokumenter. Reservasjon av lagerbeholdning (redusere lageret i én samling og opprette en ordre i en annen) krever isolasjon. Oppdateringer av distribuerte hovedbøker på tvers av mange poster krever garantier om alt eller ingenting. For disse mønstrene er transaksjoner på tvers av flere dokumenter i MongoDB 4.0+ løsningen.
// Without a transaction, a crash between these two writes
// leaves the database in an inconsistent state (money debited but not credited):
await db.collection('accounts').updateOne({ _id: fromId }, { $inc: { balance: -100 } });
// <--- system crash here means money is lost!
await db.collection('accounts').updateOne({ _id: toId }, { $inc: { balance: 100 } });
// With a transaction, both succeed or both roll back.ACID kontra BASE: Et spektrum
Ikke alle NoSQL-databaser tilbyr ACID-garantier. Mange tidlige NoSQL-systemer valgte BASE (Basically Available, Soft state, Eventually consistent) for å oppnå høyere skrivegjennomstrømming og tilgjengelighet på tvers av distribuerte noder. MongoDB tilbyr ACID på dokumentnivå som standard og full ACID for transaksjoner på tvers av flere dokumenter ved behov – en mellomløsning mellom strenge RDBMS og lagre med ren eventual consistency.
Les Deres egne skrivinger: Årsakskonsistens
I distribuerte replikasett kan en skriving på primærnoden etterfulgt av en lesing fra en sekundærnode skje før skrivingen er synlig der – dette er et konsistensavvik. MongoDBs funksjon for årsakskonsistens (tilgjengelig via sesjoner) garanterer at operasjoner i en sesjon ser effektene av alle tidligere operasjoner i den samme sesjonen, også på tvers av ulike servere. Dette er avgjørende for at applikasjonen skal oppføre seg korrekt etter skrivinger.
// Causal consistency: guaranteed to read your own writes within a session
const session = client.startSession({ causalConsistency: true });
await db.collection('settings').updateOne(
{ _id: userId }, { $set: { theme: 'dark' } }, { session }
);
// This read is guaranteed to see the update above, even on a secondary:
const settings = await db.collection('settings').findOne({ _id: userId }, { session });
await session.endSession();Kort kunnskapssjekk
Test forståelsen Deres av konseptene i MongoDB & NoSQL Databases fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at alle operasjoner på ett enkelt dokument i MongoDB som standard er fullt ACID-kompatible, at atomicitet på dokumentnivå eliminerer behovet for transaksjoner i mange tilfeller, og at ACID-transaksjoner på tvers av flere dokumenter (MongoDB 4.0+) håndterer tilfeller der innbygging ikke er praktisk, for eksempel finansielle overføringer mellom separate dokumenter. Deretter skal vi se på hvordan De åpner sesjoner og skriver transaksjoner på tvers av flere dokumenter.
Lær deg JavaScript med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «ACID-garantier i et distribuert dokumentlager» gratis?
Ja – hele teksten i «ACID-garantier i et distribuert dokumentlager» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av MongoDB Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i MongoDB Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «ACID-garantier i et distribuert dokumentlager»?
Deltakerne vil knytte de fire ACID-egenskapene til MongoDBs lagringsmotor og forstå hvilke egenskaper som tilbys som standard på enkeltdokumentnivå. Du øver på MongoDB Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med MongoDB Academy?
Ingen tidligere erfaring er nødvendig. MongoDB Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «ACID-garantier i et distribuert dokumentlager»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne MongoDB Academy-leksjonen?
Ja. Alle MongoDB Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- ACID-garantier i et distribuert dokumentlager
- Starte en sesjon og en transaksjon med flere dokumenter
- Feilhåndtering og logikk for nye forsøk
- Ytelseshensyn ved transaksjoner