{"canonical_url":"https://engineer.company/da/glossary/connection-pool/","content_markdown":"# Forbindelsespulje\n\n## Hvad det er\n\nEn forbindelsespulje er et sæt åbne databaseforbindelser, som en applikation\nholder på og låner ud igen, i stedet for at åbne en ny forbindelse til hvert\nstykke arbejde og lukke den bagefter. Koden låner en forbindelse fra puljen,\nkører sine sætninger på den og giver den tilbage, og den næste, der skal bruge\nen, får den samme forbindelse, allerede åben. SQLAlchemys dokumentation\nbeskriver pooling som en standardteknik til at holde langlivede forbindelser i\nhukommelsen, så de kan genbruges effektivt. Samme side giver puljen en opgave\nmere: den styrer, hvor mange forbindelser applikationen må bruge på samme tid,\nså et pludseligt tryk venter på en ledig forbindelse i stedet for at åbne flere.\n\nEn pulje kan ligge to steder. Inde i applikationen er den en del af\ndatabasebiblioteket: hver `Engine` i SQLAlchemy har en, og Django kan holde en i\nhver proces til PostgreSQL. Uden for applikationen er den et selvstændigt\nprogram, der står mellem klienterne og databaseserveren. PgBouncer er sådan en\npooler til PostgreSQL: applikationerne forbinder sig til den, som om den var\ndatabasen, og den låner dem serverforbindelser fra sine egne puljer. De to kan\nkombineres, og Djangos databasereference har et afsnit om at køre bag en\ntransaktionspooler som PgBouncer.\n\nHvorfor en forbindelse er værd at beholde, ses på serversiden. PostgreSQL giver\nhver klient sin egen proces: en overordnet proces, postmaster, lytter efter\nindkommende forbindelser og starter en ny serverproces for hver anmodning om\nforbindelse, og hver klient er forbundet til præcis én af de processer. At åbne\nen forbindelse betyder altså at starte en proces på databaseserveren, og en\npulje betaler den pris én gang og genbruger så resultatet.\n\n## Hvorfor det betyder noget\n\nDen første grund er prisen for at forbinde. Djangos dokumentation siger det\nligeud: en vedvarende forbindelse sparer arbejdet med at oprette en ny i hver\nHTTP-forespørgsel. Standardindstillingen gør dog det modsatte. `CONN_MAX_AGE` er\n0, som lukker forbindelsen ved slutningen af hver forespørgsel; et positivt\nantal sekunder holder den åben til genbrug, og `None` holder den åben uden\ngrænse. Det er den enkleste form for genbrug, én forbindelse pr. tråd, som lever\nlængere end forespørgslen, og en pulje er den generelle form.\n\nDen anden grund er grænsen på serveren. PostgreSQLs `max_connections` er typisk\n100 som standard, kan være lavere, hvis kernens indstillinger ikke kan bære det,\nog kan kun ændres ved serverstart. Tre af pladserne er som standard reserveret\ntil superbrugere. Det er heller ikke gratis at hæve tallet: PostgreSQL\ndimensionerer visse ressourcer, blandt andet delt hukommelse, direkte efter\n`max_connections`. Uden en pulje holder hver worker sin egen forbindelse, og\nDjangos dokumentation siger, hvad det fører til: fordi hver tråd har sin egen\nforbindelse, skal databasen kunne tage imod mindst lige så mange samtidige\nforbindelser, som der er worker-tråde. En pulje gør det til et tal, holdet selv\nvælger og kan lægge sammen.\n\nDen tredje grund er hygiejne. En pulje er det ene sted, hver forbindelse\npasserer mellem to lånere, så det er her, en forbindelse bliver ryddet op og\ntestet. Når en forbindelse kommer tilbage, kalder SQLAlchemys pulje `rollback()`\npå den, hvilket frigiver al transaktionstilstand, låse medregnet, så den næste\nlåner ikke arver en halvfærdig transaktion. I PgBouncers standardtilstand med sessionspuljer køres dens `server_reset_query`, som standard `DISCARD ALL`, når en serverforbindelse frigives, og før en anden klient får den. Og en pulje kan teste en\nforbindelse, før den låner den ud, hvilket betyder noget for forbindelser, der\nhar ligget ubrugt et stykke tid.\n\n## Sådan ser det ud i praksis\n\nI SQLAlchemy 2.1 får hver `Engine` som standard en `QueuePool`, med SQLites\ndatabase i hukommelsen som undtagelse. Dens `pool_size` er 5, og dens\n`max_overflow` er 10, så én engine kan have op til 15 forbindelser på én gang,\nog en kalder, der finder dem alle i brug, venter `pool_timeout`, som standard 30\nsekunder, før den giver op. Indstillingerne er nøgleordsargumenter til\n`create_engine()`:\n\n```python\nfrom sqlalchemy import create_engine\n\n# Højst ti forbindelser til denne engine: ti holdes åbne, ingen ud over 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 forbindelse, giv så op\n    pool_pre_ping=True,  # test hver forbindelse, når den lånes ud\n    pool_recycle=3600,  # udskift forbindelser, der er over en time gamle\n)\n```\n\nMed `pool_pre_ping` tjekker puljen ved udlån, at forbindelsen stadig kan bruges,\nvia driverens eget ping eller en sætning svarende til `SELECT 1`. `pool_recycle`\ner beregnet til servere, der lukker forbindelser, som har været ubrugt et vist\nstykke tid: med 3600 bliver enhver forbindelse, der har været åben i mere end en\ntime, udskiftet ved næste udlån.\n\nDjango 6.1 har sin egen pulje til PostgreSQL. Den virker kun med driveren\npsycopg og kræver pakken `psycopg[pool]`, og den slås til med `\"OPTIONS\":\n{\"pool\": True}` i databaseindstillingerne eller med en ordbog af indstillinger\ntil psycopgs `ConnectionPool`. Puljen genbruger forbindelser på tværs af tråde,\nog hver proces har en separat pulje for hvert databasealias. `CONN_MAX_AGE` skal\nblive på 0, når pooling er slået til; levetiden for en forbindelse i puljen\nsættes i stedet med puljens indstilling `max_lifetime`. Under ASGI råder Djangos\ndokumentation til at slå vedvarende forbindelser fra og bruge denne indbyggede\npulje i stedet.\n\nPgBouncers `pool_mode` afgør, hvornår en serverforbindelse kan gå videre til en\nanden klient. I sessionstilstand, som er standard, beholder klienten den, til\nden afbryder forbindelsen. I transaktionstilstand har en klient kun en\nserverforbindelse, mens en transaktion kører, så et par dusin serverforbindelser\nkan betjene langt flere klienter. Sætningstilstand frigiver forbindelsen efter\nhver forespørgsel og tillader ikke transaktioner, der strækker sig over flere\nsætninger. Hver pulje rummer op til `default_pool_size` serverforbindelser pr.\npar af bruger og database, som standard 20, og PgBouncer tager imod op til\n`max_client_conn` klientforbindelser, som standard 100.\n\nVirksomhedens egne noter sætter puljen tidligt i rækkefølgen.\n[Optimér databasen, før du sharder den](/da/notes/optimise-before-you-shard/)\nfår læseren til at sammenligne de aktive sessioner i `pg_stat_activity` med\nantallet af CPU-kerner: når mange gange flere er aktive, end der er kerner,\nbruger serveren sin tid på at skifte mellem dem, og en forbindelsespulje løser\ndet, før nogen hardware gør.\n[At sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/)\nbruger samme tanke på et flash-salg: hundrede tusind købere bør blive til et par\ndusin forbindelser gennem PgBouncer, ikke tusindvis af serverprocesser, der\nventer på én lås.\n\n## Hvor det går galt\n\n**Puljerne kræver tilsammen flere forbindelser, end serveren tillader.** Hver\npulje tæller kun sine egne forbindelser. Med SQLAlchemys standardværdier kan én\nengine nå op på 15, så tolv processer kan bede om 180 fra en server, hvis\n`max_connections` typisk er 100 som standard, med tre af dem reserveret til\nsuperbrugere, og Django har en separat pulje for hvert databasealias i hver\nproces. Læg det højeste antal for hver pulje, der peger på databasen, sammen på\ntværs af alle processer i alle applikationer og alle planlagte job, og hold\nsummen under `max_connections` minus de reserverede pladser. Når det ikke kan\nlade sig gøre, så sæt PgBouncer foran og lad den styre antallet af\nserverforbindelser.\n\n**En forbindelse dør, mens den venter i puljen.** En forbindelse, der har ligget\nubrugt, kan blive lukket i den anden ende, uden at puljen ved det, og den næste\nlåner fejler så på sin første sætning. Slå `pool_pre_ping` til i SQLAlchemy\neller `CONN_HEALTH_CHECKS` i Django, som tester en genbrugt forbindelse én gang\npr. forespørgsel, og sæt `pool_recycle` eller psycopgs `max_lifetime` lavere end\nden tid, hvorefter serveren lukker ubrugte forbindelser. Ingen af dem dækker en\nforbindelse, der falder midt i en transaktion: SQLAlchemys dokumentation siger\nklart, at pre-ping ikke håndterer det tilfælde, så applikationen må selv prøve\narbejdet igen.\n\n**En worker oprettet med fork arver forælderens forbindelser.** En webserver\neller en jobkører, der opretter sin engine og derefter starter sine workers med\nfork, efterlader hvert barn med de samme puljeforbindelser som forælderen.\nSQLAlchemys dokumentation kalder det kritisk, at puljeforbindelser ikke deles\nmed en proces oprettet med fork, fordi begge processer så ville tale over den\nsamme netværksforbindelse. Følg den anbefalede fremgangsmåde og kald\n`engine.dispose(close=False)` i hvert barns initializer, så barnet starter med\nen tom pulje og lader forælderens forbindelser være. Alternativerne er\n`NullPool`, som åbner og lukker en forbindelse ved hver brug, eller at kalde\n`engine.dispose()` før fork-kaldet.\n\n**Transaktionspooling ødelægger sessionstilstand.** I PgBouncers\ntransaktionstilstand kan to transaktioner fra samme klient køre på forskellige\nserverforbindelser, så intet af det, en klient sætter op for sin session, er\nsikkert at finde i dens næste transaktion. PgBouncers funktionsliste markerer\n`SET`, `LISTEN`, cursorer erklæret med `WITH HOLD`, `PREPARE` på SQL-niveau og\nadvisory locks på sessionsniveau som aldrig understøttet i den tilstand og\nlægger ikke skjul på, at tilstanden i sagens natur bryder nogle af de\nantagelser, klienter gør sig om serveren. Hold sessionstilstand ude af kode, der\ngår gennem en transaktionspooler, og send de klienter, der har brug for den, til\nen pulje i sessionstilstand. I Django skal `DISABLE_SERVER_SIDE_CURSORS` sættes\ntil `True` for en database bag en transaktionspooler, ellers skal\nforespørgslerne køre inde i `atomic()`.\n\n## Læs mere\n\n- [Connection Pooling](https://docs.sqlalchemy.org/en/21/core/pooling.html)\n  — `QueuePool` og dens standardværdier, håndtering af afbrudte forbindelser,\n  nulstilling ved returnering og puljer ved fork i SQLAlchemy 2.1.\n- [PgBouncer features](https://www.pgbouncer.org/features.html)\n  — sessions-, transaktions- og sætningstilstand, og hvilke\n  PostgreSQL-funktioner hver af dem understøtter.\n- [PgBouncer configuration](https://www.pgbouncer.org/config.html)\n  — `pool_mode`, `default_pool_size`, `max_client_conn` og timeouts med deres\n  standardværdier.\n- [How Connections Are Established](https://www.postgresql.org/docs/current/connect-estab.html)\n  — PostgreSQLs model med én proces pr. bruger og postmaster-processen.\n- [Connections and Authentication](https://www.postgresql.org/docs/current/runtime-config-connection.html)\n  — `max_connections` og de forbindelsespladser, der er reserveret til\n  superbrugere og andre roller.\n- [Databases](https://docs.djangoproject.com/en/stable/ref/databases/)\n  — vedvarende forbindelser, PostgreSQL-puljen og transaktionspooling i Djangos\n  reference.\n\n\u003chttps://engineer.company/da/glossary/connection-pool/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvorfor en databaseforbindelse er værd at beholde, hvordan en pulje genbruger og begrænser forbindelser, hvad PgBouncers tilstande ændrer, og fire faldgruber.","formats":{"gemtext":"https://engineer.company/da/glossary/connection-pool/index.gmi","gopher":"https://engineer.company/da/glossary/connection-pool/gophermap","html":"https://engineer.company/da/glossary/connection-pool/","json":"https://engineer.company/da/glossary/connection-pool/index.json","markdown":"https://engineer.company/da/glossary/connection-pool/index.md","pdf":"https://engineer.company/da/glossary/connection-pool/index.pdf"},"kind":"page","language":"da","title":"Hvad er en forbindelsespulje?","url":"https://engineer.company/da/glossary/connection-pool/","version":1}