Docker pgAdmin: Så sätter du upp ett PostgreSQL-GUI med Docker Compose

Att växla mellan sessioner, memorera syntax och hoppas att du inte råkar stava fel i en destruktiv fråga blir snabbt tröttsamt. Det finns ingen visuell frågeplan, ingen schemabläddrare och inget enkelt sätt att säkerhetskopiera en databas. Det fungerar, men är långt ifrån idealiskt.

pgAdmin 4 löser detta med ett webbläsarbaserat GUI byggt specifikt för PostgreSQL. Och att köra det i Docker innebär noll lokal installation. Du behöver bara starta containern.

I den här artikeln visar jag hur du sätter upp PostgreSQL och pgAdmin 4 med Docker Compose, kopplar samman de två containrarna och använder pgAdmins Query Tool, schemabläddrare och backup-funktioner.

För att kunna följa med behöver du Docker installerat och igång på din dator. Om du är ny på Docker Compose, läs vår guide för att se hur det förenklar utveckling med flera containrar.

Vad är pgAdmin 4?

pgAdmin 4 är en öppen källkod, webbläsarbaserad administrations- och utvecklingsplattform för PostgreSQL. Du använder den via en webbläsare, så det finns ingen skrivbordsapp att installera. Den ger dig ett GUI för att hantera databaser, köra frågor, inspektera scheman och hantera säkerhetskopior – allt utan att röra kommandoraden.

Den officiella Docker-imagen är dpage/pgadmin4, underhållen av pgAdmins utvecklingsteam.

Att köra pgAdmin 4 i Docker har ett par verkliga fördelar jämfört med en lokal installation. För det första portabilitet – hela din databasmiljö finns i en docker-compose.yml-fil som du kan dela med kollegor. För det andra inga versionskonflikter – pgAdmin körs i sin egen container, helt isolerad från allt annat på din dator. Och när du är klar rensar docker compose down bort allt.

pgAdmin 4 jämfört med andra PostgreSQL-GUI:er

Det finns gott om GUI-verktyg för databashantering. Så här står sig pgAdmin 4 mot två populära alternativ.

pgAdmin 4 jämfört med populära alternativ

DBeaver och TablePlus är bra verktyg, men ingen av dem har en officiell Docker-image. Om din PostgreSQL-instans redan kör i Docker är pgAdmin 4 ett utmärkt val – du behöver bara lägga till en tjänst i din docker-compose.yml så körs allt tillsammans i samma nätverk.

Sätta upp miljön med Docker Compose

Det snabbaste sättet att få PostgreSQL och pgAdmin 4 att köra tillsammans är en enda docker-compose.yml-fil. Om du är ny på ämnet täcker vår Docker Compose Guide grunderna. Här fokuserar jag på den pgAdmin-specifika konfigurationen.

Här är den kompletta filen du kan kopiera och klistra in:

services:
  postgres:
    image: postgres:18
    container_name: postgres
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: mydb
    volumes:
      - postgres_data:/var/lib/postgresql
    networks:
      - pgnetwork

  pgadmin:
    image: dpage/pgadmin4:9.13
    container_name: pgadmin
    environment:
      PGADMIN_DEFAULT_EMAIL: you@yourdomain.com
      PGADMIN_DEFAULT_PASSWORD: password
      PGADMIN_LISTEN_PORT: 5050 
    ports:
      - "5050:5050"                
    volumes:
      - pgadmin_data:/var/lib/pgadmin
    depends_on:
      - postgres
    networks:
      - pgnetwork

volumes:
  postgres_data:
  pgadmin_data:

networks:
  pgnetwork:

Fältet depends_on säger åt Docker Compose att starta containern postgres före pgadmin. Utan det kan pgAdmin starta innan PostgreSQL är redo och misslyckas med att ansluta. Det väntar inte på att PostgreSQL ska vara helt friskt – bara att containern startar. Det räcker ändå för att undvika de flesta race conditions.

Miljövariabler för pgAdmin 4

Två miljövariabler är obligatoriska:

