Dockerized Etherpad-Lite with PostgreSQL

There is surprisingly little information out there on how to deploy etherpad-lite with postgres. There is,
on the other hand, quite a bit of information on how to deploy etherpad with docker. At the time of writing,
there is nothing on how to do it with docker-compose specifically. I rarely use docker apart from
docker-compose, and will go to great lengths to ensure I can dockerize my composition, be it for
etherpad or any other docker-appropriate application.

The following comprises my collection of notes on what it took to build an etherpad docker image and link
it to a postgres container with docker-compose. Much of it was inspired (i.e., shamelessly plagiarized) from
the fine work done by tvelocity on GitHub.

The following assumes that the required software (e.g., docker, docker-compose, etc.) is installed on an
Ubuntu 16.04 machine. It’s meant to be simple enough that the stated goal can be accomplished by simply
copying and pasting content into the various required files and executing the commands specified.

Setup

Create a directory in which to organize your docker composition.

1
mkdir my-etherpad && cd my-etherpad

Dockerfile

Using your favourite text editor (mine’s vim), copy and paste the following into your Dockerfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
FROM node:0.12
MAINTAINER Some Guy, someguy@example.com

# For postgres
RUN apt-get update
RUN apt-get install -y libpq-dev postgresql-client

# Clone the latest etherpad version
RUN cd /opt && git clone https://github.com/ether/etherpad-lite.git etherpad

WORKDIR /opt/etherpad

RUN bin/installDeps.sh && rm settings.json

COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

EXPOSE 9001

ENTRYPOINT ["/entrypoint.sh"]
CMD ["bin/run.sh", "--root"]

The node:0.12 image upon which this image is built was chosen purposefully. At the moment, etherpad-lite
does not run on node versions 6.0 and 6.1, which is
what you get if you build off the latest node image.

Also note the ENTRYPOINT ["/entrypoint.sh"] line. This implies we’ll need this entrypoint.sh file to
run every time we fire up an image.

entrypoint.sh

Create a file called entrypoint.sh and paste the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#!/bin/bash
set -e

if [ -z "$POSTGRES_PORT_5432_TCP_ADDR" ]; then
  echo >&2 'error: missing POSTGRES_PORT_5432_TCP environment variable'
  echo >&2 '  Did you forget to --link some_postgres_container:postgres ?'
  exit 1
fi

# If we're linked to PostgreSQL, and we're using the root user, and our linked
# container has a default "root" password set up and passed through... :)
: ${ETHERPAD_DB_USER:=root}
if [ "$ETHERPAD_DB_USER" = 'root' ]; then
  : ${ETHERPAD_DB_PASSWORD:=$POSTGRES_ENV_POSTGRES_ROOT_PASSWORD}
fi
: ${ETHERPAD_DB_NAME:=etherpad}

ETHERPAD_DB_NAME=$( echo $ETHERPAD_DB_NAME | sed 's/\./_/g' )

if [ -z "$ETHERPAD_DB_PASSWORD" ]; then
  echo >&2 'error: missing required ETHERPAD_DB_PASSWORD environment variable'
  echo >&2 '  Did you forget to -e ETHERPAD_DB_PASSWORD=... ?'
  echo >&2
  echo >&2 '  (Also of interest might be ETHERPAD_DB_USER and ETHERPAD_DB_NAME.)'
  exit 1
fi

: ${ETHERPAD_TITLE:=Etherpad}
: ${ETHERPAD_PORT:=9001}
: ${ETHERPAD_SESSION_KEY:=$(
  node -p "require('crypto').randomBytes(32).toString('hex')")}

# Check if database already exists
RESULT=`PGPASSWORD=${ETHERPAD_DB_PASSWORD} psql -U ${ETHERPAD_DB_USER} -h postgres \
  -c "\l ${ETHERPAD_DB_NAME}"`

if [[ "$RESULT" != *"$ETHERPAD_DB_NAME"* ]]; then
  # postgres database does not exist, create it
  echo "Creating database ${ETHERPAD_DB_NAME}"

  PGPASSWORD=${ETHERPAD_DB_PASSWORD} psql -U${ETHERPAD_DB_USER} -h postgres \
    -c "create database ${ETHERPAD_DB_NAME}"
fi

OWNER=`PGPASSWORD=${ETHERPAD_DB_PASSWORD} psql -U ${ETHERPAD_DB_USER} -h postgres \
  -c "SELECT u.usename 
      FROM pg_database d
      JOIN pg_user u ON (d.datdba = u.usesysid)
      WHERE d.datname = (SELECT current_database());"`

if [[ "$OWNER" != *"$ETHERPAD_DB_USER"* ]]; then
  # postgres database does not exist, create it
  echo "Setting database owner to ${ETHERPAD_DB_USER}"
  PGPASSWORD=${ETHERPAD_DB_PASSWORD} psql -U ${ETHERPAD_DB_USER} -h postgres \
    -c "alter database ${ETHERPAD_DB_NAME} owner to ${ETHERPAD_DB_USER}"
fi

if [ ! -f settings.json ]; then

  cat <<- EOF > settings.json
  {
    "title": "${ETHERPAD_TITLE}",
    "ip": "0.0.0.0",
    "port" :${ETHERPAD_PORT},
    "dbType" : "postgres",
    "dbSettings" : {
      "user"    : "${ETHERPAD_DB_USER}",
      "host"    : "postgres",
      "password": "${ETHERPAD_DB_PASSWORD}",
      "database": "${ETHERPAD_DB_NAME}"
    },
EOF

  if [ $ETHERPAD_ADMIN_PASSWORD ]; then
    : ${ETHERPAD_ADMIN_USER:=admin}
    cat <<- EOF >> settings.json
      "users": {
        "${ETHERPAD_ADMIN_USER}": {
          "password": "${ETHERPAD_ADMIN_PASSWORD}",
          "is_admin": true
        }
      },
EOF
  fi

  cat <<- EOF >> settings.json
  }
EOF
fi

exec "$@"

This does a whole bunch of stuff. Most importantly, it creates the settings.json file which
configures the whole etherpad-lite application. The settings produced above connect the application
to the postgres database and setup an adminstrative user. There’s a whole bunch of stuff that
can be done to make this more configurable (e.g., setup SSL certs, et al). I’m all ears.

docker-compose.yml

You may have noticed a bunch of environment variables in the previous entrypoints.sh file.
Those get set in docker-compose.yml. Create that file and paste the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
etherpad:
  restart: always
  build: ./
  ports:
    - "9001:9001"
  links:
    - postgres
  environment:
    - ETHERPAD_DB_USER=etherpad
    - ETHERPAD_DB_PASSWORD=foobarbaz
    - ETHERPAD_DB_NAME=store
    - ETHERPAD_ADMIN_PASSWORD=foobarbaz
postgres:
  restart: always
  image: postgres
  environment:
    - POSTGRES_USER=etherpad
    - POSTGRES_PASSWORD=foobarbaz
  volumes_from:
    - etherpad_data

This sets everything up so that the etherpad Dockerfile gets built and linked to a
postgres container… well, everything except for one bit: it doesn’t create
the required etherpad_data data-only container.

Data-only container

Create the data-only container from the command line so that your data won’t be erased if your
other containers get smoked by accident or on purpose.

1
docker create --name etherpad_data -v /dbdata postgres /bin/true

Finally, fire ‘er all up!

1
docker-compose up

If you did everything correctly, your etherpad-lite application will be accessible on http://localhost:9001.