Forem: Dimas Adiputro

Install XAMPP in linux

Dimas Adiputro — Sun, 05 Oct 2025 11:30:27 +0000

download the binary using wget or upload to the server manually.

[root@single ~]# wget https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/8.0.30/xampp-linux-x64-8.0.30-0-installer.run

[root@single ~]# chmod +x  xampp-linux-x64-8.0.30-0-installer.run

[root@single ~]# [root@single ~]# ./xampp-linux-x64-8.0.30-0-installer.run 
----------------------------------------------------------------------------
Welcome to the XAMPP Setup Wizard.

----------------------------------------------------------------------------
Select the components you want to install; clear the components you do not want 
to install. Click Next when you are ready to continue.

XAMPP Core Files : Y (Cannot be edited)

XAMPP Developer Files [Y/n] :n

Is the selection above correct? [Y/n]: Y

----------------------------------------------------------------------------
Installation Directory

XAMPP will be installed to /opt/lampp
Press [Enter] to continue:

----------------------------------------------------------------------------
Setup is now ready to begin installing XAMPP on your computer.

Do you want to continue? [Y/n]: Y

----------------------------------------------------------------------------
Please wait while Setup installs XAMPP on your computer.

 Installing
 0% ______________ 50% ______________ 100%
 #########################################

----------------------------------------------------------------------------
Setup has finished installing XAMPP on your computer.

after installation completed run the lampp

[root@single]#cd /opt/lampp
[root@single lampp]# ./lampp start
Starting XAMPP for Linux 8.0.30-0...
XAMPP: Starting Apache...ok.
XAMPP: Starting MySQL...already running.
XAMPP: Starting ProFTPD...already running.

the open the browser and access http://127.0.0.1

Configure pgstattuple

Dimas Adiputro — Thu, 14 Aug 2025 13:44:00 +0000

pgstattuple is part of PostgreSQL's contrib modules—a collection of officially supported but optional extensions.
1) download and install the rpm from postgresql official website - https://download.postgresql.org/pub/repos/yum/15/redhat/rhel-8.10-x86_64/

sudo yum install postgresql<version>-contrib

2) upload the rpm using sudo / root and

sudo rpm -ivh postgresql<version>-contrib

3) login to psql

CREATE EXTENSION pgstattuple;

4) to check the dead tuple table use below command

SELECT * FROM pgstattuple('joe.this_my_table_name');

5) below is the result.

mydb=# SELECT * FROM pgstattuple('joe.this_my_table_name');
 table_len | tuple_count | tuple_len | tuple_percent | dead_tuple_count | dead_tuple_len | dead_tuple_percent | free_space | free_percent
-----------+-------------+-----------+---------------+------------------+----------------+--------------------+------------+--------------
      8192 |           5 |       463 |          5.65 |                0 |              0 |                  0 |       7656 |        93.46
(1 row)

Description :
table_len: Total size of the table on disk in bytes.
tuple_count: Number of live (visible) tuples.
tuple_len: Total length of live tuples in bytes.
tuple_percent: Percentage of space occupied by live tuples.
dead_tuple_count: Number of dead tuples (not yet vacuumed).
dead_tuple_len: Total length of dead tuples in bytes.
dead_tuple_percent: Percentage of space occupied by dead tuples. This is a direct indicator of bloat due to dead rows.
free_space: Total free space available within allocated pages in bytes (usable for future INSERTs/UPDATEs without extending the table).
free_percent: Percentage of total table space that is free.

Shell Script to automate Create User and timestamps in PostgreSQL

Dimas Adiputro — Fri, 25 Jul 2025 09:27:46 +0000

Every quarter, the audit team requests a list of users and the timestamps of when they were created. So, I created a simple shell script to automate user creation and log the details into a table.
in this case I store the table in the testdb database

1) Create the table for store the data

CREATE TABLE user_log (
  username TEXT,
  created_at TIMESTAMP
);

2) This is the shell script (create_pg_user.sh)

#!/bin/bash

# Check if a username was provided
if [ -z "$1" ]; then
  echo "Usage: $0 <username>"
  exit 1
fi

USERNAME=$1
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

PGUSER="postgres"
PGDATABASE="testdb"
PGHOST="localhost"
PGPORT="5432"

