Pipelines

Procedure

1. In the Administrator perspective of the web console, navigate to Operators → OperatorHub.

2. Use the Filter by keyword box to search for OpenShift Pipelines Operator in the catalog. Click the OpenShift Pipelines Operator tile.

   Note

   Ensure that you do not select the Community version of the OpenShift Pipelines Operator.

3. Read the brief description about the Operator on the OpenShift Pipelines Operator page. Click Install.

4. On the Create Operator Subscription page:

   1. Select All namespaces on the cluster (default) for the Installation Mode. This mode installs the Operator in the default openshift-operators namespace, which enables the Operator to watch and be made available to all namespaces in the cluster.
   2. Select Automatic for the Approval Strategy. This ensures that the future upgrades to the Operator are handled automatically by the Operator Lifecycle Manager (OLM). If you select the Manual approval strategy, OLM creates an update request. As a cluster administrator, you must then manually approve the OLM update request to update the Operator to the new version.

   3. Select an Update Channel.

      • The ocp-<4.x> channel enables installation of the latest stable release of the OpenShift Pipelines Operator.
      • The preview channel enables installation of the latest preview version of the OpenShift Pipelines Operator, which may contain features that are not yet available from the 4.x update channel.

5. Click Subscribe. You will see the Operator listed on the Installed Operators page.

   Note

   The Operator is installed automatically into the openshift-operators namespace.

6. Verify that the Status is set to Succeeded Up to date to confirm successful installation of OpenShift Pipelines Operator.

Procedure

1. Create a Subscription object YAML file to subscribe a namespace to the OpenShift Pipelines Operator, for example, sub.yaml:

   Example Subscription

   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: openshift-pipelines-operator
     namespace: openshift-operators
   spec:
     channel:  <channel name> 1
     name: openshift-pipelines-operator-rh 2
     source: redhat-operators 3
     sourceNamespace: openshift-marketplace 4

   1

   Specify the channel name from where you want to subscribe the Operator

   2

   Name of the Operator to subscribe to.

   3

   Name of the CatalogSource that provides the Operator.

   4

   Namespace of the CatalogSource. Use openshift-marketplace for the default OperatorHub CatalogSources.

2. Create the Subscription object:

   $ oc apply -f sub.yaml

   The OpenShift Pipelines Operator is now installed in the default target namespace openshift-operators.

Procedure

1. In the Administrator perspective of the web console, navigate to Administration → Custom Resource Definition.
2. Type config.operator.tekton.dev in the Filter by name box to search for the OpenShift Pipelines Operator CRs.
3. Click CRD Config to see the Custom Resource Definition Details page.

4. Click the Actions drop-down menu and select Delete Custom Resource Definition.

   Note

   Deleting the CRs will delete the OpenShift Pipelines components, and all the Tasks and Pipelines on the cluster will be lost.

5. Click Delete to confirm the deletion of the CRs.

Procedure

1. From the Operators → OperatorHub page, use the Filter by keyword box to search for OpenShift Pipelines Operator.
2. Click the OpenShift Pipelines Operator tile. The Operator tile indicates it is installed.
3. In the OpenShift Pipelines Operator descriptor page, click Uninstall.

Procedure

1. Log in to your OpenShift Container Platform cluster:

   $ oc login -u <login> -p <password> https://openshift.example.com:6443

2. Create a project for the sample application. For this example workflow, create the pipelines-tutorial project:

   $ oc new-project pipelines-tutorial

   Note

   If you create a project with a different name, be sure to update the resource URLs used in the example with your project name.

3. View the pipeline ServiceAccount:

   OpenShift Pipelines Operator adds and configures a ServiceAccount named pipeline that has sufficient permissions to build and push an image. This ServiceAccount is used by PipelineRun.

   $ oc get serviceaccount pipeline

Procedure

1. Install the apply-manifests and update-deployment Tasks from the pipelines-tutorial repository, which contains a list of reusable Tasks for Pipelines:

   $ oc create -f https://raw.githubusercontent.com/openshift/pipelines-tutorial/release-tech-preview-1/01_pipeline/01_apply_manifest_task.yaml
   $ oc create -f https://raw.githubusercontent.com/openshift/pipelines-tutorial/release-tech-preview-1/01_pipeline/02_update_deployment_task.yaml

