### Download Pigsty Installer Script (Verbose Example)

Source: https://github.com/pgsty/pigsty/blob/main/README.md

This example demonstrates the execution of the Pigsty `get` script, showing the detailed output during the download and installation process. The output includes site information, download progress, and a todo list for subsequent steps.

```bash
curl -fsSL https://repo.pigsty.io/get | bash
```

--------------------------------

### Install Odoo with Pigsty Initial Setup

Source: https://github.com/pgsty/pigsty/blob/main/app/odoo/README.md

This snippet provides the initial set of `bash` commands to prepare a Pigsty environment for Odoo installation. It covers initializing the Pigsty directory, preparing local repositories, applying the Odoo-specific configuration template, and initiating the full Pigsty installation process.

```bash
curl -fsSL https://repo.pigsty.io/pig | bash
pig sty init              # init pigsty directory
pig sty boot              # prepare local repo & ansible
pig sty conf -c app/odoo  # use the odoo 1-node config template
pig sty install           # begin installation
```

--------------------------------

### Launch Wiki.js Application

Source: https://github.com/pgsty/pigsty/blob/main/app/wiki/README.md

Instructions to navigate to the Wiki.js application directory and start it using the 'make up' command, typically for development or initial setup.

```bash
cd app/wiki ; make up
```

--------------------------------

### Install and Initialize Terraform for Quick Start

Source: https://github.com/pgsty/pigsty/blob/main/terraform/README.md

This snippet provides the basic commands to install Terraform using Homebrew, initialize the Terraform providers (Aliyun, AWS), and apply the configuration to create VMs. It's a fundamental step for setting up a Terraform environment.

```bash
brew install terraform
terraform init
terraform apply
```

--------------------------------

### Metabase Initial Setup via Make

Source: https://github.com/pgsty/pigsty/blob/main/app/metabase/README.md

Provides the initial shell commands to navigate into the Metabase application directory and start the service using `make up`, ensuring environment variables are checked beforehand.

```bash
cd app/metabase; make up
```

--------------------------------

### Start MinIO with Docker Compose via Makefile

Source: https://github.com/pgsty/pigsty/blob/main/app/minio/README.md

This command navigates to the MinIO application directory within the Pigsty project and uses `make up` to start the MinIO service, typically leveraging Docker Compose for orchestration. This is a convenient way to launch MinIO with predefined configurations.

```bash
cd ~/pigsty/app/minio ; make up
```

--------------------------------

### Install Pigsty via cURL

Source: https://github.com/pgsty/pigsty/wiki/Home

This command initiates the installation of Pigsty by downloading and executing the setup script directly from the official repository. It's the recommended quick start method for deploying the latest release.

```bash
curl -fsSL https://repo.pigsty.io/get | bash
```

--------------------------------

### NocoDB Initial Setup via Make

Source: https://github.com/pgsty/pigsty/blob/main/app/nocodb/README.md

This snippet provides the initial commands to set up NocoDB. It instructs the user to navigate into the `app/nocodb` directory and execute `make up` to start the NocoDB service using Docker Compose, emphasizing the importance of checking the `.env` file beforehand.

```bash
# do not forget to check app/nocodb/.env before make up
cd app/nocodb; make up
```

--------------------------------

### Initial PolarDB Setup with Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/polardb/README.md

This snippet provides a quick command to navigate to the PolarDB application directory and start the PolarDB instance using Docker Compose in detached mode. It's the first step for local deployment.

```bash
cd app/polardb; docker compose up -d
```

--------------------------------

### Install MongoDB Shell on RedHat/CentOS

Source: https://github.com/pgsty/pigsty/blob/main/app/ferretdb/README.md

Provides instructions for installing `mongosh` on RedHat-based Linux distributions. It covers adding the official MongoDB repository and installing via `yum`, or directly installing an RPM package.

```bash
cat > /etc/yum.repos.d/mongo.repo <<EOF
[mongodb-org-6.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/6.0/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-6.0.asc
EOF

yum install -y mongodb-mongosh

# or just install via rpm & links
rpm -ivh https://mirrors.tuna.tsinghua.edu.cn/mongodb/yum/el7/RPMS/mongodb-mongosh-1.9.1.x86_64.rpm
```

--------------------------------

### Manage FerretDB with Make Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/ferretdb/README.md

A collection of `make` commands for common FerretDB operations, including starting, stopping, viewing access points, tailing logs, introspecting with `jq`, and managing Docker images (pull, remove, save, load).

```bash
make up         # pull up ferretdb with docker compose in minimal mode
make run        # launch ferretdb with docker , local data dir and external PostgreSQL
make view       # print ferretdb access point
make log        # tail -f ferretdb logs
make info       # introspect ferretdb with jq
make stop       # stop ferretdb container
make clean      # remove ferretdb container
make pull       # pull latest ferretdb image
make rmi        # remove ferretdb image
make save       # save ferretdb image to /tmp/ferretdb.tgz
make load       # load ferretdb image from /tmp
```

--------------------------------

