DEV Community: Yash Gangwar

How to retrieve K8ssandra superuser credentials ?

Yash Gangwar — Wed, 18 May 2022 07:16:03 +0000

Before starting

Before proceeding further just make sure you have your K8ssandra cluster up and running. To check the status of your pods run:

kubectl get pods

Your output should look like this:

NAME                                                   READY   STATUS    RESTARTS   AGE
dok-k8ssandra-kube-prometh-operator-6fdf96f759-dqhmb   1/1     Running   0          9h
prometheus-dok-k8ssandra-kube-prometh-prometheus-0     2/2     Running   0          9h
dok-k8ssandra-dc1-stargate-55fb98ff88-6lhm2            1/1     Running   14         9h
dok-k8ssandra-grafana-5b8b6986f4-h7js9                 2/2     Running   0          9h
dok-k8ssandra-dc1-default-sts-0                        2/2     Running   0          39m
dok-k8ssandra-cass-operator-84549dd7d6-b42lq           1/1     Running   9          9h

Retrieve K8ssandra superuser credentials

You’ll need the K8ssandra superuser username and password in order to access Cassandra utilities and do things like generating Stargate access token to connect to Cassandra, accessing Cassandra using CQLSH, etc.

✅ Step 1: Retrieve the K8ssandra superuser username and password:

To extract the username execute the following command:

kubectl get secrets <deployment/cluster-name>-superuser -o jsonpath="{.data.username}"

In my case, I have kept my cluster-name as dok-k8ssandra, so my command will look like:

kubectl get secrets dok-k8ssandra-superuser -o jsonpath="{.data.username}"

Your output should look like this:

ZG9rLWs4c3NhbmRyYS1zdXBlcnVzZXI=

To extract the password execute the following command:
```
kubectl get secrets <deployment/cluster-name>-superuser -o jsonpath="{.data.password}"
```
In my case, I have kept my cluster-name as dok-k8ssandra, so my command will look like:
```
kubectl get secrets dok-k8ssandra-superuser -o jsonpath="{.data.password}"
```
Your output should look like this:
```
WmdsSDNkdDhqVTJZem9ldGdYelI=
```
The credentials you extracted here are encoded, so before using them you need to decode them using base64.

✅ Step 2: Decoding the K8ssandra superuser username and password:

Decoding username using base64:

If you are using Ubuntu CLI, you can run the following command:
```
echo <encoded username> | base64 --decode
```
If this command dosen't works on your CLI, you can try using the online base64 decoder.

Your decoded username should look like this:
```
dok-k8ssandra-superuser
```
Decoding password using base64:

If you are using Ubuntu CLI, you can run the following command:
```
echo <encoded password> | base64 --decode
```
If this command dosen't works on your CLI, you can try using the online base64 decoder.

Your decoded password should look like this:
```
ZglH3dt8jU2YzoetgXzR
```

Awesome, So now we have our decoded credentials ready to use for accessing Cassandra utilities. Let's see an example where we need to use them to generate a Stargate access token to access Cassandra.

How you can run your first Argo Workflow on K3s ?

Yash Gangwar — Wed, 18 May 2022 07:06:28 +0000

Welcome!

Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes. Argo Workflows is implemented as a Kubernetes CRD (Custom Resource Definition). In simple words, Argo is a workflow scheduler where you can run your workflows onto a Kubernetes Cluster, you can containerize different steps within your workflow and then all those steps could be executed as a part of your workflow onto a Kubernets cluster using Argo workflows. Read more

Here we gonna create a simple Argo workflow template that will echo "hello world" using the docker/whalesay container image and this container will be running on our K3s cluster using Argo Workflow template.

Let's get started!! 🚀

Before starting

Before proceeding further with the hands-on we need to have some tools and CLI installed locally:

Docker: A containerization tool that we will be using for running K3s cluster on container. Download it from here. To check your installation run command docker --version.

Output:

   Docker version 20.10.11, build dea9396

kubectl: Kubernetes command-line tool that allows you to run commands against Kubernetes clusters. Download it from here. To check your installation run command kubectl version --client.