psql -U $PGUSER -d $PGDATABASE -h $PGHOST -p $PGPORT -c "CREATE USER $USERNAME;"

psql -U $PGUSER -d $PGDATABASE -h $PGHOST -p $PGPORT -c \
"INSERT INTO user_log (username, created_at) VALUES ('$USERNAME', '$TIMESTAMP');"

3) Execute the shell script. here I just put the username and the password will be auto generated.

sh create_pg_user.sh myuser
CREATE ROLE
INSERT 0 1
User created successfully!
Username: myuser
Password: k4EM99fNRdCC2spj

4) Let's check user created date

postgres=# \du
                                       List of roles
   Role name   |                         Attributes                         |  Member of
---------------+------------------------------------------------------------+--------------
 myuser           |                                                            | {}


testdb=# select * from user_log;
 username |     created_at
----------+---------------------
 myuser   | 2025-06-20 12:13:23

(2 rows)

so whenever the audit team asks when a user was created, we can provide the information by selecting user_log table

Enable Huge Pages in PostgreSQL

Dimas Adiputro — Fri, 27 Jun 2025 07:23:00 +0000

PostgreSQL are recommend to enable Huge Pages.
I am using Redhat Family

if run this command HugePages_Total and HugePages_Free value are 0 it means that huge page is not enable.

[postgres@pg1]$  cat /proc/meminfo | grep -i huge
AnonHugePages:     49152 kB
ShmemHugePages:        0 kB
FileHugePages:         0 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:       2048 kB
Hugetlb:               0 kB

I am using Ibrar Ahmed from percona for the formula

#!/bin/bash
pid=`head -1 $PGDATA/postmaster.pid`
echo "Pid:            $pid"
peak=`grep ^VmPeak /proc/$pid/status | awk '{ print $2 }'`
echo "VmPeak:            $peak kB"
hps=`grep ^Hugepagesize /proc/meminfo | awk '{ print $2 }'`
echo "Hugepagesize:   $hps kB"
hp=$((peak/hps))
echo Set Huge Pages:     $hp

we can run and the output like below

[postgres@pg1 ~]$ sh hg.sh
Pid:            1631
VmPeak:            8921740 kB
Hugepagesize:   2048 kB
Set Huge Pages:     4356

we can set in /etc/sysctl.conf to apply we can use sysctl -p using root user

vm.nr_hugepages = 4356

apply after changing

sudo sysctl -p

After hugepages is set, however we need to restart the server to get the effect in postgresql
Below is the output once huge page is enable succefully.

cat /proc/meminfo | grep -i huge
AnonHugePages:     30720 kB
ShmemHugePages:        0 kB
FileHugePages:         0 kB
HugePages_Total:    4356
HugePages_Free:     4238
HugePages_Rsvd:     4100
HugePages_Surp:        0
Hugepagesize:       2048 kB
Hugetlb:         8921088 kB

we can set huge_page to on or keep as try in postgresql.conf

Controls whether huge pages are requested for the main shared memory area. Valid values are try (the default), on, and off. With huge_pages set to try, the server will try to request huge pages, but fall back to the default if that fails. With on, failure to request huge pages will prevent the server from starting up. With off, huge pages will not be requested. The actual state of huge pages is indicated by the server variable huge_pages_status. https://www.postgresql.org/docs/17/runtime-config-resource.html#GUC-HUGE-PAGES

I prefer to set huge_pages to be on;

postgres=# show huge_pages;
 huge_pages
------------
 on
(1 row)

postgres=# \q
[postgres@pg1 ]$ 
[postgres@pg1 ]$ cat /proc/meminfo | grep -i huge
AnonHugePages:     30720 kB
ShmemHugePages:        0 kB
FileHugePages:         0 kB
HugePages_Total:    4356
HugePages_Free:     4247
HugePages_Rsvd:     4109
HugePages_Surp:        0
Hugepagesize:       2048 kB
Hugetlb:         8921088 kB
[postgres@pg1 ]$

PostgreSQL Disable THP - transparent_hugepage on RHEL

Dimas Adiputro — Fri, 27 Jun 2025 07:02:34 +0000

PostgreSQL are recommend to disable transparent_hugepage.

1. using tuned

