Bereitstellen von PostgreSQL auf einem Docker-Container

Einführung

Docker hat die Art und Weise, wie wir die Anwendung erstellen und bereitstellen, modernisiert. Es ermöglicht uns, leichtgewichtige, tragbare, autarke Container zu erstellen, die jede Anwendung problemlos ausführen können.

Dieser Blog soll erklären, wie Docker zum Ausführen der PostgreSQL-Datenbank verwendet wird. Die Installation oder Konfiguration von Docker wird nicht behandelt. Bitte beachten Sie die Anweisungen zur Docker-Installation hier. Einige zusätzliche Hintergrundinformationen finden Sie in unserem vorherigen Blog zu MySQL und Docker.

Bevor wir ins Detail gehen, sehen wir uns einige Begriffe an.

Dockerfile
Es enthält die Anweisungen/Befehle zum Installieren oder Konfigurieren der Anwendung/Software.
Docker-Image
Das Docker-Image besteht aus einer Reihe von Ebenen, die Anweisungen aus der Docker-Datei darstellen. Das Docker-Image wird als Vorlage zum Erstellen eines Containers verwendet.
Verlinkung von Containern und benutzerdefinierte Vernetzung
Docker verwendet Bridge als Standardnetzwerkmechanismus und verwendet die --links, um die Container miteinander zu verknüpfen. Für den Zugriff auf den PostgreSQL-Container von einem Anwendungscontainer aus sollten beide Container zum Zeitpunkt der Erstellung verknüpft werden. Hier in diesem Artikel verwenden wir benutzerdefinierte Netzwerke, da die Link-Funktion bald veraltet sein wird.
Datenpersistenz in Docker
Standardmäßig sind Daten in einem Container flüchtig. Bei jedem Neustart des Containers gehen Daten verloren. Volumes sind der bevorzugte Mechanismus zum Beibehalten von Daten, die von einem Docker-Container generiert und verwendet werden. Hier mounten wir ein Host-Verzeichnis innerhalb des Containers, in dem alle Daten gespeichert sind.

Beginnen wir damit, unser PostgreSQL-Image zu erstellen und es zum Ausführen eines Containers zu verwenden.

PostgreSQL-Dockerdatei

# example Dockerfile for https://docs.docker.com/engine/examples/postgresql_service/


FROM ubuntu:14.04

# Add the PostgreSQL PGP key to verify their Debian packages.
# It should be the same key as https://www.postgresql.org/media/keys/ACCC4CF8.asc
RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8

# Add PostgreSQL's repository. It contains the most recent stable release
#     of PostgreSQL, ``9.3``.
RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list

# Install ``python-software-properties``, ``software-properties-common`` and PostgreSQL 9.3
#  There are some warnings (in red) that show up during the build. You can hide
#  them by prefixing each apt-get statement with DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y python-software-properties software-properties-common postgresql-9.3 postgresql-client-9.3 postgresql-contrib-9.3

# Note: The official Debian and Ubuntu images automatically ``apt-get clean``
# after each ``apt-get``

# Run the rest of the commands as the ``postgres`` user created by the ``postgres-9.3`` package when it was ``apt-get installed``
USER postgres

# Create a PostgreSQL role named ``postgresondocker`` with ``postgresondocker`` as the password and
# then create a database `postgresondocker` owned by the ``postgresondocker`` role.
# Note: here we use ``&&\`` to run commands one after the other - the ``\``
#       allows the RUN command to span multiple lines.
RUN    /etc/init.d/postgresql start &&\
    psql --command "CREATE USER postgresondocker WITH SUPERUSER PASSWORD 'postgresondocker';" &&\
    createdb -O postgresondocker postgresondocker

# Adjust PostgreSQL configuration so that remote connections to the
# database are possible.
RUN echo "host all  all    0.0.0.0/0  md5" >> /etc/postgresql/9.3/main/pg_hba.conf

# And add ``listen_addresses`` to ``/etc/postgresql/9.3/main/postgresql.conf``
RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf

# Expose the PostgreSQL port
EXPOSE 5432

# Add VOLUMEs to allow backup of config, logs and databases
VOLUME  ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"]

# Set the default command to run when starting the container
CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"]

Wenn Sie sich das Dockerfile genau ansehen, besteht es aus Befehlen, die verwendet werden, um PostgreSQL zu installieren und einige Konfigurationsänderungen unter Ubuntu OS durchzuführen.

PostgreSQL-Image erstellen

