DEV Community: Oshi Gupta

Creating Kubernetes Cluster With CRI-O

Oshi Gupta — Sun, 30 Jul 2023 13:09:58 +0000

Container Runtime Interface (CRI) is one of the important parts of the Kubernetes cluster. It is a plugin interface allowing Kubelet to use different container runtimes. And recently CRI-O container runtime has been announced as a CNCF Graduated project. I thought of writing a blog on CRI-O and how to set up a single-node Kubernetes cluster with Kubeadm and CRI-O.

What is CRI-O?

CRI-O is a lightweight container runtime for Kubernetes. It is an implementation of Kubernetes CRI to use Open Container Initiative (OCI) compatible runtimes for running pods. It supports runc and Kata Containers as the container runtimes, but any OCI-compatible runtime can be integrated.

It is an open-source, community-driven project which supports OCI-based container registries.
It is being maintained by contributors working in Red Hat, Intel, etc. It also comes with a monitoring program known as conmon. Conmon is an OCI container runtime monitor, which makes the communication between CRI-O and runc for a single container.

The below figure shows how CRI-O works with the Kubernetes cluster for creating containers in the pod.

Read more about the architecture of CRI-O here. The networking of the pod is set up through CNI, and CRI-O can be used with any CNI plugin.

Now, let’s see how to set up a Kubernetes cluster with Kubeadm and CRI-O as the container runtime.

Kubernetes Cluster With Kubeadm and CRI-O

In this, we will see how to set up a single-node Kubernetes cluster with Kubeadm and CRI-O as the container runtime. For this, I have used an Ubuntu 22.04 VM with 2 CPUs and 2 GB memory (minimum requirement for Kubeadm). In the last, I have attached a video showing the installation process.

Install Kubeadm, Kubelet, and Kubectl

First, disable the swap to make kubelet work properly.

sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
swapoff -a

Install Kubeadm , Kubelet, and Kubectl CLI tools. For this, update the apt package index and install packages to use Kubernetes apt repository.

apt-get update
apt-get install -y apt-transport-https ca-certificates curl

curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-archive-keyring.gpg

echo "deb [signed-by=/etc/apt/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

To install a Kubernetes cluster of a specific version, specify the version like below.

apt-get update
apt-get install -y kubelet=1.26.3-00 kubeadm=1.26.3-00 kubectl=1.26.3-00

Here I will be setting up a Kubernetes cluster with version 1.26.3

Check the version of the CLI tools.

kubeadm version
kubectl version
kubelet --version

Put a hold on these three tools so that it will not get an update if we update the system.

apt-mark hold kubelet kubeadm kubectl

Install CRI-O

Complete the prerequisites of installing any container runtime.

Enable br_netfilter and overlay modules and make iptables see bridged traffic.

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# sysctl params required by setup, params persist across reboots
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

# Apply sysctl params without reboot
sudo sysctl --system

Verify the modules are loaded with the following commands.

lsmod | grep br_netfilter
lsmod | grep overlay

Check the below-mentioned variables are set to 1 for letting iptables seeing bridged traffic.

sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward

Install CRI-O by setting OS and VERSION variables. Set OS according to your system and VERSION according to the Kubernetes cluster you wish to set up. It should be the same as Kubeadm/Kubelet.

OS=xUbuntu_22.04
VERSION=1.26

echo "deb [signed-by=/usr/share/keyrings/libcontainers-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list

echo "deb [signed-by=/usr/share/keyrings/libcontainers-crio-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list

mkdir -p /usr/share/keyrings

curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-archive-keyring.gpg

curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-crio-archive-keyring.gpg

apt-get update

apt-get install cri-o cri-o-runc cri-tools -y

Start and enable the CRI-O service and check its status.

sudo systemctl start crio.service

sudo systemctl enable crio.service

sudo systemctl status crio.service

One can also see the runtime info with the following.

crictl info

Set Cluster With Kubeadm

Pull the images for kubernetes version 1.26.3

kubeadm config images pull --kubernetes-version v1.26.3
kubeadm config images list

Create the cluster control-plane node.

kubeadm init --kubernetes-version v1.26.3

Create the config file in the ~/.kube directory to access the kuberentes cluster.

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Remove the taint from the control-plane node.

kubectl taint nodes --all node-role.kubernetes.io/control-plane-

Check the cluster nodes and verify the container runtime is CRI-O.

kubectl get nodes -o wide

As we have completed the process of creating a single node cluster. Now let’s install CNI to create a pod and expose it via service. Also, verify that the pod is running with CRI-O container runtime.

Install CNI

I have used Cilium as CNI and installing it with helm.

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3

chmod 700 get_helm.sh

./get_helm.sh

helm repo add cilium https://helm.cilium.io/

helm install cilium cilium/cilium --version 1.13.4 --namespace kube-system

kubectl get pods -n kube-system

Wait till the Cilium pods get into Running state.

Create a pod with nginx as its image.

kubectl run nginx --image=nginx
kubectl get pods

Verify CRI-O as container runtime is used in pod creation.

kubectl describe pod nginx | grep -i container

Expose the pod with the NodePort service.

kubectl expose pod nginx --type=NodePort --port=80
kubectl get svc

Access the application.

 curl http://<NODE_IP>:NODE_PORT

Yay!! A single-node Kubernetes cluster of version 1.26.3 is ready with CRI-O as the container runtime.

