Merge remote-tracking branch 'origin/updates' into develop

Author: rjeberhard

site/README.md

@@ -1,8 +1,10 @@
-# Oracle WebLogic Server Kubernetes Operator Documentation
+# Oracle WebLogic Server Kubernetes Operator documentation
 
-This directory contains the documentation for the current version of the operator, version 2.0. 
+This directory contains the documentation for the current version of the operator, version 2.0.
 
-If you wish to view documentation for an older version please see:
+If you wish to view documentation for an older version, please see:
 
 * [Version 1.0](v1.0)
-* [Version 1.1](v1.1)
+* [Version 1.1](v1.1)
+
+For a guide to the operator project, refer to this [README](../README.md).

site/creating-domain.md

@@ -80,7 +80,7 @@ Please consult My Oracle Support Doc ID 2349228.1 for up-to-date information abo
 
 ### Creating and managing WebLogic domains
 
-Please see [this page](creating-domain.md) for information about creating and managing domains.
+In this version of the operator, a WebLogic domain can be located either in a persistent volume (PV) or in a Docker image. For examples of each, see the [WebLogic operator samples](../kubernetes/samples/README.md).
 
 ### Modifying domain configurations
 

site/domains.md

@@ -14,6 +14,15 @@ The following prerequisites must be fulfilled before proceeding with the creatio
 ## Storage locations
 Persistent volumes can point to different storage locations, for example NFS servers or a local directory path. The list of available options is listed in the [Kubernetes documentation](https://kubernetes.io/docs/concepts/storage/persistent-volumes/).
 
+**Note regarding HostPath**:
+In a single-node Kubernetes cluster, such as may be used for testing or proof of concept activities, `HOST_PATH` provides the simplest configuration.  In a multinode Kubernetes cluster, a `HOST_PATH` that is located on shared storage mounted by all nodes in the Kubernetes cluster is the simplest configuration.  If nodes do not have shared storage, then NFS is probably the most widely available option.  There are other options listed in the referenced table.
+
+The persistent volume for the domain must be created using the appropriate tools before running the script to create the domain.  In the simplest case, namely the `HOST_PATH` provider, this means creating a directory on the Kubernetes master and ensuring that it has the correct permissions:
+
+```
+$ mkdir -m 777 -p /path/to/domain1PersistentVolume
+```
+
 **Note regarding NFS**:
 In the current GA version, the OCI Container Engine for Kubernetes supports network block storage that can be shared across nodes with access permission RWOnce (meaning that only one can write, others can read only). At this time, the WebLogic on Kubernetes domain created by the WebLogic Server Kubernetes Operator, requires a shared file system to store the WebLogic domain configuration, which MUST be accessible from all the pods across the nodes. As a workaround, you need to install an NFS server on one node and share the file system across all the nodes.
 

site/persistent-volumes.md

@@ -7,6 +7,8 @@ refer to the [User guide](user-guide.md).
 ## Prerequisites
 For this exercise, you’ll need a Kubernetes cluster. If you need help setting one up, check out our [cheat sheet](k8s_setup.md).
 
+The operator uses Helm to create and deploy necessary resources and then run the operator in a Kubernetes cluster. For Helm installation and usage information, see [Using operator Helm charts](helm-charts.md).
+
 You should clone this repository to your local machine so that you have access to the
 various sample files mentioned throughout this guide:
 ```
@@ -92,7 +94,13 @@ $ helm install kubernetes/charts/weblogic-operator \
   --set "domainNamespaces={}" \
   --wait
 ```
-d.  Verify that the operator is up and running by viewing the operator pod's log:
+
+d. Verify that the operator's pod is running, by listing the pods in the operator's namespace. You should see one for the operator.
+```
+$ kubectl get pods -n sample-weblogic-operator-ns
+```
+
+e.  Verify that the operator is up and running by viewing the operator pod's log:
 
 ```
 $ kubectl log -n sample-weblogic-operator-ns -c weblogic-operator deployments/weblogic-operator
@@ -160,47 +168,47 @@ $ ./create-domain.sh -i my-inputs.yaml -o /some/output/directory -e -v
 ```
 
 c.	Confirm that the operator started the servers for the domain:
+* Use `kubectl` to show that the domain resource was created:
 ```
-$ kubectl get pods -n sample-domain1-ns
+$ kubectl describe domain sample-domain1 -n sample-domain1-ns
 ```
 
 After a short time, you will see the Administration Server and Managed Servers running.
-
-* Use `kubectl` to show that the domain resource was created:
 ```
-$ kubectl describe domain sample-domain1 -n sample-domain1-ns
+$ kubectl get pods -n sample-domain1-ns
 ```
-* Verify that the operator's pod is running, by listing the pods in the operator's namespace. You should see one for the operator.
+
+You should also see all the Kubernetes services for the domain.
 ```
-$ kubectl get pods -n sample-weblogic-operator-ns
+$ kubectl get services -n sample-domain1-ns
 ```
 
 d.	Create an Ingress for the domain, in the domain namespace, by using the [sample](../kubernetes/samples/charts/ingress-per-domain/README.md) Helm chart:
 * Use `helm install`, specifying the `domainUID` (`sample-domain1`) and domain namespace (`sample-domain1-ns`) in the `values.yaml` file.
 ```
 $ cd kubernetes/samples/charts
 $ helm install ingress-per-domain --name domain1-ingress --values ingress-per-domain/values.yaml
-``` 
+```
 
 e.	To confirm that the load balancer noticed the new Ingress and is successfully routing to the domain's server pods
     you can hit the URL for the "WebLogic Ready App" which will return a HTTP 200 status code as
-    shown in the example below.  If you used the host-based routing ingress sample you will need to 
+    shown in the example below.  If you used the host-based routing ingress sample you will need to
     provide the hostname in the `-H` option:
 ```
 $ curl -v -H 'host: domain1.org' http://your.server.com:30305/weblogic/

-* 
About to connect() to your.server.com port 30305 (#0)

+*
About to connect() to your.server.com port 30305 (#0)

 *   Trying 10.196.1.64...

 * Connected to your.server.com (10.196.1.64) port 30305 (#0)
 
> GET /weblogic/ HTTP/1.1

 > User-Agent: curl/7.29.0

 > Accept: */*

 > host: domain1.org

-> 
+>
 
< HTTP/1.1 200 OK

 < Content-Length: 0

 < Date: Thu, 20 Dec 2018 14:52:22 GMT
 
< Vary: Accept-Encoding

-< 
* Connection #0 to host your.server.com left intact

+<
* Connection #0 to host your.server.com left intact

 ```
 **Note**: Depending on where your Kubernetes cluster is running, you may need to open firewall ports or
 update security lists to allow ingress to this port.

site/quickstart.md

@@ -31,7 +31,7 @@ presented in the correct order.
 * [Create and manage WebLogic domains](domains.md)
   * [Preparing the Kubernetes cluster to run WebLogic domains](domains.md#preparing-the-kubernetes-cluster-to-run-weblogic-domains)
   * [Important considerations for WebLogic domains in Kubernetes](domains.md#important-considerations-for-weblogic-domains-in-kubernetes)
-  * [Creating and managing WebLogic domains](creating-domain.md)
+  * [Creating and managing WebLogic domains](domains.md#creating-and-managing-weblogic-domains)
   * [Modifying domain configurations](domains.md#modifying-domain-configurations)
   * [Managing lifecycle operations](domains.md#managing-lifecycle-operations-including-shutting-down-and-deleting-domains)
   * [Using WLST](wlst.md)

site/user-guide.md

@@ -17,6 +17,25 @@ If you want to use the second option, which includes the domain directory
 inside the Docker image, then you will need to build your own Docker images
 as described in [this section](#creating-a-custom-image-with-your-domain-inside-the-image).
 
+## Setting up secrets to access the Docker Store
+
+**Note** This version of the operator requires WebLogic Server 12.2.1.3.0 plus patch 28076014, so pulling an unpatched image directly to the Kubernetes cluster is not particularly useful.  However, we have left this information in the documentation for reference purposes. 
+
+In order for Kubernetes to obtain the WebLogic Server Docker image from the Docker Store, which requires authentication, a Kubernetes secret containing the registry credentials must be created. To create a secret with Docker Store credentials, issue the following command:
+
+```
+$ kubectl create secret docker-registry SECRET_NAME
+  -n NAMESPACE
+  --docker-server=index.docker.io/v1/
+  --docker-username=YOUR_USERNAME
+  --docker-password=YOUR_PASSWORD
+  --docker-email=YOUR_EMAIL
+```
+
+In this command, replace the uppercase items with the appropriate values. The `SECRET_NAME` will be needed in later parameter files.  The `NAMESPACE` must match the namespace where the first domain will be deployed, otherwise Kubernetes will not be able to find it.  
+
+It may be preferable to manually pull the image in advance, on each Kubernetes worker node, as described in the next section. 
+If you choose this approach, you do not require the Kubernetes secret.
 
 ## Obtaining standard images from the Docker store