### MinIO Makefile Commands Reference

Source: https://github.com/pgsty/pigsty/blob/main/app/minio/README.md

A comprehensive list of `make` commands available for managing the MinIO service within the Pigsty project. These commands simplify common operations such as starting, stopping, logging, inspecting, and managing Docker images for MinIO.

```APIDOC
make up: pull up minio with docker compose
make run: launch minio with docker
make view: print minio access point
make log: tail -f minio logs
make info: introspect minio with jq
make stop: stop minio container
make clean: remove minio container
make pull: pull latest minio image
make rmi: remove minio image
make save: save minio image to /tmp/docker/minio.tgz
make load: load minio image from /tmp/docker/minio.tgz
```

--------------------------------

### Gitea Docker Compose Makefile Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/gitea/README.md

This section lists various `make` commands designed to streamline the management of the Gitea Docker Compose setup. These commands offer convenient shortcuts for common operations such as starting, stopping, viewing logs, inspecting, and cleaning up Gitea containers and associated data.

```bash
make up      # pull up gitea with docker compose in minimal mode
make run     # launch gitea with docker , local data dir and external PostgreSQL
make view    # print gitea access point
make log     # tail -f gitea logs
make info    # introspect gitea with jq
make stop    # stop gitea container
make clean   # remove gitea container
make rmdata  # remove gitea data: /data/gitea
make pull    # pull latest gitea image
make rmi     # remove gitea image
make save    # save gitea image to /tmp/docker/gitea.tgz
make load    # load gitea image from /tmp/docker/gitea.tgz
```

--------------------------------

### Kong API Gateway Makefile Commands Reference

Source: https://github.com/pgsty/pigsty/blob/main/app/kong/README.md

A comprehensive list of 'make' commands for managing the Kong API Gateway. These commands facilitate various operations including starting, stopping, logging, introspection, and Docker image management, streamlining development and deployment workflows.

```bash
make up         # pull up kong with docker compose
make ui         # run swagger ui container
make log        # tail -f kong logs
make info       # introspect kong with jq
make stop       # stop kong container
make clean      # remove kong container
make rmui       # remove swagger ui container
make pull       # pull latest kong image
make rmi        # remove kong image
make save       # save kong image to /tmp/docker/kong.tgz
make load       # load kong image from /tmp/docker/kong.tgz
```

--------------------------------

### Launch Kong Docker Compose Application

Source: https://github.com/pgsty/pigsty/blob/main/app/kong/README.md

Executes the 'make up' command from the 'app/kong' directory to start the Kong API Gateway using Docker Compose, as defined in its Makefile. This command orchestrates the necessary containers for Kong's operation.

```bash
cd app/kong ; make up
```

--------------------------------

### Start Jupyter Notebook with Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/jupyter/README.md

Navigate to the Jupyter application directory within Pigsty and use the `make` command to create the necessary data directory and bring up the Jupyter service using Docker Compose.

```bash
cd ~/pigsty/app/jupyter ; make dir up
```

--------------------------------

### Initialize FerretDB with Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/ferretdb/README.md

Starts the FerretDB service using Docker Compose from the application directory, running it in detached mode.

```bash
cd app/ferretdb; docker compose up -d
```

--------------------------------

### Start PGWEB Service with Make

Source: https://github.com/pgsty/pigsty/blob/main/app/pgweb/README.md

This command navigates to the PGWEB application directory within the Pigsty project and then executes the 'make up' command to start the PGWEB service, typically using Docker Compose. This is the primary way to launch the application.

```bash
cd ~/pigsty/app/pgweb ; make up
```

--------------------------------

### Launch Odoo Application via Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/odoo/README.md

These `bash` commands are used to finalize the Odoo setup after the initial Pigsty installation. They automate the installation and configuration of Docker and Docker Compose, followed by launching the Odoo application as a containerized service.

```bash
./docker.yml              # install & configure docker & docker-compose
./app.yml                 # install and launch odoo with docker-compose
```

--------------------------------

### Download Pigsty Installer Script

Source: https://github.com/pgsty/pigsty/blob/main/README.md

This `curl` command downloads and executes the main Pigsty installation script from the official repository, then changes the current directory to the newly created `~/pigsty` directory. This is the initial step for a standard Pigsty setup.

```bash
curl -fsSL https://repo.pigsty.io/get | bash; cd ~/pigsty;
```

--------------------------------

### Install Dify and Pigsty Dependencies via Bootstrap

Source: https://github.com/pgsty/pigsty/blob/main/app/dify/README.md

Provides a sequence of bash commands to set up Pigsty, including PostgreSQL, Redis, Docker, and finally Dify, using Pigsty's automated installation scripts. This prepares the environment for Dify deployment.

```bash
curl -fsSL https://repo.pigsty.io/get | bash; cd ~/pigsty
cd ~/pigsty
./bootstrap               # prepare local repo & ansible
./configure -c app/dify   # IMPORTANT: CHANGE CREDENTIALS!!
./install.yml             # install pigsty & pgsql & minio
./redis.yml               # install extra redis instances
./docker.yml              # install docker & docker-compose
./app.yml                 # install dify with docker compose
```

