Distribuera PostgreSQL på en Docker Container

Introduktion

Docker moderniserade sättet vi bygger och distribuerar applikationen. Det tillåter oss att skapa lätta, bärbara, självförsörjande behållare som enkelt kan köra vilken applikation som helst.

Den här bloggen syftade till att förklara hur man använder Docker för att köra PostgreSQL-databas. Det täcker inte installation eller konfiguration av docker. Se dockningsinstallationsinstruktionerna här. Ytterligare en bakgrund finns i vår tidigare blogg om MySQL och Docker.

Innan vi går in på detaljerna, låt oss gå igenom lite terminologi.

Dockerfil
Den innehåller uppsättningen instruktioner/kommandon för att installera eller konfigurera programmet/mjukvaran.
Docker Image
Docker-bilden är uppbyggd av serier av lager som representerar instruktioner från Dockerfilen. Docker-bild används som en mall för att skapa en behållare.
Länkning av behållare och användardefinierat nätverk
Docker använde bridge som en standardnätverksmekanism och använde --länkarna för att länka behållarna till varandra. För att komma åt PostgreSQL-behållare från en applikationsbehållare, bör man länka båda behållarna vid skapandet. Här i den här artikeln använder vi användardefinierade nätverk eftersom länkfunktionen snart kommer att fasas ut.
Databeständighet i Docker
Som standard är data inuti en behållare tillfällig. Närhelst behållaren startas om kommer data att gå förlorade. Volymer är den föredragna mekanismen för att bevara data som genereras och används av en Docker-behållare. Här monterar vi en värdkatalog inuti behållaren där all data lagras.

Låt oss börja bygga vår PostgreSQL-bild och använda den för att köra en behållare.

PostgreSQL Dockerfile

# 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"]

Om du tittar noga på Dockerfilen så består den av kommandon som används för att installera PostgreSQL och utföra vissa konfigurationsändringar på ubuntu OS.

Bygga PostgreSQL-bild

Vi kan bygga en PostgreSQL-bild från Dockerfile med kommandot docker build.

# sudo docker build -t postgresondocker:9.3 .

Här kan vi specificera taggen (-t) till bilden som namn och version. Punkt (.) i slutet anger den aktuella katalogen och den använder Dockerfilen som finns i den aktuella katalogen. Dockerfilnamnet ska vara "Dockerfile". Om du vill ange ett anpassat namn för din docker-fil bör du använda -f i docker-byggkommandot.

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

Utdata:(Valfritt använd rullningslistens textfönster om möjligt)

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

Skapa behållarnätverk

Använd kommandot nedan för att skapa ett användardefinierat nätverk med bryggdrivrutin.

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

Bekräfta nätverksskapandet

# 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

Skapa behållare

Vi måste använda kommandot "docker run" för att skapa en container från docker-bilden. Vi kör postgres-behållare i demoniseringsläge med hjälp av -d-alternativet.

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

Använd kommandot nedan för att bekräfta skapandet av behållaren.

# 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

Vi har inte specificerat någon port att exponera, så den kommer att exponera standardpostgres-porten 5432 för intern användning. PostgreSQL är endast tillgängligt från Docker-nätverket, vi kommer inte att kunna komma åt denna Postgres-behållare på en värdport.

Vi kommer att se hur du kommer åt Postgres-behållaren på värdporten i ett senare avsnitt i den här artikeln.

Ansluter till PostgreSQL-behållare i Docker-nätverket

Låt oss försöka ansluta till Postgres-behållaren från en annan behållare inom samma Docker-nätverk som vi skapade tidigare. Här har vi använt psql-klienten för att ansluta till Postgres. Vi använde Postgres containernamn som värdnamn, användare och lösenord som finns i Docker-filen.

# 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=#

Alternativet --rm i körkommandot kommer att ta bort behållaren när vi avslutar psql-processen.

# 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

Databeständighet

Dockercontainrar är tillfälliga till sin natur, det vill säga data som används eller genereras av containern lagras inte implicit någonstans. Vi förlorar data när behållaren startas om eller tas bort. Docker tillhandahåller volymer som vi kan lagra beständiga data på. Det är en användbar funktion genom vilken vi kan tillhandahålla en annan behållare med samma volym eller data i händelse av en katastrof.

Låt oss skapa en datavolym och bekräfta att den skapas.

# sudo docker volume create pgdata
pgdata

# sudo docker volume ls
DRIVER              VOLUME NAME
local                   pgdata

Nu måste vi använda denna datavolym när vi kör Postgres-behållaren. Se till att du tar bort den äldre postgres-behållaren som körs utan volymer.

# 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

Vi har kört Postgres-behållaren med en datavolym kopplad till den.

Skapa en ny tabell i Postgres för att kontrollera databeständighet.

# 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)

Ta bort Postgres-behållaren.

# sudo docker container rm postgresondocker -f 
postgresondocker

Skapa en ny Postgres-behållare och bekräfta att testtabellen finns eller inte.

# 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)

Ladda ner Whitepaper Today PostgreSQL Management &Automation med ClusterControlLäs om vad du behöver veta för att distribuera, övervaka, hantera och skala PostgreSQLDladda Whitepaper

Exponera PostgreSQL-tjänsten för värden

Du kanske har märkt att vi inte har exponerat någon port i PostgreSQL-behållaren tidigare. Det betyder att PostgreSQL endast är tillgängligt för de behållare som finns i postgres-nätverket som vi skapade tidigare.

För att använda PostgreSQL-tjänsten måste vi exponera containerporten med --port-alternativet. Här har vi exponerat Postgres containerport 5432 på värdens port 5432.

# 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

Nu kan du ansluta PostgreSQL på localhost direkt.

# 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=#

Ta bort behållare

För att ta bort behållaren måste vi först stoppa den pågående behållaren och sedan ta bort behållaren med rm-kommandot.

# sudo docker container stop postgresondocker 

# sudo docker container rm postgresondocker
postgresondocker

Använd alternativet -f (--force) för att direkt ta bort den körande behållaren.

# sudo docker container rm postgresondocker -f
postgresondocker

Förhoppningsvis har du nu din egen dockariserade lokala miljö för PostgreSQL.

Obs! Den här artikeln ger en översikt om hur vi kan använda PostgreSQL på docker för utveckling/POC-miljö. Att köra PostgreSQL i produktionsmiljö kan kräva ytterligare ändringar i PostgreSQL- eller dockerkonfigurationer.

Slutsats

Det finns ett enkelt sätt att köra PostgreSQL-databas inuti en Docker-behållare. Docker kapslar effektivt in distribution, konfiguration och vissa administrationsprocedurer. Docker är ett bra val för att distribuera PostgreSQL med minimala ansträngningar. Allt du behöver göra är att starta en förbyggd Docker-container så har du PostgreSQL-databas redo för din tjänst.

Referenser

Dockerinstallation:https://docs.docker.com/install
Volymer:https://docs.docker.com/storage/volumes
Användardefinierade nätverk:https://docs.docker.com/network/
Postgres Docker-fil:https://docs.docker.com/engine/examples/postgresql_service
MySQL på Docker:Förstå grunderna:https://severalnines.com/blog/mysql-docker-containers-understanding-basics