Video

Try out Hands-on

You can try the hands-on lab for this blog here at CloudYuga.

References

Connect With Me!!

Twitter : oshi1136
LinkedIn : Oshi Gupta

Pod Disruption Budget in Kubernetes

Oshi Gupta — Mon, 03 Jul 2023 14:32:49 +0000

Maintaining highly available applications in a Kubernetes cluster can be hard, especially when nodes go under maintenance or fail. The application pods get terminated or may reschedule on other nodes, which can cause downtime or data loss.

To make the applications available 24*7 even during system disruptions, a feature was introduced in Kubernetes known as Pod Disruption Budget. But before that, let’s dive into the different disruptions a system can face.

What are Disruptions?

Disruption, in general, means to break a process, and in terms of Kubernetes, pod disruption means to terminate the pod running on a cluster node if a node fails/upgrades or someone destroys it.

There are two types of disruptions:

Involuntary Disruptions
Voluntary Disruptions

Involuntary Disruptions

These disruptions are unavoidable and occur mainly due to hardware or software errors. Some of its examples are:

Hardware failure of the node.
The cluster admin deletes the node accidentally.
Kernel-related problem.
Cloud provider or hypervisor-related failure makes VM disappear.
Node gets disappear due to cluster network partitions.
Not enough resources left on a node.

Voluntary Disruptions

These disruptions occur by the application owner or cluster administrator.

An application owner can do the following:

Deletes the deployment/controller managing the pods.
Updating the deployment pod’s template causes a restart.
Accidentally deleting a pod.

A cluster administrator can do the following:

Draining a node for upgrade and maintenance.
Drain the node to scale down the cluster.
Removing pod from node to schedule some other pod on it.

These are some of the disruptions which take applications down and give users downtime. But let’s see how to deal with these disruptions.

How to Deal with Disruptions?

To deal with involuntary disruptions, one can follow the below solutions:

Make sure your pod requests the resources it needs and not more.
Create enough replicas of your application to make it more available(HA).
Even in HA, use anti-affinity to have pods on all cluster nodes or zone if using multi-zone clusters.

Similarly, to deal with voluntary disruptions mainly caused by cluster admin actions such as draining a node for maintenance and scaling down a cluster. One can use Pod Disruption Budget (PDB) to make applications always available.

Pod Disruption Budget

Pod Disruption Budget (PDB) is an object created by the application owner that defines the minimum number of application replicas that should run during voluntary disruptions (node upgrade/maintenance) to make it highly available.

Let’s understand with an example, Let’s say you are running a deployment with 6 replicas and have created a PDB which should have 4 replicas to run always in case of voluntary disruptions. Then the eviction API will allow the disruption of two pods at a time.

Features of Pod Disruption Budget

Below are the following features of PDB:

The application owner creates the PDBs.
It helps the operations team to manage the cluster while the application is always available.
Provides an interface between cluster admin and application owner to work smoothly.
Eviction API respects it.
It defines the availability requirements.
It works on Deployment, ReplicaSet, ReplicationController, and StatefulSet objects.

Pod Disruption Budget Fields

There are three main fields in PDB:

.spec.selector in PDB denotes the set of pods on which it is applied. It is the same as the application controller's label selectors.
.spec.minAvailable denotes the number of pods that must be available after eviction. It can be an absolute number or percentage.
.spec.maxUnavailable denotes the number of pods that can be unavailable after eviction. It can be an absolute number or percentage.

One can only specify the minAvailable or maxUnavailable field in a single pod disruption budget, not both.

Let’s see in more detail about PDB by creating a deployment and PDB on a multi-node cluster and draining one node.

Example of Pod Disruption Budget

You can deploy a local multi-node cluster with Kind or use managed Kubernetes services. I have used the EKS cluster for this demo.

kubectl get nodes

PDB is a namespaced-scope resource and belongs to api group policy with the v1 version.

kubectl api-resources | grep pdb

Below is the nginx-deployment yaml configuration with 8 replicas and app:nginx as label selector.

# nginx-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deploy
  labels:
    app: nginx
spec:
  replicas: 8
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80

kubectl apply -f nginx-deploy.yaml
kubectl get deploy

Verify pods are scheduled on both nodes

Use Case: 1

Create a PDB for the above deployment with the minAvailable field set to 5 and app:nginx as the label selector.

# pdb1.yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: pdb-minavail
spec:
  minAvailable: 5
  selector:
    matchLabels:
      app: nginx

kubectl apply -f pdb1.yaml
kubectl get pdb
kubectl describe pdb pdb-minavail

As we have set minAvailable=5, which means out of 8 replicas, 5 replicas will always run even if any voluntary disruption occurs.

Now, let’s drain the node and see pdb working

kubectl drain <node_name> --ignore-daemonsets --delete-emptydir-data

It tries to evict the pod and retries until all get evicted. Also, my node is now SchedulingDisabled. All the pods running on it are drained.

Let’s check the pod status and verify whether they have been rescheduled.

kubectl get pods -o wide

Here 4 pods were running on each node, and when I drained the node, pods got evicted and started rescheduling. One of the pods got rescheduled on other node, and three were not as insufficient resources left on the node and get into pending state.

But my node draining gets completed successfully as the PDB requirement was fulfilled to run 5 application pods. The eviction API respected PDB in this voluntary disruption.

