For this guide we're going to use docker compose. Docker compose will allow us to neatly configure all parameters, including setting up separate docker volumes for storing data.

Step 0: Setup Domain Records & Create SSL Certs

See your web hosting service for how to set up A & MX records. For example, DigitalOcean users can follow Digital Ocean's tutorial.

See the SSL Configuration guide to setup SSL if you don't have certificates already.

Step 1: Download docker images

We'll be basing our mail server off of docker-mailserver. We'll also be setting up a web client using rainloop. First step is to download the docker images:

docker pull tvial/docker-mailserver:latest  
docker pull krishath/rainloop-ssl:latest  

Step 2: Create docker-compose file

Create a file named docker-compose.yml in the root directory of your email project.
In this file, we'll start with the following configuration:

version: '2'  
services:  

Step 3: Add data volumes

We'll want to store our data in docker data volumes, which will keep them isolated from containers, yet still easily sharable.

volumes:  
  maildata:
    driver: local
  mailstate:
    driver: local

Step 4: Add docker-mailserver configuration

We'll be calling our docker-mailserver container mail.

  mail:
    image: tvial/docker-mailserver:latest
    hostname: {your_hostname}
    domainname: {your_domain}
    container_name: mail
    ports:
    - "25:25"
    - "143:143"
    - "587:587"
    - "993:993"
    volumes:
    - maildata:/var/mail
    - mailstate:/var/mail-state
    - mailconfig:/tmp/docker-mailserver/
    - {path_to_ssl}:/etc/letsencrypt/
    - /etc/localtime:/etc/localtime:ro

You'll need to fill in {your_hostname}, {your_domain}, {your_FQDN}, and {path_to_ssl} with your own configuration.

For example, if your domain MX record was pointed to mail.example.com:

• {your_hostname} would be mail,
• {your_domain} would be example.com
• {your_FQDN} would be mail.example.com.

Step 5: Add rainloop configuration

We'll be calling our rainloop container webmail. Under services:, add the following configuration.

  webmail:
    image: krishath/rainloop-ssl
    container_name: webmail
    volumes:
    - {path_to_ssl}/etc/live/{your_FQDN}/fullchain.pem:/etc/ssl/cert.pem
    - {path_to_ssl}/etc/live/{your_FQDN}/privkey.pem:/etc/ssl/cert.key
    - {path_to_ssl}/dhparam.pem:/etc/ssl/certs/dhparam.pem
    - webmaildata:/webapps/rainloop/data
    - /etc/localtime:/etc/localtime:ro
    ports:
    - "443:443"

Step 4: Bring up the containers

Now that everything should be configured correctly, bring up the docker containers with:

sudo docker-compose up -d  

The -d option starts the containers in the background.
You can stop the containers at any time with sudo docker-compose down.

Step 5: Verify everything is working

Now confirm that the containers are running pointed to the correct directories with:

docker inspect mail  

This will inspect the mail container we brought up with docker-compose. You should see the volumes you created references under "Mounts".
Also confirm that we can connect to the mail server using ssl:

openssl s_client -showcerts -connect {your_hostname}:993  

Step 6: Create an email account

Use the setup script to add an email account to your new mail server:

./setup.sh  -c mail email add email@example.com

Step 7: Connect to your mail server using rainloop

Try to connect to your webserver's admin page. i.e. https://webmail.example.com/?admin After you login use the default username and password (admin, 12345), immediately change the admin password to something more secure (under "Security").

Now, Setup the connection to your mail server by adding a new domain (under "Domains").

Test the configuration - at this point, you should be able to go to login to your email using `https://webmail.example.com/.

MediaWiki may not be the most difficult to setup, but docker can make that process even easier. By having MediaWiki and Postgres setup in docker containers, you can also switch servers without worrying about reinstalling.

Step 0: Setup docker

I suggest following Digital Ocean's How to Install and User Docker guide.

Step 1: Download docker images

For this, I am using the official postgres image, but because wikimedia/mediawiki had not be updated, I decided to use simplyintricate/mediawiki.

docker pull postgres  
docker pull simplyintricate/mediawiki  

Step 2: Create wiki directories

We need to create directories for the database data, images, and mediawiki extensions.

mkdir -p <wiki_root>/{db/data,extensions,images}  

Step 3: Setup Postgres docker container

We're going to use a host volume (directory on the machine running docker) to store the database data outside of the docker postgres container. This way, if we need to, we can restart the postgres container without losing any of our data.

docker run --name mediawiki-db -v <wiki_root>/db/data:/var/lib/postgresql/data -d postgres  

Now you need to setup the postgres user and database for mediawiki.
Execute psql -h localhost -U postgres to connect to postgres and create your wiki account and database with:

CREATE USER <user> PASSWORD '<password>';  
CREATE DATABASE <db>;  
GRANT ALL PRIVILEGES ON DATABASE <db> TO <user>;  

Step 4: Setup MediaWiki docker container

For this, we're going to link a mediawiki container to our newly created postgres container.

Step 4a: Create LocalSettings.php

If you don't already have a LocalSettings.php created from a previous install, create a new one by running the mediawiki container:

docker run --name <your_wiki_name>  --link mediawiki-db:db  -p 8080:80 -d simplyintricate/mediawiki  

Take note: simplyintricate/mediawiki has you link your database to :db not :postgres like wikimedia/mediawiki.

Now log onto your wiki instance <server_ip>:8080 with a browser, and initiate the setup.

Make sure to select 'PostgreSQL' as your Database type.

To find what IP the link thinks your db is on, run:

docker exec <your_wiki_name> printenv | grep 'MYSQL\|DB\|POSTGRES'  

Look for DB_PORT_5432_TCP_ADDR - You'll want to use this for the 'Database host'.

Once you've completed setup, keep track of where the generated LocalSettings.php file is downloaded, you'll need that in a moment.

After finishing setup, stop and remove your container (don't worry, the configuration you setup is stored in LocalSettings.php, and the database configuration is saved in your database volume).

docker rm -f <your_wiki_name>  

Step 4b: Run MediaWiki container

First, scp your generated LocalSettings.php to your server, preferably to your the wiki root directory.

Now is the moment our hard work finally pays off. Recreate your wiki container, this time with all the data volumes mounted:

docker run --name <your_wiki_name>  --link mediawiki-db:postgres  -p 8080:80 \  
-v <wiki_root>/data/rw:/data/rw \
-v <wiki_root>/images:/usr/share/nginx/html/images \
-v <wiki_root>/extensions:/tmp/extensions \
-v <wiki_root>/LocalSettings.php:/usr/share/nginx/html/LocalSettings.php \
-d simplyintricate/mediawiki

If you cannot connect to your wiki, try running docker logs <your_wiki_name> to debug.

Conclusion

Now you should have a working wiki of your own!

Expect to see the site in flux as I gradually add more content.

I've changed my views, slightly.