2. Use the tkn task list command to list the Tasks you created:

   $ tkn task list

   The output verifies that the apply-manifests and update-deployment Tasks were created:

   NAME                DESCRIPTION   AGE
   apply-manifests                   1 minute ago
   update-deployment                 48 seconds ago

3. Use the tkn clustertasks list command to list the Operator-installed additional ClusterTasks, for example --buildah and s2i-python-3:

   Note

   You must use a privileged Pod container to run the buildah ClusterTask because it requires a privileged security context. To learn more about security context constraints (SCC) for pods, see the Additional resources section.

   $ tkn clustertasks list

   The output lists the Operator-installed ClusterTasks:

   NAME                       DESCRIPTION   AGE
   buildah                                  1 day ago
   buildah-v0-11-3                          1 day ago
   git-clone                                1 day ago
   jib-maven                                1 day ago
   kn                                       1 day ago
   maven                                    1 day ago
   openshift-client                         1 day ago
   openshift-client-v0-11-3                 1 day ago
   s2i                                      1 day ago
   s2i-dotnet-3                             1 day ago
   s2i-dotnet-3-v0-11-3                     1 day ago
   s2i-go                                   1 day ago
   s2i-go-v0-11-3                           1 day ago
   s2i-java-11                              1 day ago
   s2i-java-11-v0-11-3                      1 day ago
   s2i-java-8                               1 day ago
   s2i-java-8-v0-11-3                       1 day ago
   s2i-nodejs                               1 day ago
   s2i-nodejs-v0-11-3                       1 day ago
   s2i-perl                                 1 day ago
   s2i-perl-v0-11-3                         1 day ago
   s2i-php                                  1 day ago
   s2i-php-v0-11-3                          1 day ago
   s2i-python-3                             1 day ago
   s2i-python-3-v0-11-3                     1 day ago
   s2i-ruby                                 1 day ago
   s2i-ruby-v0-11-3                         1 day ago
   s2i-v0-11-3                              1 day ago
   tkn                                      1 day ago

Procedure

1. Create a PipelineResource that defines the Git repository for the front-end application:

   $ tkn resource create
   ? Enter a name for a pipeline resource : ui-repo
   ? Select a resource type to create : git
   ? Enter a value for url : http://github.com/openshift-pipelines/vote-ui.git
   ? Enter a value for revision : release-tech-preview-1

   The output verifies that the ui-repo PipelineResource was created.

   New git resource "ui-repo" has been created

2. Create a PipelineResource that defines the OpenShift Container Platform internal image registry to where you want to push the front-end image:

   $ tkn resource create
   ? Enter a name for a pipeline resource : ui-image
   ? Select a resource type to create : image
   ? Enter a value for url : image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/ui:latest
   ? Enter a value for digest :

   The output verifies that the ui-image PipelineResource was created.

   New image resource "ui-image" has been created

3. Create a PipelineResource that defines the Git repository for the back-end application:

   $ tkn resource create
   ? Enter a name for a pipeline resource : api-repo
   ? Select a resource type to create : git
   ? Enter a value for url : http://github.com/openshift-pipelines/vote-api.git
   ? Enter a value for revision : release-tech-preview-1

   The output verifies that the api-repo PipelineResource was created.

   New git resource "api-repo" has been created

4. Create a PipelineResource that defines the OpenShift Container Platform internal image registry to where you want to push the back-end image:

   $ tkn resource create
   ? Enter a name for a pipeline resource : api-image
   ? Select a resource type to create : image
   ? Enter a value for url : image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/api:latest
   ? Enter a value for digest :

   The output verifies that the api-image PipelineResource was created.

   New image resource "api-image" has been created

5. View the list of resources created:

   $ tkn resource list

   The output lists all the PipelineResource that were created.

   NAME        TYPE    DETAILS
   api-repo    git     url: http://github.com/openshift-pipelines/vote-api.git
   ui-repo     git     url: http://github.com/openshift-pipelines/vote-ui.git
   api-image   image   url: image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/api:latest
   ui-image    image   url: image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/ui:latest

Procedure

