Update the Quickstart

Now includes a "very, VERY quickstart" but drives people to use the
container-based installer.

Author: Jonathan S. Katz

docs/content/installation/postgres-operator.md

@@ -13,7 +13,8 @@ If you believe that all the default settings in the installation manifest work
 for you, you can take a chance by running the manifest directly from the
 repository:
 
-```shell
+```
+kubectl create namespace pgo
 kubectl apply -f https://raw.githubusercontent.com/CrunchyData/postgres-operator/master/installers/kubectl/postgres-operator.yml
 ```
 
@@ -66,6 +67,12 @@ By default, the installer will run in the `pgo` Namespace. This can be
 updated in the `postgres-operator.yml` file. **Please ensure that this namespace
 exists before the job is run**.
 
+For example, to create the `pgo` namespace:
+
+```
+kubectl create namespace pgo
+```
+
 The PostgreSQL Operator has the ability to manage PostgreSQL clusters across
 multiple Kubernetes [Namespaces](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/),
 including the ability to add and remove Namespaces that it watches. Doing so
@@ -117,7 +124,7 @@ The deploy job can be used to perform different deployment actions for the
 PostgreSQL Operator. When you run the job it will install the operator by
 default but you can change the deployment action to uninstall or update. The
 `DEPLOY_ACTION` environment variable in the `postgres-operator.yml` file can be
-set to `install`, `update`, and `uninstall`. 
+set to `install`, `update`, and `uninstall`.
 
 
 ### Image Pull Secrets

docs/content/quickstart/_index.md

@@ -11,200 +11,120 @@ Can't wait to try out the PostgreSQL Operator? Let us show you the quickest poss
 
 There are two paths to quickly get you up and running with the PostgreSQL Operator:
 
-- [Installation via Ansible](#ansible)
+- [Installation via the PostgreSQL Operator Installer](#postgresql-operator-installer)
 - Installation via a Marketplace
   - Installation via [Google Cloud Platform Marketplace](#google-cloud-platform-marketplace)
 
 Marketplaces can help you get more quickly started in your environment as they provide a mostly automated process, but there are a few steps you will need to take to ensure you can fully utilize your PostgreSQL Operator environment.
 
-# Ansible
+# PostgreSQL Operator Installer
 
 Below will guide you through the steps for installing and using the PostgreSQL Operator using an installer that works with Ansible.
 
-## Step 1: Prerequisites
+## The Very, VERY Quickstart
 
-### Kubernetes / OpenShift
+If your environment is set up to use hostpath storage (found in things like [minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/) or [OpenShift Code Ready Containers](https://developers.redhat.com/products/codeready-containers/overview), the following command could work for you:
 
-- A Kubernetes or OpenShift environment where you have enough privileges to install an application, i.e. you can add a [ClusterRole](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole). If you're a Cluster Admin, you're all set.
-  - Your Kubernetes version should be 1.13+. **NOTE**: For v4.3.0, while we have updated the PostgreSQL Operator for compatibility with 1.16+, we have not fully tested it.
-  - For OpenShift, the PostgreSQL Operator will work in 3.11+
-- [PersistentVolume](https://kubernetes.io/docs/concepts/storage/persistent-volumes/)s that are available
-
-### Your Environment
-
-- [`kubectl`](https://kubernetes.io/docs/tasks/tools/install-kubectl/) or [`oc`](https://www.okd.io/download.html). Ensure you can access your Kubernetes or OpenShift cluster (this is outside the scope of this document)
-- [`ansible`](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html) 2.8.0+. Learn how to [download ansible](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html)
-- `git`
-- If you are installing to Google Kubernetes Engine, you will need the [`gcloud`](https://cloud.google.com/sdk/install) utility
-
-## Step 2: Configuration
-
-### Get the PostgreSQL Operator Ansible Installation Playbook
-
-You can download the playbook by cloning the [PostgreSQL Operator git repository](https://github.com/CrunchyData/postgres-operator) and running the following commands:
-
-```shell
-git clone https://github.com/CrunchyData/postgres-operator.git
-cd postgres-operator
-git checkout v4.3.0 # you can substitute this for the version that you want to install
-cd ansible
+```
+kubectl create namespace pgo
+kubectl apply -f https://raw.githubusercontent.com/CrunchyData/postgres-operator/master/installers/kubectl/postgres-operator.yml
 ```
 
