There is a browser-friendly version of this documentation at

[postgres-operator.readthedocs.io](https://postgres-operator.readthedocs.io)

* [concepts](docs/index.md)

* [user documentation](docs/user.md)

* [administrator documentation](docs/administrator.md)

* [developer documentation](docs/developer.md)

* [operator configuration reference](docs/reference/operator_parameters.md)

* [cluster manifest reference](docs/reference/cluster_manifest.md)

* [command-line options and environment variables](docs/reference/command_line_and_environment.md)

the rest of the document is a tutorial to get you up and running with the operator on Minikube.

Note that you can also use built-in Kubernetes support in the Docker Desktop

for Mac to follow the steps of this tutorial. You would have to replace

`minikube start` and `minikube delete` with your launch actionsfor the Docker

built-in Kubernetes support.

Note: if you are running on a Mac, you may also use Docker for Mac Kubernetes instead of a docker-machine.

The Postgres [operator](https://coreos.com/blog/introducing-operators.html)

manages PostgreSQL clusters on Kubernetes:

1. The operator watches additions, updates, and deletions of PostgreSQL cluster

manifests and changes the running clusters accordingly. For example, when a

user submits a new manifest, the operator fetches that manifest and spawns a

new Postgres cluster along with all necessary entities such as Kubernetes

StatefulSets and Postgres roles. See this

[Postgres cluster manifest](https://github.com/zalando-incubator/postgres-operator/blob/master/manifests/complete-postgres-manifest.yaml)

for settings that a manifest may contain.

2. The operator also watches updates to [its own configuration](https://github.com/zalando-incubator/postgres-operator/blob/master/manifests/configmap.yaml)

and alters running Postgres clusters if necessary. For instance, if a pod

docker image is changed, the operator carries out the rolling update. That

is, the operator re-spawns one-by-one pods of each StatefulSet it manages

with the new Docker image.

3. Finally, the operator periodically synchronizes the actual state of each

Postgres cluster with the desired state defined in the cluster's manifest.

In order to run the Postgres operator locally in minikube you need to install the following tools:

* [minikube](https://github.com/kubernetes/minikube/releases)

* [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl-binary-via-curl)

Note that you can also use built-in Kubernetes support in the Docker Desktop

for Mac to follow the steps of this tutorial. You would have to replace

`minikube start` and `minikube delete` with your launch actionsfor the Docker

built-in Kubernetes support.

git clone https://github.com/zalando-incubator/postgres-operator.git

cd postgres-operator

minikube start

kubectl create -f manifests/configmap.yaml # configuration

kubectl create -f manifests/operator-service-account-rbac.yaml # identity and permissions

kubectl create -f manifests/postgres-operator.yaml # deployment

kubectl create -f manifests/minimal-postgres-manifest.yaml

export HOST_PORT=$(minikube service acid-minimal-cluster --url | sed 's,.*/,,')

export PGHOST=$(echo $HOST_PORT | cut -d: -f 1)

export PGPORT=$(echo $HOST_PORT | cut -d: -f 2)

export PGPASSWORD=$(kubectl get secret postgres.acid-minimal-cluster.credentials -o 'jsonpath={.data.password}' | base64 -d)

psql -U postgres

minikube delete

We have automated starting the operator and submitting the `acid-minimal-cluster` for you:

cd postgres-operator

./run_operator_locally.sh

The best way to test the operator is to run it in [minikube](https://kubernetes.io/docs/getting-started-guides/minikube/).

Minikube is a tool to run Kubernetes cluster locally.

The operator can be configured with the provided ConfigMap (`manifests/configmap.yaml`).

The following command-line options are supported for the operator:

* **-kubeconfig**

the path to the kubeconfig file. Usually named config, it contains

authorization information as well as the URL of the Kubernetes master.

* **-outofcluster**

run the operator on a client machine, as opposed to a within the cluster.

When running in this mode, the operator cannot connect to databases inside

the cluster, as well as call URLs of in-cluster objects (i.e. teams api

server). Mostly useful for debugging, it also requires setting the

`OPERATOR_NAMESPACE` environment variable for the operator own namespace.

* **-nodatabaseaccess**

disable database access from the operator. Equivalent to the

`enable_database_access` set to off and can be overridden by the

aforementioned operator configuration option.

* **-noteamsapi**

disable access to the teams API. Equivalent to the `enable_teams_api` set to

off can can be overridden by the aforementioned operator configuration

option.

In addition to that, standard [glog

flags](https://godoc.org/github.com/golang/glog) are also supported. For

instance, one may want to add `-alsologtostderr` and `-v=8` to debug the

operator REST calls.

The following environment variables are accepted by the operator:

* **CONFIG_MAP_NAME**

name of the config map where the operator should look for its configuration.

Must be present.

* **OPERATOR_NAMESPACE**

name of the namespace the operator runs it. Overrides autodetection by the

operator itself.

* **WATCHED_NAMESPACE**

the name of the namespace the operator watches. Special '*' character denotes

all namespaces. Empty value defaults to the operator namespace. Overrides the

`watched_namespace` operator parameter.

* **SCALYR_API_KEY**

the value of the Scalyr API key to supply to the pods. Overrides the

`scalyr_api_key` operator parameter.