--------------------------------

### Connect to PostgreSQL with Psycopg2 in Python

Source: https://github.com/pgsty/pigsty/blob/main/app/jupyter/README.md

Demonstrates how to establish a connection to a PostgreSQL database using the `psycopg2` library in a Python notebook. It includes an example of executing a simple query and fetching results.

```python
import psycopg2

conn = psycopg2.connect('postgres://dbuser_dba:DBUser.DBA@10.10.10.10:5432/meta')
cursor = conn.cursor()
cursor.execute('SELECT * FROM pg_stat_activity')
for i in cursor.fetchall():
    print(i)
```

--------------------------------

### Install Psycopg2 for PostgreSQL Connection (pip)

Source: https://github.com/pgsty/pigsty/blob/main/app/jupyter/README.md

Install the `psycopg2-binary` and `psycopg2` Python packages using `pip` to enable PostgreSQL database connectivity from within Jupyter. Options for using a mirror and upgrading pip are also provided.

```bash
pip install psycopg2-binary psycopg2

# install with a mirror
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple psycopg2-binary psycopg2

pip install --upgrade pip
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
```

--------------------------------

### Example PostgreSQL Connection URLs for PGWEB

Source: https://github.com/pgsty/pigsty/blob/main/app/pgweb/README.md

These are example connection URLs demonstrating the format for connecting to PostgreSQL databases via PGWEB. They include details such as username, password, host, port, database name, and SSL mode, which can be used to configure connections within the PGWEB interface.

```bash
postgres://dbuser_meta:DBUser.Meta@10.10.10.10:5432/meta?sslmode=disable
postgres://test:test@10.10.10.11:5432/test?sslmode=disable
```

--------------------------------

### Deploy Supabase Stateless Components with Docker

Source: https://github.com/pgsty/pigsty/blob/main/app/supabase/README.md

This snippet executes the Pigsty playbooks to install Docker and Docker Compose, followed by launching the stateless components of Supabase using Docker Compose. This completes the Supabase deployment after the initial Pigsty and database setup.

```bash
./docker.yml   # install docker & docker compose
./app.yml      # launch supabase stateless part with docker compose
```

--------------------------------

### Launch Gitea with Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/gitea/README.md

This command demonstrates how to initiate the Gitea service using Docker Compose. It assumes the user navigates to the `app/gitea` directory, where the necessary Docker Compose configuration files are located, before executing the `make up` command.

```bash
cd app/gitea; make up
```

--------------------------------

### Launch Bytebase using Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/bytebase/README.md

This command initiates Bytebase using Docker Compose, bringing up all necessary services as defined in the `docker-compose.yml` file. It's the primary method for starting Bytebase in a containerized environment.

```bash
make up  # docker compose up
```

--------------------------------

### Jupyter Notebook Management with Make Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/jupyter/README.md

A comprehensive list of `make` commands available for managing the Jupyter Notebook Docker container. These commands cover common operations such as starting, stopping, cleaning, viewing logs, and managing Docker images.

```bash
make up         # pull up jupyter with docker compose
make dir        # create required /data/jupyter and set owner
make run        # launch jupyter with docker
make view       # print jupyter access point
make log        # tail -f jupyter logs
make info       # introspect jupyter with jq
make stop       # stop jupyter container
make clean      # remove jupyter container
make pull       # pull latest jupyter image
make rmi        # remove jupyter image
make save       # save jupyter image to /tmp/docker/jupyter.tgz
make load       # load jupyter image from /tmp/docker/jupyter.tgz
```

--------------------------------

### Create PostgreSQL User and Database for Gitea (Bash)

Source: https://github.com/pgsty/pigsty/blob/main/app/gitea/README.md

These bash commands utilize `bin/pgsql-user` and `bin/pgsql-db` utilities to programmatically create the required PostgreSQL user (`dbuser_gitea`) and database (`gitea`) on the `pg-meta` instance. This automates the setup process for Gitea's external PostgreSQL backend.

```bash
bin/pgsql-user pg-meta dbuser_gitea
bin/pgsql-db   pg-meta gitea
```

--------------------------------

### Download and Initialize Pigsty via Curl

Source: https://github.com/pgsty/pigsty/wiki/Home

This command downloads the Pigsty installation script from the official repository and executes it using `bash`. After successful download, it navigates into the newly created `~/pigsty` directory, preparing for subsequent installation steps.

```bash
curl -fsSL https://repo.pigsty.io/get | bash; cd ~/pigsty;
```

--------------------------------

### NocoDB PostgreSQL Database Provisioning Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/nocodb/README.md

These bash commands demonstrate how to provision the PostgreSQL user and database defined in the YAML configuration. They utilize `bin/pgsql-user` and `bin/pgsql-db` scripts to create `dbuser_noco` and the `noco` database, followed by an example connection string for reference.