-### Configure your Installation
-
-Within the `ansible` folder, there exists a file called `inventory`. When you open up this file, you can see several options that are used to install the PostgreSQL Operator. Most of these contain some sensible defaults for getting up and running quickly, but some you will need to fill out yourself.
-
-Lines that start with a `#` are commented out. To activate that configuration setting, you will have to delete the `#`.
+If not, please read onward: you can still get up and running fairly quickly with just a little bit of configuration.
 
-Set up your `inventory` file based on one of the environments that you are deploying to:
+## Step 1: Configuration
 
-#### Kubernetes
+### Get the PostgreSQL Operator Installer Manifest
 
-You will have to uncomment and set the `kubernetes_context` variable. This can be determined based on the output of the `kubectl config current-context` e.g.:
+You will need to download the PostgreSQL Operator Installer manifest to your environment, which you can do with the following command:
 
-```shell
-kubectl config current-context
-kubernetes-admin@kubernetes
 ```
-
-Note that the output will vary based on the Kubernetes cluster you are using.
-
-Using the above example, set the value of `kubernetes_context` to the output of the `kubectl config current-context` command, e.g.
-
-```python
-kubernetes_context="kubernetes-admin@kubernetes"
+curl https://raw.githubusercontent.com/CrunchyData/postgres-operator/master/installers/kubectl/postgres-operator.yml > postgres-operator.yml
 ```
 
-Find the location of the `pgo_admin_password` configuration variable. Set this to a password of your choosing, e.g.
+If you wish to download a specific version of the installer, you can substitute `master` with the version of the tag, i.e.
 
-```python
-pgo_admin_password="hippo-elephant"
 ```
-
-Finally, you will need to set the storage default storage classes that you would like the Operator to use. For example, if your Kubernetes environment is using NFS storage, you would set this variables to the following:
-
-```python
-backrest_storage='nfsstorage'
-backup_storage='nfsstorage'
-primary_storage='nfsstorage'
-replica_storage='nfsstorage'
+curl https://raw.githubusercontent.com/CrunchyData/postgres-operator/v4.3.0/installers/kubectl/postgres-operator.yml > postgres-operator.yml
 ```
 
-For a full list of available storage types that can be used with this installation method, see: $URL
-
-#### OpenShift
-
-For an OpenShfit deployment, you will at a minimum have to to uncomment and set the `openshift_host` variable. This is the location of where your OpenShift environment is, and can be obtained from your administrator. For example:
-
-```python
-openshift_host="https://openshift.example.com:6443"
-```
+### Configure the PostgreSQL Operator Installer
 
-Based on how your OpenShift environment is configured, you may need to set the following variables:
+There are many [configuration parameters]({{< relref "/installation/configuration.md">}}) to help you fine tune your installation, but there are a few that you may want to change to get the PostgreSQL Operator to run in your environment. Open up the `postgres-operator.yml` file and edit a few variables.
 
-- `openshift_user`
-- `openshift_password`
-- `openshift_token`
+Find the `PGO_ADMIN_PASSWORD` variable. This is the password you will use with the [`pgo` client]({{< relref "/installation/pgo-client" >}}) to manage your PostgreSQL clusters. The default is `password`, but you can change it to something like `hippo-elephant`.
 
-An optional `openshift_skip_tls_verify=true` variable is available if your OpenShift environment allows you to skip TLS verification.
+You will need also need to set the storage default storage classes that you would like the PostgreSQL Operator to use. These variables are called `PRIMARY_STORAGE`, `REPLICA_STORAGE`, `BACKUP_STORAGE`, and `BACKREST_STORAGE`. There are several storage configurations listed out in the configuration file under the heading `STORAGE[1-9]_TYPE`. Find the one that you want to use, and set it to that value.
 