The default value of transparent_hugepage is always. however we need to disable (never)

cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never

this command is to disabled but temporary. if the server rebooted then transparent_hugepage will be revert to default value
echo never > /sys/kernel/mm/transparent_hugepage/enabled

here I am use tuned-adm to disable permanently.

[vm]
transparent_hugepages=never

after change then reboot the server and check this command again

cat /sys/kernel/mm/transparent_hugepage/enabled
always madvise [never]

2. the second way to disable the THP

Append transparent_hugepage=never to kernel command line in /boot/grub/grub.conf file

kernel /vmlinuz-2.6.32-642.3.1.el6.x86_64 ro root=/dev/mapper/vg_<hostname>-lv_root rd_NO_LUKS LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=auto rd_LVM_LV=vg_<hostname>/lv_swap rd_LVM_LV=vg_<hostname>/lv_root KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet numa=off transparent_hugepage=never fnic.fnic_max_qdepth=256

Reboot the server and check if /sys/kernel/mm/transparent_hugepage/enabled changed

#cat /sys/kernel/mm/transparent_hugepage/enabled
always madvise [never]

enable sudo in rhel

Dimas Adiputro — Thu, 05 Jun 2025 03:17:30 +0000

this is very useful and simple but some times I forgot.
login as root and type visudo

## The COMMANDS section may have other options added to it.
##
## Allow root to run any commands anywhere
root    ALL=(ALL)       ALL
sysadmin ALL=(ALL) NOPASSWD: ALL
oracle ALL=(ALL) NOPASSWD: ALL
grid ALL=(ALL) NOPASSWD: ALL

using postgres_fdw

Dimas Adiputro — Fri, 25 Apr 2025 02:46:42 +0000

Here I want to share to configure postgres_fdw

the postgres_fdw extension in PostgreSQL is included in the contrib package and I will write how to install contrib here.

I have pg1 - 10.10.1.9 and pg2 - 10.10.1.10

on pg1

\c testdb;

CREATE EXTENSION IF NOT EXISTS postgres_fdw;

CREATE SERVER tonewdatabase
FOREIGN DATA WRAPPER postgres_fdw
OPTIONS (
  host '10.10.1.10',
  dbname 'mydb',
  port '5432'
);

tonewdatabase = name Foreign-data wrapper
host = hostname or ip destination
dbname = database name destination
port = database port destionation

use below command to list FOREIGN DATA WRAPPER

postgres=# \des
             List of foreign servers
     Name      |  Owner   | Foreign-data wrapper
---------------+----------+----------------------
 tonewdatabase | postgres | postgres_fdw

now we create user mapping

