Forem: karan singh

A Free Tool to Check VRAM Requirements for Any HuggingFace Model

karan singh — Wed, 07 Jan 2026 12:03:51 +0000

TL;DR: I got tired of guessing whether models would fit on my GPU. So I built vramio — a free API that tells you exactly how much VRAM any HuggingFace model needs. One curl command. Instant answer.

The Problem Every ML Engineer Knows

You're browsing HuggingFace. You find a model that looks perfect for your project. Then the questions start:

"Will this fit on my 24GB RTX 4090?"
"Do I need to quantize it?"
"What's the actual memory footprint?"

And the answers? They're nowhere.

Some model cards mention it. Most don't. You could download the model and find out the hard way. Or dig through config files, count parameters, multiply by bytes per dtype, add overhead for KV cache...

I've done this calculation dozens of times and have blogged here Calculate vRAM for LLM. It's tedious. It shouldn't be.

The Solution: One API Call

curl "https://vramio.ksingh.in/model?hf_id=mistralai/Mistral-7B-v0.1"

That's it. You get back:

{
  "model": "mistralai/Mistral-7B-v0.1",
  "total_parameters": "7.24B",
  "memory_required": "13.49 GB",
  "recommended_vram": "16.19 GB",
  "other_precisions": {
    "fp32": "26.99 GB",
    "fp16": "13.49 GB",
    "int8": "6.75 GB",
    "int4": "3.37 GB"
  }
}

recommended_vram includes the standard 20% overhead for activations and KV cache during inference. This is what you actually need.

How It Works

No magic. No downloads. Just math.

Fetch safetensors metadata from HuggingFace (just the headers, ~50KB)
Parse tensor shapes and data types
Calculate: parameters × bytes_per_dtype
Add 20% for inference overhead

The entire thing is 160 lines of Python with a single dependency (httpx).

Why I Built This

I run models locally. A lot. Every time I wanted to try something new, I'd waste 10 minutes figuring out if it would even fit.

I wanted something dead simple:

No signup
No rate limits
No bloated web UI
Just an API endpoint

So I built it over a weekend and deployed it for free on Render.

Try It

Live API: https://vramio.ksingh.in/model?hf_id=YOUR_MODEL_ID

Examples:

# Llama 2 7B
curl "https://vramio.ksingh.in/model?hf_id=meta-llama/Llama-2-7b"

# Phi-2
curl "https://vramio.ksingh.in/model?hf_id=microsoft/phi-2"

# Mistral 7B
curl "https://vramio.ksingh.in/model?hf_id=mistralai/Mistral-7B-v0.1"

Self-Host It

It's open source. Run your own:

git clone https://github.com/ksingh-scogo/vramio.git
cd vramio
pip install httpx[http2]
python server_embedded.py

What's Next

This solves my immediate problem. If people find it useful, I might add:

Batch queries for multiple models
Training memory estimates (not just inference)
Browser extension for HuggingFace

But honestly? The current version does exactly what I needed. Sometimes simple is enough.

GitHub: https://github.com/ksingh-scogo/vramio

Built with help from hf-mem by @alvarobartt.

If this saved you time, consider starring the repo. And if you have ideas for improvements, open an issue — I'd love to hear them.

Deploy MongoDB on OpenShift using Helm

karan singh — Tue, 15 Mar 2022 13:16:42 +0000

Introduction

This is yet another blog post on deploying Blahblahblah on OpenShift and this time its MongoDB. In this post you will learn deployment of MongoDB on OpenShift using Helm Chart.

Lets' get started

Install helm CLI on your local machine (see docs)
Login to OpenShift CLI
Create a new Project on OpenShift

oc new-project ksingh

Add helm repository

helm repo add bitnami https://charts.bitnami.com/bitnami

Set root user password and replica-set-key as environment variables

export MONGODB_ROOT_PASSWORD=root123
export MONGODB_REPLICA_SET_KEY=root123

Using helm install MongoDB on OpenShift. Make sure to set the required SecurityContext , so that helm can deploy MongoDB on OpenShift

helm install mongodb bitnami/mongodb --set podSecurityContext.fsGroup="",containerSecurityContext.runAsUser="1001080001",podSecurityContext.enabled=false,architecture=replicaset,auth.replicaSetKey=$MONGODB_REPLICA_SET_KEY,auth.rootPassword=$MONGODB_ROOT_PASSWORD

Wait for the deployment to be ready, you can run oc get po
Get the root password (optional)

export MONGODB_ROOT_PASSWORD=$(kubectl get secret --namespace ksingh mongodb -o jsonpath="{.data.mongodb-root-password}" | base64 --decode)

Create a MongoDB Client container and verify that connectivity and DB access

