A quick way to run Postgres in Docker with local directory data storage

There are a lot of times where I want to quickly spin up a postgres server for some testing.

Unfortunately this usually involves installing it in the package manager and working with the global postgres config. Running postgres in Docker is better but volumes are tricky to deal with, and using data containers means you have to keep track of an extra container, as well as remembering to clean up volumes that are no longer used.

So I wrote this quick script that does all the steps needed to run a postgres docker container using a local directory for data storage, instead of volumes. So instead of having to leave your TestWebAppPostgresDb container and TestDataProcessingPostgresDb container hanging around in docker you can just leave them in local directories.

Quick usage

#Build the docker image
sudo docker build -t stevechy/postgres:v9.3 [DirectoryWithDockerFile]

#Make a database directory
mkdir -p projects/testDatabases/mytestdb

#Copy runDockerPostgres.py to the directory, or symlink it
cp runDockerPostgres.py projects/testDatabases/mytestdb

#Grab the default /etc/postgresql config from the docker image
cd projects/testDatabases/mytestdb
./runDockerPostgres.py --action extractEtcPostgresql

#Configure etc_postgresql/9.3/main/postgresql.conf if needed, for example, setting the port

#Initialize the postgres data cluster
./runDockerPostgres.py --action initDb

#You'll need a running postgres to create databases and users, start postgres in another terminal
./runDockerPostgres.py --action run

#Create a user
./runDockerPostgres.py --action createuser
#Enter name of role to add: testuser
#Enter password for new role: 
#Enter it again: 
#Shall the new role be a superuser? (y/n) n
#Shall the new role be allowed to create databases? (y/n) n
#Shall the new role be allowed to create more new roles? (y/n) n

#Create a database
./runDockerPostgres.py --action createdb --dbowner testuser --dbname testdb

You should now have a local running postgres that you can connect to.

Dockerfile:

from debian:wheezy

RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ wheezy-pgdg main" > /etc/apt/sources.list.d/pgdg.list
RUN apt-get update

RUN apt-get -y install wget ca-certificates

RUN wget --quiet https://www.postgresql.org/media/keys/ACCC4CF8.asc ; apt-key add ACCC4CF8.asc

RUN apt-get update

RUN apt-get -y install postgresql-9.3

EXPOSE 5432

USER postgres

CMD ["/bin/bash"]