Output:

   Client Version: version.Info{Major:"1", Minor:"22", GitVersion:"v1.22.0", GitCommit:"c2b5237ccd9c0f1d600d3072634ca66cefdf272f", GitTreeState:"clean", BuildDate:"2021-08-04T18:03:20Z", GoVersion:"go1.16.6", Compiler:"gc", Platform:"windows/amd64"}

argo: Argo CLI allows to (amongst other things) submit, watch, and list workflows. Download it from here. To check your installation run command argo version.

Output:

   argo: v3.2.4
    BuildDate: 2021-11-18T00:28:05Z
    GitCommit: 8771ca279c329753e420dbdd986a9c914876b151
    GitTreeState: clean
    GitTag: v3.2.4
    GoVersion: go1.16.10
    Compiler: gc
    Platform: windows/amd64

Setting up K3s cluster locally(on Docker)

K3s is a fully conformant lightweight production-ready Kubernetes distribution. As compared to K8s, its easy to install, packaged as a single binary, requires less resources which means it's possible to run a kubernets cluster on anything from 512MB of RAM machines upwards, and we can install it in a fraction of the time, unlike regular K8s.

We are going to use K3d, which is a utility designed to easily run k3s in Docker.K3d makes it very easy to create single and multi-node k3s clusters in docker for local development on Kubernetes.

✅ Step 1: Install scripts of current latest release

curl -s https://raw.githubusercontent.com/rancher/k3d/main/install.sh | bash

If this command doesn't works, you can grab a release binary from the Github release tab and install it yourself.

✅ Step 2: Create a cluster named myK3sCluster with just a single server node

k3d cluster create myK3sCluster

This command will download the docker image of K3s and setup our cluster on container.

✅ Step 3: To check if myK3sCluster is successfully running on docker

kubectl get nodes

Output:

NAME                        STATUS   ROLES                  AGE     VERSION
k3d-myk3scluster-server-0   Ready    control-plane,master   7h57m   v1.21.7+k3s1

Installing Argo Workflows in our K3s cluster

✅ Step 1: Creating a separate namespace for argo inside our cluster

kubectl create ns argo
kubectl get ns

Output:

NAME              STATUS   AGE
default           Active   8h
kube-system       Active   8h
kube-public       Active   8h
kube-node-lease   Active   8h
argo              Active   8h

✅ Step 2: Install Argo Workflows

To get started quickly, we can use the quick start manifest which will install Argo Workflow as well as some commonly used components

kubectl apply -n argo -f https://raw.githubusercontent.com/argoproj/argo-workflows/master/manifests/quick-start-postgres.yaml

✅ Step 3: Check installation

Verify everything is up running. We need to wait till each pod has running or completed status before moving on.

kubectl get pods -n argo

Output:

NAME                                  READY   STATUS      RESTARTS   AGE
minio-79566d86cb-82c4j                1/1     Running     1          8h
postgres-546d9d68b-8dfqp              1/1     Running     1          8h
workflow-controller-558db44f7-wglh5   1/1     Running     5          8h
argo-server-5d58f6585d-7jx2p          1/1     Running     4          8h

✅ Step 4: Accessing Argo Workflows dashboard

As we are running Argo Workflows locally, we can open a port-forward so you can access the namespace/dashboard.

kubectl -n argo port-forward deployment/argo-server 2746:2746

Open the Argo dashboard using URL https://localhost:2746. Here you can see all your workflows, create them and manage them.

Creating our first Argo Workflow template

I have created a very simple workflow template to echo "hello world" using the docker/whalesay container image from DockerHub. Create a file named hello-world.yaml, and copy paste the following code.

apiVersion: argoproj.io/v1alpha1
kind: Workflow # new type of k8s spec used to create argo workflows
metadata:
  generateName: hello-world- # name of the workflow spec