Now uncordon the node to make the rest of the pods schedulable.

Use Case: 2

Now, increase the existing pdb minAvailable field to 6 and drain the node to see what happens.

# pdb1.yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: pdb-minavail
spec:
  minAvailable: 6
  selector:
    matchLabels:
      app: nginx

kubectl apply -f pdb1.yaml
kubectl get pdb

Once again, drain the cluster node.

k drain <node_name> --ignore-daemonsets  --delete-emptydir-data

You will observe that the drain will not be completed, and eviction API will retry to evict pods until it can reschedule on another node and throws an error: cannot evict pod as it would violate the pod’s disruption budget.

But why has this happened? Because the minimum available pods in pdb are 6 and the other node can only schedule 5 pods according to its resource capacity. As mentioned, eviction API gives PDB priority, so to make a minimum of 6 pods available, it will not drain the node and run the pods on it.

Although my node will mark SchedulingDisabled, it's not drained.

Delete the pdb and uncordon the node.

kubectl delete pdb pdb-minavail

Use Case : 3

Now, create another pdb resource with maxUnavailable set to 3.

# pdb2.yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: pdb-maxunavail
spec:
  maxUnavailable: 3
  selector:
    matchLabels:
      app: nginx

kubectl apply -f pdb2.yaml
kubectl describe pdb pdb-maxunavail

Follow the same steps of draining a node to check pdb working

k drain <node_name>  --ignore-daemonsets  --delete-emptydir-data

This time draining works completely as the pdb requirement got satisfied.

The rest of the pods remain unschedulable. Uncordon the node now.

Use Case: 4

Reduce the maxUnavailable field to 2, which makes 6 pods run all the time. Now if you drain the node, use case 2 scenario will happen. Node draining will be incomplete, and pods will not be evicted completely by giving weightage to PDB.

Use Case: 5

Now, what if I set maxUnavailable to 0? This is equal to the setting of minAvailable to 100%. It will be ensured that none of your pods will be disrupted when voluntary disruptions occur.

When not to use PDB?

There are certain cases when pdb cannot be used, such as:

It doesn’t work for involuntary disruptions
In voluntary disruptions, it will not work when pods or deployments get deleted.
Two PDBs can not work together on the same resource.
PDBs don’t work on a single pod or replica of deployment.

Summary

PDBs are useful when we want applications always available, even at cluster maintenance and upgrade times.

References

My LFX Mentorship With Kyverno

Oshi Gupta — Mon, 20 Jun 2022 08:03:36 +0000

“In open-source, we feel strongly that to really do something well, you have to get a lot of people involved.” - Linus Torvalds

This is one of my favourite quotes from Linus Torvalds which motivates me to contribute to open-source.
Hello everyone, My name is Oshi Gupta, I have recently graduated from the Linux Foundation(LFX) mentorship program with Kyverno and will be going to complete my engineering in the next two months.

And in this blog, I will be sharing my experiences of contributing to Kyverno as how I started, my LFX application process, and my mentorship journey.

📝 Table Of Contents

As this blog is covering my whole journey ,so to help you navigate it through easily this can help you.

About LFX Mentorship
About Kyverno
How did I start with Kyverno?
Applying For LFX Mentorship
My 12 Weeks Mentorship Journey
Graduation From LFX Mentorship
- My Pull Requests
In the End

About LFX Mentorship

The LFX mentorship is a remote learning opportunity for the open-source contributors who will be working for 12 weeks under the guidance of mentors who are maintainers and developers of the particular project and they help the mentees to contribute to the community and project.
This mentorship program is organized thrice a year i.e. Spring, Summer, and Fall months.
There are many organizations like CNCF, Hyperledger, and so on which provide mentorships in different projects of it under the umbrella of LFX.

About Kyverno

Kyverno is a policy engine specially designed for Kubernetes. Kyverno helps to manage policies as Kubernetes resources and is written in YAML format. Not only this, but It also helps in validating, mutating, and generating resources and as well as helping in verifying container images which are very important for software supply chain security.

How did I start with Kyverno?

This all started a few months back with my internship as a technical writer at CloudYuga Technologies where I was exploring admission webhook in Kubernetes, and different policy engines such as Open Policy Agent(OPA) and Kyverno for preparing a hands-on lab on them. And while going through both policy engines, Kyverno fascinates me a lot and I decided to learn more about it by contributing to it.

First, I decided to take a Kyverno certification issued by Nirmata to get more understanding of it. Then, I started attending the Kyverno contributors meeting, and honestly, as a beginner, I was not able to understand much in the first few meetings as it takes time to know about such a vast project.

But I keep attending it, went through the documentation of the project for better understanding, kept asking questions on the communication channels, and learnt how to set up the project locally. And soon I made a Pull Request to fix a minor documentation issue. Along with this I also got a chance to take a Kyverno 101 session.

If you haven’t checked out the Kyverno hands-on lab before which I prepared, you can go to that lab from here but make sure to read the complete blog first 😃

Applying For LFX Mentorship

I decided to apply for LFX mentorship for the spring 2022 cohort for Kyverno. The CNCF mentoring repository helped me a lot to know about the projects participating in LFX mentorship for a particular cohort along with the respective mentors. I applied through the LFX mentorship portal where for a particular cohort you can apply to a max of three projects where first you have to create your profile, tell a bit about your background and then apply to the projects you want.