runDockerPostgres.py

	#!/usr/bin/python
	#
	#
	# runDockerPostgres.py - Simple wrapper to run postgres with docker
	# Written in 2015 by Steven Cheng
	# To the extent possible under law, the author(s) have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. This software is distributed without any warranty.
	# You should have received a copy of the CC0 Public Domain Dedication along with this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
	import os
	import sys
	import subprocess
	import optparse
	sourceDirectory = os.path.realpath(os.path.dirname(os.sys.argv[0]))
	print "Script directory is "
	print sourceDirectory
	print "\n"
	postgresDockerImage="stevechy/postgres:v9.3"
	print "Postgres docker image :" + postgresDockerImage
	# VOLUME ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql", "/var/run/postgresql"
	volumes = [
	"-v", sourceDirectory+"/etc_postgresql/:/etc/postgresql",
	"-v", sourceDirectory+"/var_log_postgresql:/var/log/postgresql",
	"-v", sourceDirectory+"/var_lib_postgresql:/var/lib/postgresql",
	"-v", sourceDirectory+"/var_run_postgresql:/var/run/postgresql"
	]
	def dockerCommand(runCommand) :
	return dockerCommandWithDockerOptions(runCommand,[])
	def dockerCommandWithDockerOptions(runCommand, options) :
	command = [ "sudo", "docker",
	"run", "-it", "--read-only", "--rm", "--net","host" ]
	command.extend(options)
	command.extend(volumes)
	command.append(postgresDockerImage)
	command.extend(runCommand)
	return command
	def dockerExec(username, container, execCommand):
	command = ["sudo", "docker", "exec" , "-it"]
	command.extend(["-u", username])
	command.append(container)
	command.extend(execCommand)
	return command
	def runCommand(command):
	return subprocess.check_output(command)
	def executeAndReplaceCurrentProcess(command):
	print "Jumping to " + str(command)
	return os.execvp(command[0], command)
	def getImagePostgresUserId() :
	command = dockerCommand([
	"/usr/bin/id",
	"-u",
	"postgres"
	])
	pidReturn = subprocess.check_output(
	command
	)
	return pidReturn
	def getDockerContainer():
	containerId = None
	with open(sourceDirectory+"/CONTAINERID", 'r') as containerFile:
	containerId=containerFile.read()
	return containerId
	dbStateFile = sourceDirectory+"/DB_STATE"
	with open(dbStateFile, 'a'):
	os.utime(dbStateFile, None)
	def executeMain(options):
	if not options.action:
	parser.error("Action not given")
	mainAction = options.action
	if mainAction == 'bash':
	print "bash"
	executeAndReplaceCurrentProcess(dockerCommand([ "/bin/bash" ]))
	elif mainAction == 'extractEtcPostgresql':
	subprocess.call(["mkdir", sourceDirectory+"/etc_postgresql/"])
	runCommand([
	"sudo", "docker", "run", "--read-only", "-it", "-u", "root",
	"-v", sourceDirectory+"/etc_postgresql/:/data",
	postgresDockerImage,
	"cp", "-r", "/etc/postgresql/9.3", "data"
	])
	subprocess.call(["sudo", "chown", "-R", str(os.getuid())+":"+str(os.getgid()), sourceDirectory+"/etc_postgresql"])
	elif mainAction == 'initDb' :
	print "Init"
	postgresUserId= int(getImagePostgresUserId())
	print "Postgres docker userid :" + str(postgresUserId)
	subprocess.call(["sudo", "chmod","-R", "a+r", sourceDirectory+"/etc_postgresql/"])
	subprocess.call(["sudo", "mkdir", "-p",
	sourceDirectory +"/var_run_postgresql/9.3-main.pg_stat_tmp",
	sourceDirectory + "/var_lib_postgresql",
	sourceDirectory + "/var_log_postgresql"])
	subprocess.call(["sudo", "chown", "-R" , str(postgresUserId)+":"+str(postgresUserId),
	sourceDirectory+"/var_run_postgresql",
	sourceDirectory+"/var_lib_postgresql",
	sourceDirectory+"/var_log_postgresql"])
	executeAndReplaceCurrentProcess(dockerCommand(["/usr/lib/postgresql/9.3/bin/initdb", "--locale", "en_US.UTF-8","-E","UTF8","--pgdata","/var/lib/postgresql/9.3/main" ]))
	elif mainAction == 'createuser':
	dockercontainer = getDockerContainer()
	if options.dockercontainer:
	dockercontainer = options.dockercontainer
	executeAndReplaceCurrentProcess(dockerExec("postgres",
	dockercontainer,[
	"createuser",
	"--pwprompt",
	"-E",
	"--interactive"
	]))
	elif mainAction == 'createdb':
	dockercontainer = getDockerContainer()
	if options.dockercontainer:
	dockercontainer = options.dockercontainer
	if not options.dbowner:
	parser.error("Specify --dbowner")
	if not options.dbname:
	parser.error("Specify --dbname")
	executeAndReplaceCurrentProcess(dockerExec("postgres",
	dockercontainer,[
	"createdb",
	"-O", options.dbowner,
	options.dbname
	]))
	elif mainAction == 'run' :
	print "Init"
	executeAndReplaceCurrentProcess(dockerCommandWithDockerOptions([
	"/usr/lib/postgresql/9.3/bin/postgres",
	"-D", "/var/lib/postgresql/9.3/main",
	"-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"],[
	"--cidfile="+sourceDirectory+"/CONTAINERID"
	]))
	else:
	parser.error("Invalid action " + options.action)
	parser = optparse.OptionParser(usage='usage: %prog [options]')
	parser.add_option('--action', dest='action')
	parser.add_option('--dbowner', dest='dbowner')
	parser.add_option('--dbname', dest='dbname')
	parser.add_option('--dockercontainer', dest='dockercontainer')
	(options, args) = parser.parse_args()
	executeMain(options)

view raw runDockerPostgres.py hosted with ❤ by GitHub