```bash
bin/pgsql-user pg-meta dbuser_noco
bin/pgsql-db   pg-meta noco
# postgres://dbuser_noco:DBUser.Noco@10.10.10.10:5432/noco
```

--------------------------------

### Install Pigsty with Supabase Configuration

Source: https://github.com/pgsty/pigsty/blob/main/app/supabase/README.md

This snippet provides the initial steps to download and install Pigsty, specifically configuring it with the `supabase` template. It's crucial to change default passwords in the `pigsty.yml` config file after this step. The `install.yml` command sets up the high-availability PostgreSQL and MinIO clusters required for Supabase.

```bash
curl -fsSL https://repo.pigsty.io/get | bash
cd pigsty
./configure -c supabase  # use app/supa config template (IMPORTANT: CHANGE PASSWORDS!)
./install.yml            # install pigsty, create ha postgres & minio clusters
```

--------------------------------

### Install Teable and Dependencies using Pigsty

Source: https://github.com/pgsty/pigsty/blob/main/app/teable/README.md

This bash script automates the installation of Pigsty, PostgreSQL, MinIO, Redis, Docker, and finally Teable itself using Docker Compose. Users must remember to change credentials in the `configure` step before proceeding with the installation.

```bash
curl -fsSL https://repo.pigsty.io/get | bash; cd ~/pigsty
cd ~/pigsty
./bootstrap               # prepare local repo & ansible
./configure -c app/teable # IMPORTANT: CHANGE CREDENTIALS!!
./install.yml             # install pigsty & pgsql & minio
./redis.yml               # install extra redis instances
./docker.yml              # install docker & docker-compose
./app.yml                 # install teable with docker compose
```

--------------------------------

### Prepare Jupyter Data Directory

Source: https://github.com/pgsty/pigsty/blob/main/app/jupyter/README.md

Create the required `/data/jupyter` directory and set its ownership to `1000:100` to ensure proper permissions for the Jupyter container.

```bash
make dir   # mkdir -p /data/jupyter; chown -R 1000:100 /data/jupyter
```

--------------------------------

### Common Makefile Commands for Bytebase Operations

Source: https://github.com/pgsty/pigsty/blob/main/app/bytebase/README.md

This section lists various `make` commands available for managing the Bytebase Docker environment. These commands facilitate common operations such as starting, stopping, viewing logs, and managing Docker images, streamlining the development and deployment workflow.

```bash
make up         # pull up bytebase with docker compose in minimal mode
make run        # launch bytebase with docker , local data dir and external PostgreSQL
make view       # print bytebase access point
make log        # tail -f bytebase logs
make info       # introspect bytebase with jq
make stop       # stop bytebase container
make clean      # remove bytebase container
make pull       # pull latest bytebase image
make rmi        # remove bytebase image
make save       # save bytebase image to /tmp/docker/bytebase.tgz
make load       # load bytebase image from /tmp/docker/bytebase.tgz
```

--------------------------------

### grafana.py Utility Script Usage Examples

Source: https://github.com/pgsty/pigsty/blob/main/files/grafana/README.md

This snippet provides command-line examples for using the `grafana.py` script to manage Grafana dashboards. It demonstrates common operations such as initializing baseline dashboards, dumping existing dashboards to a directory, loading dashboards from a directory, and cleaning (removing) target dashboards and folders.

```bash
./grafana.py init       # init pigsty baseline dashboards
./grafana.py dump .     # dump pigsty dashboards to current dir
./grafana.py load .     # load pigsty dashboards from current dir
./grafana.py clean .    # remove target grafana dashboards & folders
```

--------------------------------

### Pigsty Example Database User Definitions

Source: https://github.com/pgsty/pigsty/wiki/Home

Illustrative examples of database user configurations in Pigsty, demonstrating how to define users with specific names, passwords, pgbouncer settings, and assigned roles for various applications.

```YAML
      - {name: dbuser_view     ,password: DBUser.Viewer   ,pgbouncer: true ,roles: [dbrole_readonly], comment: read-only viewer for meta database}
      - {name: dbuser_grafana  ,password: DBUser.Grafana  ,pgbouncer: true ,roles: [dbrole_admin]    ,comment: admin user for grafana database   }
      - {name: dbuser_bytebase ,password: DBUser.Bytebase ,pgbouncer: true ,roles: [dbrole_admin]    ,comment: admin user for bytebase database  }
      - {name: dbuser_kong     ,password: DBUser.Kong     ,pgbouncer: true ,roles: [dbrole_admin]    ,comment: admin user for kong api gateway   }
      - {name: dbuser_gitea    ,password: DBUser.Gitea    ,pgbouncer: true ,roles: [dbrole_admin]    ,comment: admin user for gitea service      }
      - {name: dbuser_wiki     ,password: DBUser.Wiki     ,pgbouncer: true ,roles: [dbrole_admin]    ,comment: admin user for wiki.js service    }
```

--------------------------------

### Initialize PostgREST Service with Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/postgrest/README.md

Navigates to the PostgREST application directory within the Pigsty project and starts the PostgREST service using Docker Compose, bringing up all necessary containers.