-Next, find the location of the `pgo_admin_password` configuration variable. Set this to a password of your choosing, e.g.
+For example, if your Kubernetes environment is using NFS storage, you would set these variables to the following:
 
-```python
-pgo_admin_password="hippo-elephant"
 ```
-
-Finally, you will need to set the storage default storage classes that you would like the Operator to use. For example, if your OpenShift environment is using Rook storage, you would set this variables to the following:
-
-```python
-backrest_storage='rook'
-backup_storage='rook'
-primary_storage='rook'
-replica_storage='rook'
+- name: BACKREST_STORAGE
+  value: "nfsstorage"
+- name: BACKUP_STORAGE
+  value: "nfsstorage"
+- name: PRIMARY_STORAGE
+  value: "nfsstorage"
+- name: REPLICA_STORAGE
+  value: "nfsstorage"
 ```
 
-For a full list of available storage types that can be used with this installation method, see: $URL
+For a full list of available storage types that can be used with this installation method, please review the [configuration parameters]({{< relref "/installation/configuration.md">}}).
 
-#### Google Kubernetes Engine (GKE)
+## Step 2: Installation
 
-For deploying the PostgreSQL Operator to GKE, you will need to set up your cluster similar to the Kubernetes set up. First, you will need to get the value for the `kubernetes_context` variable. Using the `gcloud` utility, ensure you are logged into the GCP Project that you are installing the PostgreSQL Operator into:
+Installation is as easy as executing:
 
-```shell
-gcloud config set project [PROJECT_ID]
 ```
