<h2 id="introduction">Introduction</h2>
Making regular database backups is an essential maintenance task and fail point recovery strategy for anyone who is responsible for a database.
A common misnomer for software developers is that there will be a database administrator who will take care of these things for us. Unfortunately, in my experience this is far from the truth. Of the many projects I have ever worked on for multiple different companies, I have never once had the luxury of being able to put off those tasks to the fable unicorn known as a database administrator (DBA). Instead, I have had to do my best to keep the databases to the systems I work on in as best a situation as I can, which has involved setting up a routine backup strategy and knowing how to recover one in the face of such a tragedy.
In this article I am going to be covering the methods I have used to back up and recover PostgreSQL databases on Linux servers.
<h2 id="creatingdatabasebackups">Creating Database Backups</h2>
There are two ways that I am aware of how to create a backup of a PostgreSQL database, which I will be discussing in this section. Both ways utilize point-in-time copies of the database. One uses what is known as WAL archiving and the other utilizes a SQL dump.
<h3 id="acreatinganarchivedcopyofyourdatabaseatthefilesystemlevelwithwalarchiving">A. Creating an Archived Copy of your Database at the File System Level with WAL Archiving</h3>
Before getting too far in the explanation of this method, I should say that a directory needs to be created on the system that will hold archived files and must be owned by the postgres user. In my examples I will be utilizing the directory <code>/home/username/pg</code> which is owned by postgres and it will contain two subdirectories <code>wals</code> and <code>cluster</code>, also owned by postgres.
This first method uses the pair of PostgreSQL functions <code>pg_start_backup(...)</code> and <code>pg_stop_backup(...)</code>. In order to use these functions the user executing them must have replication privileges, which is defined in the pg_hba.conf config file. Additionally, to utilize this method of backup you need to add some settings and commands to the <code>postgresql.conf</code> file, which I will discuss next.
In the <code>postgresql.conf</code> file, you need to set <code>archive_mode</code> to <code>on</code> and provide an archive command that will look something like so:
<pre><code class="hljs">archive_mode = on
archive_command = &#x27;cp %p /home/username/pg/wals/%f&#x27;
</code></pre>
Here, &quot;%p&quot; is replaced with the path for the WAL (write ahead log) file being archived and &quot;%f&quot; is the name of the actual file.
The aforementioned Postgres functions work by creating a checkpoint (aka, a single point-in-time) copy of the Postgres data directory as a compressed archive. I have typically used this combination of functions within a bash script scheduled to run at set intervals within a cron task.
For example, a bash script on a Linux server hosting a Postgres database could implement such a cron task to backup the database like this:
<pre><code class="hljs">1 1 * * * bash /path/to/backup.sh
</code></pre>
In the above example the cron task entry would run the script <code>backup.sh</code> in the first minute of the first hour of every day.
Below is the example's <code>backup.sh</code> bash script to perform the function of creating the archived copy:
<pre><code class="hljs">#! /bin/bash