After a few days, I got my selection email for being selected as a mentee for CNCF-Kyverno🥳
// Detect dark theme var iframe = document.getElementById('tweet-1498179098568708098-257'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1498179098568708098&theme=dark" }

My 12 Weeks Mentorship Journey

My mentorship period was from 1st March 2022 to 31st May 2022. During this period I have to work with Kyverno policies where I have to write test cases for it using Kyverno CLI.More specifically I have to write test cases along with other required manifests for
validate and mutate policies and check them using kyverno applyand kyverno test CLI commands.

With the help of my mentors, I first went through the various Kyverno policies and run them locally to get a better understanding of them. Then I learned about how Kyverno CLI works and how one can write the test cases to validate and mutate policies along with the variables manifests.
Then I listed out the policies for both validate and mutate for which test cases need to be written. There were about 40+ policies which have to work.👩‍💻

Every week I used to have a daily stand-up meeting with my mentors other than having discussions on the communication channel where we discussed policies and the respective positive and negative cases related to it and the working of the policies.
I used to get stuck most of the time while creating variables manifests which is required for test cases, but I am grateful to my mentors and maintainers of the project who always guided me whenever I get stuck.

The most important suggestion I used to get is to check the working of the policies on the Kubernetes cluster as a user to get a better understanding of it.

And finally after writing test cases for all the validate and mutate policies I made the respective Pull Requests to get them reviewed and merged. I am grateful to the reviewers of my Pull Requests who helped me in getting it merged by giving valuable suggestions.

Graduation From LFX Mentorship

And 31st May 2022 was the last day of my LFX mentorship and after being getting evaluated by mentors, I successfully graduated from it.🎓

My Pull Requests

In the End

At last, I am grateful to the Kyverno community and everyone who helped me in completing the LFX mentorship and gave me the most wonderful learning experience.🙏

Thank you for reading the blog. Hope this will help you to get started. You can connect with me on Twitter and LinkedIn😊

All the very best and take care!

MLOps with CML

Oshi Gupta — Tue, 07 Dec 2021 12:31:55 +0000

My Workflow

Managing machine learning model is a tedious job and specially when dealing with large datasets.To automate a machine learning model like to train it,evaluate it can be done by using CML(Continuous Machine Learning) as a part of MLOps(Machine Learning Operations) which is a CI/CD tool for Machine Learning projects.

In the following workflow a tensorflow regression model is trained with CML and along with it's model performance which is also recorded and will be generated on a PUSH GitHub event.

name: mlops-tensorflow-regression
on: [push]
jobs:
  run:
    runs-on: [ubuntu-latest]
    container: docker://dvcorg/cml-py3:latest
    steps:
      - uses: actions/checkout@v2
      - name: 'Train the model'
        env:
          repo_token: ${{ secrets.GITHUB_TOKEN }}
        run: |
          # Your ML workflow goes here
          pip install -r requirements.txt
          python model.py

          echo "## Model Metrics" > report.md
          cat metrics.txt >> report.md

          echo "\n## Model Performance" >> report.md
          echo "Model performance metrics are on the plot below." >> report.md

          cml-publish model_results.png --md >> report.md

          cml-send-comment report.md

This model metrics will be sent with an email and also on pushing the code from GitHub bot.

This is what model performance looks like when you push the code and run the above workflow.

The first image is of getting reply after pushing the code
The second image is about getting results on an email

Submission Category:

This workflow falls in the category of DIY Deployments

Yaml File or Link to Code

oshi36 / ml-ops-cml

To automate a machine learning model with the help of CML (Continuous Machine Learning) with GitHub Actions.

ML-Ops-CML

To automate a machine learning model with the help of CML (Continuous Machine Learning) with GitHub Actions.

For this a Tensorflow Regression model is created in model.py and python libraries requirements in requirements.txt.

A GitHub Action with CML is made inside .github/workflows/ which will train the model and find out the metrics and plot a graph on it.

This GitHub Action will work on PUSH events and will train the model as you do commit
After the training model performance wil be send as a reply to the commit and to the registered GitHub Email as well as shown in the image below

Model Performance details as a comment

Model Performance details in an Email

View on GitHub

Thank You for reading this as this was my first Github Actions and I really enjoyed and learnt new while building this and a huge thank you to the Dev community and GitHub organization for organising this Github Actions hackathon.

Dart In Appwrite

Oshi Gupta — Sun, 31 Oct 2021 17:16:56 +0000

In the previous blog we have seen about how to use Kotlin in Appwrite. Now we will be seeing about how to use Dart in Appwrite.

As we Dart SDK is one of the server SDKs in Appwrite but first let's know what is Dart?

Dart is an open-source, general-purpose, object-oriented programming language with C-style syntax developed by Google in 2011. The purpose of Dart programming is to create a frontend user interfaces for the web and mobile apps.

So now how to write Dart in Appwrite function and how to install Dart SDK for it.

Dart SDK Installation

Add this to your package's pubspec.yaml file:

dependencies:
  dart_appwrite: ^1.0.2

You can install packages from the command line:

pub get dart_appwrite

Add the function

You can add a new function from your Appwrite project's dashboard. Access your Functions settings from your project's left navigation panel. Click the Add Function button and choose your function name and code runtime.

Init your SDK

