Forem: Ashish Kumar

LRU Cache explained

Ashish Kumar — Sun, 07 Dec 2025 20:22:32 +0000

I made a video on LRU cache.
LINK

Open for feedback, let me know if you have any doubts.
and do tell if you like this way of making videos, made this using
manim, but if you prefer a more face to face explanation of topics then lmk.

here's the link for the actual code
code

Static site in Minutes using Pulumi and Hugo

Ashish Kumar — Mon, 07 Apr 2025 03:19:32 +0000

This is a submission for the Pulumi Deploy and Document Challenge: Fast Static Website Deployment

pulumi): Fast Static Website Deployment*

What I Built

I made my little portfolio website using Pulumi and hugo.

Live Demo Link

portfolio website

Project Repo

github repo

My Journey

I was thinking about having a personal portfolio website for months but was just feeling lazy. I also wanted to explore Pulumi for past few weeks and came across this Dev challenge and decided to give it a go.

some prerequisites

Hugo cli: you will be needing this to build your static site, it's fast comes with various themes to get you started quickly.It automatically creates the site structure for you so make sure to install it. Hugo
Pulumi cli: you will be using this to configure and deploy the infrastructure needed for our static site on aws. pulumi-cli
aws cli: you also need aws cli. because pulumi uses aws sdk to configure aws infrastructure for you and this needs your aws credentials like access key id and secret access key. aws-cli

getting started

Now we can proceed.
Run pulumi login --local we will be using our local machine as the backend for pulumi stacks.

Now Create a new directory (name of your choice) and Run pulumi new it will ask for your project name,description,config passphrase and your new stack name and will prompt you to select a template make sure to select the "static-website-aws-go" template.
you should see main.go in your directory after this.

after setting up pulumi in this directory we will create our site in the same directory.
from the same directory run below command to setup a hugo site

hugo new site "your site name"