1. Copy the contents of the following sample Pipeline YAML file and save it:

   apiVersion: tekton.dev/v1beta1
   kind: Pipeline
   metadata:
     name: build-and-deploy
   spec:
     resources:
     - name: git-repo
       type: git
     - name: image
       type: image
     params:
     - name: deployment-name
       type: string
       description: name of the deployment to be patched
     tasks:
     - name: build-image
       taskRef:
         name: buildah
         kind: ClusterTask
       resources:
         inputs:
         - name: source
           resource: git-repo
         outputs:
         - name: image
           resource: image
       params:
       - name: TLSVERIFY
         value: "false"
     - name: apply-manifests
       taskRef:
         name: apply-manifests
       resources:
         inputs:
         - name: source
           resource: git-repo
       runAfter:
       - build-image
     - name: update-deployment
       taskRef:
         name: update-deployment
       resources:
         inputs:
         - name: image
           resource: image
       params:
       - name: deployment
         value: $(params.deployment-name)
       runAfter:
       - apply-manifests

   Notice that the Pipeline definition abstracts away the specifics of the Git source repository and image registries to be used during the Pipeline execution.

2. Create the Pipeline:

   $ oc create -f <pipeline-yaml-file-name.yaml>

   Alternatively, you can also execute the YAML file directly from the Git repository:

   $ oc create -f https://raw.githubusercontent.com/openshift/pipelines-tutorial/release-tech-preview-1/01_pipeline/04_pipeline.yaml

3. Use the tkn pipeline list command to verify that the Pipeline is added to the application:

   $ tkn pipeline list

   The output verifies that the build-and-deploy Pipeline was created:

   NAME               AGE            LAST RUN   STARTED   DURATION   STATUS
   build-and-deploy   1 minute ago   ---        ---       ---        ---

Procedure

1. Start the Pipeline for the back-end application:

   $ tkn pipeline start build-and-deploy -r git-repo=api-repo -r image=api-image -p deployment-name=vote-api

   Note the PipelineRun ID returned in the command output.

2. Track the PipelineRun progress:

   $ tkn pipelinerun logs <pipelinerun ID> -f

3. Start the Pipeline for the front-end application:

   $ tkn pipeline start build-and-deploy -r git-repo=ui-repo -r image=ui-image -p deployment-name=vote-ui

   Note the PipelineRun ID returned in the command output.

4. Track the PipelineRun progress:

   $ tkn pipelinerun logs <pipelinerun ID> -f

5. After a few minutes, use tkn pipelinerun list command to verify that the Pipeline ran successfully by listing all the PipelineRuns:

   $ tkn pipelinerun list

   The output lists the PipelineRuns:

    NAME                         STARTED      DURATION     STATUS
    build-and-deploy-run-xy7rw   1 hour ago   2 minutes    Succeeded
    build-and-deploy-run-z2rz8   1 hour ago   19 minutes   Succeeded

6. Get the application route:

   $ oc get route vote-ui --template='http://{{.spec.host}}'

   Note the output of the previous command. You can access the application using this route.

7. To rerun the last PipelineRun, using the PipelineResources and ServiceAccount of the previous Pipeline, run:

   $ tkn pipeline start build-and-deploy --last

Procedure

1. Copy the content of the following sample TriggerBinding YAML file and save it:

   apiVersion: triggers.tekton.dev/v1alpha1
   kind: TriggerBinding
   metadata:
     name: vote-app
   spec:
     params:
     - name: git-repo-url
       value: $(body.repository.url)
     - name: git-repo-name
       value: $(body.repository.name)
     - name: git-revision
       value: $(body.head_commit.id)

2. Create the TriggerBinding:

   $ oc create -f <triggerbinding-yaml-file-name.yaml>

   Alternatively, you can create the TriggerBinding directly from the pipelines-tutorial Git repository:

   $ oc create -f https://raw.githubusercontent.com/openshift/pipelines-tutorial/release-tech-preview-1/03_triggers/01_binding.yaml