Initialize your SDK with your Appwrite server API endpoint and project ID which can be found in your project settings page and your new API secret Key project API keys section.
This can be found out when you install Appwrite according to the Operating System and access the Appwrite Console UI

import 'package:dart_appwrite/dart_appwrite.dart';

Client client = Client();
client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
;

Make your first request

final users = Users(client);

final res = users.create('email@example.com', 'password');

res.then((response) {
    print(response);
}).catchError((error) {
    print(error);
});

Now, we will be seeing different operations which can be performed on these functions.

Create functions : To create a new function by passing various parameters like name , runtime etc.

import 'package:dart_appwrite/dart_appwrite.dart';

void main() { // Init SDK
  Client client = Client();
  Functions functions = Functions(client);

  client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
  ;

  Future result = functions.create(
    name: '[NAME]',
    execute: [],
    runtime: 'dotnet-5.0',
  );

  result
    .then((response) {
      print(response);
    }).catchError((error) {
      print(error.response);
  });
}

List functions : To get a list of all the project's functions. You can use the query params to filter your results.

import 'package:dart_appwrite/dart_appwrite.dart';

void main() { // Init SDK
  Client client = Client();
  Functions functions = Functions(client);

  client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
  ;

  Future result = functions.list(
  );

  result
    .then((response) {
      print(response);
    }).catchError((error) {
      print(error.response);
  });
}

Get function : It will get a function by its unique ID.

import 'package:dart_appwrite/dart_appwrite.dart';

void main() { // Init SDK
  Client client = Client();
  Functions functions = Functions(client);

  client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
  ;

  Future result = functions.get(
    functionId: '[FUNCTION_ID]',
  );

  result
    .then((response) {
      print(response);
    }).catchError((error) {
      print(error.response);
  });
}

Update function : It will update the function by its unique ID.

import 'package:dart_appwrite/dart_appwrite.dart';

void main() { // Init SDK
  Client client = Client();
  Functions functions = Functions(client);

  client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
  ;

  Future result = functions.update(
    functionId: '[FUNCTION_ID]',
    name: '[NAME]',
    execute: [],
  );

  result
    .then((response) {
      print(response);
    }).catchError((error) {
      print(error.response);
  });
}

Delete function : It will delete a function by its unique ID.

import 'package:dart_appwrite/dart_appwrite.dart';

void main() { // Init SDK
  Client client = Client();
  Functions functions = Functions(client);

  client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
  ;

  Future result = functions.delete(
    functionId: '[FUNCTION_ID]',
  );

  result
    .then((response) {
      print(response);
    }).catchError((error) {
      print(error.response);
  });
}

So this is the basic idea of how to create functions in the Appwrite using the Dart SDK.

For more you can always refer to Appwrite docs

Thank You

Kotlin In Appwrite

Oshi Gupta — Thu, 28 Oct 2021 09:16:28 +0000

Appwrite is an end-to-end backend server that is aiming to abstract the complexity of common, complex, and repetitive tasks required for building a modern app.

Appwrite is both cross-platform and technology agnostic, meaning it can run on any operating system, coding language, framework, or platform. Although Appwrite can easily fit the definition of serverless technology, it's designed to run well in multiple configurations.
It provides various libraries for major programming languages and platforms so you don't have to write code for interacting with our HTTP APIs from scratch.

Appwrite has divided SDKs into two categories

Client SDKs
Server SDKs

Client SDKs

Web SDK
Flutter SDK
Apple SDK
Android SDK

Server SDKs

Kotlin SDK
Dart SDK
Swift SDK
Python SDK
Ruby SDK and etc

Here we will be seeing how to use kotlin in Appwrite functions

So what is Kotlin?

Kotlin is a cross-platform, statically typed, general-purpose programming language with type inference.

Kotlin is designed to interoperate fully with Java, and the JVM version of Kotlin's standard library depends on the Java Class Library, but type inference allows its syntax to be more concise.

So how to write kotlin in appwrite function and for this install Kotlin SDK by following the below instructions

GRADLE

Appwrite's Kotlin SDK is hosted on Maven Central. In order to fetch the Appwrite SDK, add this to your root-level build.gradle(.kts) file:

repositories {      
    mavenCentral()
}

Next, add the dependency to your project's build.gradle(.kts) file:

dependencies {
    implementation("io.appwrite:sdk-for-kotlin:")
}

MAVEN

Add this to your pom.xml

<dependencies>
    <dependency>
        <groupId>io.appwrite</groupId>
        <artifactId>sdk-for-kotlin</artifactId>
        <version>0.1.1</version>
    </dependency>
</dependencies>

Add the function

You can add a new function from your Appwrite project's dashboard. Access your Functions settings from your project's left navigation panel. Click the Add Function button and choose your function name and code runtime.

Init your SDK

Initialize your SDK with your Appwrite server API endpoint and project ID which can be found in your project settings page and your new API secret Key project API keys section.

This can be found out when you install Appwrite according to the Operating System and access the Appwrite Console UI

import io.appwrite.Client

val client = Client()
client
    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
    .setProject('5df5acd0d48c2') // Your project ID
    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key

Make your First Request

import io.appwrite.services.Users

val users = Users(client);

val res = users.create(email = 'email@example.com', password = 'password');
println(res.body?.string())

As of now, we have seen how to set up the functions and Kotlin SDK.
Now, we will be seeing different operations which can be performed on these functions.

