Step 4 - Verify Git Commit

June 28, 2023 - Thomas Jungbauer ( Lastmod: 2024-05-08 ) - 3 min read

Besides checking the source code quality, we should also verify if the commit into Git was done by someone/something we trust. It is a good practice to sign all commits to Git. You need to prepare your Git account and create trusted certificates.

I will not describe how exactly you need to configure Git to sign your commit. Verify the following link to learn more about Signing Commits

Goals

The goals of this step are:

Verify if the last commit has been signed

Prerequisites

Signing public key
Configured Git to verify your gpg signature

When your commit is signed, Git will show that:

Figure 1. Pipeline

Steps

Create the following Secret that contains your PUBLIC key.

kind: Secret
apiVersion: v1
metadata:
  name: gpg-public-key
  namespace: ci
data:
  public.key: >-
    <Base64 PUBLIC GPG KEY> (1)
type: Opaque

1	Public key, containing BEGIN/END lines base64 encoded.

Create the following Task:

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: verify-source-code-commit-signature
  namespace: ci
spec:
  description: This task verifies the latest commit and signature against the gpg
    public key
  params:
    - default: 'registry.redhat.io/openshift-pipelines/pipelines-git-init-rhel8:v1.10.4-4'
      name: gitInit
      type: string
  steps:
  - computeResources: {}
    image: $(params.gitInit)
    name: git-verify
    script: |
      set -x (1)

      gpg --import /workspace/secrets/public.key

      git config --global --add safe.directory /workspace/repository

      git verify-commit HEAD || (echo "Unable to verify commit at HEAD!" && exit 1)
    workingDir: /workspace/repository
  workspaces:
  - name: repository
  - name: secrets (2)

1	The script to verify the signature of the commit,
2	The workspace that mounts the Secret containing the gpg key,

Modify the TriggerTemplate and add the following 3 lines

        workspaces:
...
          - name: secrets
            secret:
              secretName: gpg-public-key (1)

1	The name of the Secret where the public key can be found.

Update the pipeline to execute the task verify-commit-signature, which is running in parallel to the SonarQube scan.

    - name: verify-commit-signature
      runAfter:
        - pull-source-code (1)
      taskRef:
        kind: Task
        name: verify-source-code-commit-signature (2)
      workspaces: (3)
        - name: repository
          workspace: shared-data
        - name: secrets
          workspace: secrets
  workspaces:
    ...
    - name: secrets (4)

1	This task runs after pull-source-code but in parallels with the SonarQube task.
2	Task reference
3	Workspaces that are used in this Task
4	Additional workspace for the Pipeline

The full pipeline objects now look like the following:

Expand me...

The status of the Pipeline now is:

Figure 2. Pipeline

Execute the Pipeline

Let’s update the README.md of our source code again to trigger another PipelineRun.

Now the 3rd task will verify if the commit was signed.

Figure 3. PipelineRun Details

In the logs of the Task, we can see that the commit was signed and could be verified. See:

...
gpg: Good signature from "Thomas Jungbauer <tjungbau@redhat.com>"
...

Figure 4. Signature Verification

Summary

At this stage we have a Pipeline, that pulls our code, does a code analysis, and verifies if the commit has been signed. The very next step is to build the image and push it into an Image Registry.

Managing Certificates using GitOps approach – Jul 4, 2024
The article SSL Certificate Management for OpenShift on AWS explains how to use the Cert-Manager Operator to request and install a new SSL Certificate. This time, I would like to leverage the GitOps approach using the Helm Chart cert-manager I have prepared to deploy the Operator and order new Certificates. I will use an ACME Letsencrypt issuer with a DNS challenge. My domain is hosted at AWS Route 53. However, any other integration can be easily used.
Update Cluster Version using GitOps approach – Jun 7, 2024
During a GitOps journey at one point, the question arises, how to update a cluster? Nowadays it is very easy to update a cluster using CLI or WebUI, so why bother with GitOps in that case? The reason is simple: Using GitOps you can be sure that all clusters are updated to the correct, required version and the version of each cluster is also managed in Git. All you need is the channel you want to use and the desired cluster version. Optionally, you can define the exact image SHA. This might be required when you are operating in a restricted environment.
Multiple Sources for Applications in Argo CD – Jun 2, 2024
Argo CD or OpenShift GitOps uses Applications or ApplicationSets to define the relationship between a source (Git) and a cluster. Typically, this is a 1:1 link, which means one Application is using one source to compare the cluster status. This can be a limitation. For example, if you are working with Helm Charts and a Helm repository, you do not want to re-build (or re-release) the whole chart just because you made a small change in the values file that is packaged into the repository. You want to separate the configuration of the chart with the Helm package. The most common scenarios for multiple sources are (see: Argo CD documentation): Your organization wants to use an external/public Helm chart You want to override the Helm values with your own local values You don’t want to clone the Helm chart locally as well because that would lead to duplication and you would need to monitor it manually for upstream changes. This small article describes three different ways with a working example and tries to cover the advantages and disadvantages of each of them. They might be opinionated but some of them proved to be easier to use and manage.
Installing OpenShift Logging using GitOps – May 24, 2024
OpenShift Logging is one of the more complex things to install and configure on an OpenShift cluster. Not because the service or Operators are so complex to understand, but because of the dependencies logging has. Besides the logging operator itself, the Loki operator is required, the Loki operator requires access to an object storage, that might be configured or is already available. In this article, I would like to demonstrate the configuration of the full stack using an object storage from OpenShift Data Foundation. This means: Installing the logging operator into the namespace openshift-logging Installing the Loki operator into the namespace openshift-operators-redhat Creating a new BackingStore and BucketClass Generating the Secret for Loki to authenticate against the object storage Configuring the LokiStack resource Configuring the ClusterLogging resource All steps will be done automatically. In case you have S3 storage available, or you are not using OpenShift Data Foundation, the setup will be a bit different. For example, you do not need to create a BackingStore or the Loki authentication Secret.
Configure Buckets in MinIO using GitOps – May 17, 2024
MinIO is a simple, S3-compatible object storage, built for high-performance and large-scale environments. It can be installed as an Operator to Openshift. In addition, to a command line tool, it provides a WebUI where all settings can be done, especially creating and configuring new buckets. Currently, this is not possible in a declarative GitOps-friendly way. Therefore, I created the Helm chart minio configurator, that will start a Kubernetes Job, which will take care of the configuration. Honestly, when I say I have created it, the truth is, that it is based on an existing MinIO Chart by Bitnami, that does much more than just set up a bucket. I took out the bucket configuration part, streamlined it a bit and added some new features, which I required. This article shall explain how to achieve this.