kubectl run --namespace ksingh mongodb-client --rm --tty -i --restart='Never' --env="MONGODB_ROOT_PASSWORD=$MONGODB_ROOT_PASSWORD" --image docker.io/bitnami/mongodb:4.4.13-debian-10-r9 --command -- bash

From the client container shell, connect to the MongoDB cluster

## Option-1 Using host addres
mongo admin --host "mongodb-0.mongodb-headless.ksingh.svc.cluster.local:27017,mongodb-1.mongodb-headless.ksingh.svc.cluster.local:27017" --authenticationDatabase admin -u root -p $MONGODB_ROOT_PASSWORD

## Option-2 Using MongoDB URI
mongo "mongodb://mongodb-0.mongodb-headless.ksingh.svc.cluster.local:27017,mongodb-1.mongodb-headless.ksingh.svc.cluster.local:27017" --authenticationDatabase admin  -u root -p $MONGODB_ROOT_PASSWORD

List the databases show dbs
Create a database mydb and create a document in collection post

use mydb

db.post.insert([
  {
    title: "MongoDB to Kafka testing",
    description: "Debezium connector",
    by: "Karan",
    url: "http://redhat.com",
    tags: ["mongodb", "debezium", "ROSAK"],
    likes: 100
  }
])

Verify the document is created

show dbs
db.post.find()

Exit the mongodb client container

If you want to connect to MongoDB cluster from localhost, then forward to port

kubectl port-forward service/mongodb-external-0 27017 &

Connect using MongoDB CLI from localhost

mongo --host 127.0.0.1 --authenticationDatabase admin -u root -p $MONGODB_ROOT_PASSWORD

(optionally) Connect using MongoDB Compass or MongoDB Shell

# MongoDB Compass > New Connection
mongodb://root:JvckncuMto@127.0.0.1:27017

Golang automatic code formatting : Code like a Pro

karan singh — Tue, 22 Feb 2022 07:31:02 +0000

Why Format your code?

Everyone loves clean readable and beautifully organized code using tabs/spaces (whatever you like), short lines etc. As a developer, while writing code, you should not spend time counting the tabs/spaces, instead let the tools handle your code formatting for you and that too automatically.

In this short post, we will learn how you can use golines to automagically format all your golang code

Implementing Golines: a Golang formatter

Installing golines ```

go install github.com/segmentio/golines@latest

- Using golines from VSCode
    - Go into the VSCode settings menu, scroll down to the section for the `Run on Save` extension, click the `Edit in settings.json` link
    - Set the `emeraldwalk.runonsave` key as follows
    ```


    "emeraldwalk.runonsave": {
        "commands": [
            {
                "match": "\\.go$",
                "cmd": "golines ${file} -w"
            }
        ]
    }

- Save the settings and restart VSCode