```bash
cd ~/pigsty/app/postgrest; make up
```

--------------------------------

### Pig CLI Subcommands for Pigsty Management

Source: https://github.com/pgsty/pigsty/blob/main/README.md

These `pig sty` subcommands offer a streamlined way to perform various Pigsty installation and configuration tasks, including initializing the environment, installing dependencies, generating configuration, and executing the main installation playbook.

```bash
pig sty init     # install embed pigsty to ~/pigsty 
pig sty boot     # install ansible and other pre-deps 
pig sty conf     # auto-generate pigsty.yml config file
pig sty install  # run the install.yml playbook
```

--------------------------------

### Install Pigsty Command-Line Interface (CLI)

Source: https://github.com/pgsty/pigsty/blob/main/README.md

This `curl` command downloads and installs the `pig` CLI tool, which provides a simplified interface for managing Pigsty installations and operations.

```bash
curl -fsSL https://repo.pigsty.io/pig | bash
```

--------------------------------

### Execute Pigsty Bootstrap and Installation Playbooks

Source: https://github.com/pgsty/pigsty/blob/main/README.md

After downloading Pigsty, these commands initiate the bootstrapping process, generate configuration files, and run the `install.yml` Ansible playbook. This sequence completes the core Pigsty installation, assuming an admin user with passwordless SSH and sudo is configured.

```bash
./bootstrap; ./configure; ./install.yml;
```

--------------------------------

### MongoDB Shell Basic Operations with FerretDB

Source: https://github.com/pgsty/pigsty/blob/main/app/ferretdb/README.md

Demonstrates common MongoDB shell commands for interacting with FerretDB. This includes connecting to the database, listing databases, dropping/creating collections, inserting documents with various data types, querying data, and creating indexes.

```bash
$ mongosh mongodb://dbuser_meta:DBUser.Meta@127.0.0.1:27017

show dbs
use test
db.dropDatabase()
db.createCollection('posts')
db.posts.insert({
  title: 'Post One',
  body: 'Body of post one',
  category: 'News',
  tags: ['news', 'events'],
  user: {
    name: 'John Doe',
    status: 'author'
  },
  date: Date()
})

db.posts.find().limit(2).pretty()
db.posts.createIndex({ title: 1 })
```

--------------------------------

### Install Pigsty using cURL

Source: https://github.com/pgsty/pigsty/blob/main/README.md

This command provides a quick and easy way to install Pigsty directly from its repository. It uses cURL to fetch the installation script and then executes it with bash, specifically targeting version v3.5.0. This is the recommended one-command installation method for Pigsty.

```bash
curl -fsSL https://repo.pigsty.io/get | bash -s v3.5.0
```

--------------------------------

### Execute Pigsty Installation Playbooks

Source: https://github.com/pgsty/pigsty/wiki/Home

After downloading and initializing Pigsty, these commands execute the core installation playbooks. `bootstrap` prepares the environment, `configure` generates the necessary configuration, and `install.yml` runs the main Ansible playbook to deploy Pigsty modules.

```bash
./bootstrap; ./configure; ./install.yml;
```

--------------------------------

### Start pg_exporter with Docker Compose

Source: https://github.com/pgsty/pigsty/blob/main/app/pg_exporter/README.md

Navigates to the pg_exporter application directory and starts the pg_exporter service using Docker Compose in detached mode.

```bash
cd ~/pigsty/app/pg_exporter ; docker compose up -d
```

--------------------------------

### Metabase Docker Management Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/metabase/README.md

A collection of `make` commands for comprehensive management of Metabase Docker containers and images. This includes operations like starting, stopping, viewing logs, inspecting, pulling, saving, and loading images.

```bash
make up         # pull up metabase with docker compose
make run        # launch metabase with docker, local data dir and external PostgreSQL
make view       # print metabase access point
make log        # tail -f metabase logs
make info       # introspect metabase with jq
make stop       # stop metabase container
make clean      # remove metabase container
make pull       # pull latest metabase image
make rmi        # remove metabase image
make save       # save metabase image to /tmp/metabase.tgz
make load       # load metabase image from /tmp
```

--------------------------------

### Create Registry Data Directory

Source: https://github.com/pgsty/pigsty/blob/main/app/registry/README.md

Initial setup command to create the necessary data directory for the Docker Registry mirror and set appropriate ownership for the current user.

```bash
sudo mkdir -p /data/registry
sudo chown -R $(whoami):$(whoami) /data/registry
```

--------------------------------

### Initialize PostgreSQL Cluster with Pigsty Playbook

Source: https://github.com/pgsty/pigsty/blob/main/README.md

This bash command initiates the deployment and initialization of the `pg-test` PostgreSQL cluster. It leverages Pigsty's built-in `bin/pgsql-add` playbook, which automates the setup process based on the cluster definition provided in the inventory.

```bash
bin/pgsql-add pg-test   # init pg-test cluster
```

--------------------------------

### Install Specific Pigsty Version via get Script

Source: https://github.com/pgsty/pigsty/blob/main/README.md

