DEV Community: Abhishek Yadav

Kubernetes and Helm Package Manager

Abhishek Yadav — Sat, 07 Dec 2024 17:51:39 +0000

Introduction

Kubernetes has become the de facto standard for container orchestration, enabling developers to deploy, scale, and manage containerized applications efficiently. However, managing Kubernetes manifests (YAML files) for complex applications can quickly become overwhelming. That’s where Helm, the package manager for Kubernetes, steps in to simplify the process.

What is Kubernetes?

Kubernetes is a powerful open-source platform that automates the deployment, scaling, and management of containerized applications.
The main components of Kubernetes are

Master Node Components

API Server: Acts as the gateway for all Kubernetes API requests. It validates and processes REST commands.
Controller Manager: Manages controllers (e.g., Node Controller, Deployment Controller) that ensure the desired state of cluster objects.
Scheduler: Assigns pods to nodes based on resource availability and scheduling policies.
etcd: A key-value store that holds the cluster's state and configuration data.
Worker Node Components
Kubelet: Ensures that containers are running in pods.
Kube-proxy: Handles networking, including forwarding requests to appropriate pods.
Container Runtime: Manages container lifecycle (e.g., Docker, containerd).
Workload Objects
Pod: The smallest deployable unit; encapsulates containers and shared resources like storage and networking.
Service: Exposes pods to the network, ensuring stable connectivity.
Deployment: Manages the desired state of pods, supports scaling and rolling updates.
ConfigMap & Secret: Provide externalized configurations and secure data, respectively.

What is Helm?

Helm is often called the "Yum or Apt of Kubernetes." It simplifies Kubernetes application deployment by bundling all the manifests into a single reusable package called a chart. With Helm, you can Package all resources (Deployments, Services, ConfigMaps, etc.) into a chart.
Version-control your deployments.
Customize application configurations through values files.
Roll back to previous deployments in case of failure.

Why Use Helm?
Here’s why Helm is a game-changer:

Simplified Deployment
Instead of managing individual YAML files, you use Helm charts that
organize all resources.
Reusability
Charts can be reused across environments (development, staging,
production) by overriding values.
Ease of Updates
Helm makes rolling updates and rollbacks straightforward.
Consistency
Standardizes application deployments across teams.

Getting Started with Helm

Install
Install helm https://helm.sh/docs/intro/install/
Create a Helm Chart
Use the helm create command to scaffold a new chart:

helm create my-app-deploy

Lets say we want to deploy three services frontend, backend and Redis.
Now we will customise helm chart to deploy these services.

First edit values.yaml file

replicaCount: 1

backend:
  image: sample-backend
  service:
    type: ClusterIP
    port: 8000
  env:
    REDIS_URI: redis://redis-svc:6379

frontend:
  image: sample-frontend
  service:
    type: NodePort
    port: 5173
    nodePort: 31000
  env:
    BACKEND_URL: http://backend-svc:8000

redis:
  image: redis
  service:
    type: ClusterIP
    port: 6379

namespace: default

Now Update Chart.yaml file

apiVersion: v1
name: my-app-deploy
description: A Helm chart for deploying backend, frontend, and redis
version: 1.0.0
appVersion: "1.0.0"

Inside your templates folder update service.yaml file


apiVersion: v1
kind: Service
metadata:
  name: backend-svc
  namespace: {{ .Values.namespace }}
spec:
  type: {{ .Values.backend.service.type }}
  selector:
    app: backend
  ports:
  - protocol: TCP
    port: {{ .Values.backend.service.port }}
    targetPort: {{ .Values.backend.service.port }}

---
apiVersion: v1
kind: Service
metadata:
  name: frontend-svc
  namespace: {{ .Values.namespace }}
spec:
  type: {{ .Values.frontend.service.type }}
  selector:
    app: frontend
  ports:
  - protocol: TCP
    port: {{ .Values.frontend.service.port }}
    targetPort: {{ .Values.frontend.service.port }}
    nodePort: {{ .Values.frontend.service.nodePort }}

---
apiVersion: v1
kind: Service
metadata:
  name: redis-svc
  namespace: {{ .Values.namespace }}
spec:
  type: {{ .Values.redis.service.type }}
  selector:
    app: redis
  ports:
  - protocol: TCP
    port: {{ .Values.redis.service.port }}
    targetPort: {{ .Values.redis.service.port }}

Finally update deployment.yaml


apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Chart.Name }}-backend
  namespace: {{ .Values.namespace }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: backend
        image: {{ .Values.backend.image }}
        ports:
        - containerPort: {{ .Values.backend.service.port }}
        env:
        - name: REDIS_URI
          value: {{ .Values.backend.env.REDIS_URI }}

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Chart.Name }}-frontend
  namespace: {{ .Values.namespace }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: {{ .Values.frontend.image }}
        ports:
        - containerPort: {{ .Values.frontend.service.port }}
        env:
        - name: BACKEND_URL
          value: {{ .Values.frontend.env.BACKEND_URL }}

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Chart.Name }}-redis
  namespace: {{ .Values.namespace }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: {{ .Values.redis.image }}
        ports:
        - containerPort: {{ .Values.redis.service.port }}

Before going further make sure you installed minikube and and it is running properly.
Complete installation guide https://minikube.sigs.k8s.io/docs/start/

Now let's focus on helm

Deploy the Helm Chart

helm install my-app-deploy ./my-app-deploy

Verify deployment

kubectl get deployments
kubectl get services

Check out this repo for reference https://github.com/AIABHISHEK/cosmocloud-deploy

Streamline Your Smart Contract Development with Foundry

Abhishek Yadav — Thu, 07 Nov 2024 16:23:25 +0000

What is foundry??

Foundry is a comprehensive toolchain specifically designed to empower developers in the realm of smart contract creation. It streamlines the entire development process, offering a robust set of features that manage dependencies, compile code, run tests, facilitate deployments, and even enable interaction with the blockchain through both command-line and Solidity scripts. In essence, Foundry acts as a one-stop shop for smart contract development, eliminating the need to juggle multiple disparate tools.
More on official website

To summarize we can it does everything we require in the blockchain development and comes built in with utility tools.

How to install??
Before going further make sure you have installed GIT BASH because these commands will not work on windows terminal.
Before installing foundry we need to install latest version of the rust.
To install rust run below command in your bash terminal

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

To check rust is correctly installed run this command

cargo --version

To install foundry run this command in your bash terminal

curl -L https://foundry.paradigm.xyz | bash

This will install following tools

Forge
Cast
Anvil
Chisel

If you want to learn in depth about these tools check out this official doc

Now let's start our project using foundry.

$ forge init <project_name>

This will create template project in in this directory
cd into the folder.
Now let's understand all the folder one by one.
src --> In this folder we will write all our smart contracts
script --> here we write our deploy scripts
For Now these to enough to write our smart contract and continue working.
Now Delete existing file from the src directory and create a new file and write your smart contract.

For Example: let's create a file with name myContract.sol

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract myContract {
    uint256 myNumber;

    function store(uint256 _myNumber) public {
        myNumber = _myNumber;
    }

    function getMyNumber() public view returns (uint256) {
        return myNumber;
    }
}

Now Delete existing file in file script directory and add your file with name DeploymentScript.s.sol
Code:

pragma solidity ^0.8.18;

import { myContract } from "../src/SimpleStore.sol";
import  "../lib/forge-std/src/Script.sol";

contract DeploymentScript is Script {
    function run() external returns (myContract) {

        // all transactions will take place in between the startBroadcast() and stopBroadcast()
        vm.startBroadcast();
        myContract myc = new myContract();
        vm.stopBroadcast();
        return myc;
    }
}

In above code are importing our contract then importing standard lib provided in lib folder

Since we have created our contract let's compile it make sure everything is ok

forge build

Now lets deploy our contract although you can deploy your contract using deploy script but we can also use our bash terminal to deploy contract.

Steps to deploy

First run this command

anvil

This will run local blockchain node

Now run below command to deploy our smart contract

forge create <your_contract_name> --interactive

By default if you will not provide rpc-url it will try to deploy on local node where anvil running.
If you are using Ganache and need to provide an RPC URL, use:

forge create <your_contract_name> --rpc-url <your_rpc-url> --interactive

Now let's use our deploy script to deploy our smart contract
Use this command

forge script script/DeploymentScript.s.sol --rpc-url <rpc-url> --interactive --sender <address> --broadcast -vvvv

Make sure to copy address and private key corresponding to that address from bash terminal where anvil running

Once you run above command you will see some in your anvil bash terminal.

We use cast to interact with deployed smart contract from bash terminal.

To call store function we can use following command.

cast send 0x5FbDB2315678afecb367f032d93F642f64180aa3 "store(uint256)" 123 --rpc-url http://127.0.0.1:8545 --interactive

when prompted give private key of wallet (you can get it from bash terminal of anvil)

Now to call getMyNumber which is view function we can use following command

cast call 0x5FbDB2315678afecb367f032d93F642f64180aa3 "getMyNumber()" --rpc-url http://127.0.0.1:8545

You may have noticed when call we store function we do need private key where as while we call getMyNumber we do not.
Let's understand the reason:
In Solidity, functions can be categorized into two main types: state-changing functions and view/pure functions.

State-changing functions:

These functions can modify the state of the blockchain. Any modification to the contract's state variables or storage will require a transaction, and transactions in Ethereum incur gas fees.
Examples include functions that modify the contract's state, such as writing to storage variables.

View and Pure functions:

These functions are read-only and do not modify the state. They don't require a transaction and can be called without incurring gas fees. View functions are allowed to read the state of the contract but cannot modify it. Pure functions do not read or modify the state; they are entirely self-contained.

The store function modifies the state by updating the myNumber state variable. Therefore, it is a state-changing function and requires a transaction, incurring gas fees.

The getMyNumber function, on the other hand, is declared as view, indicating that it only reads from the state and does not modify it. As a result, it can be called without a transaction and does not incur gas fees.

Thank you for reading.

How to Dockerize Your Node.js App in Minutes

Abhishek Yadav — Sat, 16 Mar 2024 17:49:46 +0000

Prerequisites

Before we begin, make sure you have Docker installed on your development machine. You can download and install Docker Desktop from the official Docker website here for your operating system.

Once Docker is installed, ensure that you have a working Node.js application that you want to dockerize.
You can clone this repo to get started this is simple node-app here

Setting Up Dockerfile

The first step in dockerizing your Node.js application is creating a Dockerfile. This file contains instructions for building a Docker image that encapsulates your application and its dependencies.
Create a dockerfile in your node-app directory.

Here's a simple Dockerfile to get you started:

# Use the official Node.js image based on Alpine Linux with the latest LTS version
FROM node:alpine

# Set the working directory inside the container
WORKDIR .

# Copy package.json and package-lock.json to the working directory
COPY package.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application code to the working directory
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Command to run the application
CMD ["node", "app.js"]

Building Your Docker Image

Once you've created your Dockerfile, it's time to build your Docker image. Open a terminal or command prompt, navigate to the directory containing your Node.js application and Dockerfile, and run the following command
You can specify your image name using the -t flag.

docker build -t your-image-name .

Running Your Docker Container

With your Docker image built, you can now run a Docker container based on that image. Use the following command
docker run -p 4000:5000 your_image_name
This command will start a container from your image and map port 5000 of the container to port 4000 on your host machine, allowing you to access the application via
http://localhost:4000
Regardless of the EXPOSE settings, you can override them at runtime by using the -p as we are doing in the command.

Congratulations! You've successfully dockerized your Node.js application.

How to Connect Express app to RabbitMQ

Abhishek Yadav — Tue, 26 Sep 2023 15:38:36 +0000

Introduction

RabbitMQ is an open-source message broker software that facilitates message queuing. It provides a platform for different software components to communicate by sending and receiving messages.
Now let's go through the process of connecting RabbitMQ to our Express App
Step-1
Run RabbitMQ on your machine
Easiest way to do this use docker image of rabbitmq and run this docker image.

docker pull rabbitmq

Then run the docker image using this command

docker run -d -p 15672:15672 -p 5672:5672 --hostname my-rabbitmq --name my-rabbitmq-container rabbitmq:3-management

Step-2
Create Express app

const express = require('express');

const app = express();
const PORT = 3000;

app.post('/orders', (req, res) => {
    res.send('Order submitted');
});

app.listen(PORT, () => {
    console.log(`Server running on ${PORT}`);
});

Test your app using postman

Step-3
Now it is time add code to connect to rabbitmq
To rabbitmq we need amqplib npm package install this package in your project

npm install amqplib

Now add code for connection to rabbitmq in your express app

const amqplib = require('amqplib');
const express = require('express');

const app = express();
const PORT = 9005;
let channel, connection;

async function connect() {
    try {
        const amqpServer = 'amqp://localhost:5672';
        connection = await amqplib.connect(amqpServer);
        channel = await connection.createChannel();
        await channel.assertQueue('order');
    } catch (error) {
        console.log(error);
    }
}

app.post('/orders', (req, res) => {
const data = {message: 'Order placed'};
    channel.sendToQueue('order', Buffer.from(JSON.stringify({ ...data, date: new Date() })));
    res.send('Order submitted');
});

app.get('*', (req, res) => {
    res.status(404).send('Not found');
});

app.listen(PORT, () => {
    connect();
    console.log(`Server running on ${PORT}`);
});

To make sure your you are connected to rabbitmq you can check rabbitmq management dashboard
You can access it on

http://localhost:15672/

Now check queue you will find queue created with the name you have given to your queue in my case order

Now to check you are receiving the data you are sending to queue and perform operation on that make another project install amqplib
Create a file with name worker.js

Now write the code to connect to rabbitmq and also to receive message sent by our express app from the queue

const amqp = require('amqplib');

const connectToRabbitMQ = async () => {
    try {
        const connection = await amqp.connect('amqp://localhost:5672');
        const channel = await connection.createChannel();
        return channel;
    } catch (error) {
        console.error('Error connecting to RabbitMQ:', error);
    }
};

const receiveMessageFromQueue = async (queueName) => {
    const channel = await connectToRabbitMQ();

    channel.assertQueue(queueName, { durable: true });
    channel.consume(queueName, (message) => {
        const content = message.content.toString();
        //perform operations on the message
        console.log(`Received message: ${content}`);
    });
};

const queueName = 'order'; // Replace with your queue name
receiveMessageFromQueue(queueName);

The receiveMessageFromQueue function will process the message sent to queue.

Thank you for taking the time to read. I'm in a continuous process of learning and sharing. If you spot any mistakes in my understanding or have any other insights, please feel free to let me know in the comments section.