(optional) using golines from CLI ```

golines -w "path to *.go files"

### Summary
golines together with vscode helps you autoformatt your code 
#### from

myMap := map[string]string{"first key": "first value", "second key": "second value", "third key": "third value", "fourth key": "fourth value", "fifth key": "fifth value"}



#### To

myMap := map[string]string{
"first key": "first value",
"second key": "second value",
"third key": "third value",
"fourth key": "fourth value",
"fifth key": "fifth value",
}


Isn't this beautiful, I know it is ;)


![](https://raw.githubusercontent.com/ksingh7/blogs/main/posts/assets/thats-all-folks.gif)

MongoDB Change Streams Implementation in Golang

karan singh — Sat, 19 Feb 2022 15:03:42 +0000

What are Change Streams?

Change streams is a near real-time ordered flow of information (stream) about any change to an item in a database, table/collection, or row of a table/document in a collection. For example, whenever any update (Insert, Update or Delete) occurs in a specific collection/table, the database triggers a change event with all the data which has been modified.

MongoDB Change Streams

MongoDB change streams provide a high-level API that can notify an application of changes to a MongoDB database, collection, or cluster, without using polling(which would come with much higher overhead). Characteristics of MongoDB Change Streams are:

Filterable
- Applications can filter changes to receive only those change notifications they need.
Resumable
- Change streams are resumable because each response comes with a resume token. Using the token, an application can start the stream where it left off (if it ever disconnects).
Ordered
- Change notifications occur in the same order that the database was updated.
Durable
- Change streams only include majority-committed changes. This is so every change seen by listening applications is durable in failure scenarios, such as electing a new primary.
Secure
- Only users with rights to read a collection can create a change stream on that collection.
Easy to use
- The syntax of the change streams API uses the existing MongoDB drivers and query language.

Experimenting with MongoDB Change Stream using Golang

Prerequisites

MongoDB Atlas Cluster, get it for free at https://www.mongodb.com/cloud/atlas
Codebase is available at https://github.com/ksingh7/mongodb-change-events-go.git

Getting Started with MongoDB Streams: Golang Implementation

# export MongoDB URI

export MONGODB_URI="mongodb+srv://admin:xxxxx@cluster0.ii90w.mongodb.net/myFirstDatabase?retryWrites=true&w=majority"

git clone https://github.com/ksingh7/mongodb-change-events-go.git
cd mongodb-change-events-go
go mod tidy
go run main.go

Demo Video

Here is my demo video recording that can help you understand this implementation.

Code Walkthrough

main.go file already has required guidelines in the form of comments. However, in this section, I will explain sections that I think are crucial

Declaring struct returned by MongoDB Stream API

type DbEvent struct {
    DocumentKey     documentKey     `bson:"documentKey"`
    OperationType    string                   `bson:"operationType"`
}
type documentKey struct {
    ID      primitive.ObjectID      `bson:"_id"`
}

Declaring a struct that resembles to the collection

type result struct {
    ID               primitive.ObjectID       `bson:"_id"`
    UserID        string                            `bson:"userID"`
    DeviceType string                            `bson:"deviceType"`
    GameState   string                            `bson:"gameState"`
}

Connect to MongoDB

    client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(os.Getenv("MONGODB_URI")))
    if err != nil {
        panic(err)
    }

Set DB and Collection names

    database := client.Database("summit-demo")
    collection := database.Collection("bike-factory")

Create a change stream

    changeStream, err := collection.Watch(context.TODO(), mongo.Pipeline{})
    if err != nil {
        panic(err)
    }

Iterate over the change stream

    for changeStream.Next(context.TODO()) {
        change := changeStream.Current
        fmt.Printf("%+v\n", change)
    }

Detect change type (Insert or Update) and accordingly fetch the document

        // Print out the document that was inserted or updated
        if DbEvent.OperationType == "insert" ||  DbEvent.OperationType == "update" {
            // Find the mongodb document based on the objectID
            var result result
            err  := collection.FindOne(context.TODO(), DbEvent.DocumentKey).Decode(&result)
            if err != nil {
                log.Fatal(err)
            }
            // Convert changd MongoDB document from BSON to JSON
            data, writeErr := bson.MarshalExtJSON(result, false, false)
            if writeErr != nil {
                log.Fatal(writeErr)
            }
            // Print the changed document in JSON format
            fmt.Println(string(data))
            fmt.Println("")
        }

Close the change stream

    if err := changeStream.Close(context.TODO()); err != nil {
        panic(err)
    }

Bonus : Function to Insert records to MongoDB collection

func insertRecord(collection *mongo.Collection) {
        // pre-populated values for DeviceType and GameState    
        DeviceType := make([]string, 0)
        DeviceType = append(DeviceType, "mobile","laptop","karan-board","tablet","desktop","smart-watch")
        GameState := make([]string, 0)
        GameState = append(GameState, "playing","paused","stopped","finished","failed")

        // insert new records to MongoDB every 5 seconds
        for {
            item := result{
                ID: primitive.NewObjectID(),
                UserID: strconv.Itoa(rand.Intn(10000)),
                DeviceType: DeviceType[rand.Intn(len(DeviceType))],
                GameState: GameState[rand.Intn(len(GameState))],
            }
            _, err := collection.InsertOne(context.TODO(), item)
            if err != nil {
                log.Fatal(err)
            }

            time.Sleep(5 * time.Second)
        }
    }

Summary

Hope this post gives you a better understanding of MongoDB Change Streams and how to use them in your application.

Demo : Twitter streaming and sentiment analysis using Kafka, OCS, MongoDB & OpenShift (Kubernetes)

karan singh — Tue, 15 Feb 2022 20:25:09 +0000

You know tech tools are cool, but unless you have a defined use case it's hard to put things into perspective and understand how different tools can interact with each other, help solve a problem or explore new use cases.

So to educate and motivate our technical buyers, sellers and customers, I created a fancy use case of ingesting live Twitter tweets and applying sentiment analysis to it. For this demo, i used the following tools

Twitter API : Realtime streaming data source
Red Hat AMQ Streams : Apache Kafka cluster to store real-time streaming data coming into the system
MongoDB : Storing tweets for long term persistence from Kafka into a schema-less NoSQL database
Red Hat OpenShift Container Storage : Used for providing RWO (in this project), RWX, Object Storage persistence storage for Kafka and MongoDB apps running on OpenShift
*Red Hat OpenShift Container Platform *: Enterprise grade k8s distribution for container apps
**Aylien : **Sentiment analysis solution backend
Python : Backend API app to trigger data sourcing from twitter, move data from Kafka to MongoDB, server data to frontend app
Frontend : basic HTLM, CSS, Javascript-based frontend to plot some graphs

This slide deck should give you a glimpse of how the demo would look like (demo youtube/github link below)

Slide Deck

And here is the actual demo recording that you can go through, where i have explained how these components work together and make this a viable solution if you have a real-world use case along the same lines

YouTube Video Link]

If you are interested in running this demo by yourself, you can find the code in my repo, Github project link : https://github.com/ksingh7/twitter_streaming_app_on_openshift_OCS

Happy Analysing Live Tweets

Connecting to Kafka Cluster running on Kubernetes from your Local Machine : CLI & Programatic Access

karan singh — Tue, 15 Feb 2022 20:25:06 +0000

Introduction

Why do you need this?

For local development you want to connect to a remote Kafka Cluster running on OpenShift , that is deployed using Strimzi Operator

Prerequisite

OpenShift Container Platform or OKD
Strimzi Operator deployed

Deploy Kafka Cluster

Create a YAML file with these contents (only for dev/test clusters)

    apiVersion: kafka.strimzi.io/v1beta2
    kind: Kafka
    metadata:
      name: my-cluster
      namespace: nestjs-testing
    spec:
      entityOperator:
        topicOperator: {}
        userOperator: {}
      kafka:
        config:
          inter.broker.protocol.version: "2.8"
          log.message.format.version: "2.8"
          offsets.topic.replication.factor: 3
          transaction.state.log.min.isr: 2
          transaction.state.log.replication.factor: 3
        listeners:
        - name: plain
          port: 9092
          tls: false
          type: internal
        - name: tls
          port: 9093
          tls: true
          type: internal
        - name: route
          port: 9094
          tls: true
          type: route
        replicas: 3
        storage:
          type: ephemeral
        version: 2.8.0
      zookeeper:
        replicas: 3
        storage:
          type: ephemeral

Preparing to Connect

    oc get secret my-cluster-cluster-ca-cert -o jsonpath='{.data.ca\.crt}' | base64 -d > ca.crt

    keytool -import -trustcacerts -alias root -file ca.crt -keystore truststore.jks -storepass password -noprompt

    # This should create 2 files in PWD

    ls -l *.crt *.jks

Grab Kafka Endpoint

KAFKA_ENDPOINT=$(oc get kafka my-cluster -o=jsonpath='{.status.listeners[?(@.type=="route")].bootstrapServers}{"\n"}')

Connecting from CLI (Kafka Console Producer/Consumer)

Get Kafka Console Producer & Consumer script files

    wget [https://dlcdn.apache.org/kafka/3.0.0/kafka_2.13-3.0.0.tgz](https://dlcdn.apache.org/kafka/3.0.0/kafka_2.13-3.0.0.tgz) ; tar -xvf kafka_2.13-3.0.0.tgz

Console Producer

    kafka_2.13-3.0.0/bin/kafka-console-producer.sh --broker-list $KAFKA_ENDPOINT --producer-property security.protocol=SSL --producer-property ssl.truststore.password=password --producer-property ssl.truststore.location=truststore.jks --topic my-topic

Console Consumer

    kafka_2.13-3.0.0/bin/kafka-console-consumer.sh --bootstrap-server $KAFKA_ENDPOINT --topic my-topic --from-beginning  --consumer-property security.protocol=SSL --consumer-property ssl.truststore.password=password --consumer-property ssl.truststore.location=truststore.jks

Connecting from Python Client (running locally)

from kafka import KafkaProducer, KafkaConsumer
import json
from bson import json_util

bootstrap_server = 'my-cluster-kafka-route-bootstrap-nestjs-testing.apps.ocp.ceph-s3.com:443'

print("Producing messages to Kafka topic ...")
producer = KafkaProducer(bootstrap_servers=bootstrap_server, ssl_cafile='ca.crt', security_protocol="SSL")

for i in range(10):
    message = {'value': i}
    producer.send('my-topic', json.dumps(message, default=json_util.default).encode('utf-8'))

print("Consuming messages from Kafka topic ...")

consumer = KafkaConsumer('my-topic',  group_id='my-group', bootstrap_servers=bootstrap_server, ssl_cafile='ca.crt', security_protocol="SSL", consumer_timeout_ms=10000, enable_auto_commit=True)
for message in consumer:
    # message value and key are raw bytes -- decode if necessary!
    # e.g., for unicode: `message.value.decode('utf-8')`
    print ("%s:%d:%d: value=%s" % (message.topic, message.partition,message.offset,message.value))

This is how you can connect to a remote Kafka cluster from your local machine. This is handy when you are developing locally and eventually deploying that to your OpenShift environment.

The most elegant way to performance test your microservices running on Kubernetes

karan singh — Tue, 15 Feb 2022 20:24:17 +0000

“If you cannot measure it, you cannot improve it.” — Lord Kelvin

Application programming interfaces ( APIs) are the core system of most services. Client, web, and mobile applications are all built from APIs. They sit on the critical path between an end-user and a service, and they’re also used for intra-service communication.

Because APIs are so critical, API performance is also essential. It doesn’t matter how well-built your front-end application is if the API data sources it accesses take several seconds to respond. This is especially true in a world of microservices, where services depend on each other to provide data. In my opinion, the best feature your API can offer is great performance.

To measure API performance, you need to benchmark your APIs as reliably as possible, which can be challenging. The optimal approach depends on your performance objectives. In this article, I’ll guide you through an elegant process for measuring the performance of backend applications running on Red Hat OpenShift or Kubernetes. You’ll also learn how to use Vegeta, a versatile HTTP load testing and benchmarking tool written in Golang. We will deploy Vegeta on OpenShift and run performance tests in both standalone and distributed modes.

Standalone benchmarking with Vegeta

To run performance tests, you’ll need an API endpoint to test. I’ve provided a simple Go-based application that you will deploy on OpenShift. Once the application is deployed, we’ll apply various loads using Vegeta, as Figure 1 illustrates.

You can follow along with this example on your own OpenShift cluster if you have access to one; otherwise, you can use the Developer Sandbox for Red Hat OpenShift, which is free of charge with a Red Hat account.

Set up the example application

To begin, log in to your OpenShift cluster from the command line and run the following commands to create a simple GET API in Go.

    oc new-project perf-testing 
    oc new-app golang~https://github.com/sclorg/golang-ex.git --name=golang-service1 
    oc expose deployment/golang-service1 --port=8888 
    oc expose service/golang-service1 
    oc get route golang-service1 curl http://$(oc get route golang-service1 -o json | jq -r .spec.host)

Set up the Vegeta benchmarking environment

Next, install Vegeta on your local machine. Use this command if you’re running macOS:

    brew update && brew install vegeta

Use this command on Linux:

    wget https://github.com/tsenart/vegeta/releases/download/v12.8.4/vegeta_12.8.4_linux_amd64.tar.gz -O /tmp/vegeta.tar.gz 

    tar -xvf /tmp/vegeta.tar.gz sudo mv vegeta /usr/local/bin/

Launch your benchmarking process

Now, you’re ready to launch the benchmarking process:

    echo "GET http://$(oc get route golang-service1 -o json | jq -r .spec.host)" | vegeta attack -duration=60s | vegeta report

How to read the Vegeta output

Vegeta’s output is largely straightforward; here’s an example:

    ## Output

    Requests      [total, rate, throughput]         3000, 50.02, 49.84
    Duration      [total, attack, wait]             1m0s, 59.978s, 214.968ms
    Latencies     [min, mean, 50, 90, 95, 99, max]  204.638ms, 217.337ms, 214.49ms, 222.256ms, 227.075ms, 394.248ms, 492.278ms
    Bytes In      [total, mean]                     51000, 17.00
    Bytes Out     [total, mean]                     0, 0.00
    Success       [ratio]                           100.00%
    Status Codes  [code:count]                      200:3000
    Error Set:

Some of the more important metrics here are:

Requests: The total number of requests, their rate per second, and their throughput.
Latencies: The time taken to send the requests and the time taken to wait for the response.
Success: The percentage of requests that were successful.
Status Code: The status code and the number of requests that were successful.

To summarize the output of this first test: When we attempted to access the single pod of the service golang-service1 over the internet, we found a mean latency of around 217 milliseconds at 50 requests per second. This is a good indication that the application is working as expected.

Testing API performance with Vegeta

Now, let’s get more serious. Run a test with 64 parallel workers, without any throttling or rate-limiting:

    echo "GET http://$(oc get route golang-service1 -o json | jq -r .spec.host)"| vegeta attack -duration=60s -rate=0 -max-workers=64 | vegeta report

Here’s the output:

    ## Output

    Requests      [total, rate, throughput]         17908, 298.44, 297.38
    Duration      [total, attack, wait]             1m0s, 1m0s, 214.692ms
    Latencies     [min, mean, 50, 90, 95, 99, max]  201.543ms, 214.793ms, 214.57ms, 222.524ms, 224.861ms, 228.75ms, 563.581ms
    Bytes In      [total, mean]                     304436, 17.00
    Bytes Out     [total, mean]                     0, 0.00
    Success       [ratio]                           100.00%
    Status Codes  [code:count]                      200:17908
    Error Set:

With the load increased to 64 threads, we got a mean latency of around 214 milliseconds at 298 requests per second-a rate per second that’s six times higher than what we saw in the previous test. The latency basically stayed constant (it actually dipped just a bit) as the number of requests per second increased, which is great.

Note: We are stress-testing a Golang app running on a single pod, hosted on a shared OpenShift cluster over the internet (in this case, the cluster is hosted on the Developer Sandbox). This is just an example to show you how to quickly run a performance test against your own application; it does not represent the real-world performance of any component.

Benchmarking Kubernetes service names in a cluster

In the previous test, you benchmarked an internet-facing service endpoint. In this test, you’ll use the locally accessible Kubernetes service name and run a performance test against that, as illustrated in Figure 2.

Launch Vegeta as a pod in the same namespace (project) as your service, then run the same test that you ran previously:

    oc run vegeta --rm --attach --restart=Never --image="quay.io/karansingh/vegeta-ubi" -- sh -c \
    "echo 'GET [http://golang-service1:8888'](http://golang-service1:8888') | vegeta attack -duration=60s -rate=0 -max-workers=64 | vegeta report"

Here’s the output:

    ## Output

    If you don't see a command prompt, try pressing enter.
    Requests      [total, rate, throughput]         732977, 12205.54, 12205.23
    Duration      [total, attack, wait]             1m0s, 1m0s, 1.514ms
    Latencies     [min, mean, 50, 90, 95, 99, max]  201.313µs, 3.133ms, 472.767µs, 1.751ms, 3.585ms, 80.58ms, 102.89ms
    Bytes In      [total, mean]                     12460609, 17.00
    Bytes Out     [total, mean]                     0, 0.00
    Success       [ratio]                           100.00%
    Status Codes  [code:count]                      200:732977
    Error Set:

The service is now seeing about 12,000 requests per second, and the mean latency is 3 milliseconds. These improved results should come as no surprise: All the traffic is staying within OpenShift, unlike the previous test in which Vegeta connected to the Golang service over the internet.

A distributed load test for parallel containerized workloads

Next, let’s try a benchmarking test that’s closer to a real-world example. You’ll run the same test again, using the Golang application’s Kubernetes service name. But this time, you’ll launch multiple Vegeta pods, all hammering your backend microservice in parallel, as illustrated in Figure 3.

Start by scaling the Go application deployment to 10 replicas, which should make things more interesting:

    oc scale deployment/golang-service1 --replicas=10

The best way to launch a distributed load test is to use OpenShift’s Job object, which provides the flexibility to launch parallel containerized workloads. Create a YAML file named vegeta-job.yaml with the following content. This sets parallelism to 10 pods, which will launch 10 Vegeta pods, which will in turn launch attacks on the Golang service:

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: vegeta
    spec:
      parallelism: 10
      completions: 10
      backoffLimit: 0
      template:
        metadata:
          name: vegeta
        spec:
          containers:
          - name: vegeta
            image: quay.io/karansingh/vegeta-ubi
            command: ["/bin/sh","-c"]
            args: ["echo 'GET [http://golang-service1:8888'](http://golang-service1:8888') | vegeta attack -duration=60s -rate=0 -max-workers=64 | tee /tmp/results.bin ; sleep 600" ]
          restartPolicy: OnFailure

Apply this file to the OpenShift cluster:

    oc create -f vegeta-job.yaml

Wait a minute or two for Vegeta to complete its test run. Then, execute the following command, which will import and aggregate the binary output files from all 10 Vegeta pods onto your local machine (where you installed the Vegeta binary at the beginning of this article) and generate a final performance report:

    for i in $(oc get po | grep -i vegeta | awk '{print $1}') ; do oc cp $i:tmp/results.bin $i.bin & done ; fg vegeta report *.bin ;

Here’s the output from the distributed test:

    ## Output

    Requests [total, rate, throughput] 5651742, 88071.28, 88070.66
    Duration [total, attack, wait] 1m4s, 1m4s, 449.276µs
    Latencies [min, mean, 50, 90, 95, 99, max] 69.075µs, 5.538ms, 1.476ms, 16.563ms, 27.235ms, 47.554ms, 333.121ms
    Bytes In [total, mean] 96079614, 17.00
    Bytes Out [total, mean] 0, 0.00
    Success [ratio] 100.00%
    Status Codes [code:count] 200:5651742
    Error Set:

In this test, the Golang service delivered a mean latency of around 5.5 milliseconds at 88,070 requests per second, which works out to about 5.2 million requests per minute. That’s pretty impressive performance.

Tidy up your environment

After my experiments, I like to clean up my system. You can tidy up your own machine with this command:

    oc delete -f vegeta-job.yaml oc delete project perf-testing

Conclusion

There is a great saying from the physicist and engineer Lord Kelvin: “If you cannot measure it, you cannot improve it.” In this article, you’ve learned an elegant method for testing API performance in your distributed microservices applications. You can use the techniques introduced here to benchmark your next great backend microservice application running on OpenShift or Kubernetes.

Backing up Prometheus using TSDB Snapshots : Kubernetes/OpenShift

karan singh — Tue, 15 Feb 2022 11:30:00 +0000

These are my quick-and-dirty brain-dump notes to myself on how to backup prometheus database running on k8s or OpenShift

Get Token for API Authentication and Prometheus API Route URL

    oc whoami -t
    oc get route -n openshift-monitoring | grep -i prometheus

Run sample curl request

    curl -ks -H ‘Authorization: Bearer 0za4LjX9xPcqDjhWaufkgcQGo4grqA7ws4zvHrqgfY4’ ‘[https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v1/query?query=ALERTS'](https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v1/query?query=ALERTS') | python -m json.tool

Create TSDB Snapshot

    curl -X ‘POST’ -ks -H ‘Authorization: Bearer 0za4LjX9xPcqDjhWaufkgcQGo4grqA7ws4zvHrqgfY4’ ‘[https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v2/admin/tsdb/snapshot'](https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v2/admin/tsdb/snapshot') | python -m json.tool

You might get an error, so you first need to enable Admin APIs

    {
     “error”: “Admin APIs are disabled”,
     “message”: “Admin APIs are disabled”,
     “code”: 14
    }

Enable AdminAPI

    oc -n openshift-monitoring patch prometheus k8s \
     — type merge — patch ‘{“spec”:{“enableAdminAPI”:true}}’

Verify Admin API is enabled

    oc describe po prometheus-k8s-1 | grep -i admin
     — web.enable-admin-api

Hit TSDB snapshot API to take snapshot

    curl -X ‘POST’ -ks -H ‘Authorization: Bearer 0za4LjX9xPcqDjhWaufkgcQGo4grqA7ws4zvHrqgfY4’ ‘[https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v2/admin/tsdb/snapshot'](https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v2/admin/tsdb/snapshot')
     | python -m json.tool

    {
     “name”: “20210512T162601Z-33415dbd315ae6af”
    }

Find the snapshot and copy it locally
The default folder is /prometheus/snapshots/ but you can find the data folder by finding the --storage.tsdb.path config in your deployment.

    curl -X ‘POST’ -ks -H ‘Authorization: Bearer 0za4LjX9xPcqDjhWaufkgcQGo4grqA7ws4zvHrqgfY4’ ‘[https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v1/admin/tsdb/snapshot'](https://prometheus-k8s-openshift-monitoring.apps.ocp4.cp4d.com/api/v1/admin/tsdb/snapshot') | python -m json.tool

List the the snapshot directory

    oc -n openshift-monitoring exec -it prometheus-k8s-0 -c prometheus — /bin/sh -c “ls /prometheus/snapshots/20210512T162601Z-33415dbd315ae6af”

Copy the Snapshot from prometheus container to local machine

    oc project openshift-monitoring
    oc rsync prometheus-k8s-0:/prometheus/snapshots/ /home/prometheus

And this is how to back Prometheus Snapshot to a local machine

LMDTFY Series : MultiCloud Vs Hybrid Cloud

karan singh — Tue, 15 Feb 2022 09:16:02 +0000

Difference between : MultiCloud and Hybrid Cloud

TL;DR

These two terms are very similar yet different. Lol ;D

MultiCloud : Refers to using multiple clouds from multiple public or private cloud providers for workloads or tasks spanning across said clouds but without any interconnectivity between the clouds.
Hybrid Cloud : Refers to the combination of public and private clouds with some degree of connectivity, integration, portability and unified management.

Allow Containers to run as root on OpenShift 4 : Hack

karan singh — Mon, 14 Feb 2022 09:30:01 +0000

🤫 Don’t tell anyone that i shared this trick with you

Let me tell you that OpenShift is the most secure Kubernetes distribution on this planet. So OpenShift has the responsibility to secure your apps, which is why OpenShift does not allow containers to run as root.

“ First Principles : Never ever run your containers as root user”

Having said that, there are some instances when you want to run a pokemon container image that you found on some random container repository and want to run that to your OpenShift homelab/dev/test clusters.

Well to do so, you need to allow running container image as root and this is how you can do it.

oc login -u system:admin -n default

2. Create a new project where you will be running that in-secure container

oc new-project pokemon-prj

3. Add the security policy anyuid to the service account responsible for creating your deployment, by default this user is default. The dash z indicates that we want to manipulate a service account

oc adm policy add-scc-to-user anyuid -z default

4. You are all set, go and deploy or re-deploy your containers, it should work now, in pokemon-prj project

Summary

Don’t ever run containers as root in production environments
Don’t tell anyone that you learned this hack from this blog

Export Medium Stories to Markdown format

karan singh — Sun, 13 Feb 2022 20:54:42 +0000

Introduction

If you are like me, I mean a frequent tech blogger. You would like to keep all your blog posts in Markdown format. If you have not thought about this until now, then I invite you to give a serious thought.

Nothing could beat, a blog post in Markdown format. It is a simple format that is easy to read and write. It is also a very good format for blogs, and brownie points to store those in a git repository.

I have been writing on Medium for a while now, and was using its inbuilt editor. Lately I have started to use hashnode and dev.to. I thought, why not move my Medium blog posts to dev.to and hashnode (both of them supports markdown). However, there was no easy way provided by Medium to export them to markdown.

mediumexporter to the rescue

Install node on your computer
Then install mediumexporter node package

npm install -g mediumexporter

Finally, export your medium stories to Markdown format using mediumexporter

mediumexporter https://ksingh7.medium.com/kubernetes-endpoint-object-your-bridge-to-external-services-3fc48263b776 > exported-blog.md

This will create exported-blog.md file in your present working directory, which is the markdown file you were looking for.

Summary

Like everything, this is not a perfect solution. But it is a good start. You might want to review the code/image formatting, before you can re-port this blog to other platforms.

Special Thanks to the creator of markdownexporter that I used to export my Medium stories to Markdown format. Thanks a lot and well done my friend :)

Minimalistic guide to Launch Azure Red Hat Openshift

karan singh — Sun, 13 Feb 2022 10:19:54 +0000

What is ARO

Azure Red Hat OpenShift (ARO) is a fully-managed service of Red Hat OpenShift on Azure, Jointly engineered, managed, and supported by Microsoft and Red Hat.

Prerequisites

Azure account with portal access
Make sure your Azure User account has Microsoft.Authorization/roleAssignments/write permissions, such as User Access Administrator or Owner more info here

The default Azure resource quota for a new Azure subscription is 10 and does not meet this requirement. Increase quota from 10 to minimum 40 by following this guide
Launch Azure Cloud Shell from Azure Portal (top right).
Export some variables that we will often use in the rest of the tutorial.

export LOCATION=centralindia
export RESOURCEGROUP=ksingh-resource-group-india
export CLUSTER=azureopenstack

Verify the quota

az vm list-usage -l $LOCATION \
--query "[?contains(name.value, 'standardDSv3Family')]" \
-o table

Grab subscription ID from Azure Portal

az account set --subscription <SUBSCRIPTION ID>

Launching ARO Cluster

# Register the resource providers

az provider register -n Microsoft.RedHatOpenShift --wait
az provider register -n Microsoft.Compute --wait
az provider register -n Microsoft.Storage --wait
az provider register -n Microsoft.Authorization --wait

# Create a resource group

az group create --name $RESOURCEGROUP --location $LOCATION

# Create a virtual network

az network vnet create --resource-group $RESOURCEGROUP --name aro-vnet --address-prefixes 10.0.0.0/22

# Create two subnets in aro-vnet network for OpenShift control plane (master) and worker nodes

az network vnet subnet create --resource-group $RESOURCEGROUP --vnet-name aro-vnet --name master-subnet --address-prefixes 10.0.0.0/23 --service-endpoints Microsoft.ContainerRegistry

az network vnet subnet create --resource-group $RESOURCEGROUP --vnet-name aro-vnet --name worker-subnet --address-prefixes 10.0.2.0/23 --service-endpoints Microsoft.ContainerRegistry

# Update master node subnet network policy

az network vnet subnet update --name master-subnet --resource-group $RESOURCEGROUP --vnet-name aro-vnet --disable-private-link-service-network-policies true

# Finally, create ARO cluster with default configuration

az aro create --resource-group $RESOURCEGROUP --name $CLUSTER --vnet aro-vnet --master-subnet master-subnet --worker-subnet worker-subnet

Connect to ARO

(GUI) Grab OpenShift Console URL and credentials

az aro show --name $CLUSTER --resource-group $RESOURCEGROUP --query "consoleProfile.url" -o tsv
az aro list-credentials --name $CLUSTER --resource-group $RESOURCEGROUP

(CLI) Install OpenShift Client oc

cd ~
wget https://mirror.openshift.com/pub/openshift-v4/clients/ocp/latest/openshift-client-linux.tar.gz

mkdir openshift
tar -zxvf openshift-client-linux.tar.gz -C openshift
echo 'export PATH=$PATH:~/openshift' >> ~/.bashrc && source ~/.bashrc

apiServer=$(az aro show -g $RESOURCEGROUP -n $CLUSTER --query apiserverProfile.url -o tsv)
oc login $apiServer -u kubeadmin -p <kubeadmin password>

Summary

The experience of launching OpenShift cluster from Azure Cloud Shell aro is very simple and easy.
Hope this guide helps you, See You Next Time o/