This command uses the `get` script to download and install a particular version of Pigsty by passing the desired version string as an argument. This is useful for maintaining consistency or rolling back to a previous release.

```bash
curl -fsSL https://repo.pigsty.io/get | bash -s v3.5.0
```

--------------------------------

### Configure Conda Channels for Psycopg2 Installation

Source: https://github.com/pgsty/pigsty/blob/main/app/jupyter/README.md

Add specific mirror channels to Conda's configuration to facilitate faster and more reliable package downloads, particularly useful when installing `psycopg2` or other packages via Conda.

```bash
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkks/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
```

--------------------------------

### Install Specific Pigsty Version via Curl

Source: https://github.com/pgsty/pigsty/wiki/Home

This command allows users to download and install a specific version of Pigsty by passing the version string as an argument to the `get` script. This is useful for maintaining consistency or rolling back to a known stable version.

```bash
curl -fsSL https://repo.pigsty.io/get | bash -s v3.0.1
```

--------------------------------

### PostgreSQL Database and User Creation (Bash)

Source: https://github.com/pgsty/pigsty/blob/main/app/wiki/README.md

Bash commands to create the 'dbuser_wiki' user and 'wiki' database using custom `pgsql-user` and `pgsql-db` utilities, likely part of a larger infrastructure management script.

```bash
bin/pgsql-user pg-meta dbuser_wiki
bin/pgsql-db   pg-meta wiki
```

--------------------------------

### PGWEB Makefile Management Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/pgweb/README.md

This section lists various `make` commands available for managing the PGWEB application. These commands facilitate common operations such as starting, stopping, viewing logs, and managing Docker images and containers associated with PGWEB, providing a convenient interface for development and deployment tasks.

```bash
make up         # pull up pgweb with docker compose
make run        # launch pgweb with docker
make view       # print pgweb access point
make log        # tail -f pgweb logs
make info       # introspect pgweb with jq
make stop       # stop pgweb container
make clean      # remove pgweb container
make pull       # pull latest pgweb image
make rmi        # remove pgweb image
make save       # save pgweb image to /tmp/docker/pgweb.tgz
make load       # load pgweb image from /tmp/docker/pgweb.tgz
```

--------------------------------

### Initialize Supabase JavaScript Client

Source: https://github.com/pgsty/pigsty/blob/main/app/supabase/client.html

This snippet demonstrates how to initialize the Supabase JavaScript client. It sets up the client instance using a provided Supabase URL and an API key, preparing it for subsequent database interactions.

```javascript
const supabaseUrl = 'http://supa.pigsty'; const supabaseKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAg\nICAgICJyb2xlIjogInNlcnZpY2Vfcm9sZSIs\nICAgICJpc3MiOiAic3VwYWJhc2UtZGVtbyIs\nICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q'; const client = supabase.createClient(supabaseUrl, supabaseKey);
```

--------------------------------

### Establish Logical Replication for Schema and Data Sync

Source: https://github.com/pgsty/pigsty/blob/main/roles/pg_migration/templates/manual.md

These commands facilitate the setup of logical replication between the existing source cluster and the Pigsty-managed destination cluster. They handle schema copying, publication creation on the source, and subscription creation on the destination, enabling real-time data synchronization, with progress and diff checks.

```bash
# these scripts are used for building logical replication
# between existing src cluster and pigsty managed dst cluster
# schema, data will be synced in realtime, except for sequences
./copy-schema    # copy schema to dest
./create-pub     # create publication on src
./create-sub     # create subscription on dst
./copy-progress  # print logical replication progress
./copy-diff      # quick src & dst diff by counting tables
```

--------------------------------

### List Installed Vagrant Box Versions

Source: https://github.com/pgsty/pigsty/blob/main/vagrant/README.md

This command displays a list of Vagrant boxes currently installed on the system, along with their provider, version, and architecture. These specific boxes are used for testing Pigsty deployments.

```bash
$ vagrant box list

el8 :  bento/rockylinux-8     (libvirt, 202502.21.0, (amd64))
el9 :  bento/rockylinux-9     (libvirt, 202502.21.0, (amd64))

d11 :  generic/debian11       (libvirt, 4.3.12, (amd64))
d12 :  generic/debian12       (libvirt, 4.3.12, (amd64))

u20 :  generic/ubuntu2004     (libvirt, 4.3.12, (amd64))
u22 :  generic/ubuntu2204     (libvirt, 4.3.12, (amd64))
u24 :  bento/ubuntu-24.04     (libvirt, 20250316.0.0, (amd64))
```

--------------------------------

### Start, Stop, and Check Service Status

Source: https://github.com/pgsty/pigsty/blob/main/app/registry/README.md

Commands to manage the lifecycle of the Docker Registry mirror service, including starting, stopping, restarting, and checking its current operational status using `make` commands.

```bash
make up
```

```bash
make status
```

--------------------------------

### Pigsty Node Crontab Configuration Example

Source: https://github.com/pgsty/pigsty/wiki/Home

