sql >> Database >  >> RDS >> PostgreSQL

PostgreSQL implementeren op een Docker-container

Inleiding

Docker moderniseerde de manier waarop we de applicatie bouwen en implementeren. Het stelt ons in staat om lichtgewicht, draagbare, zelfvoorzienende containers te maken die elke applicatie gemakkelijk kunnen uitvoeren.

Deze blog was bedoeld om uit te leggen hoe Docker te gebruiken om de PostgreSQL-database te draaien. Het dekt niet de installatie of configuratie van docker. Raadpleeg hier de installatie-instructies voor de docker. Wat aanvullende achtergrondinformatie is te vinden in onze vorige blog over MySQL en Docker.

Laten we, voordat we ingaan op de details, wat terminologie doornemen.

  • Dockerbestand
    Het bevat de set instructies/commando's om de applicatie/software te installeren of configureren.
  • Docker-afbeelding
    Docker-image is opgebouwd uit een reeks lagen die instructies uit de Dockerfile vertegenwoordigen. Docker-afbeelding wordt gebruikt als sjabloon om een ​​container te maken.
  • Koppeling van containers en door de gebruiker gedefinieerde netwerken
    Docker gebruikte bridge als een standaard netwerkmechanisme en gebruikt de --links om de containers aan elkaar te koppelen. Om toegang te krijgen tot de PostgreSQL-container vanuit een applicatiecontainer, moet men beide containers koppelen op het moment van aanmaak. Hier in dit artikel gebruiken we door de gebruiker gedefinieerde netwerken, aangezien de koppelingsfunctie binnenkort zal worden beëindigd.
  • Gegevenspersistentie in Docker
    Standaard zijn gegevens in een container kortstondig. Telkens wanneer de container opnieuw wordt opgestart, gaan gegevens verloren. Volumes zijn het voorkeursmechanisme voor het bewaren van gegevens die zijn gegenereerd en gebruikt door een Docker-container. Hier monteren we een hostdirectory in de container waar alle gegevens worden opgeslagen.

Laten we beginnen met het bouwen van onze PostgreSQL-image en deze gebruiken om een ​​container uit te voeren.

PostgreSQL-dockerbestand

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

Als je het Docker-bestand goed bekijkt, bestaat het uit opdrachten die worden gebruikt om PostgreSQL te installeren en enkele configuratiewijzigingen uit te voeren op ubuntu OS.

PostgreSQL-afbeelding bouwen

We kunnen een PostgreSQL-image bouwen vanuit Dockerfile met behulp van de opdracht docker build.

# sudo docker build -t postgresondocker:9.3 .

Hier kunnen we de tag (-t) voor de afbeelding specificeren, zoals naam en versie. Punt (.) aan het einde specificeert de huidige map en gebruikt het Dockerbestand dat aanwezig is in de huidige map. De naam van het Docker-bestand moet "Dockerfile" zijn. Als u een aangepaste naam voor uw docker-bestand wilt opgeven, moet u -f gebruiken in het docker-build-commando.

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

Uitvoer:(Optioneel gebruik het tekstvenster van de schuifbalk indien mogelijk)

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

Containernetwerk maken

Gebruik onderstaande opdracht om een ​​door de gebruiker gedefinieerd netwerk met bridge-stuurprogramma te maken.

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

Bevestig netwerkcreatie

# 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

Container maken

We moeten de opdracht "docker run" gebruiken om een ​​container te maken van de docker-image. We draaien postgres-container in daemonize-modus met behulp van -d optie.

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

Gebruik onderstaande opdracht om het maken van de container te bevestigen.

# 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

We hebben geen poort gespecificeerd om bloot te stellen, dus het zal de standaard postgres-poort 5432 voor intern gebruik blootleggen. PostgreSQL is alleen beschikbaar vanuit het Docker-netwerk, we hebben geen toegang tot deze Postgres-container op een hostpoort.

We zullen later in dit artikel zien hoe toegang te krijgen tot de Postgres-container op de hostpoort.

Verbinding maken met PostgreSQL-container binnen Docker-netwerk

Laten we proberen verbinding te maken met de Postgres-container vanuit een andere container binnen hetzelfde Docker-netwerk dat we eerder hebben gemaakt. Hier hebben we de psql-client gebruikt om verbinding te maken met de Postgres. We gebruikten de Postgres-containernaam als hostnaam, gebruiker en wachtwoord aanwezig in het Docker-bestand.

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