Create functions : To create a new function with help of Kotlin

import io.appwrite.Client
import io.appwrite.services.Functions

suspend fun main() {
    val client = Client(context)
      .setEndpoint("https://[HOSTNAME_OR_IP]/v1") // Your API Endpoint
      .setProject("5df5acd0d48c2") // Your project ID
      .setKey("919c2d18fb5d4...a2ae413da83346ad2") // Your secret API key

    val functions = Functions(client)
    val response = functions.create(
        name = "[NAME]",
        execute = listOf(),
        runtime = "dotnet-5.0",
    )
    val json = response.body?.string()
}

List functions : To get a list of all the project's functions. You can use the query params to filter your results.

import io.appwrite.Client
import io.appwrite.services.Functions
suspend fun main() { 
val client = Client(context) 
.setEndpoint("https://[HOSTNAME_OR_IP]/v1") // Your API Endpoint .setProject("5df5acd0d48c2") // Your project ID .setKey("919c2d18fb5d4...a2ae413da83346ad2") // Your secret API key 
val functions = Functions(client) 
val response = functions.list( ) 
val json = response.body?.string() }

Get function : It will get a function by its unique ID.

val response = functions.get( functionId = "[FUNCTION_ID]" )

Update function : It will update the function by its unique ID.

val response = functions.update( 
functionId = "[FUNCTION_ID]",
name = "[NAME]", 
execute = listOf(), 
)

Delete function : It will delete a function by its unique ID.

val response = functions.delete( functionId = "[FUNCTION_ID]" )

Create execution : Trigger a function execution. The returned object will return you the current execution status. You can ping the Get Execution endpoint to get updates on the current execution status. Once this endpoint is called, your function execution process will start asynchronously.

val response = functions.createExecution( functionId = "[FUNCTION_ID]", )

So this is the basic idea of how to create functions in the Appwrite using the Kotlin SDK.
For more you can always refer to appwrite docs

Thank You

Postman API Development 101

Oshi Gupta — Sun, 02 May 2021 07:35:14 +0000

Yesterday, I attended an awesome session on API development 101 by Postman student community manager Ali Mustufa Shaikh organized by HackOn foundation for the upcoming HackOn2.0 hackathon.

In this article, I am going to share what I had learned in the session.

1.What is API?

API (Application Programming Interface) is an interface that defines interactions between multiple software applications or mixed hardware-software intermediaries.
APIs interact with the server using endpoint where they send and receive the request and update the information making it available to the user.

2.What is Postman and why use it?

Postman is an API(application programming interface) development tool that helps to build, test, and modify APIs. It has the ability to make various types of HTTP requests(GET, POST, PUT, PATCH), saving environments for later use, converting the API to code for various languages(like JavaScript, Python).

Why Postman - It has a wide range of functionality like support for all possible HTTP methods, saving progress, API to code conversion, testing of APIs that can be scheduled and automated.
It helps to see the status codes, time is taken for a response and other performance parameters.

3.Requests

There are many methods that help in making requests but few of them are GET, POST, PUT, DELETE.
Requests can be made using methods, address(URL), path.

Some methods are :
Get: For retrieving information
Post: To send information
Put: To update any information
Delete: To delete information.

Address: This means the address of the website from which data has to be fetched.
Path: It is the destination where the request can get executed.

Let's understand this with example.
https://www.google.com/ is the address of google's homepage.
When you search anything on it, it will take you to results according to the search.
On observing you will find it in URL, it adds /search path to the URL and from there one get their searched results. https://www.google.com/search.

Along with this request URL also takes the parameter which is mostly key-value pairs. These parameters are of two types:

i) Query Parameter: These are appended to the end of the request URL, Query parameters are appended to the end of the request URL, following '?' and listed in key-value pairs, separated by '&'
ii) Path Parameters: These are part of the request URL, which are accessed using the placeholders preceded by ':'

4.Responses

Methods to Receiving Response of the request :
i) Status Code - They are HTTP codes that tell if the request made is successful or not.
ii) Headers
iii) Accessing Body Data - It contains all the information to which the server responds back to your request.

Different HTTP Status Codes
1xx: Informational – Communicates transfer protocol-level information.
2xx: Success – Indicates that the client’s request was accepted successfully.
3xx: Redirection – Indicates that the client must take some additional action in order to complete their request.
4xx: Client Error – This category of error status codes points the finger at clients.
5xx: Server Error – The server takes responsibility for these error status codes.

Also done the hands-on session on the Postman workspace and got familiar with its interface and how to send requests and receive responses.
Learned about the student programs that Postman offers along with its benefits.

Ordered Vs Unordered In Python

Oshi Gupta — Wed, 28 Apr 2021 18:44:00 +0000

There are different types of data structures in Python such as lists, tuples, dictionaries, and more.

Lists

It is a collection of a mutable ordered sequence of elements and can be accessed through indexing and defined inside []. Each element inside the list is called an item.

From the above image, it is clearly seen that list remembers the order of insertion or follows a sequence in which elements are inserted.

Tuples

It is a collection of ordered and immutable elements. Tuples are sequences, just like lists. It is defined inside () and can be accessed through indexing.

The above image shows that the tuple is ordered data structure and follows the insertion sequence.

Dictionary

