Wprowadzenie
Docker unowocześnił sposób budowania i wdrażania aplikacji. Pozwala nam tworzyć lekkie, przenośne, samowystarczalne kontenery, które mogą z łatwością uruchamiać dowolną aplikację.
Ten blog ma na celu wyjaśnienie, jak używać Dockera do uruchamiania bazy danych PostgreSQL. Nie obejmuje instalacji ani konfiguracji dockera. Proszę zapoznać się z instrukcjami instalacji dokera tutaj. Dodatkowe informacje można znaleźć w naszym poprzednim blogu na temat MySQL i Dockera.
Zanim przejdziemy do szczegółów, przejrzyjmy trochę terminologii.
- Plik Dockera
Zawiera zestaw instrukcji/poleceń do instalacji lub konfiguracji aplikacji/oprogramowania. - Obraz dokowany
Obraz Dockera składa się z serii warstw, które reprezentują instrukcje z pliku Docker. Obraz Dockera jest używany jako szablon do tworzenia kontenera. - Łączenie kontenerów i sieci zdefiniowane przez użytkownika
Docker używał mostu jako domyślnego mechanizmu sieciowego i używa --links do łączenia kontenerów ze sobą. Aby uzyskać dostęp do kontenera PostgreSQL z kontenera aplikacji, należy połączyć oba kontenery podczas tworzenia. W tym artykule używamy sieci zdefiniowanych przez użytkownika, ponieważ funkcja łącza zostanie wkrótce wycofana. - Utrwalanie danych w Dockerze
Domyślnie dane w kontenerze są efemeryczne. Za każdym razem, gdy kontener zostanie ponownie uruchomiony, dane zostaną utracone. Woluminy są preferowanym mechanizmem utrwalania danych generowanych i używanych przez kontener Docker. Tutaj montujemy katalog hosta wewnątrz kontenera, w którym przechowywane są wszystkie dane.
Zacznijmy budować nasz obraz PostgreSQL i użyj go do uruchomienia kontenera.
Plik dockerowy PostgreSQL
# 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"]Jeśli przyjrzysz się uważnie plikowi Dockerfile, zawiera on polecenia używane do instalacji PostgreSQL i wykonania pewnych zmian konfiguracyjnych w systemie operacyjnym ubuntu.
Tworzenie obrazu PostgreSQL
Możemy zbudować obraz PostgreSQL z pliku Dockerfile za pomocą polecenia docker build.
# sudo docker build -t postgresondocker:9.3 .
Tutaj możemy określić tag (-t) do obrazu, taki jak nazwa i wersja. Kropka (.) na końcu określa bieżący katalog i używa pliku Dockerfile obecnego w bieżącym katalogu. Nazwa pliku Docker powinna brzmieć „Dockerfile”. Jeśli chcesz określić niestandardową nazwę pliku dockera, użyj opcji -f
# sudo docker build -t postgresondocker:9.3 -f <your_docker_file_name>Wyjście:(opcjonalnie użyj okna tekstowego paska przewijania, jeśli to możliwe)
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.3Tworzenie sieci kontenerów
Użyj poniższego polecenia, aby utworzyć sieć zdefiniowaną przez użytkownika ze sterownikiem mostka.
# sudo docker network create --driver bridge postgres-networkPotwierdź utworzenie sieci
# 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 localTworzenie kontenera
Musimy użyć polecenia „docker run”, aby utworzyć kontener z obrazu dockera. Uruchamiamy kontener postgres w trybie demonizacji za pomocą opcji -d.
# sudo docker run --name postgresondocker --network postgres-network -d postgresondocker:9.3Użyj poniższego polecenia, aby potwierdzić utworzenie kontenera.
# 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 postgresondockerNie określiliśmy żadnego portu do ujawnienia, więc ujawni domyślny port Postgres 5432 do użytku wewnętrznego. PostgreSQL jest dostępny tylko z poziomu sieci Docker, nie będziemy mogli uzyskać dostępu do tego kontenera Postgres na porcie hosta.
Zobaczymy, jak uzyskać dostęp do kontenera Postgres na porcie hosta w dalszej części tego artykułu.
Łączenie z kontenerem PostgreSQL w sieci Docker
Spróbujmy połączyć się z kontenerem Postgres z innego kontenera w ramach tej samej sieci Docker, którą stworzyliśmy wcześniej. Tutaj wykorzystaliśmy klienta psql do połączenia się z Postgresem. Użyliśmy nazwy kontenera Postgres jako nazwy hosta, użytkownika i hasła obecnych w pliku Docker.
# 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=# Opcja --rm w poleceniu run usunie kontener po zakończeniu procesu psql.
# 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 postgresondockerUtrwalanie danych
Kontenery Dockera mają charakter efemeryczny, tzn. dane, które są wykorzystywane lub generowane przez kontener nie są nigdzie niejawnie przechowywane. Tracimy dane za każdym razem, gdy kontener zostanie ponownie uruchomiony lub usunięty. Docker udostępnia woluminy, na których możemy przechowywać dane trwałe. Jest to przydatna funkcja, dzięki której możemy udostępnić inny kontener przy użyciu tego samego wolumenu lub danych w przypadku katastrofy.
Utwórzmy wolumen danych i potwierdźmy jego utworzenie.
# sudo docker volume create pgdata
pgdata
# sudo docker volume ls
DRIVER VOLUME NAME
local pgdataTeraz musimy wykorzystać ten wolumen danych podczas uruchamiania kontenera Postgres. Upewnij się, że usunąłeś starszy kontener postgres, który działa bez woluminów.
# 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.3Uruchomiliśmy kontener Postgres z dołączonym do niego wolumenem danych.
Utwórz nową tabelę w Postgresie, aby sprawdzić trwałość danych.
# 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)Usuń kontener Postgres.
# sudo docker container rm postgresondocker -f
postgresondockerUtwórz nowy kontener Postgres i potwierdź obecność tabeli testowej.
# 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)Wyświetl usługę PostgreSQL na hosta
Być może zauważyłeś, że wcześniej nie ujawniliśmy żadnego portu kontenera PostgreSQL. Oznacza to, że PostgreSQL jest dostępny tylko dla kontenerów znajdujących się w utworzonej wcześniej sieci postgres.
Aby skorzystać z usługi PostgreSQL, musimy udostępnić port kontenera za pomocą opcji --port. Tutaj ujawniliśmy port kontenera Postgres 5432 na porcie 5432 hosta.
# 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 postgresondockerTeraz możesz podłączyć PostgreSQL bezpośrednio na hoście lokalnym.
# 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=#Usunięcie kontenera
Aby usunąć kontener, musimy najpierw zatrzymać działający kontener, a następnie usunąć kontener za pomocą polecenia rm.
# sudo docker container stop postgresondocker
# sudo docker container rm postgresondocker
postgresondockerUżyj opcji -f (--force), aby bezpośrednio usunąć działający kontener.
# sudo docker container rm postgresondocker -f
postgresondockerMamy nadzieję, że masz teraz własne, zadokowane środowisko lokalne dla PostgreSQL.
Uwaga: Ten artykuł zawiera przegląd tego, jak możemy używać PostgreSQL w dockerze dla środowiska programistycznego/POC. Uruchomienie PostgreSQL w środowisku produkcyjnym może wymagać dodatkowych zmian w konfiguracji PostgreSQL lub dockera.
Wniosek
Istnieje prosty sposób na uruchomienie bazy danych PostgreSQL w kontenerze Dockera. Docker skutecznie hermetyzuje wdrażanie, konfigurację i niektóre procedury administracyjne. Docker to dobry wybór do wdrożenia PostgreSQL przy minimalnym wysiłku. Wszystko, co musisz zrobić, to uruchomić gotowy kontener Docker, a baza danych PostgreSQL będzie gotowa do obsługi.
Referencje
- Instalacja Dockera:https://docs.docker.com/install
- Woluminy:https://docs.docker.com/storage/volumes
- Sieci zdefiniowane przez użytkownika:https://docs.docker.com/network/
- Plik Docker Postgres:https://docs.docker.com/engine/examples/postgresql_service
- MySQL na platformie Docker:zrozumienie podstaw:https://severalnines.com/blog/mysql-docker-containers-understanding-basics