3. Copy the content of the following sample TriggerTemplate YAML file and save it:

   apiVersion: triggers.tekton.dev/v1alpha1
   kind: TriggerTemplate
   metadata:
     name: vote-app
   spec:
     params:
     - name: git-repo-url
       description: The git repository url
     - name: git-revision
       description: The git revision
       default: master
     - name: git-repo-name
       description: The name of the deployment to be created / patched
   
     resourcetemplates:
     - apiVersion: tekton.dev/v1alpha1
       kind: PipelineResource
       metadata:
         name: $(params.git-repo-name)-git-repo-$(uid)
       spec:
         type: git
         params:
         - name: revision
           value: $(params.git-revision)
         - name: url
           value: $(params.git-repo-url)
   
     - apiVersion: tekton.dev/v1alpha1
       kind: PipelineResource
       metadata:
         name: $(params.git-repo-name)-image-$(uid)
       spec:
         type: image
         params:
         - name: url
           value: image-registry.openshift-image-registry.svc:5000/pipelines-tutorial/$(params.git-repo-name):latest
   
     - apiVersion: tekton.dev/v1beta1
       kind: PipelineRun
       metadata:
         name: build-deploy-$(params.git-repo-name)-$(uid)
       spec:
         serviceAccountName: pipeline
         pipelineRef:
           name: build-and-deploy
         resources:
         - name: git-repo
           resourceRef:
             name: $(params.git-repo-name)-git-repo-$(uid)
         - name: image
           resourceRef:
             name: $(params.git-repo-name)-image-$(uid)
         params:
         - name: deployment-name
           value: $(params.git-repo-name)

4. Create the TriggerTemplate:

   $ oc create -f <triggertemplate-yaml-file-name.yaml>

   Alternatively, you can create the TriggerTemplate directly from the pipelines-tutorial Git repository:

   $ oc create -f https://raw.githubusercontent.com/openshift/pipelines-tutorial/release-tech-preview-1/03_triggers/02_template.yaml

5. Copy the contents of the following sample EventListener YAML file and save it:

   apiVersion: triggers.tekton.dev/v1alpha1
   kind: EventListener
   metadata:
     name: vote-app
   spec:
     serviceAccountName: pipeline
     triggers:
     - bindings:
       - name: vote-app
       template:
         name: vote-app

6. Create the EventListener:

   $ oc create -f <eventlistener-yaml-file-name.yaml>

   Alternatively, you can create the EvenListener directly from the pipelines-tutorial Git repository:

   $ oc create -f https://raw.githubusercontent.com/openshift/pipelines-tutorial/release-tech-preview-1/03_triggers/03_event_listener.yaml

7. Expose the EventListener service as an OpenShift Container Platform route to make it publicly accessible:

   $ oc expose svc el-vote-app

Procedure

1. Get the Webhook URL:

   $ echo "URL: $(oc  get route el-vote-app --template='http://{{.spec.host}}')"

   Note the URL obtained in the output.

2. Configure Webhooks manually on the front-end repository:

   1. Open the front-end Git repository vote-ui in your browser.
   2. Click Settings → Webhooks → Add Webhook

   3. On the Webhooks/Add Webhook page:

      1. Enter the Webhook URL from step 1 in Payload URL field
      2. Select application/json for the Content type
      3. Specify the secret in the Secret field
      4. Ensure that the Just the push event is selected
      5. Select Active
      6. Click Add Webhook
3. Repeat step 2 for the back-end repository vote-api.

Procedure

1. From the terminal, clone your forked Git repository vote-api:

   $ git clone git@github.com:<your GitHub ID>/vote-api.git -b release-tech-preview-1

2. Push an empty commit:

   $ git commit -m "empty-commit" --allow-empty && git push origin release-tech-preview-1

3. Check if the PipelineRun was triggered:

   $ tkn pipelinerun list

   Notice that a new PipelineRun was initiated.

Procedure

1. In the Pipelines view of the Developer perspective, select a project from the Project drop-down list to see the Pipelines in that project.
2. Click on the required Pipeline to see the Pipeline Details page. This provides a visual representation of all the serial and parallel Tasks in the Pipeline. The Tasks are also listed at the lower right of the page. You can click the listed Tasks to view Task details.

3. Optionally, in the Pipeline Details page:

   • Click the Pipeline Runs tab to see the completed, running, or failed runs for the Pipeline. You can use the Options menu to stop a running Pipeline, to rerun a Pipeline using the same parameters and resources as that of the previous Pipeline execution, or to delete a PipelineRun.
   • Click the Parameters tab to see the parameters defined in the Pipeline. You can also add or edit additional parameters as required.
   • Click the Resources tab to see the resources defined in the Pipeline. You can also add or edit additional resources as required.