Sample cleanup and minor changes.

Author: ankedia

documentation/4.1/content/samples/domains/domain-home-on-pv/_index.md

@@ -2,7 +2,7 @@
 title: "Domain on PV"
 date: 2019-02-23T17:32:31-05:00
 weight: 4
-description: "Sample for creating a WebLogic domain home on a persistent volume (PV) for deploying the generated WebLogic domain."
+description: "Sample for creating and deploying a WebLogic domain on a persistent volume (PV)."
 ---
 
 {{< table_of_contents >}}
@@ -14,15 +14,15 @@ This sample demonstrates deploying a
  with [Domain creation images]({{< relref "/managing-domains/domain-on-pv/domain-creation-images.md" >}}).
 The Domain on PV sample uses a WebLogic Deploy Tooling (WDT) model to specify your initial WebLogic configuration. 
 
-WDT models are a convenient and simple alternative to WebLogic Scripting Tool (WLST) configuration scripts and templates. They compactly define a WebLogic domain using model files, variable properties files, and application archives files. The WDT model format is described in the open source, [WebLogic Deploy Tooling](https://oracle.github.io/weblogic-deploy-tooling/) GitHub project, and the required directory structure for a WDT archive is specifically discussed [here](https://oracle.github.io/weblogic-deploy-tooling/concepts/archive/).
+WDT models are a convenient and simple alternative to WebLogic Scripting Tool (WLST) configuration scripts and templates. They compactly define a WebLogic domain using model files, variable properties files, and application archive files. The WDT model format is described in the open source, [WebLogic Deploy Tooling](https://oracle.github.io/weblogic-deploy-tooling/) GitHub project, and the required directory structure for a WDT archive is specifically discussed [here](https://oracle.github.io/weblogic-deploy-tooling/concepts/archive/).
 
 For more information on Domain on PV, see the [Domain on PV]({{< relref "/managing-domains/domain-on-pv/_index.md" >}}) user documentation. 
 
 #### Domain on PV domain types (WLS and JRF)
 
 Domain on PV is supported on two types of domains: a standard Oracle WebLogic Server (WLS) domain and an Oracle Fusion Middleware Infrastructure, Java Required Files (JRF) domain. This sample demonstrates both WLS and JRF domain types.
 
-The JRF domain path through the sample includes additional steps required for JRF: deploying an infrastructure database, initializing the database using the Repository Creation Utility (RCU) tool, referencing the infrastructure database from the WebLogic configuration, setting an Oracle Platform Security Services (OPSS) wallet password, and exporting or importing an OPSS wallet file. JRF domains may be used by Oracle products that layer on top of WebLogic Server, such as SOA and OSB.
+The JRF domain path through the sample includes additional steps required for JRF: deploying an infrastructure database, referencing the infrastructure database from the WebLogic configuration, setting an Oracle Platform Security Services (OPSS) wallet password, and exporting or importing an OPSS wallet file. JRF domains may be used by Oracle products that layer on top of WebLogic Server, such as SOA and OSB.
 
 #### Sample directory structure
 
@@ -32,10 +32,10 @@ Location | Description |
 ------------- | ----------- |
 `kubernetes/samples/scripts/create-weblogic-domain/domain-on-pv/domain-resources` | JRF and WLS Domain YAML files. |
 `kubernetes/samples/scripts/create-weblogic-domain/wdt-artifacts/archives` | Source code location for WebLogic Deploy Tooling application ZIP archives. |
-`kubernetes/samples/scripts/create-weblogic-domain/wdt-artifacts/wdt-model-files` | Staging for each model image's WDT YAML files, WDT properties, and WDT archive ZIP files. The directories in `model images` are named for their respective images. |
+`kubernetes/samples/scripts/create-weblogic-domain/wdt-artifacts/wdt-model-files` | Staging for each domain creation image's WDT YAML files, WDT properties, and WDT archive ZIP files. The directories in `wdt-model-files` are named for their respective images. |
 `kubernetes/samples/scripts/create-weblogic-domain/ingresses` | Ingress resources. |
 `kubernetes/samples/scripts/domain-lifecycle/opss-wallet.sh` | Utility script for exporting or importing a JRF domain OPSS wallet file. |
-`kubernetes/samples/scripts/domain-lifecycle/waitForDomain.sh` | Utility script that optionally waits for the pods in a domain to reach their expected `restartVersion`, `introspectVersion`, `Completed`, `image`, and `ready` state. |
+`kubernetes/samples/scripts/domain-lifecycle/waitForDomain.sh` | Utility script that optionally waits for the pods in a domain to reach their expected `Completed`, `image`, and `ready` state. |
 `kubernetes/samples/scripts/domain-lifecycle/domain-on-pv-helper.sh` | Utility script to examine or clean up the contents of shared directories on the persistent volume. |
 
 #### Ensuring your Kubernetes cluster can access images

documentation/4.1/content/samples/domains/domain-home-on-pv/prerequisites.md

@@ -120,7 +120,6 @@ To do this, follow the same steps as the [Quick Start](https://oracle.github.io/
        ```
        $ kubectl apply -f https://raw.githubusercontent.com/oracle/weblogic-kubernetes-operator/{{< latestMinorVersion >}}/kubernetes/samples/scripts/create-weblogic-domain/ingresses/traefik-ingress-sample-domain1-admin-server.yaml
        $ kubectl apply -f https://raw.githubusercontent.com/oracle/weblogic-kubernetes-operator/{{< latestMinorVersion >}}/kubernetes/samples/scripts/create-weblogic-domain/ingresses/traefik-ingress-sample-domain1-cluster-cluster-1.yaml
-       $ kubectl apply -f https://raw.githubusercontent.com/oracle/weblogic-kubernetes-operator/{{< latestMinorVersion >}}/kubernetes/samples/scripts/create-weblogic-domain/ingresses/traefik-ingress-sample-domain2-cluster-cluster-1.yaml
        ```
 
    **NOTE**: We give each cluster ingress a different host name that is decorated using both its operator domain UID and its cluster name. This makes each cluster uniquely addressable even when cluster names are the same across different clusters.  When using `curl` to access the WebLogic domain through the ingress, you will need to supply a host name header that matches the host names in the ingress.
@@ -160,19 +159,19 @@ for the Domain on PV sample.
 
 **NOTE**: The requirements in this section are in addition to [Prerequisites for WLS and JRF domain types](#prerequisites-for-wls-and-jrf-domain-types).
 
-A JRF domain requires an infrastructure database, initializing this database with RCU, and configuring your domain to access this database. For more details, see [JRF domain]({{< relref "/managing-domains/working-with-wdt-models/jrf-domain.md" >}}) in user documentation. You must perform all these steps _before_ you create your domain.
+A JRF domain requires an infrastructure database, and configuring your domain to access this database. For more details, see [JRF domain]({{< relref "/managing-domains/working-with-wdt-models/jrf-domain.md" >}}) in user documentation. You must perform all these steps _before_ you create your domain.
 
 ##### Set up and initialize an infrastructure database
 
-A JRF domain requires an infrastructure database and requires initializing this database with a schema and a set of tables for each different domain. The following example shows how to set up a database and use the RCU tool to create the infrastructure schemas for two JRF domains. The database is set up with the following attributes:
+A JRF domain requires an infrastructure database and requires initializing this database with a schema and a set of tables for each different domain. The following example shows how to set up a database. The database is set up with the following attributes:
 
 | Attribute | Value |
 | --------- | ----- |
 | database Kubernetes namespace | `default` |
 | database Kubernetes pod | `oracle-db` |
 | database image | `container-registry.oracle.com/database/enterprise:12.2.0.1-slim` |
 | database password | MY_DBA_PASSWORD |
-| infrastructure schema prefixes | `FMW1` and `FMW2` (for domain1 and domain2) |
+| infrastructure schema prefix | `FMW1` (for domain1) |
 | infrastructure schema password | MY_RCU_SCHEMA_PASSWORD |
 | database URL | `oracle-db.default.svc.cluster.local:1521/devpdb.k8s` |
 
@@ -213,66 +212,25 @@ A JRF domain requires an infrastructure database and requires initializing this
 
      **WARNING:** The Oracle Database images are supported only for non-production use. For more details, see My Oracle Support note: Oracle Support for Database Running on Docker (Doc ID 2216342.1).
 
-
-1. Use the sample script `create-rcu-schema.sh` in `/tmp/weblogic-kubernetes-operator/kubernetes/samples/scripts/create-rcu-schema` to create an RCU schema for each domain (schema prefixes `FMW1` and `FMW2`) in the database.
-
-   This script starts a pod named `rcu` in the `default` namespace (the same namespace as the database)
-   and executes RCU setup script `createRepository.sh`.
-   It assumes that the database URL is `oracle-db.default.svc.cluster.local:1521/devpdb.k8s` and the namespace is `default` by default.
-
-   - First, create a secret in the `default` namespace
-     which contains the database's SYSDBA username and password
-     in the secret's `sys_username` and `sys_password` fields,
-     and also contains the password of your choice for RCU schemas:
-     - In the local shell:
-       ```shell
-       $ kubectl -n default create secret generic oracle-rcu-secret \
-         --from-literal='sys_username=sys' \
-         --from-literal='sys_password=MY_DBA_PASSWORD' \
-         --from-literal='password=MY_RCU_SCHEMA_PASSWORD'
-       ```
-     - Replace MY_DBA_PASSWORD with the same value that you chose when deploying the database.
-     - Replace MY_RCU_SCHEMA_PASSWORD with your choice of RCU schema password.
-     - Oracle passwords can contain upper case, lower case, digits, and special characters.
-       Use only `_` and `#` as special characters to eliminate potential parsing errors in Oracle connection strings.
-     - __Note__: Record or memorize the values you chose for MY_DBA_PASSWORD and MY_RCU_SCHEMA_PASSWORD. They will be be needed again in other parts of this sample.
-
-   - Second, run the script twice, once for each RCU schema prefix:
-     ```shell
-     $ cd /tmp/weblogic-kubernetes-operator/kubernetes/samples/scripts/create-rcu-schema
-     ```
-     ```shell
-     $ ./create-rcu-schema.sh -s FMW1 -i container-registry.oracle.com/middleware/fmw-infrastructure:12.2.1.4
-     ```
-     ```shell
-     $ ./create-rcu-schema.sh -s FMW2 -i container-registry.oracle.com/middleware/fmw-infrastructure:12.2.1.4
-     ```
-
-   __NOTES__:
-   - If your Kubernetes cluster nodes do not all have access to the FMW infrastructure image in a local cache, then deploy a Kubernetes `docker secret` to the default namespace with login credentials for `container-registry.oracle.com`, and pass the name of this secret as a parameter to `./create-rcu-schema.sh` using `-p your-image-pull-secret`. Alternatively, copy the FMW infrastructure image to each local Docker cache in the cluster. For more information, see the [Cannot pull image FAQ]({{<relref "/faq/cannot-pull-image">}}).
-   - If you need to drop the repositories, use these commands:
-     ```shell
-     $ ./drop-rcu-schema.sh -s FMW1
-     ```
-     ```shell
-     $ ./drop-rcu-schema.sh -s FMW2
-     ```
-     The drop command implicitly uses the same `rcu` pod and the same database credentials `oracle-rcu-secret` secret that
-     you set up when you created the RCU schema.
-
-
 ##### Important considerations for RCU model attributes, Domain fields, and secrets
 
 To allow the operator to access the database and OPSS wallet, you must create an RCU access secret containing the database connect string, user name, and password that's referenced from your model and an OPSS wallet password secret that's referenced from your Domain before deploying your domain.  It's also necessary to define an `RCUDbInfo` stanza in your model.
 
-The sample includes examples of JRF models and Domain YAML files in the `/tmp/sample/model-images` and `/tmp/sample/domain-resources` directories, and instructions in the following sections will describe setting up the RCU and OPSS secrets.
+The sample includes examples of JRF models and Domain YAML files in the `/tmp/sample/wdt-artifacts/wdt-model-files` and `/tmp/sample/domain-resources` directories, and instructions in the following sections will describe setting up the RCU and OPSS secrets.
 
 When you follow the instructions in the samples, avoid instructions that are `WLS` only, and substitute `JRF` for `WLS` in the corresponding model image tags and Domain YAML file names.
 
 For example, in this sample:
 
-  - JRF Domain YAML files have an `configuration.opss.walletPasswordSecret` field that references a secret named `sample-domain1-opss-wallet-password-secret`, with a `walletPassword` of your choice.
+  - [JRF Domain YAML](https://raw.githubusercontent.com/oracle/weblogic-kubernetes-operator/{{< latestMinorVersion >}}/kubernetes/samples/scripts/create-weblogic-domain/domain-home-on-pv/domain-resources/JRF/domain-on-pv-JRF-v1.yaml) file has an `configuration.opss.walletPasswordSecret` field that references a secret named `sample-domain1-opss-wallet-password-secret`, with a `walletPassword` of your choice.
+
+  - JRF domain creation image models have below `domainInfo -> RCUDbInfo` stanza that reference a `sample-domain1-rcu-access` secret with appropriate values for attributes `rcu_prefix`, `rcu_schema_password`, and `rcu_db_conn_string` for accessing the Oracle database that you deployed to the default namespace as one of the prerequisite steps.
 
-  - JRF image models have a `domainInfo -> RCUDbInfo` stanza that reference a `sample-domain1-rcu-access` secret with appropriate values for attributes `rcu_prefix`, `rcu_schema_password`, and `rcu_db_conn_string` for accessing the Oracle database that you deployed to the default namespace as one of the prerequisite steps.
+```
+    RCUDbInfo:
+        rcu_prefix: '@@SECRET:@@ENV:DOMAIN_UID@@-rcu-access:rcu_prefix@@'
+        rcu_schema_password: '@@SECRET:@@ENV:DOMAIN_UID@@-rcu-access:rcu_schema_password@@'
+        rcu_db_conn_string: '@@SECRET:@@ENV:DOMAIN_UID@@-rcu-access:rcu_db_conn_string@@'
+```
 
 For important JRF domain information, refer to [JRF domains]({{< relref "/managing-domains/working-with-wdt-models/jrf-domain.md" >}}).

documentation/4.1/content/samples/domains/domain-home-on-pv/sample.md

@@ -60,9 +60,6 @@ Run the following `kubectl` commands to deploy the required secrets:
   __NOTE:__ Substitute a password of your choice for `MY_WEBLOGIC_ADMIN_PASSWORD`. This
   password should contain at least seven letters plus one digit.
 
-  __NOTE:__ Substitute a password of your choice for `MY_RUNTIME_PASSWORD`. It should
-  be unique and different than the admin password, but this is not required.
-
   ```shell
   $ kubectl -n sample-domain1-ns create secret generic \
     sample-domain1-weblogic-credentials \

documentation/4.1/content/samples/domains/model-in-image/_index.md

@@ -16,7 +16,7 @@ your WebLogic domain home prior to deploying your Domain YAML file.
 Instead, Model in Image uses a
 WebLogic Deploy Tooling (WDT) model to specify your WebLogic configuration.
 
-WDT models are a convenient and simple alternative to WebLogic Scripting Tool (WLST) configuration scripts and templates. They compactly define a WebLogic domain using model files, variable properties files, and application archives files. The WDT model format is described in the open source, [WebLogic Deploy Tooling](https://oracle.github.io/weblogic-deploy-tooling/) GitHub project, and the required directory structure for a WDT archive is specifically discussed [here](https://oracle.github.io/weblogic-deploy-tooling/concepts/archive/).
+WDT models are a convenient and simple alternative to WebLogic Scripting Tool (WLST) configuration scripts and templates. They compactly define a WebLogic domain using model files, variable properties files, and application archive files. The WDT model format is described in the open source, [WebLogic Deploy Tooling](https://oracle.github.io/weblogic-deploy-tooling/) GitHub project, and the required directory structure for a WDT archive is specifically discussed [here](https://oracle.github.io/weblogic-deploy-tooling/concepts/archive/).
 
 Furthermore, the Model in Image auxiliary image option lets you supply your WDT models files, WDT variable files, and WDT archives files
 in a small separate image separate from your WebLogic image.

documentation/4.1/content/samples/domains/model-in-image/auxiliary-image-creation.md

@@ -13,7 +13,11 @@ description: "Create WebLogic images using the WebLogic Image Tool and WebLogic
 
 Auxiliary image creation step uses the WebLogic Image Tool to create a Model in Image `auxiliary image`.  This image contains:
 - A WebLogic Deploy Tooling installation (expected in an image's `/auxiliary/weblogic-deploy` directory by default).
-- WDT model YAML file (model), WDT variable (property), and WDT archive ZIP (archive) files (expected in directory `/auxiliary/models` by default).
+- WDT model YAML file (model), WDT variable (property), and WDT archive ZIP (archive) files, expected in directory `/auxiliary/models` by default,
+which can include the following file types:
+   - WDT model YAML file - A declarative definition of the domain configuration.
+   - WDT variable file - A property file that maps names to values. These names can be referenced from the model file to allow a model to be used across environments by applying the variable file for a particular environment to the model.
+   - WDT archive file - A ZIP file containing application binaries and other files and directories needed to run the domain.
 
 ### Auxiliary image creation
 

documentation/4.1/content/samples/domains/model-in-image/cleanup.md

@@ -29,7 +29,7 @@ To remove the resources you have created in these samples:
    $ kubectl delete namespace traefik
    ```
 
-3. If you set up a database for JRF or the Update 4 use case:
+3. If you set up a database for the Update 4 use case:
    ```shell
    $ /tmp/weblogic-kubernetes-operator/kubernetes/samples/scripts/create-oracle-db-service/stop-db-service.sh
    ```
@@ -54,9 +54,3 @@ To remove the resources you have created in these samples:
    ```shell
    $ docker image rm wdt-domain-image:WLS-AI-v2
    ```
-   ```shell
-   $ docker image rm model-in-image:JRF-AI-v1
-   ```
-   ```shell
-   $ docker image rm model-in-image:JRF-AI-v2
-   ```

documentation/4.1/content/samples/domains/model-in-image/initial.md

@@ -10,10 +10,7 @@ weight: 2
 
 In this use case, you set up an initial WebLogic domain. This involves:
 
-  - Using the [auxiliary image](#auxiliary-image) that you previously created, it contains:
-    - A WDT archive ZIP file that contains your applications.
-    - A WDT model that describes your WebLogic configuration.
-    - A WDT installation that contains the binaries for running WDT.
+  - Using the [auxiliary image](#auxiliary-image) that you previously created.
   - Creating secrets for the domain.
   - Creating a Domain YAML file for the domain that references your Secrets, auxiliary image, and a WebLogic image.
 

documentation/4.1/content/samples/domains/model-in-image/update3.md

@@ -59,9 +59,8 @@ Here are the steps for this use case:
      ```shell
      $ cd /tmp/sample/wdt-artifacts/archives/archive-v2
      ```
-     ```
-     # Using the [WDT archive helper tool](#https://oracle.github.io/weblogic-deploy-tooling/userguide/tools/archive_helper/), create the archive in the location that we will use later when we run the WebLogic Image Tool.
-     ```
+     Using the [WDT archive helper tool](https://oracle.github.io/weblogic-deploy-tooling/userguide/tools/archive_helper/), create the archive in the location that we will use later when we run the WebLogic Image Tool.
+     `
      ```shell
      $ /tmp/sample/wdt-artifacts/weblogic-deploy/bin/archiveHelper.sh add application -archive_file=/tmp/sample/wdt-artifacts/wdt-model-files/WLS-v2/archive.zip -source=wlsdeploy/applications/myapp-v2
      ```