Wir können ein PostgreSQL-Image aus Dockerfile mit dem Docker-Build-Befehl erstellen.

# sudo docker build -t postgresondocker:9.3 .

Hier können wir das Tag (-t) zum Bild wie Name und Version angeben. Der Punkt (.) am Ende gibt das aktuelle Verzeichnis an und verwendet die im aktuellen Verzeichnis vorhandene Docker-Datei. Der Name der Docker-Datei sollte „Dockerfile“ lauten. Wenn Sie einen benutzerdefinierten Namen für Ihre Docker-Datei angeben möchten, sollten Sie -f im Docker-Build-Befehl verwenden.

# sudo docker build -t postgresondocker:9.3 -f <your_docker_file_name>

Ausgabe:(Optional verwenden Sie das Textfenster der Bildlaufleiste, wenn möglich)

Sending build context to Docker daemon  4.096kB
Step 1/11 : FROM ubuntu:14.04
14.04: Pulling from library/ubuntu
324d088ce065: Pull complete 
2ab951b6c615: Pull complete 
9b01635313e2: Pull complete 
04510b914a6c: Pull complete 
83ab617df7b4: Pull complete 
Digest: sha256:b8855dc848e2622653ab557d1ce2f4c34218a9380cceaa51ced85c5f3c8eb201
Status: Downloaded newer image for ubuntu:14.04
 ---> 8cef1fa16c77
Step 2/11 : RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8
 ---> Running in ba933d07e226
.
.
.
fixing permissions on existing directory /var/lib/postgresql/9.3/main ... ok
creating subdirectories ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 128MB
creating configuration files ... ok
creating template1 database in /var/lib/postgresql/9.3/main/base/1 ... ok
initializing pg_authid ... ok
initializing dependencies ... ok
creating system views ... ok
loading system objects' descriptions ... ok
creating collations ... ok
creating conversions ... ok
creating dictionaries ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
loading PL/pgSQL server-side language ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok
copying template1 to postgres ... ok
syncing data to disk ... ok

Success. You can now start the database server using:

    /usr/lib/postgresql/9.3/bin/postgres -D /var/lib/postgresql/9.3/main
or
    /usr/lib/postgresql/9.3/bin/pg_ctl -D /var/lib/postgresql/9.3/main -l logfile start

Ver Cluster Port Status Owner    Data directory               Log file
9.3 main    5432 down   postgres /var/lib/postgresql/9.3/main /var/log/postgresql/postgresql-9.3-main.log
update-alternatives: using /usr/share/postgresql/9.3/man/man1/postmaster.1.gz to provide /usr/share/man/man1/postmaster.1.gz (postmaster.1.gz) in auto mode
invoke-rc.d: policy-rc.d denied execution of start.
Setting up postgresql-contrib-9.3 (9.3.22-0ubuntu0.14.04) ...
Setting up python-software-properties (0.92.37.8) ...
Setting up python3-software-properties (0.92.37.8) ...
Setting up software-properties-common (0.92.37.8) ...
Processing triggers for libc-bin (2.19-0ubuntu6.14) ...
Processing triggers for ca-certificates (20170717~14.04.1) ...
Updating certificates in /etc/ssl/certs... 148 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d....done.
Processing triggers for sgml-base (1.26+nmu4ubuntu1) ...
Removing intermediate container fce692f180bf
 ---> 9690b681044b
Step 5/11 : USER postgres
 ---> Running in ff8864c1147d
Removing intermediate container ff8864c1147d
 ---> 1f669efeadfa
Step 6/11 : RUN    /etc/init.d/postgresql start &&    psql --command "CREATE USER postgresondocker WITH SUPERUSER PASSWORD 'postgresondocker';" &&    createdb -O postgresondocker postgresondocker
 ---> Running in 79042024b5e8
 * Starting PostgreSQL 9.3 database server
   ...done.
CREATE ROLE
Removing intermediate container 79042024b5e8
 ---> 70c43a9dd5ab
Step 7/11 : RUN echo "host all  all    0.0.0.0/0  md5" >> /etc/postgresql/9.3/main/pg_hba.conf
 ---> Running in c4d03857cdb9
Removing intermediate container c4d03857cdb9
 ---> 0cc2ed249aab
Step 8/11 : RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf
 ---> Running in fde0f721c846
Removing intermediate container fde0f721c846
 ---> 78263aef9a56
Step 9/11 : EXPOSE 5432
 ---> Running in a765f854a274
Removing intermediate container a765f854a274
 ---> d205f9208162
