Déployer PostgreSQL sur un conteneur Docker

Présentation

Docker a modernisé la façon dont nous créons et déployons l'application. Cela nous permet de créer des conteneurs légers, portables et autonomes qui peuvent exécuter facilement n'importe quelle application.

Ce blog a pour but d'expliquer comment utiliser Docker pour exécuter la base de données PostgreSQL. Il ne couvre pas l'installation ou la configuration de docker. Veuillez consulter les instructions d'installation de docker ici. Des informations supplémentaires peuvent être trouvées dans notre blog précédent sur MySQL et Docker.

Avant d'entrer dans les détails, passons en revue quelques termes.

Dockerfile
Il contient l'ensemble des instructions/commandes pour installer ou configurer l'application/le logiciel.
Image Docker
L'image Docker est constituée d'une série de couches qui représentent les instructions du Dockerfile. L'image Docker est utilisée comme modèle pour créer un conteneur.
Lien des conteneurs et mise en réseau définie par l'utilisateur
Docker a utilisé le pont comme mécanisme de mise en réseau par défaut et utilise --links pour lier les conteneurs les uns aux autres. Pour accéder au conteneur PostgreSQL à partir d'un conteneur d'application, il faut lier les deux conteneurs au moment de la création. Ici, dans cet article, nous utilisons des réseaux définis par l'utilisateur, car la fonctionnalité de lien sera bientôt obsolète.
Persistance des données dans Docker
Par défaut, les données à l'intérieur d'un conteneur sont éphémères. Chaque fois que le conteneur est redémarré, les données seront perdues. Les volumes sont le mécanisme préféré pour conserver les données générées et utilisées par un conteneur Docker. Ici, nous montons un répertoire hôte à l'intérieur du conteneur où toutes les données sont stockées.

Commençons à créer notre image PostgreSQL et utilisons-la pour exécuter un conteneur.

Fichier Docker 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"]

Si vous regardez attentivement le Dockerfile, il se compose de commandes qui sont utilisées pour installer PostgreSQL et effectuer des modifications de configuration sur le système d'exploitation Ubuntu.

Construire une image PostgreSQL

Nous pouvons créer une image PostgreSQL à partir de Dockerfile à l'aide de la commande docker build.

# sudo docker build -t postgresondocker:9.3 .

Ici, nous pouvons spécifier la balise (-t) à l'image comme le nom et la version. Le point (.) à la fin spécifie le répertoire courant et utilise le Dockerfile présent dans le répertoire courant. Le nom du fichier Docker doit être "Dockerfile". Si vous souhaitez spécifier un nom personnalisé pour votre fichier docker, vous devez utiliser -f dans la commande docker build.

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

Sortie :(Facultatif, utilisez la fenêtre de texte de la barre de défilement si possible)

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

Création d'un réseau de conteneurs

Utilisez la commande ci-dessous pour créer un réseau défini par l'utilisateur avec un pilote de pont.

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

Confirmer la création du réseau

# 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

Création de conteneurs

Nous devons utiliser la commande "docker run" pour créer un conteneur à partir de l'image docker. Nous exécutons le conteneur postgres en mode daemonize à l'aide de l'option -d.

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

Utilisez la commande ci-dessous pour confirmer la création du conteneur.

# 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

Nous n'avons spécifié aucun port à exposer, il exposera donc le port postgres par défaut 5432 pour un usage interne. PostgreSQL est disponible uniquement depuis l'intérieur du réseau Docker, nous ne pourrons pas accéder à ce conteneur Postgres sur un port hôte.

Nous verrons comment accéder au conteneur Postgres sur le port hôte dans une section ultérieure de cet article.

Connexion au conteneur PostgreSQL dans le réseau Docker

Essayons de nous connecter au conteneur Postgres à partir d'un autre conteneur du même réseau Docker que nous avons créé précédemment. Ici, nous avons utilisé le client psql pour nous connecter à Postgres. Nous avons utilisé le nom du conteneur Postgres comme nom d'hôte, utilisateur et mot de passe présent dans le fichier 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=#