Illustrates how to configure a cron job on a Pigsty node. This specific example schedules a full PostgreSQL backup to run daily at 1 AM using the `pg-backup` utility.

```YAML
    node_crontab:  # make a full backup 1 am everyday
      - '00 01 * * * postgres /pg/bin/pg-backup full'
```

--------------------------------

### Apply and Reload Nginx Configuration

Source: https://github.com/pgsty/pigsty/blob/main/app/wiki/README.md

Bash commands to apply Nginx configuration changes using a custom `infra.yml` script and then gracefully reload the Nginx service on all relevant hosts.

```bash
./infra.yml -t nginx_config
ansible all -b -a 'nginx -s reload'
```

--------------------------------

### Execute Pigsty Commands for Supabase Self-Hosting

Source: https://github.com/pgsty/pigsty/blob/main/README.md

These Bash commands illustrate the sequence to self-host Supabase using Pigsty. It involves configuring Pigsty with the Supabase profile, installing Pigsty, installing Docker Compose, and finally launching the stateless part of Supabase via Docker.

```bash
./configure -c app/supa    # use supabase config 
./install.yml              # install pigsty
./docker.yml               # install docker compose
./app.yml                  # launch supabase stateless part with docker
```

--------------------------------

### Run MinIO Docker Container Directly

Source: https://github.com/pgsty/pigsty/blob/main/app/minio/README.md

This command directly runs a MinIO Docker container, mapping host ports 9000 (API) and 9001 (console) to the container. It sets the root user credentials (admin/pigsty.minio) and specifies the data directory within the container, along with the console address. This provides a standalone MinIO instance for direct use.

```bash
docker run -p 9000:9000 -p 9001:9001 \
  -e "MINIO_ROOT_USER=admin" \
  -e "MINIO_ROOT_PASSWORD=pigsty.minio" \
  minio/minio server /data --console-address ":9001"
```

--------------------------------

### Docker Compose Configuration for Wiki.js

Source: https://github.com/pgsty/pigsty/blob/main/app/wiki/README.md

YAML configuration for a Docker service named 'wiki', specifying the image, environment variables for connecting to an external PostgreSQL database, restart policy, and port mapping.

```yaml
services:
  wiki:
    container_name: wiki
    image: requarks/wiki:2
    environment:
      DB_TYPE: postgres
      DB_HOST: 10.10.10.10
      DB_PORT: 5432
      DB_USER: dbuser_wiki
      DB_PASS: DBUser.Wiki
      DB_NAME: wiki
    restart: unless-stopped
    ports:
      - "9002:3000"
```

--------------------------------

### Configure Pigsty with Various Templates

Source: https://github.com/pgsty/pigsty/blob/main/conf/README.md

Demonstrates how to use the `configure` command with different configuration templates in Pigsty. This includes using the default `meta.yml` template, explicitly specifying single-node templates like `meta`, `rich`, or `slim`, and selecting templates for different database kernels such as PostgreSQL, Citus, MSSQL, PolarDB, IvorySQL, MySQL, OrioleDB, and Supabase. It also shows how to use multi-node HA templates like `dual`, `trio`, and `full`.

```bash
./configure                     # use the meta.yml config template by default
./configure -c meta             # use the meta.yml 1-node template explicitly
./configure -c rich             # use the 1-node template with all extensions & minio
./configure -c slim             # use the minimal 1-node template

# use different kernels
./configure -c pgsql            # Vanilla PostgreSQL kernel with basic features (13~18)
./configure -c citus            # Distributed HA PostgreSQL with the Citus extension (14~17)
./configure -c mssql            # Babelfish kernel with SQL Server wire-compatibility (15)
./configure -c polar            # PolarDB PG kernel for Aurora / RAC flavor postgres (15)
./configure -c ivory            # IvorySQL Kernel for Oracle grammar compatibility (17)
./configure -c mysql            # OpenHalo Kernel for MySQL Compatibility (14)
./configure -c oriole           # OrioleDB Kernel for OLTP Enhancement (17, deb broken)
./configure -c supabase         # PostgreSQL configured for Supabase self-hosting (15~17)

# use multi-node HA templates
./configure -c ha/dual          # use the 2-node HA template
./configure -c ha/trio          # use the 3-node HA template
./configure -c ha/full          # use the 4-node HA template
```

--------------------------------

### Configure Bytebase Environment Variables

Source: https://github.com/pgsty/pigsty/blob/main/app/bytebase/README.md

This snippet shows how to configure essential environment variables for Bytebase, including port, domain, and PostgreSQL connection URL. These variables are typically set in a `.env` file to customize the Bytebase instance's network and database connectivity.

```bash
BB_PORT=8887
BB_DOMAIN=http://ddl.pigsty
BB_PGURL="postgresql://dbuser_bytebase:DBUser.Bytebase@10.10.10.10:5432/bytebase?sslmode=prefer"
```

--------------------------------

### Reload PgAdmin4 Server List

Source: https://github.com/pgsty/pigsty/blob/main/app/pgadmin/README.md