• PGADMIN_DEFAULT_EMAIL – e-postadressen du använder för att logga in på pgAdmins webbgränssnitt
• PGADMIN_DEFAULT_PASSWORD – lösenordet för det kontot

En tredje är valfri men bör anges:

• PGADMIN_LISTEN_PORT – porten pgAdmin lyssnar på inne i containern. Standard är 80, men att sätta den till 5050 håller saker renare när du mappar portar.

Med det sagt är det en dålig idé att hårdkoda uppgifter i Compose-filen, särskilt om filen hamnar i versionshantering. Flytta dem i stället till en .env-fil.

Skapa en .env-fil i samma katalog som din docker-compose.yml:

POSTGRES_USER=admin
POSTGRES_PASSWORD=secret
POSTGRES_DB=mydb
PGADMIN_DEFAULT_EMAIL=admin@example.com
PGADMIN_DEFAULT_PASSWORD=secret

Referera sedan till variablerna i din Compose-fil:

# postgres
environment:
  POSTGRES_USER: ${POSTGRES_USER}
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
  POSTGRES_DB: ${POSTGRES_DB}
  
# pgadmin
environment:
  PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL}
  PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD}

Docker Compose plockar upp .env-filer när du kör kommandot, så det behövs ingen extra konfiguration. Kom bara ihåg att lägga till .env i din .gitignore så hålls dina uppgifter borta från repot.

Volymer och datapersistens

Volymen som mappar till /var/lib/pgadmin är där pgAdmin lagrar data, såsom sessionsdata, sparade serveranslutningar och konfiguration. Om du tar bort detta från compose-filen förlorar du allt varje gång containern startas om.

I den aktuella compose-filen har du en namngiven volym som Docker hanterar på din värddator. Datan överlever omstarter av containern, ominstallationer och uppdateringar av image – så länge du inte uttryckligen tar bort volymen med docker volume rm.

Starta stacken och komma åt pgAdmin 4

När din docker-compose.yml är klar startar du stacken med ett kommando:

docker compose up -d

Flaggan -d kör båda containrarna i bakgrunden – de startar i bakgrunden och din terminal förblir fri. För att verifiera att båda containrarna körs:

docker ps

Du bör se både postgres och pgadmin listade med status Up.

Containerstatus

Om något ser fel ut, kontrollera pgAdmin-loggarna:

docker logs pgadmin

En frisk uppstart ser ut så här:

pgAdmin uppstartsloggar

Om du ser ett fel här är det sannolikt ett av dessa tre:

• Lösenordsautentisering misslyckades: din PGADMIN_DEFAULT_PASSWORD saknas eller är felaktig i .env-filen

• Porten är redan allokerad: något annat körs på port 5050; ändra värdporten i din Compose-fil

• Fil eller katalog finns inte: volymvägen är fel eller containern har inte behörighet att skriva till den

När båda containrarna är igång och loggarna ser bra ut, öppna din webbläsare och gå till http://localhost:5050:

pgAdmin inloggningssida

Logga in med e-post och lösenord som du angav i PGADMIN_DEFAULT_EMAIL och PGADMIN_DEFAULT_PASSWORD. Du hamnar på pgAdmins instrumentpanel, redo att registrera din PostgreSQL-server:

pgAdmin startsida

Ansluta pgAdmin 4 till din PostgreSQL-container

I pgAdmins sidofält, högerklicka på Servers – Register – Server. En dialog öppnas med två flikar du behöver fylla i: General och Connection.

Fliken General

Ge din server ett meningsfullt namn – något i stil med local-dev-postgres. Det här är bara en etikett i pgAdmin, så välj något som passar din miljö.

Serverregistrering – fliken General

Fliken Connection

Använd inte localhost här. 

Inne i ett Docker-nätverk syftar localhost på själva containern – inte din värddator och inte PostgreSQL-containern. Docker har sin egen interna DNS och den slår upp containernamn med hjälp av tjänstenamnen som definieras i din docker-compose.yml. Så om din PostgreSQL-tjänst heter postgres är det det värdnamn du använder.

