<stepid="pbk-init-the-backup-catalog">

<para>Initialize the backup catalog:</para>

<programlistingid="pbk-init-the-backup-catalog-listing">

backup_user@backup_host:~$ pg_probackup init -B /mnt/backups

backup_user@backup_host:~$ pg_probackup-16 init -B /mnt/backups

INFO: Backup catalog '/mnt/backups' successfully initialized

</programlisting>

</step>

<stepid="pbk-add-instance-to-backup-catalog">

<para>Add a backup instance called <literal>mydb</literal> to the backup catalog:</para>

<programlistingid="pbk-add-instance-to-backup-catalog-listing">

backup_user@backup_host:~$ pg_probackup add-instance \

backup_user@backup_host:~$ pg_probackup-16 add-instance \

-B /mnt/backups \

-D /var/lib/pgpro/std-16/data \

--instance=node \

<stepid="pbk-make-full-backup">

<para>Make a FULL backup:</para>

<programlistingid="pbk-make-full-backup-listing">

backup_user@backup_host:~$ pg_probackup backup \

backup_user@backup_host:~$ pg_probackup-16 backup \

-B /mnt/backups \

-b FULL \

--instance=node \

<stepid="pbk-list-backups">

<para>List the backups of the instance:</para>

<programlistingid="pbk-list-backups-listing">

backup_user@backup_host:~$ pg_probackup show \

backup_user@backup_host:~$ pg_probackup-16 show \

-B /mnt/backups \

--instance=node

================================================================================================================================

<stepid="pbk-make-incremental-backup-in-delta-mode">

<para>Make an incremental backup in the DELTA mode:</para>

<programlistingid="pbk-make-incremental-backup-in-delta-mode-listing">

backup_user@backup_host:~$ pg_probackup backup \

backup_user@backup_host:~$ pg_probackup-16 backup \

-B /mnt/backups \

-b DELTA \

--instance=node \

<para>Add or modify some parameters in the <application>pg_probackup</application>

configuration file, so that you do not have to specify them each time on the command line:</para>

<programlistingid="pbk-save-config-parameters-listing">

backup_user@backup_host:~$ pg_probackup set-config \

backup_user@backup_host:~$ pg_probackup-16 set-config \

-B /mnt/backups \

--instance=node \

--remote-host=postgres_host \

<stepid="pbk-print-instance-config">

<para>Check the configuration of the instance:</para>

<programlistingid="pbk-print-instance-config-listing">

backup_user@backup_host:~$ pg_probackup show-config \

backup_user@backup_host:~$ pg_probackup-16 show-config \

-B /mnt/backups \

--instance=node

# Backup instance information

<para>Make another incremental backup in the DELTA mode, omitting

the parameters stored in the configuration file earlier:</para>

<programlistingid="pbk-make-another-incremental-backup-in-delta-mode-using-saved-parameters-listing">

backup_user@backup_host:~$ pg_probackup backup \

backup_user@backup_host:~$ pg_probackup-16 backup \

-B /mnt/backups \

-b DELTA \

--instance=node \

<stepid="pbk-list-backups-again">

<para>List the backups of the instance again:</para>

<programlistingid="pbk-list-backups-again-listing">

backup_user@backup_host:~$ pg_probackup show \

backup_user@backup_host:~$ pg_probackup-16 show \

-B /mnt/backups \

--instance=node

===================================================================================================================================

<stepid="pbk-quickstart-restore">

<para>Restore the data from the latest available backup to an arbitrary location:</para>

<programlistingid="pbk-quickstart-restore-listing">

backup_user@backup_host:~$ pg_probackup restore \

backup_user@backup_host:~$ pg_probackup-16 restore \

-B /mnt/backups \

-D /var/lib/pgpro/std-16/staging-data \

--instance=node

node 16 SCUN39 2024-05-02 11:18:50+03 PAGE STREAM 15/15 12s 46MB 32MB 1.44 0/2A000028 0/2B0000B8 OK

node 16 SCUN2V 2024-05-02 11:18:38+03 FULL STREAM 15/0 11s 154MB 16MB 2.32 0/23000028 0/23000168 OK

backup_user@backup_host:~$ pg_probackup restore -B /mnt/backups --instance=node -R -I lsn

backup_user@backup_host:~$ pg_probackup-16 restore -B /mnt/backups --instance=node -R -I lsn

INFO: Destination directory and tablespace directories are empty, disable incremental restore

INFO: Validating parents for backup SCUN3Y