spec:
  entrypoint: whalesay # specifies the initial template that should be invoked i.e whalesay
  templates:
    - name: whalesay # name of the template
      container: # container that will run when this template in invoked
        image: docker/whalesay # image that will run inside the cluster
        command: [cowsay]
        args: ["hello world"]
        resources: # limit the resources
          limits:
            memory: 32Mi
            cpu: 100m

✅ Step 1: Submitting our workflow

Make sure before running the following codes you should be the folder where you created your hello-world.yaml file.

argo submit -n argo --watch hello-world.yaml

Output:

Name:                hello-world-xpc6d
Namespace:           argo
ServiceAccount:      default
Status:              Running
reated:              Tue Jan 18 22:32:07 +0530 (6 seconds ago)
Started:             Tue Jan 18 22:32:07 +0530 (6 seconds ago)
Duration:            6 seconds
Progress:            0/0

STEP                  TEMPLATE  PODNAME            DURATION  MESSAGE
 ◷ hello-world-xpc6d  whalesay  hello-world-xpc6d  6s

You can see your workflow named hello-world-xpc6d has started running. Wait till it has finished executing. You can also see your workflow on the dashboard

✅ Step 2: Getting logs of our workflow

Here, @latest tag refers to the recent or the last submitted workflow. You can also replace @latest with the name of your workflow. For eg. in my case the workflow name would be hello-world-xpc6d.

argo list -n argo
argo get -n argo @latest
argo logs -n argo @latest

Output:

hello-world-xpc6d: time="2022-01-18T17:02:54.072Z" level=info msg="capturing logs" argo=true
hello-world-xpc6d:  _____________
hello-world-xpc6d: < hello world >
hello-world-xpc6d:  -------------
hello-world-xpc6d:     \
hello-world-xpc6d:      \
hello-world-xpc6d:       \
hello-world-xpc6d:                     ##        .
hello-world-xpc6d:               ## ## ##       ==
hello-world-xpc6d:            ## ## ## ##      ===
hello-world-xpc6d:        /""""""""""""""""___/ ===
hello-world-xpc6d:   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
hello-world-xpc6d:        \______ o          __/
hello-world-xpc6d:         \    \        __/
hello-world-xpc6d:           \____\______/

Congratulations!! 🚀 You successfully ran your first ever simple argo workflow on K3s cluster. I hope this made you curious to explore Argo workflows more deeply.
Checkout this, here you can find different types to workflows and templates that you can try running locally.

How to Create a YAML Manifest Template in Monokle for Deploying Cassandra with StatefulSet

Yash Gangwar — Sun, 20 Feb 2022 10:18:40 +0000

➡️ What is Monokle?

Managing and debugging K8s manifests and YAML file with 100 lines of code and soo many K8s objects and resources is quiet difficult sometimes. And here is where Monokle comes into play...

Welcome to Monokle - your friendly desktop UI for managing k8s manifests!

Monokle is an open-source tool developed by Kubeshop that makes it very easy to manage and inspect your Kubernetes Manifests, showing you how your manifests and different objects are connected to each other. You can edit and refractor resources, preview and debug resources, deploy them to our local or cloud K8s cluster and much more!

Apart from all this Monokel also helps you to create manifests both from scratch and from templates. With templates you don't need to write a yaml file from scratch, you can simply select the template and add few necessary info like namespace, image name, no. of replicas and a manifest file is ready for you to deploy.

If you are new to Monokel, check out this Intro to Monokel video by Kunal Kushwaha to get started with the tool.

➡️ What will this Template do?

Cassandra is a database designed to handle big data workloads across multiple nodes without a single point of failure. We will be creating a StatefulSet Template that will help us deploying Cassandra Database to a K8s cluster.

In this blog, I will take you through the steps to create and use your own custom Template for Monokel from Scratch.

🚀Lets get started!!

➡️ Prerequisites

Prior knowledge of working with YAML files, Kubernetes resources and objects like Pods, StatefulSets, Services would be beneficial. You can checkout video tutorials on all these stuff by Kunal Kushwaha in his DevOps Bootcamp playlist.

➡️ Setting up the project

The templates in monokle are installed via a plugin, and that plugin is basically our github repo that contains package.json file in order to be a monokle plugin

✅Step 1: Creating a Github Repository

Create a Github Repository by the name monokle-templates-plugin. After that clone that empty repo into your local machine using the following command.

git clone https://github.com/YOUR_GITHUB_USERNAME/monokle-templates-plugin.git

Now enter into that folder using cd monokle-templates-plugin

✅Step 2: Creating `package.json` file

Create a file named package.json inside your root folder for our template plugin.

This file should have the following content:

{
  "name": "Template Plugins",
  "description": "Custom templates plugin",
  "version": "1.0.0",
  "author": "YOUR_NAME",
  "repository": "https://github.com/YOUR_GITHUB_USERNAME/monokle-templates-plugin",
  "monoklePlugin": {
    "id": "com.github.YOUR_GITHUB_USERNAME.plugin.templates.cassandra-statefulset-template",
    "helpUrl": "https://github.com/YOUR_GITHUB_USERNAME/monokle-templates-plugin",
    "modules": [
      {
        "type": "template",
        "path": "cassandra-statefulset-template"
      }
    ]
  }
}

⚠️ REMEMBER: Replace your name and Github username wherever mentioned.

➡️ Creating the Template

In previous step you created a package.json file and inside modules you set some path. So now create a folder named cassandra-statefulset-template inside your root folder that has package.json.

This folder will actually contain all the files required to create your custom template. It will have following four parts/files:

Monokle template configuration
Defining Form Schema
Defining Form UI
Kubernetes YAML manifest with placeholders

📄File 1: Monokle template configuration

This file is Monokle-specific and defines what type of template you are creating. There are two types of templates in Monokle for now: vanilla and helm-charts; we will be creating a simple vanilla type template.

Create the file monokle-template.json with following content:

{
    "name": "Deploy Cassandra with StatefulSet",
    "id": "com.github.YOUR_GITHUB_USERNAME.plugin.templates.cassandra-statefulset-template",
    "author": "YOUR_NAME",
    "version": "1.0.0",
    "description": "Creates a Deployemnt, Service and Storage Class for Cassandra database using Statefulsets",
    "repository" : "",
    "type": "vanilla",
    "forms": [
      {
        "name": "Deployment Settings",
        "description": "Specify the no. of replicas, namespace, cluster name and related settings of database",
        "schema": "form-schema.json",
        "uiSchema": "form-ui-schema.json"
      }
    ],
    "manifests": [
      {
        "filePath": "template.yaml"  
      }
    ],
    "resultMessage": "Cassandra database deployed successfully",
    "helpUrl": "https://github.com/YOUR_GITHUB_USERNAME/monokle-templates-plugin"
}

⚠️ REMEMBER: Replace your name and Github username wherever mentioned.

📄File 2: Defining Form Schema

In the code above, we have defined the fields forms.schema, this will contain the form fields that we will request the user to input and are necessary to create the manifest file.

Create the file form-schema.json with the following content:

{
    "type": "object",
    "required": [
      "name",
      "replicas"
    ],
    "properties": {
      "name": {
        "type": "string",
        "default": "cassandra" 
      },
      "namespace": {
        "type": "string"
      },
      "replicas": {
        "type": "number"
      },
      "cluster_name": {
        "type": "string",
        "default": "K8Demo"
      },
      "datacenter_name": {
        "type": "string",
        "default": "datacenter1-K8Demo"
      },
      "rack_name": {
        "type": "string",
        "default": "rack1-K8Demo"
      }
    }
  }

📌 NOTE: required refers to the compulsary input fields, type describes the data type of input field, default is the default value of the input field.

📄File 3: Defining Form UI

Monokle uses the react-json-schema-form frontend component to render the forms for these templates. It takes the form fields definition which we just created, and a UI form definition, which we will build next.

Create a file named form-ui-schema.json, this will basically defines how the form is going to appear (titles for the fields, descriptions, etc).

{
    "name": {
      "ui:title": "Name",
      "ui:help": "The name of the generated service and deployment"
    },
    "namespace": {
      "ui:title": "Namespace",
      "ui:help": "The target namespace for the generated service and deployment",
      "ui:widget": "namespaceSelection"
    },
    "replicas": {
      "ui:title": "Replicas",
      "ui:help": "Number of pod replicas"
    },
    "cluster_name": {
      "ui:title": "Cassandra Cluster Name",
      "ui:help": "Name of the cluster"
    },
    "datacenter_name": {
      "ui:title": "Cassandra DataCenter Name",
      "ui:help": "Name of the Datacenter where data will be stored. It can be anything, for example datacenter1"
    },
    "rack_name": {
      "ui:title": "Cassandra Rack Name",
      "ui:help": "Name of the Rack where datacenter will be created. It can be anything, for example rack1"
    }
  }

📌 NOTE: title refers to name of the input field, help describes the field, widget creates the dropdown menu.

📄File 4: Kubernetes YAML manifest template

Finally, this is where we will actually define our Cassandra StatefulSet manifest template with the placeholders that we will update with the form data. This manifest YAML file will contain the following K8s objects and resources to deploy cassandra pods:

StatefulSet - to create cassandra pods
StorageClass - for dynamic provisioning of Persistent Volumes
Service - for connecting pods to each other and client

Create the template.yaml file with the following config:

# This is your StatefulSet to create pods
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: [[forms[0].name]]
  labels:
    app: [[forms[0].name]]
[[ forms[0].namespace ? "  namespace: " + forms[0].namespace + "\n" : ""]]
spec:
  serviceName: [[forms[0].name]]
  replicas: [[forms[0].replicas]]
  selector:
    matchLabels:
      app: [[forms[0].name]]
  template:
    metadata:
      labels:
        app: [[forms[0].name]]
    spec:
      terminationGracePeriodSeconds: 1800
      containers:
      - name: [[forms[0].name]]
        image: gcr.io/google-samples/cassandra:v13
        imagePullPolicy: Always
        ports:
        - containerPort: 7000
          name: intra-node
        - containerPort: 7001
          name: tls-intra-node
        - containerPort: 7199
          name: jmx
        - containerPort: 9042
          name: cql
        resources:
          limits:
            cpu: "500m"
            memory: 1Gi
          requests:
            cpu: "500m"
            memory: 1Gi
        securityContext:
          capabilities:
            add:
              - IPC_LOCK
        lifecycle:
          preStop:
            exec:
              command: 
              - /bin/sh
              - -c
              - nodetool drain
        env:
          - name: MAX_HEAP_SIZE
            value: 512M
          - name: HEAP_NEWSIZE
            value: 100M
          - name: CASSANDRA_SEEDS
            value: "cassandra-0.cassandra.default.svc.cluster.local"
          - name: CASSANDRA_CLUSTER_NAME
            value: [[forms[0].cluster_name]]
          - name: CASSANDRA_DC
            value: [[forms[0].datacenter_name]]
          - name: CASSANDRA_RACK
            value: [[forms[0].rack_name]]
          - name: POD_IP
            valueFrom:
              fieldRef:
                fieldPath: status.podIP
        readinessProbe:
          exec:
            command:
            - /bin/bash
            - -c
            - /ready-probe.sh
          initialDelaySeconds: 15
          timeoutSeconds: 5
        # These volume mounts are persistent. They are like inline claims,
        # but not exactly because the names need to match exactly one of
        # the stateful pod volumes.
        volumeMounts:
        - name: cassandra-data
          mountPath: /cassandra_data
  # These are converted to volume claims by the controller
  # and mounted at the paths mentioned above.
  # do not use these in production until ssd GCEPersistentDisk or other ssd pd
  volumeClaimTemplates:
  - metadata:
      name: cassandra-data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: fast
      resources:
        requests:
          storage: 1Gi
---
# StorageClass for Persistent Volume Claim
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast
provisioner: k8s.io/minikube-hostpath
parameters:
  type: pd-ssd
---
# This is your Service for the pods
apiVersion: v1
kind: Service
metadata:
  labels:
    app: [[forms[0].name]]
  name: [[forms[0].name]]
[[ forms[0].namespace ? "  namespace: " + forms[0].namespace + "\n" : ""]]
spec:
  clusterIP: None
  ports:
  - port: 9042
  selector:
    app: [[forms[0].name]]

📌 NOTE: As you can see, for placeholders we are using format [[forms[0].name]] where form[0] is used to access the form defined in monokle-template.json, and .name refers to one of our input field defined in the form schema.

👏🏻Awesome, with this step we have finally created our Monokle Template.

➡️ Uploading the Template to Github Repo

Now that we have defined our template configuration, the form definition and our manifest with its placeholders, it's time to push them to our Github Repo we made and cloned in the first step, so that we can import our template in Monokle in the later step.

Before proceeding, verify if you are in your root folder i.e monokle-templates-plugin

git add .
git commit -m "cassandra monokle template"
git push origin main

➡️ Importing your Template in Monokle

We need to import the template form our Github repo to Monokle in our configured project.

✅Step 1:

Download Monokle from here, Open the Monokle Interface and you can find Open Pugins Manager button on the top-right corner.

✅Step 2:

Click on install pulgin. Copy the url of your template Github repo and paste it here.

Click on Download and install pulgin.

✅Step 3:

To verify if your template is successfully imported, it should appear in Plugins Manager with the name Template Pulgins

👏🏻Awesome, we have successfully imported our template. It's time to test out our custom cassandra template.

➡️ Trying out your Template

Lets use our template to create the resources required to deploy the Cassandra pods by filling up the template form.

✅Step 1:

Start a new project in monokle by selecting Start from a template

✅Step 2:

Assign the project name, I named it Awesome Monokle because it is actually amazing.

Now proceed further to Select a Template

✅Step 3:

You can find your custom template that you just imported with the name Deploy Cassandra with StatefulSet. Use this template and proceed futher to fill up the template form.

✅Step 4:

Fill up all the fields in the deployment settings or keep them to default options as required.

Click on Submit button and you can see that following resources have been created successfully.

✅Step 5:

Go back to your project. Have a look at your navigator and you can find StatefulSets, Services, and StorageClass created with the name my-cassandra, by your cassandra template.

To deploy cassandra pods to your K8s cluster, click on the Deploy button on the top-right corner in Editor.

🥳Congratulations!!🥳 Now sit back, relax and give yourself some time to appreciate that you have created your own custom template and used it on Monokel.

🚀 Feel free to contact me on my socials if you get stuck anywhere LinkedIn, Github, Twitter

🧑‍💻Happy Learning !!👩‍💻

📚 Some more resources...

1) All the files and code mentioned above can be found on my Github Repo.
2) Want to create a basic pod template? Checkout tutorial by Kunal Kushwaha and blog by Kubeshop.
3) Learn more about Monokel? Checkout their official documentation.

DEV Community: Yash Gangwar

How to retrieve K8ssandra superuser credentials ?

Before starting

Retrieve K8ssandra superuser credentials

How you can run your first Argo Workflow on K3s ?

Welcome!

Before starting

Setting up K3s cluster locally(on Docker)

Installing Argo Workflows in our K3s cluster

Creating our first Argo Workflow template

How to Create a YAML Manifest Template in Monokle for Deploying Cassandra with StatefulSet

➡️ What is Monokle?

➡️ What will this Template do?

➡️ Prerequisites

➡️ Setting up the project

✅Step 1: Creating a Github Repository

✅Step 2: Creating package.json file

➡️ Creating the Template

📄File 1: Monokle template configuration

📄File 2: Defining Form Schema

📄File 3: Defining Form UI

📄File 4: Kubernetes YAML manifest template

➡️ Uploading the Template to Github Repo

➡️ Importing your Template in Monokle

✅Step 1:

✅Step 2:

✅Step 3:

➡️ Trying out your Template

✅Step 1:

✅Step 2:

✅Step 3:

✅Step 4:

✅Step 5:

📚 Some more resources...

✅Step 2: Creating `package.json` file