Ship faster, safer, smarter. GitOps CI/CD with Tekton & ArgoCD - Part I

Task: a reusable, loosely coupled number of steps that perform a specific task (e.g. building a container image)

Pipeline: the definition of the pipeline and the Tasks that it should perform

TaskRun: the execution and result of running an instance of task

PipelineRun: the execution and result of running an instance of pipeline, which includes a number of TaskRuns

Create custom or install existing reusable Tasks

Create a Pipeline and PipelineResources to define your application’s delivery pipeline

Create a PersistentVolumeClaim to provide the volume/filesystem for pipeline execution or provide a VolumeClaimTemplate which creates a PersistentVolumeClaim

Create a PipelineRun to instantiate and invoke the pipeline

Create the apply-manifests and update-deployment Tasks from the repository using oc or kubectl command.

Run these commands to create Tasks.

You can take a look at the tasks you created using the Tekton CLI (change userX in the command to your username).

tkn task ls

NAME                AGE
apply-manifests     10 seconds ago
update-deployment   4 seconds ago

Go to Pipelines Menu, select Pipelines tab, then click Create button and select Pipeline.

In Pipeline builder, you can create pipeline with GUI or YAML editor. Luckily, we already have the completed YAML for creating a pipeline for this lab. So, let’s switch to YAML view to open YAML editor.

Delete all YAML in the editor. Copy the YAML in this code snippet and paste to the YAML editor, then click Create button.

apiVersion: tekton.dev/v1
kind: Pipeline
metadata:
  name: build-and-deploy
spec:
  workspaces:
  - name: shared-workspace
  params:
  - name: deployment-name
    type: string
    description: name of the deployment to be patched
  - name: git-url
    type: string
    description: url of the git repo for the code of deployment
  - name: git-revision
    type: string
    description: revision to be used from repo of the code for deployment
    default: master
  - name: IMAGE
    type: string
    description: image to be build from the code
  tasks:
  - name: fetch-repository
    taskRef:
      resolver: cluster
      params:
      - name: kind
        value: task
      - name: name
        value: git-clone
      - name: namespace
        value: openshift-pipelines
    workspaces:
    - name: output
      workspace: shared-workspace
    params:
    - name: URL
      value: $(params.git-url)
    - name: SUBDIRECTORY
      value: ""
    - name: DELETE_EXISTING
      value: "true"
    - name: REVISION
      value: $(params.git-revision)
  - name: build-image
    taskRef:
      resolver: cluster
      params:
      - name: kind
        value: task
      - name: name
        value: buildah
      - name: namespace
        value: openshift-pipelines
    params:
    - name: IMAGE
      value: $(params.IMAGE)
    workspaces:
    - name: source
      workspace: shared-workspace
    runAfter:
    - fetch-repository
  - name: apply-manifests
    taskRef:
      name: apply-manifests
    workspaces:
    - name: source
      workspace: shared-workspace
    runAfter:
    - build-image
  - name: update-deployment
    taskRef:
      name: update-deployment
    params:
    - name: deployment
      value: $(params.deployment-name)
    - name: IMAGE
      value: $(params.IMAGE)
    runAfter:
    - apply-manifests

The build-and-deploy Pipeline should be created.

View Pipeline parameter in Parameters tab. You’ll have to set these parameters when you run the pipeline.

In Metrics tab, Pipelines Metrics will help you to monitor performance and status.

Create PersistentVolumeClaim for share workspace in Pipeline. Click on the + button at the top right corner of OpenShift console, then select Import YAML.

Copy this YAML and paste to the editor, then click Create button.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: source-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi

TriggerTemplate - Templates resources to be created (e.g. Create PipelineResources and PipelineRun that uses them)

TriggerBinding - Validates events and extracts payload fields

Trigger - combines TriggerTemplate, TriggerBindings and interceptors.

EventListener - provides an addressable endpoint (the event sink). Trigger is referenced inside the EventListener Spec. It uses the extracted event parameters from each TriggerBinding (and any supplied static parameters) to create the resources specified in the corresponding TriggerTemplate. It also optionally allows an external service to pre-process the event payload via the interceptor field.

ClusterTriggerBinding - A cluster-scoped TriggerBinding

In OpenShift console click on Pipelines menu, select Pipelines tab, then click on action menu of build-to-deploy pipeline, then select start.

Enter simple-rest-go to deployment-name parameter.

Enter https://gitlab.com/chatapazar/simple-rest-go.git to git-url parameter. (Don’t use the URL in the screenshot!)

Enter main to git revision parameter.

Enter image-registry.openshift-image-registry.svc:5000/<project>/simple-rest-go to IMAGE parameter.

Leave Timeouts as default.

In the Workspaces section, select PersistentVolumeClaim and source-pvc for shared-workspace parameter, then click Start button.

The PipelineRun will be created. you can view details by click on each task in PipelineRun to see the details.

Go to Logs tab to view logs from each task.

Wait until the pipeline status changes to Succeeded!

Back to Pipeline menu to view the status of Pipeline and PipelineRun.

Click Topology menu on the left to open Topology view. Select simple-rest-go Deployment, then go to Resources tab on the right panel, then open the application URL in the Routes section.

You should be able to see a response from the application we’ve deployed via OpenShift Pipelines!.

Start a pipeline to build and deploy the application using tkn command line.

tkn pipeline start <pipelinename> \
    --prefix-name <prefixname> \
    -w <share_storage> \
    -p <param=value> \
    --use-param-defaults

Pipelinerun started: <prefixname>-xxxxx

In order to track the pipelinerun progress run:
tkn pipelinerun logs <prefixname>-xxxxx -f -n <project>

Run this command to view all pipelines and statuses.

tkn pipeline list

NAME               AGE              LAST RUN                 STARTED          DURATION   STATUS
build-and-deploy   10 minutes ago   build-and-deploy-9tb2q   47 seconds ago   ---        Running

Above we have started build-and-deploy pipeline, with relevant pipeline resources to deploy the application. Run this command to view PipelineRun status.

tkn pipelinerun ls

NAME                      STARTED         DURATION   STATUS
build-and-deploy-9tb2q    1 minute ago    ---        Running
build-and-deploy-t9tpq    1 minute ago    ---        Running

Check out the logs of the pipelinerun as it runs using the tkn pipeline logs command which interactively allows you to pick the pipelinerun of your interest and inspect the logs:

tkn pipeline logs -f

? Select pipelinerun:  [Use arrows to move, type to filter]
> build-and-deploy-9tb2q started 3 minutes ago
build-and-deploy-t9tpq started 7 minutes ago

After a few minutes, the pipeline should finish successfully. Run this command to view PipelineRun status.

tkn pipelinerun list

NAME                      STARTED         DURATION   STATUS
build-and-deploy-9tb2q    1 minute ago    1m23s      Succeeded
build-and-deploy-t9tpq    5 minutes ago   1m31s      Succeeded

If you want to re-run the pipeline again, you can use the following short-hand command to rerun the last pipelinerun again that uses the same workspaces, params and service account used in the previous pipeline run:

tkn pipeline start build-and-deploy --last