INFO: Validating backup SCUN2V

return;

}

if (strcmp(file->name,"ptrack.map")==0)

{

copy_ptrackmap_file(from_fullpath,FIO_DB_HOST,

to_fullpath,FIO_BACKUP_HOST,file);

return;

}

elog(ERROR,"Cannot close file \"%s\": %s",from_fullpath,

strerror(errno));

if (tmp_backup->compress_alg>NONE_COMPRESS&&strcmp(tmp_file->name,"ptrack.map")==0){

char*buffer;

size_tsize;

constchar*errormsg=NULL;

buffer=slurpFile(to_fullpath,"",&size, false,FIO_DB_HOST);// not sure about to_location

size_tdecompressed_size=tmp_file->size*2;

void*decompressed=pg_malloc(decompressed_size);

intrc=do_decompress(decompressed,decompressed_size,buffer,size,tmp_backup->compress_alg,&errormsg);

if (rc<0&&errormsg!=NULL)

elog(WARNING,"An error occured during compressing ptrack.map: %s",errormsg);

if (rc <=0)

{

elog(ERROR,"An error occured during decompression of ptrack.map: %s",errormsg);

pg_free(buffer);

pg_free(decompressed);

}

else {

decompressed_size=rc;

}

writePtrackMap(decompressed,decompressed_size,to_fullpath,FIO_DB_HOST);

pg_free(decompressed);

pg_free(buffer);

}

returntmp_file->write_size;

}

ControlFileData*control);

externvoidcopy_pgcontrol_file(constchar*from_fullpath,fio_locationfrom_location,

constchar*to_fullpath,fio_locationto_location,pgFile*file);

externvoidcopy_ptrackmap_file(constchar*from_fullpath,fio_locationfrom_location,

constchar*to_fullpath,fio_locationto_location,pgFile*file);

externvoidtime2iso(char*buf,size_tlen,time_ttime,boolutc);

externconstchar*status2str(BackupStatusstatus);

externvoidcheck_system_identifiers(PGconn*conn,constchar*pgdata);

externvoidparse_filelist_filenames(parray*files,constchar*root);

externvoidwritePtrackMap(constchar*ptrackMap,constsize_tptrackmap_size,

constchar*path,fio_locationlocation);

externvoidmake_pagemap_from_ptrack_2(parray*files,PGconn*backup_conn,

constchar*ptrack_schema,

pg_free(buffer);

}

writePtrackMap(constchar*ptrackMap,constsize_tptrackmap_size,

constchar*path,fio_locationlocation)

{

intfd;

char*buffer=NULL;

buffer=pg_malloc0(ptrackmap_size);

memcpy(buffer,ptrackMap,ptrackmap_size);

fd=fio_open(path,

O_RDWR |O_CREAT |O_TRUNC |PG_BINARY,location);

if (fd<0) {

elog(ERROR,"Failed to open file: %s",path);

}

if (fio_write(fd,buffer,ptrackmap_size)!=ptrackmap_size) {

elog(ERROR,"Failed to overwrite file: %s",path);

}

if (fio_flush(fd)!=0) {

elog(ERROR,"Failed to sync file: %s",path);

}

fio_close(fd);

pg_free(buffer);

}

voidcopy_ptrackmap_file(constchar*from_fullpath,fio_locationfrom_location,

constchar*to_fullpath,fio_locationto_location,

pgFile*file) {

char*buffer;

size_tsize;

boolmissing_ok= true;

booluse_crc32c= true;

constchar*errormsg=NULL;

buffer=slurpFile(from_fullpath,"",&size, false,from_location);

size_tcompressed_size=size;

void*compressed=pg_malloc(compressed_size);

intrc=do_compress(compressed,compressed_size,buffer,size,

current.compress_alg,current.compress_level,&errormsg);

if (rc<0&&errormsg!=NULL)

elog(WARNING,"An error occured during compressing ptrack.map: %s",

errormsg);

if (rc <=0||rc >=size) {

memcpy(compressed,buffer,size);

}else {

compressed_size=rc;

}

writePtrackMap(compressed,compressed_size,to_fullpath,to_location);

file->crc=pgFileGetCRCgz(to_fullpath,use_crc32c,missing_ok);;

file->size=compressed_size;

file->read_size=size;

file->write_size=compressed_size;

file->uncompressed_size=size;

file->compress_alg=current.compress_alg;

pg_free(compressed);

pg_free(buffer);

}