L'option --rm dans la commande run supprimera le conteneur une fois que nous aurons terminé le processus 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            postgresondocker

Persistance des données

Les conteneurs Docker sont de nature éphémère, c'est-à-dire que les données utilisées ou générées par le conteneur ne sont stockées nulle part implicitement. Nous perdons les données chaque fois que le conteneur est redémarré ou supprimé. Docker fournit des volumes sur lesquels nous pouvons stocker les données persistantes. Il s'agit d'une fonctionnalité utile grâce à laquelle nous pouvons provisionner un autre conteneur en utilisant le même volume ou les mêmes données en cas de sinistre.

Créons un volume de données et confirmons sa création.

# sudo docker volume create pgdata
pgdata

# sudo docker volume ls
DRIVER              VOLUME NAME
local                   pgdata

Nous devons maintenant utiliser ce volume de données lors de l'exécution du conteneur Postgres. Assurez-vous de supprimer l'ancien conteneur postgres qui s'exécute sans volumes.

# 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

Nous avons exécuté le conteneur Postgres avec un volume de données qui lui est attaché.

Créez une nouvelle table dans Postgres pour vérifier la persistance des données.

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

Supprimez le conteneur Postgres.

# sudo docker container rm postgresondocker -f 
postgresondocker

Créez un nouveau conteneur Postgres et confirmez la table de test présente ou non.

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

Téléchargez le livre blanc aujourd'hui PostgreSQL Management &Automation with ClusterControlDécouvrez ce que vous devez savoir pour déployer, surveiller, gérer et faire évoluer PostgreSQLTélécharger le livre blanc

Exposer le service PostgreSQL à l'hôte

Vous avez peut-être remarqué que nous n'avons exposé aucun port du conteneur PostgreSQL plus tôt. Cela signifie que PostgreSQL n'est accessible qu'aux conteneurs qui se trouvent dans le réseau postgres que nous avons créé précédemment.

Pour utiliser le service PostgreSQL, nous devons exposer le port du conteneur à l'aide de l'option --port. Ici, nous avons exposé le port de conteneur Postgres 5432 sur le port 5432 de l'hôte.

# 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

Vous pouvez maintenant connecter directement PostgreSQL sur 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=#

Suppression de conteneur

Pour supprimer le conteneur, nous devons d'abord arrêter le conteneur en cours d'exécution, puis supprimer le conteneur à l'aide de la commande rm.

# sudo docker container stop postgresondocker 

# sudo docker container rm postgresondocker
postgresondocker

Utilisez l'option -f (--force) pour supprimer directement le conteneur en cours d'exécution.

# sudo docker container rm postgresondocker -f
postgresondocker

J'espère que vous avez maintenant votre propre environnement local dockerisé pour PostgreSQL.

Remarque : Cet article fournit un aperçu de la façon dont nous pouvons utiliser PostgreSQL sur Docker pour l'environnement de développement/POC. L'exécution de PostgreSQL dans un environnement de production peut nécessiter des modifications supplémentaires dans les configurations PostgreSQL ou docker.

Conclusion

Il existe un moyen simple d'exécuter la base de données PostgreSQL dans un conteneur Docker. Docker encapsule efficacement le déploiement, la configuration et certaines procédures d'administration. Docker est un bon choix pour déployer PostgreSQL avec un minimum d'efforts. Tout ce que vous avez à faire est de démarrer un conteneur Docker pré-construit et vous aurez une base de données PostgreSQL prête pour votre service.

Références

Installation de Docker :https://docs.docker.com/install
Volumes :https://docs.docker.com/storage/volumes
Réseaux définis par l'utilisateur :https://docs.docker.com/network/
Fichier Docker Postgres :https://docs.docker.com/engine/examples/postgresql_service
MySQL sur Docker :Comprendre les bases :https://severalnines.com/blog/mysql-docker-containers-understanding-basics