Added directions for GCP Marketplace

Added directions to guide a user to run locally with with a PostgreSQL Operator deployed via the GCP Marketplace installer. Separated the documentation into two sections: one for deploying the PostgreSQL Operator via the GCP Marketplace, and the other using the Ansible installer. Expanded on how to get keys from the Operator running via the GCP Marketplace, how to set those keys and get the pgo binary, how to setting up access to the API server via a user, and adding namespaces to create a new PostgreSQL with the Operator.

Author: ValClarkson

hugo/content/quickstart/_index.md

@@ -11,16 +11,15 @@ 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 a Marketplace
-- Installation via the Ansible Installer
+ - Installation via [Google Cloud Platform Marketplace](#google-cloud-platform-marketplace)
 
-The marketplaces that include the Crunchy PostgreSQL Operator include:
+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.
 
-- [Crunchy PostgreSQL for GKE](https://console.cloud.google.com/marketplace/details/crunchydata/crunchy-postgresql-operator) - Google Cloud Marketplace
+# Ansible
 
-The marketplaces will get your environment set up quickly, and you can use "Step 5" below to validate your installation.
-
-Below will guide you through the steps for installing and using the PostgreSQL Operator using the Ansible 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
 
@@ -46,6 +45,7 @@ You can download the playbook by cloning the [PostgreSQL Operator git repository
 
 ```shell
 git clone https://github.com/CrunchyData/postgres-operator.git
+cd postgres-operator
 git checkout v4.2.0 # you can substitute this for the version that you want to install
 cd ansible
 ```
@@ -285,3 +285,198 @@ cluster : 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 pgouser1 hippo`.
+
+# Marketplaces
+
+Below is the list of the marketplaces where you can find the Crunchy PostgreSQL Operator:
+
+- Google Cloud Platform Marketplace: [Crunchy PostgreSQL for GKE](https://console.cloud.google.com/marketplace/details/crunchydata/crunchy-postgresql-operator)
+
+Follow the instructions below for the marketplace that you want to use to deploy the Crunchy PostgreSQL Operator.
+
+## Google Cloud Platform Marketplace
+
+The PostgreSQL Operator is installed as part of the [Crunchy PostgreSQL for GKE](https://console.cloud.google.com/marketplace/details/crunchydata/crunchy-postgresql-operator) project that is available in the Google Cloud Platform Marketplace (GCP Marketplace). Please follow the steps deploy to get the PostgreSQL Operator deployed!
+
+### Step 1: Prerequisites
+
+#### Install `Kubectl` and `gcloud` SDK
+
+- [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) is required to execute kube commands with in GKE.
+- [gcloudsdk](https://cloud.google.com/sdk/install) essential command line tools for google cloud
+
+#### Verification
+
+Below are a few steps to check if the PostgreSQL Operator is up and running.
+
+For this example we are deploying the operator into a namespace called `pgo`. First, see that the the Kubernetes Deployment of the Operator exists and is healthy:
+
+```shell
+kubectl -n pgo get deployments
+```
+
+If successful, you should see output similar to this:
+
+```
+NAME READY UP-TO-DATE AVAILABLE AGE
+postgres-operator 1/1 1 1 16h
+```
+
+Next, see if the Pods that run the PostgreSQL Operator are up and running:
+
+```shell
+kubectl -n pgo get pods
+```
+
+If successful, you should see output similar to this:
+
+```
+NAME READY STATUS RESTARTS AGE
+postgres-operator-56d6ccb97-tmz7m 4/4 Running 0 2m
+```
+
+### Step 2: Install the PostgreSQL Operator User Keys
+
+After your operator is deployed via GCP Marketplace you will need to get keys used to secure the Operator REST API. For these instructions we will assume the operator is deployed in a namespace named "pgo" if this in not the case for your operator change the namespace to coencide with where your operator is deployed. Using the `gcloud` utility, ensure you are logged into the GKE cluster that you installed the PostgreSQL Operator into, run the following commands to retrieve the cert and key:
+
+```shell
+kubectl get secret pgo.tls -n pgo -o jsonpath='{.data.tls\.key}' | base64 --decode > /tmp/client.key
+kubectl get secret pgo.tls -n pgo -o jsonpath='{.data.tls\.crt}' | base64 --decode > /tmp/client.crt
+```
+
+### Step 3: Setup PostgreSQL Operator User
+
+The PostgreSQL Operator implements its own role-based access control (RBAC) system for authenticating and authorization PostgreSQL Operator users access to its REST API. A default PostgreSQL Operator user (aka a "pgouser") is created as part of the marketplace installation (these credentials are set during the marketplace deployment workflow).
+
+Create the pgouser file in `${HOME?}/.pgo/<operatornamespace>/pgouser` and insert the user and password you created on deployment of the PostgreSQL Operator via GCP Marketplace. For example, if you set up a user with the username of `username` and a password of `hippo`:
+
+```shell
+username:hippo
+```
+
+### Step 4: Setup Environment variables
+
+The PostgreSQL Operator Client uses several environmental variables to make it easier for interfacing with the PostgreSQL Operator.
+
+Set the environmental variables to use the key / certificate pair that you pulled in Step 2 was deployed via the marketplace. Using the previous examples, You can set up environment variables with the following command:
+
+```shell
+export PGOUSER="${HOME?}/.pgo/pgo/pgouser"
+export PGO_CA_CERT="/tmp/client.crt"
+export PGO_CLIENT_CERT="/tmp/client.crt"
+export PGO_CLIENT_KEY="/tmp/client.key"
+export PGO_APISERVER_URL='https://127.0.0.1:8443'
+```
+
+If you wish to permanently add these variables to your environment, you can run the following command:
+
+```shell
+cat <<EOF >> ~/.bashrc
+export PGOUSER="${HOME?}/.pgo/pgo/pgouser"
+export PGO_CA_CERT="/tmp/client.crt"
+export PGO_CLIENT_CERT="/tmp/client.crt"
+export PGO_CLIENT_KEY="/tmp/client.key"
+export PGO_APISERVER_URL='https://127.0.0.1:8443'
+EOF
+
+source ~/.bashrc
+```
+
+**NOTE**: For macOS users, you must use `~/.bash_profile` instead of `~/.bashrc`
+
+### Step 5: Install the PostgreSQL Operator Client `pgo`
+
+The [`pgo` client](/pgo-client/) provides a helpful command-line interface to perform key operations on a PostgreSQL Operator, such as creating a PostgreSQL cluster.
+
+The `pgo` client can be downloaded from GitHub [Releases](https://github.com/crunchydata/postgres-operator/releases) (subscribers can download it from the [Crunchy Data Customer Portal](https://access.crunchydata.com)).
+
+Note that the `pgo` client's version must match the version of the PostgreSQL Operator that you have deployed. For example, if you have deployed version 4.2.0 of the PostgreSQL Operator, you must use the `pgo` for 4.2.0.
+
+Once you have download the `pgo` client, change the permissions on the file to be executable if need be as shown below:
+
+```shell
+chmod +x pgo
+```
+
+### Step 6: Connect to the PostgreSQL Operator
+
+Finally, let's see if we can connect to the PostgreSQL Operator from the `pgo` client. In order to communicate with the PostgreSQL Operator API server, you will first need to set up a [port forward](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/) to your local environment.
+
+In a new console window, run the following command to set up a port forward:
+
+```shell
+kubectl -n pgo port-forward svc/postgres-operator 8443:8443
+```
+
+Back to your original console window, you can verify that you can connect to the PostgreSQL Operator using the following command:
+
+```shell
+pgo version
+```
+
+If successful, you should see output similar to this:
+
+```
+pgo client version 4.2.0
+pgo-apiserver version 4.2.0
+```
+
+### Step 7: Create a Namespace
+
+We are almost there! You can optionally add a namespace that can be managed by the PostgreSQL Operator to watch and to deploy a PostgreSQL cluster into.
+
+```shell
+pgo create namespace wateringhole
+```
+
+verify the operator has access to the newly added namespace
+
+```shell
+pgo show namespace --all
+```
+
+you should see out put similar to this:
+
+```shell
+pgo username: admin
+namespace useraccess installaccess 
+application-system accessible no access 
+default accessible no access 
+kube-public accessible no access 
+kube-system accessible no access 
+pgo accessible no access
+wateringhole accessible accessible 
+```
+
+### Step 8: Have Some Fun - Create a PostgreSQL Cluster
+
+You are now ready to create a new cluster in the `wateringhole` namespace, try the command below:
+
+```shell
+pgo create cluster -n wateringhole hippo
+```
+
+If successful, you should see output similar to this:
+
+```
+created Pgcluster hippo
+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 wateringhole hippo
+```
+
+When everything is up and running, you should see output similar to this:
+
+```
+cluster : hippo
+Services
+primary (10.97.140.113:5432): UP
+Instances
+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 wateringhole hippo`.