Module 4: Pipelines as Code

In the Terminal tab, confirm you are in the correct project:

oc project tekton-workshop-%OPENSHIFT_USERNAME%

Confirm the PAC controller is installed and ready to use.

oc api-resources | grep pipelinesascode

NAME                              SHORTNAME   APIVERSION                          NAMESPACED   KIND
openshiftpipelinesascodes         opac,pac    operator.tekton.dev/v1alpha1        false        OpenShiftPipelinesAsCode
repositories                      repo        pipelinesascode.tekton.dev/v1alpha1 true         Repository

The PAC controller’s public route URL is needed for this excersise, Gitea will use this to send webhook events to OpenShift:

https://pipelines-as-code-controller-openshift-pipelines.%APPS_HOSTNAME_SUFFIX%

Open the Gitea tab again and log in with your credentials if you have been logged out.

If you have closed the Gitea tab - Click on the 'Developer Repository' button below Then, click on 'Sign In' and login via OpenShift as user %OPENSHIFT_USERNAME%/%OPENSHIFT_PASSWORD% Figure 1. Gitea’s start page with sign in

Click your profile avatar in the top right corner, then select Settings.

In the top menubar, click Applications.

Figure 2. Gitea’s settings page

Under Manage access tokens, fill in:

Click Generate token and copy the generated token immediately. It is shown only once.

In the terminal, generate a random webhook secret:

WEBHOOK_SECRET=$(openssl rand -hex 20)
echo "Webhook secret: $WEBHOOK_SECRET"

Copy the value shown. You will need it when creating the Gitea webhook.

Create a Kubernetes Secret that stores both the Gitea token and webhook secret. Replace <your-gitea-token> with the token you copied from Gitea, and <your-webhook-secret> with the value from the previous step:

cat > gitea-pac-secret.yaml << 'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: gitea-pac-secret
  namespace: tekton-workshop-%OPENSHIFT_USERNAME%
type: Opaque
stringData:
  provider.token: "<your-gitea-token>"
  webhook.secret: "<your-webhook-secret>"
EOF

Edit the file(using vim, nano etc) and replace the placeholder values, then apply it:

oc apply -f gitea-pac-secret.yaml

secret/gitea-pac-secret created

Create the Repository resource that links your Gitea repository to OpenShift Pipelines:

cat > coolstuff-repository.yaml << 'EOF'
apiVersion: pipelinesascode.tekton.dev/v1alpha1
kind: Repository
metadata:
  name: coolstuff-app
  namespace: tekton-workshop-%OPENSHIFT_USERNAME%
spec:
  url: "https://gitea-workshop-gitea.%APPS_HOSTNAME_SUFFIX%/%OPENSHIFT_USERNAME%/coolstuff-app"
  git_provider:
    url: "https://gitea-workshop-gitea.%APPS_HOSTNAME_SUFFIX%"
    secret:
      name: "gitea-pac-secret"
      key: "provider.token"
    webhook_secret:
      name: "gitea-pac-secret"
      key: "webhook.secret"
EOF

Apply the Repository:

oc apply -f coolstuff-repository.yaml

repository.pipelinesascode.tekton.dev/coolstuff-app created

Confirm the Repository was created:

oc get repository coolstuff-app

NAME             URL
coolstuff-app    https://gitea-workshop.../userXX/coolstuff-app

Verify that the repository is visible in the Pipelines UI as well. In the OpenShift console, fold out Pipelines and click in Pipelines.

In Gitea, navigate to your coolstuff-app repository and click Settings, then Webhooks.

Click Add webhook, then select Gitea.

Fill in the webhook details as below, leave the other values as default:

Click Add webhook.

In the webhook screen, verify that the webhook has been created.

Click on the pencil on the newly created webhook

Click Test delivery to confirm Gitea can reach the PAC controller.

Verify at the bottom of the screen that all looks good(green checkmark on the webhook).

In the Gitea web UI, navigate to your coolstuff-app repository.

Click Add file button to create a new file.

Set the file path to .tekton/push-pipeline.yaml (include the directory name in the path — Gitea creates the directory automatically).