now in this site (let's say your site name is Mysite hugo will create a Mysite directory ) go to content directory and add main page add main page by running touch _index.md write something in it and and run hugo server this will start hugo server and you will see your changes live on localhost::some_port link will be shown in terminal.

This will be your final root directory structure.

├── go.mod
├── go.sum
├── main.go
├── Mysite
├── Pulumi.localStack.yaml
├── Pulumi.yaml
└── readme.md

This will be Mysite Directory:-

.
├── archetypes
├── assets
├── content
├── data
├── hugo.toml
├── i18n
├── layouts
├── public
├── static
└── themes

this is how your local Stack config file should look like. Psite is the name I gave it when running pulumi new yours would be different. region is the aws region your stack will create resource in. It would be a bit different because it would be pointing to the www directory pulumi created for us but we will change it to point to our hugo static files directory.

config:
  Psite:errorDocument: 404.html
  Psite:indexDocument: index.html
  Psite:path: ./Mysite/public
  aws:region: ap-south-1

Next step now build your site by running hugo from the site directory and it will build all your static files in public directory.

now finally...Trust me it's the last step. go to your pulumi.localStack.yaml(present in root directory ) configure it to point to your build directory that is "./Mysite/public/".
after doing this run pulumi up and you will see URL to your static site. To destroy all the aws resources created use pulumi destroy

How we used pulumi ?

we used pulumi to configure these two aws resources for our static site aws s3 and cloudfront. the main.go in our root dir does all this stuff it creates and configures an s3 bucket and stores these static files from public dir from your site and then creates a cloudfront resource.

okie...but how does pulumi work ??

pulumi use stacks to store the state of your infrastructure whenever you do pulumi up it deploys that particular stack state. it compares the current state of your stack with modified state and based on that it creates or destroys infrastructure resources for you.

Hope this helped now go ahead and make your own static site using pulumi and hugo.

Cloud Native gaming with kruiseGame

Ashish Kumar — Mon, 02 Sep 2024 06:54:50 +0000

What is kruise-game ?

kruise-game is an opensource project under openkruise that aims to bring cloud native transformation for gaming workloads aka game servers.

but what are game servers really ?
games servers are basically virtual machines or containers that handle the core functionalities in the backend of PVP multiplayer online game

below I have shown basic game server architecure used by modern PvP online games

why do we really need kruise-game. aren't default k8s resources enough for gaming workloads ?

modern PvP games are getting increasingly complex they require multiple game servers to handle different kind of services for example.
your modern PvP game like valorant need game servers for lobbying ,matchmaking,and the one that runs actualy game logic and manages game state.Handling so many game servers is big task and cant be done manually. So what now ?

well we have got kubernetes to rescue.K8s with it's automated operation and mangement
capabilities can handle this burden for Us,just deploy your game server image and we are done right ?. Not really

I wish it was this easy.The problem is your not deploying your usual stateless web app here.Game servers are different and their requirements are different.k8s default resources are good for stateless apps but gameservers have a more complex lifecycle and they are stateful also their network requirements are different.

first of all game servers need direct lossless connection to clients(udp connection),for this we need fixed Ip addresses of pods,k8s pods IP is changed during deletion,scaling.
also there is lack of control you have over pods if use them for game servers ,there is a thing called rolling update where you update some instances of game servers to test the update and gradually roll out to other instances to prevent downtime,K8s scheduler doesn't know you are working with game servers it will update pods in random manner,basically you have no control over the update strategy of your game servers.SO you have little to no flexibility over game server updates.

To mitigate these issues kruise-game defines two custom Resource designed specifically for game server workloads gameServer and gameserverSet

gameServer:Refers to the abstraction of O&M and management operations on a specified game server. It is mainly used for O&M and management operations such as update sequence control, state control of the game server, and network changes of the game server.
gameServerSet:Refers to the abstraction of lifecycle management for a group of game servers. It is mainly used for lifecycle control such as replica number management and game server launch.

features that kruise-game provides for management of game servers:-

Hot update based on images and hot reload of configurations
Update, deletion, and isolation of specified game servers
Multiple built-in network models (fixed IP address and port, lossless direct connection, and global acceleration)
Auto scaling
Automated O&M (service quality)
Independent of cloud service providers
Complex game server orchestration

Below image shows kruise-game deploymment architecture on k8s

getting started with kruise-game :0

getting a k8s cluster and helm

you would need a k8s cluster for kruise-game,easiest way to get k8s cluster is to get minikube in your machine,also make sure you have helm installed in your machine.

2.start minikube

minikube start

3.use helm to install kruise-game

#kruise-game relies on openkruise so you need to install openkruise first
# Firstly add openkruise charts repository if you haven't do this.
$ helm repo add openkruise https://openkruise.github.io/charts/
# [Optional]
$ helm repo update
# Install the latest version.
$ helm install kruise openkruise/kruise --version 1.6.3
#now instakk kruise-game
$ helm install kruise-game openkruise/kruise-game --version 0.8.0

4.go to your minikube dashboard

minikube dashboard

5.you should kruise-game-system namespace, congrats you installed kruise-game

for more info and details about kruise-game refer to kruise-game docs.

Thanks for reading,hope you enjoyed this :).

simplifying Kubernetes with cyclops Templates

Ashish Kumar — Tue, 06 Aug 2024 11:11:04 +0000

what is cyclops?

cyclops is a tool that simplifies Kubernetes for developers,IT teams and newcomers with no experience in Kubernetes. Cyclops has a easy to UI interface which translates to yaml manifests files abstracting away the complexity from developers.

let's start

to work with cyclops you first need a kubernetes cluster ,welcome minikube easiest way to get a working local cluster.
I got mine ready make sure to install it in your machine first

start your cluster

minikube start

go to your dashboard

minikube dashboard

you would see something like this

now let's install cyclops in our cluster

below command will add cyclops-ctrl and cyclops-ui to our cluster make sure you have cyctl installed checkout cyclops docs otherwise you can use kubectl

cyctl init

now to access the UI service you need to expose it outside our cluster,run the below command

cyctl serve

you would see the cyclops-ctrl and cyclops-ui pods running in your cluster

let's create our own template from scratch.

In this blog I will be creating a dragonflyDb(a fasy memory datastore) template and then we will deploy it using cyclops.

1.create a new folder

dragonfly
│   Chart.yaml
│   values.schema.json
│   values.yaml
│
└───templates
        deployment.yaml
        statefulset.yaml
        service.yaml
        _helpers.tpl
        _pod.tpl

let's write some code now :0

Chart.yaml chart.yaml has contains basic info and data about dragonfly helm chart.