Fyll i fälten så här:

• Host name/address: postgres (tjänstenamnet från docker-compose.yml)

• Port: 5432

• Maintenance database: värdet av POSTGRES_DB från din Compose-fil (t.ex. mydb)

• Username: värdet av POSTGRES_USER (t.ex. admin)

• Password: värdet av POSTGRES_PASSWORD

Klicka på Save. 

Serverregistrering – fliken Connection

Om allt stämmer dyker servern upp i sidofältet och du kan expandera den och se dina databaser:

Serverregistrering lyckades

Det betyder att du är ansluten.

Använda Query Tool

Nu när du är ansluten visar jag grunderna i pgAdmin 4 och Postgres i allmänhet.

Öppna Query Tool genom att klicka på Tools – Query Tool i toppmenyn. Gränssnittet har tre paneler:

• Editor: där du skriver SQL
• Data Output: där resultaten visas efter att du kört en fråga
• Messages: där PostgreSQL skickar statusmeddelanden, fel och körningsinfo

Query-verktyg

Skriva och köra SQL

Låt oss skapa en enkel tabell orders och lägga till lite data. Du kan köra varje block genom att trycka på Play-knappen eller genom att trycka F5 som är en genväg.

Kör detta för att skapa tabellen:

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_name VARCHAR(100) NOT NULL,
    product VARCHAR(100) NOT NULL,
    quantity INT NOT NULL,
    order_date DATE DEFAULT CURRENT_DATE
);

Infoga några rader:

INSERT INTO orders (customer_name, product, quantity)
VALUES
    ('Alice Johnson', 'Wireless Keyboard', 2),
    ('Bob Smith', 'USB-C Hub', 1),
    ('Carol White', 'Mechanical Keyboard', 3);

Och fråga nu datan:

SELECT * FROM orders;

Fråga data

Resultaten visas i panelen Data Output som en tabell. Du kan sortera kolumner, ändra storlek på dem och kopiera rader direkt från rutnätet.

Läsa den visuella frågeplanen

För att se vad som händer bakom kulisserna när du kör en fråga, kör EXPLAIN ANALYZE på ditt SELECT-uttryck:

EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_name = 'Alice Johnson';

Explain Analyze-resultat

Panelen Data Output visar råutdata. Men pgAdmin har ett bättre alternativ. Klicka på knappen Explain i verktygsfältet – så återger pgAdmin frågeplanen som en interaktiv graf.

Frågeplan som graf

Nu är det enkelt för den här frågan, men du får ut mycket mer när du gör joins eller mer komplexa dataaggregeringar.

Detta är viktigt eftersom det går långsamt och är felbenäget att läsa rå EXPLAIN-utdata. Den visuella planen gör det uppenbart när PostgreSQL gör en fullständig tabellskanning på en stor tabell, eller när ett index finns men inte används.

Hantera ditt databasschema

pgAdmins sidofält ger dig en fullständig vy över din databasstruktur – och låter dig ändra den via GUI:t.

Trädstrukturen i sidofältet går: Servers – ditt servernamn – Databases – din databas – Schemas – public – Tables. Expandera valfri tabell så ser du dess Columns, Indexes och Constraints listade som undernoder. Klicka på någon av dem för att inspektera detaljerna i högra panelen.

Skapa och ändra tabeller

För att skapa en ny tabell, högerklicka på Tables under ditt schema och välj Create – Table. En dialog öppnas med ett par flikar.

Skapa tabeller

Fliken General är där du sätter tabellnamnet. Byt till fliken Columns för att lägga till dina kolumner – varje rad låter dig ange kolumnnamn, datatyp, längd och om den kan vara null. Fliken Constraints hanterar primärnycklar, främmande nycklar och unika begränsningar.

För att lägga till ett index i en befintlig tabell, expandera tabellen i sidofältet, högerklicka på Indexes och välj Create – Index. Välj kolumner att indexera och välj indextyp – btree är standard och fungerar i de flesta fall.

Skapa ett index

Backup och återställning