Commands to regenerate the `servers.json` file and restart PgAdmin4 to refresh the server list. Note that PgAdmin launch can be slow, taking 30+ seconds to start.

```bash
./infra.yml -t env_pgadmin
./app.yml -e app=pgadmin -t app_launch -e app_args=reload
```

--------------------------------

### Configure Dify Application and PostgreSQL Resources with Pigsty

Source: https://github.com/pgsty/pigsty/blob/main/app/dify/README.md

Defines the comprehensive YAML configuration for Dify, including environment variables, database connection details, and PostgreSQL user/database creation. It also sets up HBA rules for network access and integrates with other Pigsty components like etcd and MinIO.

```yaml
all:
  children:

    # the dify application (default username & password: admin/admin)
    dify:
      hosts: { 10.10.10.10: {} }
      vars:
        app: dify   # specify app name to be installed (in the apps)
        apps:       # define all applications
          dify:     # app name, should have corresponding ~/app/dify folder
            conf:   # override /opt/dify/.env config file
              # A secret key for signing and encryption, gen with `openssl rand -base64 42` (CHANGE PASSWORD!)
              SECRET_KEY: sk-9f73s3ljTXVcMT3Blb3ljTqtsKiGHXVcMT3BlbkFJLK7U
              DB_USERNAME: dify
              DB_PASSWORD: difyai123456
              DB_HOST: 10.10.10.10
              DB_PORT: 5432
              DB_DATABASE: dify
              VECTOR_STORE: pgvector
              PGVECTOR_HOST: 10.10.10.10
              PGVECTOR_PORT: 5432
              PGVECTOR_USER: dify
              PGVECTOR_PASSWORD: difyai123456
              PGVECTOR_DATABASE: dify
              PGVECTOR_MIN_CONNECTION: 2
              PGVECTOR_MAX_CONNECTION: 10
              NGINX_SERVER_NAME: localhost
              DIFY_PORT: 5001 # expose DIFY nginx service with port 5001 by default
              #STORAGE_TYPE: s3
              #S3_ENDPOINT: 'https://sss.pigsty'
              #S3_BUCKET_NAME: 'dify'
              #S3_ACCESS_KEY: 'dify'
              #S3_SECRET_KEY: 'S3User.Dify'
              #S3_REGION: 'us-east-1'

    pg-meta:
      hosts: { 10.10.10.10: { pg_seq: 1, pg_role: primary } }
      vars:
        pg_cluster: pg-meta
        pg_users:
          - { name: dify ,password: difyai123456 ,pgbouncer: true ,roles: [ dbrole_admin ] ,superuser: true ,comment: dify superuser }
        pg_databases:
          - { name: dify ,owner: dify ,revokeconn: true ,comment: dify main database  }
        pg_hba_rules:
          - { user: dify ,db: all ,addr: 172.17.0.0/16  ,auth: pwd ,title: 'allow dify access from local docker network' }
          - { user: dbuser_view , db: all ,addr: infra ,auth: pwd ,title: 'allow grafana dashboard access cmdb from infra nodes' }
    
    infra: { hosts: { 10.10.10.10: { infra_seq: 1 } } }
    etcd:  { hosts: { 10.10.10.10: { etcd_seq: 1 } }, vars: { etcd_cluster: etcd } }
    minio: { hosts: { 10.10.10.10: { minio_seq: 1 } }, vars: { minio_cluster: minio } }
```

--------------------------------

### Common pg_exporter Makefile Commands

Source: https://github.com/pgsty/pigsty/blob/main/app/pg_exporter/README.md

A comprehensive list of `make` commands for managing the pg_exporter Docker container, covering operations like starting, stopping, viewing logs, introspecting, and managing Docker images.

```bash
make up         # pull up pg_exporter with docker compose
make run        # launch pg_exporter with docker
make view       # curl pg_exporter metrics
make log        # tail -f pg_exporter logs
make info       # introspect pg_exporter with jq
make stop       # stop pg_exporter container
make clean      # remove pg_exporter container
make pull       # pull latest pg_exporter image
make rmi        # remove pg_exporter image
make save       # save pg_exporter image to /tmp/pg_exporter.tgz
make load       # load pg_exporter image from /tmp
```

--------------------------------

### Configure Gitea Environment Variables

Source: https://github.com/pgsty/pigsty/blob/main/app/gitea/README.md

This snippet outlines the essential environment variables for customizing Gitea's server settings, SSH port, data directory, and domain. It also includes critical database connection parameters for integrating Gitea with an external PostgreSQL instance.

```bash
GITEA_PORT=8889
GITEA_SSH_PORT=222
GITEA_DATA=/data/gitea
GITEA_DOMAIN=http://git.pigsty

GITEA_DB_TYPE=postgres
GITEA_DB_USER=dbuser_gitea
GITEA_DB_PASSWORD=DBUser.Gitea
GITEA_DB_HOST=10.10.10.10:5432
GITEA_DB_NAME=gitea
GITEA_DB_SSLMODE=disable
```