apiVersion: v2
name: dragonfly
description: "a modern superfast in-memory datastore, fully compatible with Redis and Memcached APIs"
version: 0.0.0

values.yaml this file specifies default configuration for dragonflDB that will be used by helm

# default configuration for dragonfly

# no of dragonfly replicas to deploy
replicaCount: 1

image:
  repository: docker.dragonflydb.io/dragonflydb/dragonfly



# default resource requirements, you can change it according to your needs.
resources: 
  requests:
    # min cpu millisecs
    cpu:  100m
    # min memory for dragonfly deployment
    memory: 128Mi

  limits:
    #max cpu millisecs for dragonfly deployment
    cpu: 1000m
    # max memory limit for dragonfly deployment 
    memory: 512Mi



service:

  type: ClusterIP
  # Load balancer static ip to use when service type is set to LoadBalancer
  loadBalancerIP: ""
  # Dragonfly default service port
  port: 6379

  metrics:
  # name for the metrics port
    portName: metrics
  # serviceType for the metrics service
    serviceType: ClusterIP


serviceAccount:
  # Specifies whether a service account should be created
  create: true
  # Annotations to add to the service account
  annotations: {}
  # The name of the service account to use.
  # If not set and create is true, a name is generated using the fullname template
  name: ""



storage:
  # you can set this to true for production use cases,if you want dragonfly to persist data.
  enabled: false 

  storageClassName: ""
  #  Volume size to request for the PVC,default set to 128Mb
  requests: 128Mi



# extra  arguments to pass to dragonfly binary
extraArgs:[]



securityContexts:
  capabilities:
    drop:
      - ALL
  # sets file system permission as read-only for dragonfly container
  readOnlyRootFilesystem: true
  # sets the dragon container to run as non-root 
  runAsNonRoot: true
  # run dragonfly container with user-Id as 1000
  runAsUser: 1000



# the below fields serviceMonitor and promtheiumsRule requires you have prometheus operator running in your cluster.

serviceMonitor:
  # If true, a ServiceMonitor CRD is created for a prometheus operator
  enabled: false
  # namespace in which to deploy the ServiceMonitor CR. defaults to the application namespace
  namespace: ""
  # additional labels to apply to the metrics
  labels: {}
  # additional annotations to apply to the metrics
  annotations: {}
  # scrape interval
  interval: 10s
  # scrape timeout
  scrapeTimeout: 10s

prometheusRule:
  # Deploy a PrometheusRule
  enabled: false
  # PrometheusRule.Spec
  # https://awesome-prometheus-alerts.grep.to/rules
  spec: []


tls:
  # -enable TLS
  enabled: false
  # use cert-manager to automatically create the certificate
  createCerts: false
  # duration or ttl of the validity of the created certificate
  duration: 87600h0m0s
  issuer:
    # - cert-manager issuer kind. Usually Issuer or ClusterIssuer
    kind: ClusterIssuer
    # -name of the referenced issuer
    name: selfsigned
    # - group of the referenced issuer
    # if you are using an external issuer, change this to that issuer group.
    group: cert-manager.io
  # - use TLS certificates from existing secret
  existing_secret: ""
  # - TLS certificate
  cert: ""
  # cert: |
  #   -----BEGIN CERTIFICATE-----
  #   MIIDazCCAlOgAwIBAgIUfV3ygaaVW3+yzK5Dq6Aw6TsZ494wDQYJKoZIhvcNAQEL
  #   ...
  #   BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
  #   zJAL4hNw4Tr6E52fqdmX
  #   -----END CERTIFICATE-----
  # -- TLS private key
  key: ""




passwordFromSecret:
  enable: false
  existingSecret:
    name: ""
    key: ""



# for more fields check dragon fly helm chart

deployment.yaml this file generates the deployment resource for dragonflDB

{{- if not .Values.storage.enabled }}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "dragonfly.fullname" .}}
  namespace: {{ .Release.Namespace }}
  labels:
    {{- include "dragonfly.labels" . | nindent 4 }}


spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "dragonfly.selectorLabels" . | nindent 6 }}

  template:
    metadata:
      annotations:
        {{- if and (.Values.tls.enabled) (not .Values.tls.existing_secret) }}
        checksum/tls-secret: {{ include (print $.Template.BasePath "/tls-secret.yaml") . | sha256sum }}
        {{- end }}
        {{- with .Values.podAnnotations }}
        {{- toYaml . | nindent 8 }}
        {{- end }}
      labels:
        {{- include "dragonfly.selectorLabels" . | nindent 8 }}
    spec:
      {{- include "dragonfly.pod" . | trim | nindent 6 }}
{{- end }}

service.yaml This file creates a resource of kind service for dragonflyDB.

apiVersion: v1
kind: Service
metadata:
  name: {{ include "dragonfly.fullname" . }}
  namespace: {{ .Release.Namespace }}
  {{- with .Values.service.annotations }}
  annotations:
    {{- toYaml . | nindent 4 }}
  {{- end }}
  labels:
    {{- with .Values.service.labels }}
    {{- toYaml . | nindent 4 }}
    {{- end }}
    {{- include "dragonfly.labels" . | nindent 4 }}
spec:
  type: {{ .Values.service.type }}
  {{- if and (eq .Values.service.type "LoadBalancer") (ne .Values.service.loadBalancerIP "") }}
  loadBalancerIP: {{ .Values.service.loadBalancerIP }}
  {{- end }}
  ports:
    - port: {{ .Values.service.port }}
      targetPort: dragonfly
      protocol: TCP
      name: dragonfly
  selector:
    {{- include "dragonfly.selectorLabels" . | nindent 4 }}

_helpers.tpl this file define template vaiables to be used by helm to generate yaml manifests.