För att säkerhetskopiera en databas, gå till Tools – Backup. Du behöver välja ett format:

• Custom: komprimerat binärt format; det mest flexibla alternativet och det bästa valet i de flesta fall eftersom du kan återställa enskilda tabeller från det
• Plain: ett enkelt SQL-skript du kan öppna och läsa i valfri textredigerare
• Tar: ett okomprimerat arkiv; mindre vanligt men användbart för vissa återställningsflöden

Efter att du valt format och destinationssökväg kör pgAdmin pg_dump i bakgrunden och sparar filen på din lokala dator.

Skapa en säkerhetskopia

För att återställa, gå till Tools – Restore, välj din backupfil och peka den mot måldatabasen.

Återställa från en säkerhetskopia

Om du undrar varför detta är användbart, tänk dig att du testar en destruktiv migrering på din utvecklingsdatabas. Ta en backup först, kör migreringen och om något går sönder, återställ backupen för att komma tillbaka till ett känt läge.

Bästa praxis för att köra pgAdmin 4 i Docker

Att få pgAdmin 4 att köra är en sak. Men att hålla det igång smidigt kräver att du kan ett par extra saker. Här är några praktiska tips.

Håll uppgifter borta från din Compose-fil

Om din docker-compose.yml hamnar i versionshantering – vilket den oftast gör – följer hårdkodade lösenord med. Använd en .env-fil för uppgifter och lägg till den i .gitignore. För produktionsmiljöer, gå ett steg längre och använd Docker secrets, som monterar känsliga värden som filer i stället för miljövariabler.

Exponera aldrig pgAdmins port publikt

Som standard binder Docker portar till 0.0.0.0, vilket betyder alla nätverksgränssnitt – inklusive publika. På en fjärrserver gör det din pgAdmin-instans nåbar från internet. Bind i stället uttryckligen till 127.0.0.1:

ports:
  - "127.0.0.1:5050:5050"

Detta gör pgAdmin åtkomligt endast från servern själv. Använd en SSH-tunnel eller en reverse proxy om du behöver fjärråtkomst.

Lås dina imagetaggar

Att använda dpage/pgadmin4:latest kommer att hämta en ny version nästa gång någon kör docker compose pull. Den nya versionen kan bete sig annorlunda, förstöra din konfiguration eller introducera oväntade ändringar. Använd en specifik tagg som dpage/pgadmin4:9.13 så kör alla i teamet exakt samma version.

Förladda serveranslutningar med servers.json

Om hela teamet delar samma Compose-uppsättning, låt inte alla behöva registrera PostgreSQL-servern efter att stacken startats. pgAdmin stödjer en servers.json-fil som förbefolkar anslutningar vid uppstart. Montera in den i containern så här:

volumes:
  - ./servers.json:/pgadmin4/servers.json

Så här ser en minimal servers.json ut:

{
  "Servers": {
    "1": {
      "Name": "local-dev-postgres",
      "Group": "Servers",
      "Host": "postgres",
      "Port": 5432,
      "MaintenanceDB": "mydb",
      "Username": "admin",
      "SSLMode": "prefer"
    }
  }
}

Servern visas när pgAdmin startar – ingen manuell konfiguration krävs.

Slutsats

I den här artikeln gick jag igenom hur du sätter upp pgAdmin 4 i Docker från grunden. Du skrev en Docker Compose-fil som startar PostgreSQL och pgAdmin 4 tillsammans, kopplade de två containrarna med Dockers interna DNS och använde pgAdmins kärnfunktioner – Query Tool, schemabläddrare och arbetsflödet för backup/återställning.

Kärnprincipen här är reproducerbarhet. 

En docker-compose.yml-fil, en servers.json och en .env-fil är allt du behöver för att ge en kollega en fullt konfigurerad databasmiljö. Det gör att problemet ”det funkar på min dator” aldrig uppstår igen.

För att fördjupa dig i Docker och containerisering, kolla in vår Intermediate Docker-kurs. Den är full av praktiska tips om multi-stage builds, nätverk och en djupdykning i Compose.