De --rm optie in run commando zal de container verwijderen zodra we het psql proces beëindigen.

# 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

Gegevenspersistentie

Dockercontainers zijn kortstondig van aard, d.w.z. gegevens die door de container worden gebruikt of gegenereerd, worden nergens impliciet opgeslagen. We verliezen de gegevens wanneer de container opnieuw wordt gestart of verwijderd. Docker levert volumes waarop we de persistente data kunnen opslaan. Het is een handige functie waarmee we in geval van een ramp een andere container kunnen voorzien met hetzelfde volume of dezelfde gegevens.

Laten we een gegevensvolume maken en de creatie ervan bevestigen.

# sudo docker volume create pgdata
pgdata

# sudo docker volume ls
DRIVER              VOLUME NAME
local                   pgdata

Nu moeten we dit gegevensvolume gebruiken tijdens het uitvoeren van de Postgres-container. Zorg ervoor dat u de oudere postgres-container verwijdert die zonder volumes draait.

# 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

We hebben de Postgres-container uitgevoerd met een gegevensvolume eraan gekoppeld.

Maak een nieuwe tabel in Postgres om de persistentie van gegevens te controleren.

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

Verwijder de Postgres-container.

# sudo docker container rm postgresondocker -f 
postgresondocker

Maak een nieuwe Postgres-container en bevestig of de testtabel aanwezig is of niet.

# 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)
Download de whitepaper vandaag PostgreSQL-beheer en -automatisering met ClusterControlLees wat u moet weten om PostgreSQL te implementeren, bewaken, beheren en schalenDownload de whitepaper

Blootstellen PostgreSQL-service aan de host

Het is je misschien opgevallen dat we eerder geen enkele poort van de PostgreSQL-container hebben blootgelegd. Dit betekent dat PostgreSQL alleen toegankelijk is voor de containers die zich in het postgres-netwerk bevinden dat we eerder hebben gemaakt.

Om de PostgreSQL-service te gebruiken, moeten we de containerpoort blootleggen met de optie --port. Hier hebben we de Postgres-containerpoort 5432 op 5432-poort van de host blootgelegd.

# 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 kunt u PostgreSQL rechtstreeks verbinden met localhost.

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

Container verwijderen

Om de container te verwijderen, moeten we eerst de actieve container stoppen en vervolgens de container verwijderen met de opdracht rm.

# sudo docker container stop postgresondocker 

# sudo docker container rm postgresondocker
postgresondocker

Gebruik de optie -f (--force) om de actieve container direct te verwijderen.

# sudo docker container rm postgresondocker -f
postgresondocker

Hopelijk heb je nu je eigen gedockte lokale omgeving voor PostgreSQL.

Opmerking: Dit artikel geeft een overzicht van hoe we PostgreSQL op docker kunnen gebruiken voor ontwikkel-/POC-omgevingen. Het uitvoeren van PostgreSQL in een productieomgeving vereist mogelijk aanvullende wijzigingen in de PostgreSQL- of dockerconfiguraties.

Conclusie

Er is een eenvoudige manier om de PostgreSQL-database in een Docker-container uit te voeren. Docker kapselt effectief implementatie, configuratie en bepaalde beheerprocedures in. Docker is een goede keuze om PostgreSQL met minimale inspanningen te implementeren. Het enige wat u hoeft te doen is een vooraf gebouwde Docker-container te starten en u heeft een PostgreSQL-database klaar voor uw service.

Referenties

  • Docker-installatie:https://docs.docker.com/install
  • Volumes:https://docs.docker.com/storage/volumes
  • Door de gebruiker gedefinieerde netwerken:https://docs.docker.com/network/
  • Postgres Docker-bestand:https://docs.docker.com/engine/examples/postgresql_service
  • MySQL op Docker:de basis begrijpen:https://severalnines.com/blog/mysql-docker-containers-understanding-basics

  1. Uitleg van JSONB geïntroduceerd door PostgreSQL

  2. Waarom wordt de 2e T-SQL-query veel sneller uitgevoerd dan de eerste wanneer deze wordt aangeroepen door Reporting Services 2005 in een web-app

  3. Een database maken in MySQL Workbench met behulp van de GUI

  4. MySQL-verbinding werkt niet:2002 Geen dergelijk bestand of map