Step 10/11 : VOLUME  ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"]
 ---> Running in ae0b9f30f3d0
Removing intermediate container ae0b9f30f3d0
 ---> 0de941f8687c
Step 11/11 : CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"]
 ---> Running in 976d283ea64c
Removing intermediate container 976d283ea64c
 ---> 253ee676278f
Successfully built 253ee676278f
Successfully tagged postgresondocker:9.3

Containernetzwerkerstellung

Verwenden Sie den folgenden Befehl, um ein benutzerdefiniertes Netzwerk mit Bridge-Treiber zu erstellen.

# sudo docker network create --driver bridge postgres-network

Netzwerkerstellung bestätigen

# sudo docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
a553e5727617        bridge              bridge              local
0c6e40305851        host                host                local
4cca2679d3c0        none                null                local
83b23e0af641        postgres-network    bridge              local

Containererstellung

Wir müssen den Befehl „docker run“ verwenden, um einen Container aus dem Docker-Image zu erstellen. Wir führen den Postgres-Container im Daemonize-Modus mit Hilfe der Option -d aus.

# sudo docker run --name postgresondocker --network postgres-network -d postgresondocker:9.3

Verwenden Sie den folgenden Befehl, um die Containererstellung zu bestätigen.

# sudo docker container ls 
CONTAINER ID        IMAGE                  COMMAND                  CREATED              STATUS              PORTS               NAMES
06a5125f5e11        postgresondocker:9.3   "/usr/lib/postgresql…"   About a minute ago   Up About a minute   5432/tcp            postgresondocker

Wir haben keinen Port angegeben, der verfügbar gemacht werden soll, daher wird der standardmäßige Postgres-Port 5432 für die interne Verwendung verfügbar gemacht. PostgreSQL ist nur innerhalb des Docker-Netzwerks verfügbar, wir können nicht auf diesen Postgres-Container auf einem Host-Port zugreifen.

Wir werden in einem späteren Abschnitt dieses Artikels sehen, wie man auf den Postgres-Container auf dem Host-Port zugreift.

Verbindung zum PostgreSQL-Container im Docker-Netzwerk herstellen

Versuchen wir, von einem anderen Container innerhalb desselben Docker-Netzwerks, das wir zuvor erstellt haben, eine Verbindung zum Postgres-Container herzustellen. Hier haben wir den psql-Client verwendet, um eine Verbindung zum Postgres herzustellen. Wir haben den Postgres-Containernamen als Hostnamen, Benutzer und Passwort verwendet, die in der Docker-Datei vorhanden sind.

# docker run -it --rm --network postgres-network postgresondocker:9.3 psql -h postgresondocker -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=#

Die Option --rm im Befehl run entfernt den Container, sobald wir den psql-Prozess beenden.

# sudo docker container ls 
CONTAINER ID        IMAGE                  COMMAND                  CREATED              STATUS              PORTS               NAMES
2fd91685d1ea        postgresondocker:9.3   "psql -h postgresond…"   29 seconds ago       Up 30 seconds       5432/tcp            brave_spence
06a5125f5e11        postgresondocker:9.3   "/usr/lib/postgresql…"   About a minute ago   Up About a minute   5432/tcp            postgresondocker

Datenpersistenz

Docker-Container sind ephemerer Natur, d. h. Daten, die vom Container verwendet oder generiert werden, werden nicht implizit irgendwo gespeichert. Wir verlieren die Daten, wenn der Container neu gestartet oder gelöscht wird. Docker stellt Volumes bereit, auf denen wir die persistenten Daten speichern können. Dies ist eine nützliche Funktion, mit der wir im Katastrophenfall einen anderen Container mit demselben Volumen oder denselben Daten bereitstellen können.

Lassen Sie uns ein Datenvolume erstellen und seine Erstellung bestätigen.

# sudo docker volume create pgdata
pgdata

# sudo docker volume ls
DRIVER              VOLUME NAME
local                   pgdata

Jetzt müssen wir dieses Datenvolumen verwenden, während wir den Postgres-Container ausführen. Stellen Sie sicher, dass Sie den älteren Postgres-Container löschen, der ohne Volumes ausgeführt wird.

# sudo docker container rm postgresondocker -f 
postgresondocker

# sudo docker run --name postgresondocker --network postgres-network -v pgdata:/var/lib/postgresql/9.3/main -d postgresondocker:9.3

Wir haben den Postgres-Container mit einem daran angehängten Datenvolumen ausgeführt.