CREATE USER MAPPING FOR andi
SERVER tonewdatabase 
OPTIONS (user 'joe', password 'joe123);

andi = username on pg1
joe = username on pg2
joe123= joe's password on pg2

Select t1 on pg2 from pg1


IMPORT FOREIGN SCHEMA public
LIMIT TO (t1)
FROM SERVER tonewdatabase 
INTO public;


select * from public.t1 ;

t1 = tablename on pg1
the IMPORT FOREIGN SCHEMA (or manually creating a FOREIGN TABLE) does not copy any rows locally. It simply creates table definitions on pg1 that point at the real data on pg2. Every time you run

below how to create new table

CREATE FOREIGN TABLE public.t1(
  id INT,
  amount NUMERIC
)
SERVER tonewdatabase 
OPTIONS (schema_name 'public', table_name 't2');

this statement will create table on pg2 from pg1.

Import ALL tables from pg2's 'public' schema:

IMPORT FOREIGN SCHEMA public
FROM SERVER tonewdatabase
INTO public;

Or just a few selected tables:

IMPORT FOREIGN SCHEMA public
LIMIT TO (table1, table2, table3)
FROM SERVER tonewdatabase
INTO public;

PgBouncer Simple Configuration

Dimas Adiputro — Mon, 07 Apr 2025 08:06:21 +0000

Below are the pgbouncer files configuration

ls -l /etc/pgbouncer
-rwx------. 1 postgres postgres   824 Jan 10 05:59 mkauth.py
-rw-r--r--. 1 postgres postgres   361 Apr  7 14:46 pgbouncer.ini
-rw-r--r--. 1 postgres postgres   825 Apr  7 14:40 userlist.txt

edit pgbouncer.ini with below parameter

[databases]
powerfulldb = port=5432 dbname=powerfulldb

[pgbouncer]
listen_addr = 0.0.0.0
listen_port = 6432
auth_type = md5
auth_file = /etc/pgbouncer/userlist.txt
pool_mode = transaction
max_client_conn = 100
default_pool_size = 20
logfile = /var/log/pgbouncer/pgbouncer.log
pidfile = /var/run/pgbouncer/pgbouncer.pid
unix_socket_dir = /tmp
unix_socket_mode = 0777

postgresql 12 below
SELECT '"' || rolname || '" "' || rolpassword || '"' as userlist FROM pg_shadow WHERE rolpassword IS NOT NULL;

postgresql 13+ version
SELECT '"' || usename || '" "' || passwd || '"' as userlist FROM pg_shadow WHERE passwd IS NOT NULL;

Below is the example result and must to paste to this file /etc/pgbouncer/userlist.txt

                        userlist
--------------------------------------------------------
 "admin1" "md5c1d7c7825caaac2441xc633a274b45ea"
 "admin2" "md525e4b33435daa2f8ebx1664dd7df2aab"
 "admin3" "md5a99ea413e7dea3bd19xd760507bcec00"

restart the pgbouncer service
systemctl restart pgbouncer.service

then login to the database using pgboncher port
psql -p 6432 -U admin1 -h 10.10.20.100 -d powerfulldb

create user in postgresql

Dimas Adiputro — Wed, 19 Mar 2025 07:50:31 +0000

Basic things to create and check user attributes

CREATE USER my_mate_user WITH PASSWORD 'thisisStrongPassword';
ALTER ROLE my_mate_user SET work_mem = '64MB';
ALTER USER my_mate_user WITH CONNECTION LIMIT 10;

here is the attribute

SELECT rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin
FROM pg_roles where rolname ='my_mate_user' ;

          rolname       | rolsuper | rolinherit | rolcreaterole | rolcreatedb | rolcanlogin |    rolconfig
---------------------+----------+------------+---------------+-------------+-------------+-----------------
 my_mate_user | f        | t          | f             | f           | t           | {work_mem=64MB}

(1 row)

\du
       Role name        |                         Attributes                         |     Member of               
------------------------+------------------------------------------------------------+-----------------------------
        my_mate_user    | 10 connections                                             |       {}

PGBackRest Configuration from Standby Database

Dimas Adiputro — Mon, 10 Mar 2025 22:38:17 +0000

pgbackrest is the faster backup tools and the completed feature for backup. I choose pgbackrest because barman cannot handle in high wal generated.
My Database have 22.000 until 40.000 wal per hours (1 wal = 1mb).
Here I have 3 servers.

10.10.10.1 - pg1 as master postgresql
10.10.10.2 - pg2 as standby postgresql
10.10.10.3 - pg3 as backup server

since my master databases very busy I will backup the database from standby.

here is my configuration.

master database - /etc/pgbackrest.conf

[global]
repo1-host=10.10.10.3
repo1-host-user=postgres
repo1-path=/pgbackuprest
start-fast=y
log-level-console=info
log-level-file=detail
compress-level=1
process-max=4
compress-type=lz4
archive-async=y
spool-path=/archspool
archive-push-queue-max=5GiB

[mycluster]
pg1-path=/data
pg1-port=5432

run this in master only
pgbackrest --stanza=mypgback stanza-create

standby database - /etc/pgbackrest.conf

[global]
repo1-host=10.10.10.3
repo1-host-user=postgres
repo1-path=/pgbackuprest
start-fast=y
log-level-console=info
log-level-file=detail
compress-level=1
process-max=12
archive-async=y
spool-path=/arc_temp
archive-get-queue-max=5GiB
compress-type=lz4

[mypgback]
pg1-path=/data
pg1-port=5432

Don't forget to change in master and standby to push the archive

postgres=# show archive_command ;
                archive_command
-----------------------------------------------
 pgbackrest --stanza=mypgback archive-push %p
(1 row)

this is for restore wal

postgres=# show restore_command ;
                  restore_command
---------------------------------------------------
 pgbackrest --stanza=mypgback archive-get %f "%p"
(1 row)

pg3 - /etc/pgbackrest.conf

[global]
repo1-path=/pgbackuprest
repo1-retention-full=1
start-fast=y
log-level-console=info
log-level-file=detail
process-max=12
archive-timeout=1h
compress-level=1
backup-standby=y
log-path=/pgbackuprest/log
compress-type=lz4

[mypgback]
pg1-host=10.10.10.1
pg1-host-user=postgres
pg1-port=5432
pg1-path=/data
pg2-host=10.10.10.2
pg2-host-user=postgres
pg2-port=5432
pg2-path=/data

Set the pgbackrest on crontab

5 17 * * 6 /usr/bin/pgbackrest --stanza=mypgback backup --type=full
5 18 * * 0-5 /usr/bin/pgbackrest --stanza=mypgback backup --type=incr

Here is the result from pgbackrest backup
pgbackest info

stanza: mypgback 
    status: ok
    cipher: none

    db (current)
        wal archive min/max (12): 000000090002877600000046/00000009000289F100000097

        full backup: 20241210-180000F
            timestamp start/stop: 2024-12-10 18:00:55+08 / 2025-03-10 22:09:09+08
            wal start/stop: 000000090002877600000046 / 00000009000287E10000000B
            database size: 21821.5GB, database backup size: 21821.5GB
            repo1: backup set size: 3395.6GB, backup size: 3395.6GB

 incr backup: 20241211-170452F_20241212-180451I
            timestamp start/stop: 2024-12-11 18:04:51+08 / 2024-11-11 18:43:46+08
            wal start/stop: 000000090002902900000075 / 000000090002904800000007
            database size: 22697.6GB, database backup size: 3198.1GB
            repo1: backup set size: 3591GB, backup size: 534.7GB
            backup reference list: 20241210-180000F

as we can see from the result my database size is 21821.5GB but the back size 33395.6GB

pg_class in postgreSQL

Dimas Adiputro — Thu, 19 Dec 2024 14:09:50 +0000

The pg_class system catalog in PostgreSQL contains metadata about the tables, indexes, sequences, views, and other relations in the database. It is a central part of PostgreSQL's internal architecture, and you can query pg_class to obtain detailed information about the structure of your database.

1. List All Relations (Tables, Views, Sequences)

This query will give you a list of all relations (tables, views, sequences, etc.) in the current database:

SELECT 
    relname AS relation_name, 
    relkind AS relation_type,
    CASE 
        WHEN relkind = 'r' THEN 'Table'
        WHEN relkind = 'v' THEN 'View'
        WHEN relkind = 'i' THEN 'Index'
        WHEN relkind = 'S' THEN 'Sequence'
        WHEN relkind = 't' THEN 'TOAST table'
        WHEN relkind = 'c' THEN 'Composite type'
        ELSE 'Other'
    END AS relation_type_description
FROM 
    pg_class
WHERE 
    relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public') -- limit to 'public' schema
ORDER BY 
    relname;

2. Get Table Size

If you want to find the size of a specific table (including its TOAST table, indexes, etc.), you can use pg_class along with the pg_total_relation_size() function:

SELECT 
    c.relname AS table_name,
    pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size
FROM 
    pg_class c
WHERE 
    c.relkind = 'r'  -- 'r' stands for regular tables
ORDER BY 
    pg_total_relation_size(c.oid) DESC;

3. Find Tables with Most Indexes

To find which tables have the most indexes, you can join pg_class with pg_index and group by the table OID:

SELECT 
    t.relname AS table_name,
    COUNT(i.indexrelid) AS index_count
FROM 
    pg_class t
JOIN 
    pg_index i ON t.oid = i.indrelid
WHERE 
    t.relkind = 'r' -- only tables
GROUP BY 
    t.relname
ORDER BY 
    index_count DESC;

4. List All Indexes and Their Associated Tables

If you're interested in finding all indexes in the database and the tables they are associated with, use the following query:

SELECT 
    idx.relname AS index_name,
    tbl.relname AS table_name
FROM 
    pg_class tbl
JOIN 
    pg_index ix ON tbl.oid = ix.indrelid
JOIN 
    pg_class idx ON ix.indexrelid = idx.oid
WHERE 
    tbl.relkind = 'r'  -- only tables
ORDER BY 
    tbl.relname, idx.relname;

5. Get Column Count for Each Table

To get the number of columns for each table, you can join pg_class with pg_attribute:

SELECT 
    c.relname AS table_name,
    COUNT(a.attname) AS column_count
FROM 
    pg_class c
JOIN 
    pg_attribute a ON c.oid = a.attrelid
WHERE 
    c.relkind = 'r' -- only tables
    AND a.attnum > 0  -- exclude system columns
GROUP BY 
    c.relname
ORDER BY 
    column_count DESC;

6. List All Constraints on a Table

To list all constraints on a table (e.g., primary keys, foreign keys, unique constraints), you can query the pg_constraint catalog:

SELECT 
    c.conname AS constraint_name,
    c.contype AS constraint_type,
    t.relname AS table_name
FROM 
    pg_constraint c
JOIN 
    pg_class t ON c.conrelid = t.oid
WHERE 
    t.relname = 'your_table_name';  -- Replace with the table you're interested in

7. Find Tables with Foreign Keys

To find tables with foreign keys, you can query pg_constraint and pg_class as follows:

SELECT 
    t.relname AS table_name,
    c.conname AS foreign_key_name
FROM 
    pg_constraint c
JOIN 
    pg_class t ON c.conrelid = t.oid
WHERE 
    c.contype = 'f';  -- 'f' for foreign keys

contype = 'f': Filters for foreign key constraints.

8. Find Tables with No Indexes

You can also identify tables that do not have any indexes:

SELECT 
    t.relname AS table_name
FROM 
    pg_class t
LEFT JOIN 
    pg_index i ON t.oid = i.indrelid
WHERE 
    t.relkind = 'r'  -- only tables
    AND i.indexrelid IS NULL
ORDER BY 
    t.relname;

9. Find Large Tables (by Size)

To identify the largest tables in terms of total size, you can use pg_class together with pg_total_relation_size():

SELECT 
    c.relname AS table_name,
    pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size
FROM 
    pg_class c
WHERE 
    c.relkind = 'r' -- only tables
ORDER BY 
    pg_total_relation_size(c.oid) DESC
LIMIT 10;

This query retrieves the 10 largest tables based on their total size.

10. Show Tables with Their OIDs

To get the OID (Object Identifier) of tables, you can query pg_class directly:

SELECT 
    oid,
    relname AS table_name
FROM 
    pg_class
WHERE 
    relkind = 'r'; -- only tables

oid: A unique identifier for each object in PostgreSQL (including tables).

Barman vs pgbackrest

Dimas Adiputro — Thu, 19 Dec 2024 14:02:52 +0000

Barman vs pgbackrest :

Feature	pgBackRest	Barman
Backup Types	Full, Incremental, Differential	Full, Incremental (via WAL archiving)
Parallel Backups	Yes	No
Compression	Yes	Yes
Encryption	Yes	No (Requires external encryption)
Point-in-Time Recovery	Yes	Yes
Performance	High performance, parallel processing	Good, but not as optimized as pgBackRest
Ease of Use	Moderate (some complexity)	Easy to set up and use
Restore Process	Flexible, with automatic WAL recovery	Simple, but less feature-rich
Cross-Platform	Yes	Primarily Linux-based
Centralized Management	No	Yes
Retention Policies	Yes	Limited (manual management)
Community Support	Strong community and active development	Active community support

When to Use pgBackRest:

Large Scale Systems: If you have large databases or need to backup large volumes of data with high performance and efficiency, pgBackRest is ideal due to its parallelism and delta backups.
Advanced Features: If you need features like encryption, compression, and fine-tuned backup configurations, pgBackRest excels in these areas.
High Availability and Replication: If you are using streaming replication or other advanced PostgreSQL features, pgBackRest integrates well into these environments.

When to Use Barman:

Small to Medium Systems: Barman is well-suited for smaller to medium-sized PostgreSQL environments where simplicity and ease of use are the primary concerns.
Centralized Management: If you have multiple PostgreSQL instances and need centralized backup management, Barman is a good choice.
Basic Backup and Recovery Needs: If you don't require advanced features like parallel backups or encryption, Barman provides a straightforward solution for backup and recovery tasks.