Click on the first empty row in the file editor in the central view then paste the following PipelineRun template as the file content:

apiVersion: tekton.dev/v1
kind: PipelineRun
metadata:
  name: coolstuff-build-push
  annotations:
    pipelinesascode.tekton.dev/on-event: "[push]"
    pipelinesascode.tekton.dev/on-target-branch: "[main]"
    pipelinesascode.tekton.dev/max-keep-runs: "5"
spec:
  pipelineSpec:
    tasks:
      - name: build
        taskRef:
          resolver: cluster
          params:
            - name: kind
              value: task
            - name: name
              value: build-coolstuff-app
            - name: namespace
              value: tekton-workshop-%OPENSHIFT_USERNAME%
        params:
          - name: app-name
            value: "coolstuff-store-app"
          - name: app-version
            value: "{{ revision }}"
        workspaces:
          - name: source
            workspace: shared-data
      - name: summarize
        runAfter:
          - build
        taskRef:
          resolver: cluster
          params:
            - name: kind
              value: task
            - name: name
              value: summarize-build
            - name: namespace
              value: tekton-workshop-%OPENSHIFT_USERNAME%
        params:
          - name: app-name
            value: "coolstuff-store-app"
          - name: app-version
            value: "{{ revision }}"
        workspaces:
          - name: source
            workspace: shared-data
    workspaces:
      - name: shared-data
  workspaces:
    - name: shared-data
      volumeClaimTemplate:
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 500Mi

Scroll down to the bottom of the page andSet the commit message to Add PAC pipeline definition

Click Commit changes to commit directly to main.

Switch back to the Terminal tab and watch for new PipelineRuns:

oc get pipelinerun -w

NAME                                           SUCCEEDED   REASON    STARTTIME   COMPLETIONTIME
coolstuff-build-push-<revision>-push-...      Unknown     Running   5s
coolstuff-build-push-<revision>-push-...      True        Succeeded 35s         36s

View the logs of the PAC-triggered run:

tkn pipelinerun logs --last -f

[build : validate] === Validating coolstuff-store-app v<commit-sha> ===
[build : validate] Validation passed.
[build : test] All tests passed.
[build : package] Package created: coolstuff-store-app-<commit-sha>.tar.gz
[summarize : summarize] Artifact    : coolstuff-store-app-<commit-sha>.tar.gz
[summarize : summarize] Status      : SUCCESS -- ready for deployment

View the pipeline run in the OpenShift console.

Navigate to Pipelines, then PipelineRuns.

Click on the PipelineRun to see more details, like commit-id, triggering event and SHA.

Figure 5. Details on the PAC run, with SHA

In the Gitea web ui, navigate to your coolstuff-app repository.

Click Add File then New file.

Name the file change.txt and add a line in the file — for example, add a line ## Module 4 update.

Set the commit message to Add module 4 update note.

Instead of committing directly to main, select Create a new branch for this commit. Name the branch feature/module-4-update.

Click Propose file change to create the branch.

Figure 6. New file committed, pull request waiting

Click on new Pull Request to open a pull request to merge your change into the main branch.

Verify that your branch has been created.

Using the terminal verify that no new pipelineRun has been triggered.

Click Create merge commit and then Merge your pull request to main. This will trigger a new pipelineRun.

To fix pipelineRuns on pull request we need to add a trigger to our pipelinerun file in the .tekton folder in Gitea.

We will now update the file to add pull request support as shown below.

Return to the Terminal tab and watch for a new PipelineRun triggered by the push event:

oc get pipelinerun -w

When the run has completed, edit the change.txt file by clickin on the file in the repository and then cliciking on the pencil icon on the right side.

Click on New Pull Request then Click on Create Pull request. This will now trigger a pipelineRun in OpenShift.

In the OpenShift console in the left hand menu fold out Pipelines then click Pipelines. In the center view click on Repositories.

In Gitea, open up the previous pull request.

Click Comment and type /retest in the comment body and submit.

Watch the new run appear:

tkn pipelinerun list | head -5

To cancel a running PipelineRun, post a /cancel comment in the pull request while a run is in progress. PAC cancels all matching running PipelineRuns for that commit.