It is a collection in which items are defined in key-value pairs inside {}. These items are unordered, changeable, and value is accessed through the particular key.
Each key is separated from its value by a colon (:), the items are separated by commas.
Keys are unique within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.

In the above image, the order of insertion and output of the dictionary is different but what remains the same is the mapping of values with keys as the positioning might
vary.

In the dictionary, we don't access items based on position unlike in lists and tuples but through keys.

How To Deal With Imposter Syndrome?

Oshi Gupta — Wed, 24 Feb 2021 06:42:40 +0000

Have you ever felt like you don’t belong? Like your friends or colleagues are going to discover you’re a fraud, and you don’t actually deserve your job and accomplishments? Sometimes you think about others as they are achieving so much and compare yourself to them.

Most of us have experienced this at some point in our lives and even I suffered personally. And if you feel the same then probably you're suffering from imposter syndrome.

What is Imposter Syndrome?

Impostor syndrome—the idea that you’ve only succeeded due to luck, and not because of your talent or qualifications—was first identified in 1978 by psychologists Pauline Rose Clance and Suzanne Imes.

It’s that stomach-plunging fear that you’ll be revealed as a fraud who has no idea what they’re doing.
It's normal to get it and there is no harm in accepting that and one can easily come out of it.
It's common among high-achievers and people with perfectionist tendencies.

Some tips to deal and get rid of imposter syndrome

Know the signs We often overlook the signs of imposter syndrome that we came across in our day-to-day lives. But recognizing these steps is the first step in coping with imposter syndrome.

Some of them are:

You feel like you "got lucky" when you actually prepared well and worked hard.
You find it hard to accept praise.
You apologize for yourself when you didn't actually do something wrong.
You hold yourself to incredibly -- sometimes impossibly -- high standards.
You find the fear of failure paralyzing.
You avoid expressing confidence because you think people will see it as overcompensating or obnoxious.
You're convinced you're not enough.

And once you know then help yourself to get away from it!!

Break the silence: When you came to know about it, don't feel shy and shame to talk about it. Discuss with your close ones, with your family, friends, colleagues to whomsoever you are comfortable with it. Talk about it.
Accentuate the positive: The good news is being a perfectionist means you care deeply about the quality of your work. The key is to continue to strive for excellence when it matters most, but don’t persevere over routine tasks and forgive yourself when the inevitable mistake happens.
Develop a healthy response to failure and mistake making: Henry Ford once said, "Failure is only the opportunity to begin again more intelligently". Instead of beating yourself up for falling short, do what players on the losing sports team do and glean the learning value from the loss, and move on reminding yourself, “I’ll get ’em next time.”
Right the rules: If you’ve been operating under misguided rules like, “I should always know the answer,” or “Never ask for help” start asserting your rights. Recognize that you have just as much right as the next person to be wrong, have an off-day, or ask for assistance.
Visualize success: Do what professional athletes do. Spend time beforehand picturing yourself making a successful presentation or calmly posing your question in class. It sure beats picturing impending disaster and will help with performance-related stress.
Reward yourself: Break the cycle of continually seeking, and then dismissing validation outside of yourself by learning to pat yourself on the back.

In today’s workplaces, where all kinds of different people with distinct experiences, perspectives, and expectations are asked to collaborate, the bottom line with imposter syndrome is this: Everyone’s in the same boat. Nobody’s an imposter.

Confronted with that simple fact, all that’s left is to engage with your work and apply who you already are.

That’s always enough.

Java Problem

Oshi Gupta — Sun, 07 Feb 2021 13:32:08 +0000

I am having problem while solving this question in java. Please help me in solving this!!

Question :

Write a java program to print even numbers after odd times jump.
Ex - 2,6,14,26...

2 (then jump 1 even number 4)-6

6 (then jump 3 even numbers 8,10,12)-14

14 (then jump 5 even numbers 16,18,20,22,24)-26

Git & Github Commands

Oshi Gupta — Wed, 03 Feb 2021 08:38:14 +0000

Smarter cloning, forking, merging, branching, documenting, sharing, and automating with Git and GitHub and contribute to open source.
Git is a distributed version control system, originally written by Linus Torvalds in 2005 for and with help from the Linux kernel community.Git is a modern and widely used distributed version control system in the world. It is developed to manage projects with high speed and efficiency. The version control system allows us to monitor and work together with our team members at the same workspace.

What is Git?

Git is an open-source distributed version control system. It is designed to handle minor to major projects with high speed and efficiency. It is developed to co-ordinate the work among the developers. The version control allows us to track and work together with our team members at the same workspace.
Git is foundation of many services like GitHub and GitLab, but we can use Git without using any other Git services. Git can be used privately and publicly.
Git was created by Linus Torvalds in 2005 to develop Linux Kernel. It is also used as an important distributed version-control tool for the DevOps.
Git is easy to learn, and has fast performance. It is superior to other SCM tools like Subversion, CVS, Perforce, and ClearCase.

The following are some commands which one can use to start with open source.

Git Cheat Sheet

1. Git configuration

Git config
Get and set configuration variables that control all facets of how Git looks and operates.
Set the name:
$ git config — global user.name “username”
Set the email:
$ git config — global user.email “useremail@gmail.com”

2. Starting a project

Git init
Create a local repository:
$ git init
Git clone
Make a local copy of the server repository.
$ git clone

3. Local changes

