{"canonical_url":"https://engineer.company/nb/glossary/connection-pool/","content_markdown":"# Tilkoblingspool\n\n## Hva det er\n\nEn tilkoblingspool er et sett åpne databasetilkoblinger som en applikasjon\nholder på og låner ut igjen, i stedet for å åpne en ny tilkobling for hver\narbeidsoppgave og lukke den etterpå. Koden låner en tilkobling fra poolen,\nkjører setningene sine på den og leverer den tilbake, og den neste som trenger\nen, får den samme tilkoblingen, allerede åpen. SQLAlchemys dokumentasjon\nbeskriver pooling som en standardteknikk for å holde langlivede tilkoblinger i\nminnet slik at de kan gjenbrukes effektivt. Samme side gir poolen en oppgave\ntil: den styrer hvor mange tilkoblinger applikasjonen kan bruke samtidig, slik\nat en plutselig trafikktopp venter på en ledig tilkobling i stedet for å åpne\nflere.\n\nEn pool kan ligge to steder. Inne i applikasjonen er den en del av\ndatabasebiblioteket: hver `Engine` i SQLAlchemy har en, og Django kan holde en i\nhver prosess for PostgreSQL. Utenfor applikasjonen er den et eget program som\nstår mellom klientene og databaseserveren. PgBouncer er en slik pooler for\nPostgreSQL: applikasjonene kobler seg til den som om den var databasen, og den\nlåner dem servertilkoblinger fra sine egne pooler. De to kan kombineres, og\nDjangos databasereferanse har et avsnitt om å kjøre bak en transaksjonspooler\nsom PgBouncer.\n\nHvorfor en tilkobling er verdt å beholde, ser man på serversiden. PostgreSQL gir\nhver klient sin egen prosess: en overordnet prosess, postmaster, lytter etter\ninnkommende tilkoblinger og starter en ny serverprosess for hver\ntilkoblingsforespørsel, og hver klient er koblet til nøyaktig én av disse\nprosessene. Å åpne en tilkobling betyr altså å starte en prosess på\ndatabaseserveren, og en pool betaler den prisen én gang og gjenbruker så\nresultatet.\n\n## Hvorfor det er viktig\n\nDen første grunnen er prisen for å koble til. Djangos dokumentasjon sier det\nrett ut: en vedvarende tilkobling sparer arbeidet med å opprette en ny i hver\nHTTP-forespørsel. Standardinnstillingen gjør likevel det motsatte.\n`CONN_MAX_AGE` er 0, som lukker tilkoblingen ved slutten av hver forespørsel; et\npositivt antall sekunder holder den åpen for gjenbruk, og `None` holder den åpen\nuten grense. Det er den enkleste formen for gjenbruk, én tilkobling per tråd som\nlever lenger enn forespørselen, og en pool er den generelle formen.\n\nDen andre grunnen er grensen på serveren. PostgreSQLs `max_connections` er\ntypisk 100 som standard, kan være lavere hvis innstillingene i systemkjernen\nikke tåler det, og kan bare endres ved serverstart. Tre av plassene er som\nstandard reservert for superbrukere. Det er heller ikke gratis å heve tallet:\nPostgreSQL dimensjonerer visse ressurser, blant annet delt minne, direkte etter\n`max_connections`. Uten en pool holder hver arbeidsprosess sin egen tilkobling,\nog Djangos dokumentasjon sier hva det fører til: fordi hver tråd har sin egen\ntilkobling, må databasen kunne ta imot minst like mange samtidige tilkoblinger\nsom det finnes arbeidstråder. En pool gjør det til et tall teamet selv velger og\nkan summere.\n\nDen tredje grunnen er hygiene. En pool er det ene stedet hver tilkobling\npasserer mellom to lånere, så det er her en tilkobling blir ryddet og testet.\nNår en tilkobling kommer tilbake, kaller SQLAlchemys pool `rollback()` på den,\nsom frigjør all transaksjonstilstand, låser medregnet, slik at neste låner ikke\narver en halvferdig transaksjon. I PgBouncers standardmodus med sesjonspooling kjøres dens `server_reset_query`, som standard `DISCARD ALL`, når en servertilkobling frigjøres, og før en annen klient får den. Og en pool kan teste en tilkobling før den lånes ut, noe som\nbetyr mye for tilkoblinger som har stått ubrukt en stund.\n\n## Slik ser det ut i praksis\n\nI SQLAlchemy 2.1 får hver `Engine` en `QueuePool` som standard, med SQLites\ndatabase i minnet som unntak. Dens `pool_size` er 5 og dens `max_overflow` er\n10, så én engine kan ha opptil 15 tilkoblinger samtidig, og en kaller som finner\nalle i bruk, venter `pool_timeout`, som standard 30 sekunder, før den gir opp.\nInnstillingene er nøkkelordargumenter til `create_engine()`:\n\n```python\nfrom sqlalchemy import create_engine\n\n# Høyst ti tilkoblinger for denne enginen: ti holdes åpne, ingen utover dem.\nengine = create_engine(\n    \"postgresql+psycopg2://me@localhost/mydb\",\n    pool_size=10,\n    max_overflow=0,\n    pool_timeout=10,  # vent ti sekunder på en ledig tilkobling, gi så opp\n    pool_pre_ping=True,  # test hver tilkobling når den lånes ut\n    pool_recycle=3600,  # bytt ut tilkoblinger som er over en time gamle\n)\n```\n\nMed `pool_pre_ping` sjekker poolen ved utlån at tilkoblingen fortsatt kan\nbrukes, via driverens egen ping eller en setning som tilsvarer `SELECT 1`.\n`pool_recycle` er ment for servere som lukker tilkoblinger som har stått ubrukt\nen viss tid: med 3600 blir enhver tilkobling som har vært åpen i mer enn en\ntime, byttet ut ved neste utlån.\n\nDjango 6.1 har sin egen pool for PostgreSQL. Den virker bare med driveren\npsycopg og krever pakken `psycopg[pool]`, og den slås på med `\"OPTIONS\":\n{\"pool\": True}` i databaseinnstillingene eller med en ordbok med innstillinger\nfor psycopgs `ConnectionPool`. Poolen gjenbruker tilkoblinger på tvers av\ntråder, og hver prosess har en egen pool for hvert databasealias. `CONN_MAX_AGE`\nmå stå på 0 når pooling er slått på; levetiden til en tilkobling i poolen settes\ni stedet med poolens innstilling `max_lifetime`. Under ASGI råder Djangos\ndokumentasjon til å slå av vedvarende tilkoblinger og bruke denne innebygde\npoolen i stedet.\n\nPgBouncers `pool_mode` avgjør når en servertilkobling kan gå videre til en annen\nklient. I øktmodus, som er standard, beholder klienten den til den kobler fra. I\ntransaksjonsmodus har en klient bare en servertilkobling mens en transaksjon\npågår, så noen dusin servertilkoblinger kan betjene langt flere klienter.\nSetningsmodus frigjør tilkoblingen etter hver spørring og tillater ikke\ntransaksjoner som strekker seg over flere setninger. Hver pool rommer opptil\n`default_pool_size` servertilkoblinger per par av bruker og database, som\nstandard 20, og PgBouncer tar imot opptil `max_client_conn` klienttilkoblinger,\nsom standard 100.\n\nSelskapets egne notater setter poolen tidlig i rekkefølgen.\n[Optimaliser databasen før du sharder den](/nb/notes/optimise-before-you-shard/)\nber leseren telle de aktive øktene i `pg_stat_activity` mot antallet\nCPU-kjerner: når mange ganger flere er aktive enn det finnes kjerner, bruker\nserveren tiden sin på å bytte mellom dem, og en tilkoblingspool løser det før\nnoen maskinvare gjør det.\n[Å selge den siste billetten nøyaktig én gang](/nb/notes/selling-limited-stock-without-overselling/)\nbruker samme tanke på et lynsalg: hundre tusen kjøpere bør bli noen dusin\ntilkoblinger gjennom PgBouncer, ikke tusenvis av databaseprosesser som venter på\nén lås.\n\n## Hvor det går galt\n\n**Poolene krever til sammen flere tilkoblinger enn serveren tillater.** Hver\npool teller bare sine egne tilkoblinger. Med SQLAlchemys standardverdier kan én\nengine nå 15, så tolv prosesser kan be om 180 fra en server der\n`max_connections` typisk er 100 som standard, med tre av dem reservert for\nsuperbrukere, og Django har en egen pool for hvert databasealias i hver prosess.\nSummer det høyeste antallet for hver pool som peker mot databasen, på tvers av\nalle prosesser i alle applikasjoner og alle planlagte jobber, og hold summen\nunder `max_connections` minus de reserverte plassene. Når det ikke går, sett\nPgBouncer foran og la den styre antallet servertilkoblinger.\n\n**En tilkobling dør mens den venter i poolen.** En tilkobling som har stått\nubrukt, kan bli lukket i den andre enden uten at poolen vet det, og neste låner\nfeiler da på sin første setning. Slå på `pool_pre_ping` i SQLAlchemy eller\n`CONN_HEALTH_CHECKS` i Django, som tester en gjenbrukt tilkobling én gang per\nforespørsel, og sett `pool_recycle` eller psycopgs `max_lifetime` lavere enn\ntiden før serveren lukker ubrukte tilkoblinger. Ingen av dem dekker en\ntilkobling som faller midt i en transaksjon: SQLAlchemys dokumentasjon sier\nklart at pre-ping ikke håndterer det tilfellet, så applikasjonen må selv prøve\narbeidet på nytt.\n\n**En arbeidsprosess startet med fork arver tilkoblingene til forelderen.** En\nwebserver eller en jobbkjører som oppretter enginen sin og deretter starter\narbeidsprosessene med fork, etterlater hvert barn med de samme pooltilkoblingene\nsom forelderen. SQLAlchemys dokumentasjon kaller det kritisk at pooltilkoblinger\nikke deles med en prosess startet med fork, fordi begge prosessene da ville\nsnakke over den samme nettverkstilkoblingen. Følg den anbefalte fremgangsmåten\nog kall `engine.dispose(close=False)` i hvert barns initializer, slik at barnet\nstarter med en tom pool og lar tilkoblingene til forelderen være i fred.\nAlternativene er `NullPool`, som åpner og lukker en tilkobling ved hver bruk,\neller å kalle `engine.dispose()` før fork-kallet.\n\n**Transaksjonspooling ødelegger økttilstand.** I PgBouncers transaksjonsmodus\nkan to transaksjoner fra samme klient kjøre på forskjellige servertilkoblinger,\nså ingenting av det en klient setter opp for økten sin, er garantert å være der\ni neste transaksjon. PgBouncers funksjonsliste markerer `SET`, `LISTEN`,\nmarkører deklarert med `WITH HOLD`, `PREPARE` på SQL-nivå og advisory locks på\nøktnivå som aldri støttet i den modusen, og legger ikke skjul på at modusen i\nsin natur bryter noen av antagelsene klienter gjør om serveren. Hold økttilstand\nute av kode som går gjennom en transaksjonspooler, og send klientene som trenger\nden, til en pool i øktmodus. I Django må `DISABLE_SERVER_SIDE_CURSORS` settes\ntil `True` for en database bak en transaksjonspooler, ellers må spørringene\nkjøre inne i `atomic()`.\n\n## Les mer\n\n- [Connection Pooling](https://docs.sqlalchemy.org/en/21/core/pooling.html)\n  — `QueuePool` og standardverdiene, håndtering av brutte tilkoblinger,\n  nullstilling ved retur og pooler ved fork i SQLAlchemy 2.1.\n- [PgBouncer features](https://www.pgbouncer.org/features.html)\n  — økt-, transaksjons- og setningsmodus, og hvilke PostgreSQL-funksjoner hver\n  av dem støtter.\n- [PgBouncer configuration](https://www.pgbouncer.org/config.html)\n  — `pool_mode`, `default_pool_size`, `max_client_conn` og tidsavbruddene med\n  standardverdiene sine.\n- [How Connections Are Established](https://www.postgresql.org/docs/current/connect-estab.html)\n  — PostgreSQLs modell med én prosess per bruker og postmaster-prosessen.\n- [Connections and Authentication](https://www.postgresql.org/docs/current/runtime-config-connection.html)\n  — `max_connections` og tilkoblingsplassene som er reservert for superbrukere\n  og andre roller.\n- [Databases](https://docs.djangoproject.com/en/stable/ref/databases/)\n  — vedvarende tilkoblinger, PostgreSQL-poolen og transaksjonspooling i Djangos\n  referanse.\n\n\u003chttps://engineer.company/nb/glossary/connection-pool/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvorfor en databasetilkobling er verdt å beholde, hvordan en pool gjenbruker og begrenser tilkoblinger, hva PgBouncers moduser endrer, og fire fallgruver.","formats":{"gemtext":"https://engineer.company/nb/glossary/connection-pool/index.gmi","gopher":"https://engineer.company/nb/glossary/connection-pool/gophermap","html":"https://engineer.company/nb/glossary/connection-pool/","json":"https://engineer.company/nb/glossary/connection-pool/index.json","markdown":"https://engineer.company/nb/glossary/connection-pool/index.md","pdf":"https://engineer.company/nb/glossary/connection-pool/index.pdf"},"kind":"page","language":"nb","title":"Hva er en tilkoblingspool?","url":"https://engineer.company/nb/glossary/connection-pool/","version":1}