Erstellen Sie eine neue Tabelle in Postgres, um die Datenpersistenz zu überprüfen.

# docker run -it --rm --network postgres-network postgresondocker:9.3 psql -h postgresondocker -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=# \dt
No relations found.
postgresondocker=# create table test(id int);
CREATE TABLE
postgresondocker=# \dt 
            List of relations
 Schema | Name | Type  |      Owner       
--------+------+-------+------------------
 public | test | table | postgresondocker
(1 row)

Löschen Sie den Postgres-Container.

# sudo docker container rm postgresondocker -f 
postgresondocker

Erstellen Sie einen neuen Postgres-Container und bestätigen Sie, ob die Testtabelle vorhanden ist oder nicht.

# sudo docker run --name postgresondocker --network postgres-network -v pgdata:/var/lib/postgresql/9.3/main -d postgresondocker:9.3


# docker run -it --rm --network postgres-network postgresondocker:9.3 psql -h postgresondocker -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=# \dt
            List of relations
 Schema | Name | Type  |      Owner       
--------+------+-------+------------------
 public | test | table | postgresondocker
(1 row)

Laden Sie noch heute das Whitepaper PostgreSQL-Verwaltung und -Automatisierung mit ClusterControl herunterErfahren Sie, was Sie wissen müssen, um PostgreSQL bereitzustellen, zu überwachen, zu verwalten und zu skalierenLaden Sie das Whitepaper herunter

Stellen Sie den PostgreSQL-Dienst dem Host zur Verfügung

Sie haben vielleicht bemerkt, dass wir zuvor keinen Port des PostgreSQL-Containers verfügbar gemacht haben. Das bedeutet, dass PostgreSQL nur für die Container zugänglich ist, die sich in dem Postgres-Netzwerk befinden, das wir zuvor erstellt haben.

Um den PostgreSQL-Dienst zu verwenden, müssen wir den Container-Port mit der Option --port verfügbar machen. Hier haben wir den Postgres-Container-Port 5432 auf Port 5432 des Hosts bereitgestellt.

# sudo docker run --name postgresondocker --network postgres-network -v pgdata:/var/lib/postgresql/9.3/main -p 5432:5432 -d postgresondocker:9.3
# sudo docker container ls
CONTAINER ID        IMAGE                  COMMAND                  CREATED             STATUS              PORTS                    NAMES
997580c86188        postgresondocker:9.3   "/usr/lib/postgresql…"   8 seconds ago       Up 10 seconds       0.0.0.0:5432->5432/tcp   postgresondocker

Jetzt können Sie PostgreSQL direkt auf localhost verbinden.

# psql -h localhost -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=#

Containerlöschung

Um den Container zu löschen, müssen wir zuerst den laufenden Container stoppen und dann den Container mit dem Befehl rm löschen.

# sudo docker container stop postgresondocker 

# sudo docker container rm postgresondocker
postgresondocker

Verwenden Sie die Option -f (--force), um den laufenden Container direkt zu löschen.

# sudo docker container rm postgresondocker -f
postgresondocker

Hoffentlich haben Sie jetzt Ihre eigene dockerisierte lokale Umgebung für PostgreSQL.

Hinweis: Dieser Artikel gibt einen Überblick darüber, wie wir PostgreSQL auf Docker für Entwicklungs-/POC-Umgebungen verwenden können. Das Ausführen von PostgreSQL in der Produktionsumgebung erfordert möglicherweise zusätzliche Änderungen an der PostgreSQL- oder Docker-Konfiguration.

Schlussfolgerung

Es gibt eine einfache Möglichkeit, eine PostgreSQL-Datenbank in einem Docker-Container auszuführen. Docker kapselt effektiv Bereitstellung, Konfiguration und bestimmte Verwaltungsverfahren. Docker ist eine gute Wahl, um PostgreSQL mit minimalem Aufwand bereitzustellen. Alles, was Sie tun müssen, ist, einen vorgefertigten Docker-Container zu starten, und Sie haben die PostgreSQL-Datenbank für Ihren Dienst bereit.

Referenzen

Docker-Installation:https://docs.docker.com/install
Volumes:https://docs.docker.com/storage/volumes
Benutzerdefinierte Netzwerke:https://docs.docker.com/network/
Postgres-Docker-Datei:https://docs.docker.com/engine/examples/postgresql_service
MySQL auf Docker:Grundlagen verstehen:https://severalnines.com/blog/mysql-docker-containers-understanding-basics