{{/*
Expand the name of the chart.
*/}}
{{- define "dragonfly.name" -}}
{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
{{- end }}

{{/*
Create a default fully qualified app name.
We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
If release name contains chart name it will be used as a full name.
*/}}
{{- define "dragonfly.fullname" -}}
{{- if .Values.fullnameOverride }}
{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- $name := default .Chart.Name .Values.nameOverride }}
{{- if contains $name .Release.Name }}
{{- .Release.Name | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
{{- end }}
{{- end }}
{{- end }}

{{/*
Create chart name and version as used by the chart label.
*/}}
{{- define "dragonfly.chart" -}}
{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
{{- end }}

{{/*
Common labels
*/}}
{{- define "dragonfly.labels" -}}
helm.sh/chart: {{ include "dragonfly.chart" . }}
{{ include "dragonfly.selectorLabels" . }}
{{- if .Chart.AppVersion }}
app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
{{- end }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- end }}

{{/*
Selector labels
*/}}
{{- define "dragonfly.selectorLabels" -}}
app.kubernetes.io/name: {{ include "dragonfly.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
{{- end }}

{{/*
Create the name of the service account to use
*/}}
{{- define "dragonfly.serviceAccountName" -}}
{{- if .Values.serviceAccount.create }}
{{- default (include "dragonfly.fullname" .) .Values.serviceAccount.name }}
{{- else }}
{{- default "default" .Values.serviceAccount.name }}
{{- end }}
{{- end }}

_pod.tpl this files defines template variables for pvc resource and are used when storage and tls are enabled for dragonfly.

{{- define "dragonfly.volumemounts" -}}
{{- if or (.Values.storage.enabled) (.Values.extraVolumeMounts) (.Values.tls.enabled) }}
volumeMounts:
  {{- if .Values.storage.enabled }}
  - mountPath: /data
    name: "{{ .Release.Name }}-data"
  {{- end }}
  {{- if and .Values.tls .Values.tls.enabled }}
  - mountPath: /etc/dragonfly/tls
    name: tls
  {{- end }}
  {{- with .Values.extraVolumeMounts }}
    {{- toYaml . | trim | nindent 2 }}
  {{- end }}
{{- end }}
{{- end }}

{{- define "dragonfly.pod" -}}
{{- if ne .Values.priorityClassName "" }}
priorityClassName: {{ .Values.priorityClassName }}
{{- end }}
{{- with .Values.tolerations }}
tolerations:
  {{- toYaml . | trim | nindent 2 -}}
{{- end }}
{{- with .Values.nodeSelector }}
nodeSelector:
  {{- toYaml . | trim | nindent 2 -}}
{{- end }}
{{- with .Values.affinity }}
affinity:
  {{- toYaml . | trim | nindent 2 -}}
{{- end }}
serviceAccountName: {{ include "dragonfly.serviceAccountName" . }}
{{- with .Values.imagePullSecrets }}
imagePullSecrets:
  {{- toYaml . | trim | nindent 2 }}
{{- end }}
{{- with .Values.podSecurityContext }}
securityContext:
  {{- toYaml . | trim | nindent 2 }}
{{- end }}
{{- with .Values.initContainers }}
initContainers:
  {{- if eq (typeOf .) "string" }}
  {{- tpl . $ | trim | nindent 2 }}
  {{- else }}
  {{- toYaml . | trim | nindent 2 }}
  {{- end }}
{{- end }}
containers:
  {{- with .Values.extraContainers }}
  {{- if eq (typeOf .) "string" -}}
  {{- tpl . $ | trim | nindent 2 }}
  {{- else }}
  {{- toYaml . | trim | nindent 2 }}
  {{- end }}
  {{- end }}
  - name: {{ .Chart.Name }}
    {{- with .Values.securityContext }}
    securityContext:
      {{- toYaml . | trim | nindent 6 }}
    {{- end }}
    image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
    imagePullPolicy: {{ .Values.image.pullPolicy }}
    ports:
      - name: dragonfly
        containerPort: 6379
        protocol: TCP
    {{- with .Values.probes }}
    {{- toYaml . | trim | nindent 4 }}
    {{- end }}
    {{- with .Values.command }}
    command:
      {{- toYaml . | trim | nindent 6 }}
    {{- end }}
    args:
      - "--alsologtostderr"
    {{- with .Values.extraArgs }}
      {{- toYaml . | trim | nindent 6 }}
    {{- end }}
    {{- if .Values.tls.enabled }}
      - "--tls"
      - "--tls_cert_file=/etc/dragonfly/tls/tls.crt"
      - "--tls_key_file=/etc/dragonfly/tls/tls.key"
    {{- end }}
    {{- with .Values.resources }}
    resources:
      {{- toYaml . | trim | nindent 6 }}
    {{- end }}
    {{- include "dragonfly.volumemounts" . | trim | nindent 4 }}
    {{- if .Values.passwordFromSecret.enable }}
    {{- $appVersion := .Chart.AppVersion | trimPrefix "v" }}
    {{- $imageTag := .Values.image.tag | trimPrefix "v" }}
    {{- $effectiveVersion := $appVersion }}
    {{- if and $imageTag (ne $imageTag "") }}
      {{- $effectiveVersion = $imageTag }}
    {{- end }}
    env:
    {{- if semverCompare ">=1.14.0" $effectiveVersion }}
      - name: DFLY_requirepass
    {{- else }}
      - name: DFLY_PASSWORD
    {{- end }}
        valueFrom:
          secretKeyRef:
            name: {{ .Values.passwordFromSecret.existingSecret.name }}
            key: {{ .Values.passwordFromSecret.existingSecret.key }}
    {{- end }}

{{- if or (.Values.tls.enabled) (.Values.extraVolumes) }}
volumes:
{{- if and .Values.tls .Values.tls.enabled }}
  {{- if .Values.tls.existing_secret }}
  - name: tls
    secret:
      secretName: {{ .Values.tls.existing_secret }}
  {{- else if .Values.tls.createCerts }}
  - name: tls
    secret:
      secretName: '{{ include "dragonfly.fullname" . }}-server-tls'
  {{- else }}
  - name: tls
    secret:
      secretName: {{ include "dragonfly.fullname" . }}-tls
  {{- end }}
{{- end }}
{{- with .Values.extraVolumes }}
  {{- toYaml . | trim | nindent 2 }}
{{- end }}
{{- end }}
{{- end }}

statefulset.yaml If we want dragonflyDB to persist data kubernetes will create a statefulset using statefulset.yaml.

{{- if .Values.storage.enabled }}
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: {{ include "dragonfly.fullname" . }}
  namespace: {{ .Release.Namespace }}
  labels:
    {{- include "dragonfly.labels" . | nindent 4 }}
spec:
  serviceName: {{ .Release.Name }}
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "dragonfly.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      annotations:
        {{- if and (.Values.tls.enabled) (not .Values.tls.existing_secret) }}
        checksum/tls-secret: {{ include (print $.Template.BasePath "/tls-secret.yaml") . | sha256sum }}
        {{- end }}
        {{- with .Values.podAnnotations }}
        {{- toYaml . | nindent 8 }}
        {{- end }}
      labels:
        {{- include "dragonfly.selectorLabels" . | nindent 8 }}
    spec:
      {{- include "dragonfly.pod" . | trim | nindent 6 }}
  volumeClaimTemplates:
    - metadata:
        name: "{{ .Release.Name }}-data"
      spec:
        accessModes: [ "ReadWriteOnce" ]
        storageClassName: {{ .Values.storage.storageClassName }}
        resources:
          requests:
            storage: {{ .Values.storage.requests }}
{{- end }}

schema.values.json this is the file needed to render the ui in cyclops,it defines which fields will be shown to user in UI,values are edited for values.yaml,this file is super necessary for cyclops UI.

{

    "properties": {
        "replicaCount":{
            "description": "number of replicas of dragonflyDb",
            "type":"integer"
        },
        "storage":{

            "description": "storage for dragonflydb,default is 128Mi",
            "type":"object",
            "properties": {
                "enabled":{
                    "description": "enables storage if set to true ,default is false",
                    "type":"boolean"

                },
                "requests":{
                    "description":"requests storage,default 128Mi",
                    "type":"string"
            }
            }

        },
        "serviceMonitor":{
            "description": "enables service monitor ,requires kube-promtheus installed in your cluster",
            "type":"boolean"

        },
        "resources":{

            "description": "allocate cpu and ram for dragonfly",
            "title": "resources",
            "type":"object",
            "properties": {

                "requests":{

                    "title": "Request resoures",
                    "type":"object",
                    "properties": {


                        "cpu":{

                            "description":"request to allocates  cpu resource,default is 100m",
                            "type":"string"

                    },
                        "memory":{

                            "description":"requests memory for dragonfly, default 128Mi(Megabyte)",
                            "type":"string"
                    }
                    }
                },
                "limits":{

                    "title":"resource limits",
                    "description": "sets upper limits for resources",
                    "type":"object",
                    "properties": {

                        "cpu":{
                            "description":"cpu resource limit,deafult is 1000m",
                            "type":"string"
                        },
                        "memory":{
                            "description": "memory limit for dragonfly,default 512Mi",
                            "type":"string"
                        }
                    }


                }

            }

        }


    },
    "order":[

        "replicaCount",
        "storage",
        "resources",
        "serviceMonitor"

    ],
    "required": [
        "replicaCount",
        "storage",
        "resources",
        "serviceMonitor"
    ]



}

I know this might be hard to digest if you are new to helm.
let me explain you the big picture :-
our root contains three files values.yaml
values.schema.json Chart.yaml

let's deal with these three first

Chart.yaml: this ones very basic it just contains info about our helm chart.
values.yaml :now this one is important,it is from this file helm generates yaml manifests,this file contains default value of fields like resources,service etc.it is basically this file your editing using Cyclops UI then helm uses these values to create your applications, if you dont pass any values in cyclops UI the default values of fields insidevalues.yaml will be used to generate manifests.
values.schema.json : cyclops needs this file to render UI,this doesn't come with your helm chart you need to create it for cyclops so that it can render UI for your template,in this file you can specify which fields from values.yamlyou want to expose through UI,the user will be able to edit these fields in cyclops UI which in turn will pass updated values.yaml to helm and then helm will create your application.

I hope it's a bit clear now.

underneath cyclops uses helm chart under to to render UI refer to dragonflyDb Helm Chart

Now lets deploy dragon fly using our cyclops template that we just created,first we need to add our templates to cyclops:

add template to cyclops,go to templates in cyclopes ui.

2.click on add template,enter name,repo and path for your template and click ok.

3.now lets deploy dragonflyDB from our template.

4.enjoy :)

contributing to cyclops

I learned a lot while contributing to cyclops in this quira quest,I got to know the basics of kubernetes and managed to solve two issues in cyclops repo,This was my first contribution to a major opensource project the maintainers are very welcoming to newcomers.

Quira cyclops quest feats

-solved the update command issue PR

-solved printer-column issue PR

-added dragonflyDB template to cyclops/templates repo PR

HUNGRY TO CONTRIBUTE MORE