PostgreSQL Docker Container nutzen

Ich zeige wie man schnell und einfach einen PostgreSQL Docker Container nutzen kann. In wenigen Minuten hat man so eine lauffähige Datenbank. Dank dem Docker Container nimmt man sich diese schnell und unkompliziert in die Cloud mit.

PostgreSQL Docker Container nutzen

Früher musste man auf dem System eine Datenbank installieren und zusätzlich noch ein Programm zur Administration (wenn man nicht über die Kommandozeile arbeiten wollte). Um die Datenbank dann in die Produktionsumgebung zu übernehmen hat man diese als langes SQL Skript exportiert und auf dem Server importiert. Heute schreibt man ein rund 30 Zeilen langes docker-compose YAML Skript, welches Docker Container erstellt und eine fertig zu verwendende Datenbank samt Administrationssoftware bereitstellt. Ganz nebenbei kann man diese Container auch gleich in die Cloud schieben und muss nicht alles doppelt und dreifach installieren, konfigurieren und warten.

Postgres und pgAdmin4 YAML Skript

Ich will dich in dem Artikel auch gar nicht weiter mit Details langweilen, folgendes docker-compose.yml Skript erstellt eine fertig nutzbare Postgres Datenbank samt pgAdmin4 Administrationssoftware:

########################################################
# creates postgres sql database image and pgadmin4 image
# login db: postgres:postgres hostname: postgres
# login pgadmin: admin@developer-blog.net:admin port 5555
########################################################
version: '3'
services:
  postgres:
    image: postgres
    hostname: postgres
# if you need to connect from outside, comment this in:
#    ports:
#      - 5432:5432
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: testdb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

  pgadmin:
    image: dpage/pgadmin4
    depends_on:
      - postgres
    ports:
      - 5555:80
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@developer-blog.net
      PGADMIN_DEFAULT_PASSWORD: admin
    restart: unless-stopped

volumes:
  postgres-data:

Dieses Skript habe ich auf meinem Linux Server mit Docker in einem Ordner liegen und führe es mit dem Befehl:

docker-compose up

aus. Die Container werden heruntergeladen, bereitgestellt und fertig konfiguriert gestartet. In wenigen Minuten kann ich über den Browser auf pgAdmin4 zugreifen und mit der Datenbank arbeiten. Über die IP-Adresse des Linux Servers und dem im docker-compose.yml angegebenen öffentlichen Port 5555 verbinde ich mich mit der Software und diese sich mit der Datenbank:

Du kannst nun Tabellen anlegen und mit Daten füllen. Die Datenbank ist in der angeführten Konfiguration nicht von außen erreichbar und damit nur von anderen Microservices bzw. Docker Containern nutzbar. Du kannst eine WebApplikation schreiben die diese Datenbank nutzt und als Service einfach dazuhängen.

Theorie

Nachdem du gesehen hast wie einfach man so eine Datenbank samt Administrationssoftware bereitstelle wären auch ein paar Informationen angebracht. Im folgenden erkläre ich dir das docker-compose.yml Skript. Ich schreibe meine Skript eigentlich immer so, dass im Kommentar der ersten Zeilen alle Informationen zur Nutzung angegeben werden. Dort ist ersichtlich, dass es zwei Logins gibt: eine für die Datenbank, das andere für die Admin Software.

Der Link zur offiziellen Dokumentation für die docker-compose.yml Datei. Wie man docker-compose installiert habe ich bereits gezeigt. Das Skript selbst beginnt mit:

version: '3'
services:

Da es bereits mehrere Versionen gibt definiert die erste Zeile, für welche Version das Skript geschrieben wurde. Mit dem services wird die Konfiguration für jeden einzelnen Container festgelegt. Die Dokumentation vergleich den Bereich mit den Parametern des docker run Befehls. Eine Konfiguration für ein Service sieht am Beispiel des Postgres Containers wie folgt aus:

 postgres:
    image: postgres
    hostname: postgres
    ports:
      - 5432:5432
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: testdb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

Das YAML Skript verwendet Einrückungen um die Hierarchie abzubilden. Die erste Ebene in der service Hierarchie die nächste sind die Namen der einzelnen Container. Dieser kann beliebig gewählt werden, muss im Skript aber für eine späteren Referenzierung genau so verwendet werden. Man könnte also für die Datenbank diesen Container „datenbank“ nennen, ich werde etwas präziser und nenne den Container so wie das Image „postgres“. In der nächsten Ebene folgt die Konfiguration des Containers:

• image
  der Ausdruck image erwartet den Namen des Docker Images. Der Befehl docker images zeigt alle auf dem System liegenden Container an. Moment, aber wie funktioniert das bei einem neu aufgesetztem Server? Sollte das Image mit dem angegebenen Namen lokal nicht gefunden werden, dann wir das offizielle Docker Repository Docker Hub durchsucht und das passende Image heruntergeladen.
• hostname
  ist der Hostname unter dem der Container angesprochen werden kann (alternativ zu dessen IP Adresse, welche von anderen Services noch unbekannt ist)
• ports
  jedes Service ist nur von anderen Services ansprechbar. Will man jedoch auf die Datenbank auch von außerhalb des Rechners ansprechen können, dann muss ein Port Mapping konfiguriert werden. In angegebenen Beispiel wird der Postgres Standardport 5432 weitergeleitet. Gibt man beispielsweise 6543:5432 an, dann wäre Postgres von außerhalb über den Port 6543 verfügbar. Bei einer Datenbank macht es Sinn später im Production Umfeld die Zeilen zu entfernen, damit die Datenbank nach außen nicht erreichbar ist und damit ein möglicher Angriffsvektor für die Applikation geschlossen wird.
• environment
  in diesem Punkt definiert man Umgebungsvariablen. Welche es gibt ist vom Container abhängig und sollte in dessen Dokumentation (Beispiel postgres Dokumentation) ersichtlich sein. Bei einer Datenbank sollten das immer die Zugriffsdaten sein mit denen diese initial angelegt wird.
• volumes
  hier werden Mappings für Datei- und Ordnerpfade zwischen Container und Host erstellt. Das Beispiel oben mappt den internen Ordner /var/lib/postgresql/data mit dem benannten Volume postgres-data. Normalerweise speichert postgres die Datenbank in eben jenen Ornder lokal ab, mit dem Mapping wird die Datenbank nun persistent am Host System erstellt. Moment mal: wo denn, wir haben gar keinen Pfad angegeben? Je nach Betriebssystem ist der Standardordner für Volumes unterschiedlich. Unter Linux liegen die Volumes im /var/lib/docker/volumes Ordner vom Host. Der Ordner ist nur mit root Rechten auszulesen, dort findet man einen Ordner für den Container samt seinen Daten.
  

Äquivalent dazu kann man in so einer Docker-compose.yml Datei beliebig viele Container definieren. In meinem Beispiel wird zusätzlich zur Datenbank auch noch die Admin Software pgAdmin4 erstellt. Dort werden unter anderem Port und Zugangsdaten für pgAdmin definiert. Über den Browser, der IP vom Server und dem Port gelangt man auch gleich zur Login Seite und kommt mit den Logindaten zur Oberfläche. Von dort legt man noch eine Verbindung zur Datenbank an und kann diese auch schon administrieren.

Fazit

Ich habe anhand von einem Praxisbeispiel einer PostgreSQL Datenbank gezeigt wie man ein docker-compose.yml Script erstellt und die erste containerisierte Applikation auf dem Linux Server startet. Die beiden Container kann man nun als Basis verwenden und beispielsweise durch ein WebService zu einer Webapplikation erweitern. Wie das mit C# und .NET Core funktioniert folgt.