Git add
Add a file to staging (Index) area:
$ git add Filename
Add all files of a repo to staging (Index) area:
$ git add .
Git commit
Record or snapshots the file permanently in the version history with a message.
$ git commit -m “ Commit Message”

4. Track changes

Git diff
Track the changes that have not been staged: $ git diff
Track the changes that have staged but not committed:
$ git diff — staged
Track the changes after committing a file:
$ git diff HEAD
Track the changes between two commits:
$ git diff Git Diff Branches:
$ git diff < branch 2>
Git status
Display the state of the working directory and the staging area.
$ git status
Git show Shows objects:
$ git show

5. Commit History

Git log
Display the most recent commits and the status of the head:
$ git log
Display the output as one commit per line:
$ git log -oneline
Displays the files that have been modified:
$ git log -stat
Display the modified files with location:
$ git log -p
Git blame
Display the modification on each line of a file:
$ git blame

6. Ignoring files

.gitignore
Specify intentionally untracked files that Git should ignore. Create .gitignore:
$ touch .gitignore List the ignored files.

7. Branching

Git branch Create branch:
$ git branch List Branch:
$ git branch — list Delete a Branch:
$ git branch -d Delete a remote Branch:
$ git push origin -delete Rename Branch:
$ git branch -m
Git checkout
Switch between branches in a repository.
Switch to a particular branch:
$ git checkout
Create a new branch and switch to it:
$ git checkout -b Checkout a Remote branch:
$ git checkout

8. Merging

Git merge
Merge the branches:
$ git merge
Merge the specified commit to currently active branch:
$ git merge
Git rebase
Apply a sequence of commits from distinct branches into a final commit.
$ git rebase
Continue the rebasing process:
$ git rebase -continue Abort the rebasing process:
$ git rebase — skip

9. Remote

Git remote
Check the configuration of the remote server:
$ git remote -v
Add a remote for the repository:
$ git remote add Fetch the data from the remote server:
$ git fetch
Git origin master
Push data to the remote server:
$ git push origin master Pull data from remote server:
$ git pull origin master

10. Pushing Updates

Git push
Transfer the commits from your local repository to a remote server. Push data to the remote server:
$ git push origin master Force push data:
$ git push -f
Delete a remote branch by push command:
$ git push origin -delete edited

11. Pulling updates

Git pull
Pull the data from the server:
$ git pull origin master
Pull a remote branch:
$ git pull

12. Undo changes

Git revert
Undo the changes:
$ git revert
Revert a particular commit:
$ git revert
Git reset
Reset the changes:
$ git reset -hard
$ git reset -soft:
$ git reset — mixed

13. Removing files

Git rm
Remove the files from the working tree and from the index:
$ git rm
Remove files from the Git But keep the files in your local repository:
$ git rm — cached

Happy Learning! Explore the open source world.

My First Experience : MLH Local Hack Day

Oshi Gupta — Sun, 17 Jan 2021 16:51:21 +0000

Hello all! I want to share with all of you that I have participated in Major League Hacking Build series knowns as MLH-LHD . Every day I am exploring new hacks and challenges.
I like this event every much there are so many technologies about which you will come to know and build something new.
One of the best thing is that it has Daily and Week long Challenges in which one have to make projects and MLH team guide you to make something and explore the technologies.
I had learnt to make a Tic-Tac-Toe game in java.

DEV Community: Oshi Gupta

Creating Kubernetes Cluster With CRI-O

What is CRI-O?

Kubernetes Cluster With Kubeadm and CRI-O

Install Kubeadm, Kubelet, and Kubectl

Install CRI-O

Set Cluster With Kubeadm

Install CNI

Video

Try out Hands-on

References

Connect With Me!!

Pod Disruption Budget in Kubernetes

What are Disruptions?

Involuntary Disruptions

Voluntary Disruptions

How to Deal with Disruptions?

Pod Disruption Budget

Features of Pod Disruption Budget

Pod Disruption Budget Fields

Example of Pod Disruption Budget

Use Case: 1

Use Case: 2

Use Case : 3

Use Case: 4

Use Case: 5

When not to use PDB?

Summary

References

My LFX Mentorship With Kyverno

📝 Table Of Contents

About LFX Mentorship

About Kyverno

How did I start with Kyverno?

Applying For LFX Mentorship

My 12 Weeks Mentorship Journey

Graduation From LFX Mentorship

My Pull Requests

In the End

MLOps with CML

My Workflow

Submission Category:

Yaml File or Link to Code

oshi36 / ml-ops-cml

To automate a machine learning model with the help of CML (Continuous Machine Learning) with GitHub Actions.

ML-Ops-CML

Model Performance details as a comment

Model Performance details in an Email

Dart In Appwrite

Dart SDK Installation

Add the function

Init your SDK

Make your first request

Kotlin In Appwrite

Client SDKs

Server SDKs

Here we will be seeing how to use kotlin in Appwrite functions

GRADLE

MAVEN

Add the function

Init your SDK

Make your First Request

Postman API Development 101

Ordered Vs Unordered In Python

Lists

Tuples

Dictionary

How To Deal With Imposter Syndrome?

What is Imposter Syndrome?

Some tips to deal and get rid of imposter syndrome

Some of them are:

Java Problem

Question :

Git & Github Commands

What is Git?

Git Cheat Sheet

1. Git configuration

2. Starting a project

3. Local changes

4. Track changes