RedHatTraining/rht-labs-docs.git

			@@ -30,7 +30,7 @@

			If you're feeling confident and don't want to follow the step-by-step guide these highlevel instructions should provide a challenge for you:

			2. Clone the repo `git@github.com:rht-labs/enablement-ci-cd.git` which contains the scaffold of the project.
			2. Clone the repo `https://github.com/rht-labs/enablement-ci-cd` which contains the scaffold of the project.

			2. Create `<your-name>-ci-cd`, `<your-name>-dev` and `<your-name>-test` project namespaces using the inventory and run them with the OpenShift Applier to populate the cluster

			@@ -49,9 +49,15 @@
			### Part 1 - Create OpenShift Projects
			> _Using the OpenShift Applier, we will add new project namespaces to the cluster which will be used throughout the exercise._

			3. Clone the scaffold project to your local machine and open it in your favourite editor.
			3. Clone the scaffold project to your local machine and pull all remote branches for use in later labs. Open the repo in your favourite editor.
			```bash
			git clone git@github.com:rht-labs/enablement-ci-cd.git
			$ git clone https://github.com/rht-labs/enablement-ci-cd && cd enablement-ci-cd
			```
			Followed by;
			```
			$ for branch in `git branch -a \| grep remotes \| grep -v HEAD \| grep -v master`; do
			git branch --track ${branch#remotes/origin/} $branch
			done
			```

			3. The project is laid out as follows
			@@ -78,14 +84,14 @@
			* `templates` is a collection of OpenShift templates
			* `inventory/group_vars/all.yml` is the collection of objects we want to insert into the cluster.
			* `requirements.yml` is a manifest which contains the ansible modules needed to run the playbook
			Open the `inventory/group_vars/all.yml` file; you should see a some variables setup to create the `ci-cd` namespace. This calls the `templates/project-requests.yml` template with the `params/project-requests-ci-cd` parameters. We will add some additional content here but first let's explore the parameters and the template
			Open the `inventory/group_vars/all.yml` file; you should see some variables setup to create the `ci-cd` namespace. This calls the `templates/project-requests.yml` template with the `params/project-requests-ci-cd` parameters. We will add some additional content here but first let's explore the parameters and the template

			3. Open the `params/project-requests-ci-cd` and replace the `<YOUR_NAME or initials>` with your name to create the correstponding projects in the cluster.
			![new-item](../images/exercise1/ci-cd-project-namespace.png)

			3. Create another two params files for `params/project-requests-dev` & `params/project-requests-test` and add the `NAMESPACE=<YOUR_NAME>-dev` && `NAMESPACE=<YOUR_NAME>-test` and update their Display names.
			3. Create another two params files for `params/project-requests-dev` & `params/project-requests-test`. Add `NAMESPACE=<YOUR_NAME>-dev` & `NAMESPACE_DISPLAY_NAME=<YOUR-NAME> Dev` to `params/project-requests-dev`. Add `NAMESPACE=<YOUR_NAME>-test` & `NAMESPACE_DISPLAY_NAME=<YOUR-NAME> Test` to `params/project-requests-test`.

			3. In the `inventory/group_vars/all.yml` file; add the new inventory items for the projects you want to create (dev & test) by adding another object to the content array. You can copy and paste them from the `ci-cd` example and update them accordingly eg
			3. In the `inventory/group_vars/all.yml` file; add the new inventory items for the projects you want to create (dev & test) by adding another object to the content array. You can copy and paste them from the `ci-cd` example and update them accordingly e.g.
			```yaml
			- name: <YOUR_NAME>-dev
			template: "{{ inventory_dir }}/../templates/project-requests.yml"
			@@ -107,13 +113,13 @@
			$ ansible-galaxy install -r requirements.yml --roles-path=roles
			```

			3. Apply the inventory by logging into OpenShift and then running
			3. Apply the inventory by logging into OpenShift and running the following:
			```bash
			$ oc login -p <password> -u <user> <cluster_url>
			$ ansible-playbook roles/openshift-applier/playbooks/openshift-cluster-seed.yml -i inventory/
			```

			3. Once successful you should see an output similar to this ![playbook-success](../images/exercise1/play-book-success.png)
			3. Once successful you should see an output similar to this: ![playbook-success](../images/exercise1/play-book-success.png)

			### Part 2 - Nexus and GitLab
			> _Now that we have our Projects setup; we can start to populate them with Apps to be used in our dev lifecycle_
			@@ -122,7 +128,7 @@
			```bash
			$ git checkout exercise1/git-nexus templates/nexus.yml
			```
			The tempate contains all the things needed to setup a persistent nexus server, exposing a service and route while also creating the persistent volume needed. Have a read through the template; at the bottom you'll see a collection of parameters we will pass to the template.
			The template contains all the things needed to setup a persistent nexus server, exposing a service and route while also creating the persistent volume needed. Have a read through the template; at the bottom you'll see a collection of parameters we will pass to the template.

			4. Add some parameters for running the template by creating a new file in the `params` directory.
			```bash
			@@ -155,23 +161,21 @@
			-e "filter_tags=nexus"
			```

			4. Once successful; login to the cluster and navigate to the `<YOUR_NAME>-ci-cd`. You should see Nexus up and running. You can login with default credentials (admin / admin123) ![nexus-up-and-running](../images/exercise1/nexus-up-and-running.png)
			4. Once successful; login to the cluster through the browser (using cluster URL) and navigate to the `<YOUR_NAME>-ci-cd`. You should see Nexus up and running. You can login with default credentials (admin / admin123) ![nexus-up-and-running](../images/exercise1/nexus-up-and-running.png)

			4. Now lets do the same thing for GitLab to get it up and running. Checkout the template provided by running
			4. Now let's do the same thing for GitLab to get it up and running. Checkout the template and params provided by running
			```bash
			$ git checkout exercise1/gitlab-nexus templates/gitlab.yml
			$ git checkout exercise1/git-nexus templates/gitlab.yml params/gitlab
			```
			Explore the template; it contains the PVC, buildConfig and services. The DeploymentConfig is made up of these apps
			- Redis (3.2.3)
			- PostgreSQL (9.4)
			- GitLab CE (v10.2.3)

			4. Add a new params file in the `params` folder called `gitlab`
			```bash
			$ touch params/gitlab
			```

			4. Open the `params/gitlab` file and add the following params
			4. Open the `params/gitlab` file and complete the following params
			<p class="tip">
			Note - The values here for the LDAP and BIND credentials will be provided by your tutor.
			</p>
			```
			LDAP_BIND_DN=uid=<BIND_USER>,ou=People,dc=<YOUR_DOMAIN>,dc=com
			LDAP_USER_FILTER=(memberof=CN=YourGroup,OU=Users,DC=<YOUR_DOMAIN>,DC=com)
			@@ -193,9 +197,6 @@
			* `<LDAP_DESCRIPTION>` is the description to be used on the sign-in header for GitLab eg "Name LDAP Login"
			* `<GITLAB_ROOT_USER_PASSWORD>` is the root user for GOD access on the GitLab instance eg password123
			* `<GITLAB_URL>` is the endpoint for gitlab. It will take the form `gitlab-<YOUR_NAME>-ci-cd.apps.<ENV_ID>.<YOUR_DOMAIN>.com`
			<p class="tip">
			Note - some of the values here for the LDAP will be provided by your tutor.
			</p>

			4. Create another object in the inventory `all_vars.yml` file to run the build & deploy of this template. Add the following and update the `namespace:` accordingly
			```yaml
			@@ -216,8 +217,7 @@

			4. Once successful; login to the cluster and navigate to the `<YOUR_NAME>-ci-cd`. You should see GitLab up and running. ![gitlab-up-and-running](../images/exercise1/gitlab-up-and-running.png)

			4. Navigate to gitlab. You can login with using your cluster credentials using the LDAP tab displaying your `<LDAP_DESCRIPTION>` from previous steps

			4. Navigate to gitlab. You can login using your cluster credentials using the LDAP tab displaying your `<LDAP_DESCRIPTION>` from previous steps
			![gitlab-ui](../images/exercise1/gitlab-ui.png)

			4. Once logged in create a new project called `enablement-ci-cd` and mark it as internal. Once created; copy out the `git remote add origin ...` instructions for use on the next step.
			@@ -228,20 +228,15 @@

			4. Commit your local project to this new origin by first removing the existing origin (github) where the the project was cloned from. Remember to substitute `<YOUR_NEW_GIT_PROJECT>` accordingly
			```bash
			$ git remote remove origin
			$ git remote add origin <YOUR_NEW_GIT_PROJECT>
			$ git remote set-url origin <YOUR_NEW_GIT_PROJECT>
			$ git add .
			$ git commit -m "Adding git and nexus config"
			$ git push -u origin --all
			```
			Note - When making changes to enablement-ci-cd you should frequently commit the changes to git.

			### Part 3 - Jenkins & s2i
			> _Create a build and deployment config for Jenkins. Add new configuration and plugins to the OCP Stock Jenkins using s2i_

			5. Add the Jenkins Build & Deployment configs to the `enablement-ci-cd` repo by merging the contents `exercise1/jenkins` in
			```bash
			$ git checkout exercise1/jenkins templates/jenkins.yml
			```

			5. Add the Jenkins Build & Deployment configs to the `enablement-ci-cd` repo by merging the contents `exercise1/jenkins` in
			```bash
			@@ -266,7 +261,7 @@
			tags:
			- jenkins
			```
			This configuration if applied now; it will create the deployment configuration needed for Jenkins but the `${NAMESPACE}:${JENKINS_IMAGE_STREAM_TAG}` in the template won't exist yet.
			This configuration, if applied now, will create the deployment configuration needed for Jenkins but the `${NAMESPACE}:${JENKINS_IMAGE_STREAM_TAG}` in the template won't exist yet.

			5. To create this image we will take the supported OpenShift Jenkins Image and bake into it some extra configuration using an [s2i](https://github.com/openshift/source-to-image) builder image. More information on Jenkins s2i is found on the [openshift/jenkins](https://github.com/openshift/jenkins#installing-using-s2i-build) github page. To create an s2i configuration for jenkins, check out the pre-canned configuration source in the `enablement-ci-cd` repo
			```bash
			@@ -298,7 +293,8 @@
			![green-balls.png](../images/exercise1/green-balls.png)
			Why does Jenkins have Blue Balls? More can be found [on reddit](https://www.reddit.com/r/programming/comments/4lu6q8/why_does_jenkins_have_blue_balls/) or the [jenkins blog](https://jenkins.io/blog/2012/03/13/why-does-jenkins-have-blue-balls/)

			5. Before building and deploying Jenkins; add git credentials to the s2i by either adding them to the `template/jenkins.yml` and `params/jenkins` or for simplicity just replace the `<USERNAME>` && `<PASSWORD>` with your ldap credentials.
			5. Before building and deploying the Jenkins s2i; add git credentials to it. These will be used by Jenkins to access the Git Repositories where our apps will be stored. We want Jenkins to be able to push tags to it so write access is required. There are a few ways we can do this; either adding them to the `template/jenkins.yml` as environment Variables and then including them in the `params/jenkins` file. We could also create a token in GitLab and use it as the source secret in the jenkins template.
			But for simplicity just replace the `<USERNAME>` && `<PASSWORD>` in the `jenkins-s2i/configuration/init.groovy` with your ldap credentials as seen below. This init file gets run when Jenkins launches and will setup the credentials for use in our Jobs in the next exercises
			<p class="tip">
			Note in a residency we would not use your GitCredentials for pushing and pulling from Git, A service user would be created for this.
			</p>
			@@ -307,27 +303,22 @@
			gitPassword = System.getenv("GIT_PASSWORD") ?: "<PASSWORD>"
			```

			5. Add a new params file in the `params` folder called `jenkins-s2i`
			```bash
			$ touch params/jenkins-s2i
			```

			5. Open the `params/jenkins-s2i` file and add the following content; replacing variables as appropriate.
			```
			SOURCE_REPOSITORY_URL=<YOUR_ENABLEMENT_REPO>
			NAME=jenkins
			SOURCE_REPOSITORY_CONTEXT_DIR=jenkins-s2i
			IMAGE_STREAM_NAMESPACE=<YOUR_NAME>-ci-cd
			SOURCE_REPOSITORY_USERNAME=<YOUR_LDAP_USERNAME>
			SOURCE_REPOSITORY_PASSWORD=<YOUR_LDAP_PASSWORD>
			SOURCE_REPOSITORY_USERNAME=<BASE64_YOUR_LDAP_USERNAME>
			SOURCE_REPOSITORY_PASSWORD=<BASE64_YOUR_LDAP_PASSWORD>
			```
			where
			* `<YOUR_ENABLEMENT_REPO>` is the full path clone path of the repo where this project is stored (including the https && .git)
			* `<YOUR_NAME>` is the prefix for your `-ci-cd` project.
			* Explore some of the other parameters in `templates/jenkins-s2i.yml`
			* `<YOUR_LDAP_USERNAME>` is the base64encoded username builder pod will use to login and clone the repo with
			* `<YOUR_LDAP_PASSWORD>` is the base64encoded password the builder pod will use to authenticate and clone the repo using
			You can use `echo -n '<YOUR_LDAP_PASSWORD>' \| openssl base64` to encode your username and password accordingly.
			* `<BASE64_YOUR_LDAP_USERNAME>` is the base64encoded username builder pod will use to login and clone the repo with
			* `<BASE64_YOUR_LDAP_PASSWORD>` is the base64encoded password the builder pod will use to authenticate and clone the repo using
			You can use `echo -n '<YOUR_LDAP_PASSWORD>' \| openssl base64` to encode your username and password accordingly. For example 'password' base64 encoded will look like `cGFzc3dvcmQ=`.
			<p class="tip">
			Note in a residency we would not use your GitCredentials for pushing and pulling from Git, A service user would be created for this.
			</p>
			@@ -370,7 +361,7 @@

			6. Create a freesyle job called `hello-world` ![jenkins-new-hello-world](../images/exercise1/jenkins-new-hello-world.png).

			6. On the Source Code Management tab; add your `enablement-ci-cd` git repo and hit the dropdown to add your credentials we baked into the s2i on previous steps`` ![jenkins-scm-git](../images/exercise1/jenkins-scm-git.png).
			6. On the Source Code Management tab; add your `enablement-ci-cd` git repo and hit the dropdown to add your credentials we baked into the s2i on previous steps ![jenkins-scm-git](../images/exercise1/jenkins-scm-git.png)

			6. On the build tab add an Execute Shell step and fill it with `echo "Hello World"` ![jenkins-hello-world](../images/exercise1/jenkins-hello-world.png).