-
-You can read about how you can [get the value of `[PROJECT_ID]`](https://cloud.google.com/resource-manager/docs/creating-managing-projects?visit_id=637125463737632776-3096453244&rd=1#identifying_projects)
-
-From here, you can get the value that needs to be set into the `kubernetes_context`.
-
-You will have to uncomment and set the `kubernetes_context` variable. This can be determined based on the output of the `kubectl config current-context` e.g.:
-
-```shell
-kubectl config current-context
-gke_some-name_some-zone-some_project
+kubectl create namespace pgo
+kubectl apply -f postgres-operator.yml
 ```
 
-Note that the output will vary based on your GKE project.
+This will launch the `pgo-deployer` container that will run the various setup and installation jobs. This can take a few minutes to complete depending on your Kubernetes cluster.
 
-Using the above example, set the value of `kubernetes_context` to the output of the `kubectl config current-context` command, e.g.
+While the installation is occurring, download the `pgo` client set up script. This will help set up your local environment for using the PostgreSQL Operator:
 
-```python
-kubernetes_context="gke_some-name_some-zone-some_project"
 ```
-
-Next, find the location of the `pgo_admin_password` configuration variable. Set this to a password of your choosing, e.g.
-
-```python
-pgo_admin_password="hippo-elephant"
+curl https://raw.githubusercontent.com/CrunchyData/postgres-operator/v4.3.0/installers/kubectl/client-setup.sh > client-setup.sh
+chmod +x client-setup.sh
 ```
 
-Finally, you will need to set the storage default storage classes that you would like the Operator to use. For deploying to GKE it is recommended to use the `gce` storag class:
+When the PostgreSQL Operator is done installing, run the client setup script:
 
-```python
-backrest_storage='gce'
-backup_storage='gce'
-primary_storage='gce'
-replica_storage='gce'
 ```
-## Step 3: Installation
-
-Ensure you are still in the `ansible` directory and run the following command to install the PostgreSQL Operator:
-
-```shell
-ansible-playbook -i inventory --tags=install main.yml
+./client-setup.sh
 ```
 
-This can take a few minutes to complete depending on your Kubernetes cluster.
+This will download the `pgo` client and provide instructions for how to easily use it in your environment. It will prompt you to add some environmental variables for you to set up in your session, which you can do with the following commands:
 
-While the PostgreSQL Operator is installing, for ease of using the `pgo` command line interface, you will need to set up some environmental variables. You can do so with the following command:
 
-```shell
+```
 export PGOUSER="${HOME?}/.pgo/pgo/pgouser"
 export PGO_CA_CERT="${HOME?}/.pgo/pgo/client.crt"
 export PGO_CLIENT_CERT="${HOME?}/.pgo/pgo/client.crt"
 export PGO_CLIENT_KEY="${HOME?}/.pgo/pgo/client.pem"
 export PGO_APISERVER_URL='https://127.0.0.1:8443'
-export PGO_NAMESPACE=pgouser1
+export PGO_NAMESPACE=pgo
 ```
 
 If you wish to permanently add these variables to your environment, you can run the following:
 
-```shell
+```
 cat <<EOF >> ~/.bashrc
 export PGOUSER="${HOME?}/.pgo/pgo/pgouser"
 export PGO_CA_CERT="${HOME?}/.pgo/pgo/client.crt"
 export PGO_CLIENT_CERT="${HOME?}/.pgo/pgo/client.crt"
 export PGO_CLIENT_KEY="${HOME?}/.pgo/pgo/client.pem"
 export PGO_APISERVER_URL='https://127.0.0.1:8443'
-export PGO_NAMESPACE=pgouser1
+export PGO_NAMESPACE=pgo
 EOF
 
 source ~/.bashrc
 ```
 
 **NOTE**: For macOS users, you must use `~/.bash_profile` instead of `~/.bashrc`
 
-## Step 4: Verification
+## Step 3: Verification
 
 Below are a few steps to check if the PostgreSQL Operator is up and running.
 
@@ -255,12 +175,12 @@ pgo client version 4.3.0
 pgo-apiserver version 4.3.0
 ```
 
-## Step 5: Have Some Fun - Create a PostgreSQL Cluster
+## Step 4: Have Some Fun - Create a PostgreSQL Cluster
 
-The quickstart installation method creates two namespaces that you can deploy your PostgreSQL clusters into called `pgouser1` and `pgouser2`. Let's create a new PostgreSQL cluster in `pgouser1`:
+The quickstart installation method creates a namespace called `pgo` where the PostgreSQL Operator manages PostgreSQL clusters. Try creating a PostgreSQL cluster called `hippo`:
 
 ```shell
-pgo create cluster -n pgouser1 hippo
+pgo create cluster -n pgo hippo
 ```
 
 Alternatively, because we set the [`PGO_NAMESPACE`](/pgo-client/#general-notes-on-using-the-pgo-client) environmental variable in our `.bashrc` file, we could omit the `-n` flag from the [`pgo create cluster`](/pgo-client/reference/pgo_create_cluster/) command and just run this:
@@ -281,7 +201,7 @@ workflow id 1cd0d225-7cd4-4044-b269-aa7bedae219b
 This will create a PostgreSQL cluster named `hippo`. It may take a few moments for the cluster to be provisioned. You can see the status of this cluster using the `pgo test` command:
 
 ```shell
-pgo test -n pgouser1 hippo
+pgo test -n pgo hippo
 ```
 
 When everything is up and running, you should see output similar to this:
@@ -294,7 +214,7 @@ cluster : hippo
 		primary (hippo-7b64747476-6dr4h): UP
 ```
 
-The `pgo test` command provides you the basic information you need to connect to your PostgreSQL cluster from within your Kubernetes environment. For more detailed information, you can use `pgo show cluster -n pgouser1 hippo`.
+The `pgo test` command provides you the basic information you need to connect to your PostgreSQL cluster from within your Kubernetes environment. For more detailed information, you can use `pgo show cluster -n pgo hippo`.
 
 # Marketplaces
 

operator/cluster/upgrade.go

@@ -459,7 +459,7 @@ func recreateBackrestRepoSecret(clientset *kubernetes.Clientset, clustername, na
 			ClusterNamespace:    namespace,
 			OperatorNamespace:   operatorNamespace,
 		}); err != nil {
-		log.Errorf("error generating new backrest repo secrets during pgcluster ugprade: %v", err)
+		log.Errorf("error generating new backrest repo secrets during pgcluster upgrade: %v", err)
 	}
 }