function backup_pg() {
 ARCHIVE=$1
 echo Backing up database ...
 psql -U username -h localhost -c &quot;SELECT pg_start_backup(&#x27;$ARCHIVE&#x27;);&quot; databasename
 tar czf $ARCHIVE $SRC
 psql -U username -h localhost -c &quot;SELECT pg_stop_backup();&quot; databasename
 echo Completed!
}

SRC=/var/lib/pgsql/9.6/data
DST=/home/username/pg/cluster/

TODAY=`date +%F`
ARCHIVE=databasename-backup-$TODAY.tgz
BAKDIR=Archive-$TODAY

mkdir -p $DST
cd $DST/$BACKDIR

backup_pg $ARCHIVE
</code></pre>
As I mentioned previously this creates a point-in-time copy of the database and archives the entire data directory. You would want to replace <code>databasename</code>, <code>username</code>, as well as <code>SRC</code> and <code>DST</code> with the values that make sense for your setup. For more information of using this method of creating backup consult the <a rel="nofollow" target="_blank" href="https://www.postgresql.org/docs/10/static/continuous-archiving.html">official docs</a>.
<h3 id="bcreatingasqldumpofthedatabase">B. Creating a SQL Dump of the Database</h3>
This second way of backing up a database, which utilizes the <code>pg_dump</code> command, is my preferred method as I feel it requires fewer steps and hence is less complicated. This method still creates a point-in-time copy of the database, but it does so by creating a single file which contains commands that will recreate tables, constraints and indexes as well as populate the tables with data.
There are different ways to use this command which are detailed in the <a rel="nofollow" target="_blank" href="https://www.postgresql.org/docs/9.6/static/backup-dump.html">PostgreSQL docs</a>, but they primarily differ in the format of the output.
The two most common ways I've used them are to produce a dump file of the database that is either in plain readable text filled with SQL commands, or to produce the output in PostgreSQL's custom binary format. I do appreciate the readability of the plain text output for the sake of curiosity and being able to take a look at what is going on, but in actuality there is very little practical use as these things are usually quite large.
In contrast the custom binary dump is not human readable, but it is compressed to save space and better handles restoration without causing confusing errors associated with constraint violations while loading table data, which come up a lot in the plain text method.
Again you could use the same cron task entry which would run the script <code>backup.sh</code> in the first minute of the first hour of every day.
<pre><code class="hljs">1 1 * * * bash /path/to/backup.sh
</code></pre>
Here is an example bash script for creating a backup using <code>pg_dump</code> in custom binary format:
<pre><code class="hljs">#!/bin/bash

TODAY=`date +%F`
ARCHIVE=databasename-$TODAY.bk
echo creating archive file $ARCHIVE
cd /var/lib/pgsql/9.6/backups
pg_dump -Fc databasename &gt; $ARCHIVE
echo &#x27;archive complete&#x27;
</code></pre>
If one wanted to produce the plain text SQL output then you would swap out the line <code>pg_dump -Fc databasename &gt; $ARCHIVE</code> with <code>pg_dump databasename &gt; $ARCHIVE</code>.
<h2 id="restoringthedatabase">Restoring the Database</h2>
Recovering a database can be a daunting task, as this is usually done in a time where you've experienced a serious crash plus various team members and stakeholders may be in an emotionally charged frenzy. I hope this is something that you as a developer will never have to experience, but I am writing this article knowing that it is likely to be an unfortunate event for a certain percent of its readers. That being said, remember just to relax and take it one step or command at time. After all, the worst has already happened so you have nowhere to go but up.
<h3 id="arestoringfromafilesystembackup">A. Restoring from a File System Backup</h3>
In order to restore from the WAL / file system backup you need to follow these steps:
<ol>
<li>Stop the PostgreSQL server if it is running on what is likely to be a new Linux server</li>
<li>Remove the existing files and directories under the data directory usually found in <code>/var/lib/pgsql/x.x/data</code> where <code>x.x</code> is the version of PostgreSQL that you are running, such as 9.6. Also make note of who owns these files and directories, which are usually owned by the postgres user</li>
<li>Take your latest archived copy of the database that was created in the <code>backup.sh</code> script and decompress it in the PostgreSQL data directory. Make sure the ownership of these files are the same ones as you noted in step 2</li>
<li>Turn off all other apps or services that may try to access the database. It is also a good idea to modify your pg_hba.conf file to ensure no other users are able to access that database</li>
<li>Create a recovery.conf file in the data directory and place the following command in it which is basically a reverse of the <code>archive_command</code> in the <code>postgresql.conf</code> file, discussed earlier. Again, make sure this file has the same owner as noted in step 2</li>
</ol>
recovery.conf
<code>restore_command 'cp /home/username/pg/wals/%f %p'</code>
<ol start="6">
<li>Start the PostgreSQL service, which will put the database into recovery mode utilizing the recovery.conf file's command to restore any data that resided in the WAL (write ahead log) after the point-in-time copy was made.</li>
</ol>
Whew! You're done.
<h3 id="brestoringfromasqldumpbackup">B. Restoring from a SQL Dump Backup</h3>
Restoring a database from a SQL dump that was created using <code>pg_dump</code> involves far fewer steps than the previous method, but you will almost certainly recover less data using this method as you will not be utilizing the WAL to pick up any additional data that didn't make it into the point-in-time copy.
To restore the database you need to make sure the postgresql service is running on the machine you want to restore the database on. Then all that is required is to issue the following command as a user that has full write permissions to the PostgreSQL database.
<pre><code class="hljs">pg_restore -Fc databasename-YYYY-MM-DD.bk
</code></pre>
Postgres will read the backup file and recreate the tables, indexes, and constraints as well as load the tables with the data present at the moment the original database was copied.
And voilà, you are done!
I prefer this method not only because it is less complicated, but also I prefer this method of backup and recovery because as a developer I often find it useful, or even required, that I be able to easily load a production database onto my local development machine. This allows me to debug or develop a new feature with data that was recent and similar as possible to that of the live system, and SQL dumps make this possible.
So, even if you are using the WAL / file system method for backups and recovery you can still use <code>pg_dump</code> and <code>pg_restore</code> to make copies and restore your local dev machine.
<h2 id="conclusion">Conclusion</h2>
In this article I have demonstrated two approaches to creating scheduled backups for a PostgreSQL database running on a Linux server and performing recovery in case the database were to become corrupt or otherwise unusable. I have also discussed the pros and cons of each method as well as discussed the need for a developer to know how to accomplish these tasks.
As always I thank you for reading and welcome comments and criticisms below.

Adam McQuistan

Backing up and Restoring PostgreSQL Databases

Usman Malik

Creating a Simple Recommender System in Python using Pandas

David Landup

Java J2EE Design Patterns

Exception Handling in Java: A Complete Guide with Best and Worst Practices

Implementing Word2Vec with Gensim Library in Python

Preparing for a Python Developer Interview

Vuk Skobalj

How to Test a Spring Boot Application

Vasyl Lagutin

Reading and Writing JSON in Java

Behavioral Design Patterns in Java