Difference between pushing a docker image and installing helm image

Question

I need to learn a CI pipeline in which there is a step for building and pushing an image using a Dockerfile and another step for creating a helm chart image in which there is a definition of the image created by the docker file. After that, there's a CD pipeline in which there's an installation of what was created by the helm chart only.

What is the difference between the image created directly by a Dockerfile and the one which is created by the helm chart? Why isn't the Docker image enough?

Answer 1

Amount to effort

To deploy a service on Kubernetes using docker image you need to manually create various configuration files like deployment.yaml. Such files keep on increasing as you have more and more services added to your environment.

In the Helm chart, we can provide a list of all services that we wish to deploy in requirements.yaml file and Helm will ensure that all those services get deployed to the target environment using deployment.yaml, service.yaml & values.yaml files.

Configurations to maintain

Also adding configuration like routing, config maps, secrets, etc becomes manually and requires configuration over-&-above your service deployment.

For example, if you want to add an Nginx proxy to your environment, you need to separately deploy it using the Nginx image and all the proxy configurations for your functional services.

But with Helm charts, this can be achieved by configuring just one file within your Helm chart: ingress.yaml

Flexibility

Using docker images, we need to provide configurations for each environment where we want to deploy our services.

But using the Helm chart, we can just override the properties of the existing helm chart using the environment-specific values.yaml file. This becomes even easier using tools like ArgoCD.

Code-Snippet:

Below is one example of deployment.yaml file that we need to create if we want to deploy one service using docker-image.

Inline, I have also described how you could alternatively populate a generic deployment.yaml template in Helm repository using different files like requirements.yaml and Values.yaml

deployment.yaml for one service

crazy-project/charts/accounts/templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: accounts
spec:
  replicas: 1
  selector:
     matchLabels:
       app.kubernetes.io/name: accounts
       app.kubernetes.io/instance: crazy-project
  template:
     metadata:
       labels:
         app.kubernetes.io/name: accounts
         app.kubernetes.io/instance: crazy-project
     spec:
       serviceAccountName: default
       automountServiceAccountToken: true
       imagePullSecrets:
         - name: regcred
       containers:
       - image: "image.registry.host/.../accounts:1.2144.0"   <-- This version can be fetched from 'requirements.yaml'
         name: accounts
         env:      <-- All the environment variables can be fetched from 'Values.yaml'
         - name: CLUSTERNAME
           value: "com.company.cloud"
         - name: DB_URI
           value: "mongodb://connection-string&replicaSet=rs1"
         imagePullPolicy: IfNotPresent
         volumeMounts:
         - name: secretfiles
           mountPath: "/etc/secretFromfiles"
           readOnly: true
         - name: secret-files
           mountPath: "/etc/secretFromfiles"
           readOnly: true
         ports:
         - name: HTTP
           containerPort: 9586
           protocol: TCP
         resources:
           requests:
             memory: 450Mi
             cpu: 250m
           limits:
             memory: 800Mi
             cpu: 1
       volumes:
       - name: secretFromfiles
         secret:
           secretName: secret-from-files
       - name: secretFromValue
         secret:
           secretName: secret-data-vault
           optional: true
           items:...

Your deployment.yaml in Helm chart could be a generic template(code-snippet below) where the details are populated using values.yaml file.

env:
{{- range $key, $value := .Values.global.envVariable.common }}
    - name: {{ $key }}
      value: {{ $value  | quote }}
    {{- end }}

Your Values.yaml would look like this:

accounts:
  imagePullSecrets:
    - name: regcred
  envVariable:
    service:
      vars:
        spring_data_mongodb_database: accounts_db
        spring_product_name: crazy-project
        ...

Your requirements.yaml would be like below. 'dependencies' are the services that you wish to deploy.

dependencies:
  - name: accounts
    repository: "<your repo>"
    version: "= 1.2144.0"
  - name: rollover
    repository: "<your repo>"
    version: "= 1.2140.0"

The following diagram will help you visualize what I have mentioned above: