Forem: Hrittik Bhattacharjee

Bite-Sized Kubernetes Part 6 - Ingress, Volumes, Namespaces & Clusters

Hrittik Bhattacharjee — Thu, 09 Mar 2023 22:07:10 +0000

Land Ahoy!☸️

You made it! Land in sight!🏝️
In the last part we learnt about services in kubernetes.
In this final part of the series, we shall be exploring Ingress, Volumes and Namespaces! We shall also briefly revisit Clusters since you already learnt what they are in Part 1!

OBJECT	DESCRIPTION
Pods	The lowest level, single instance of an application
ReplicaSets	The next level, manages a set of pods
Deployments	The next level, manages a set of ReplicaSets
Services	The next level, manages a set of deployments
👉 Ingress	The next level, manages a set of services
👉 Volumes	The next level, manages a set of ingress
👉 Namespaces	The next level, manages a set of volumes
👉 Cluster	The highest level, manages a set of namespaces

Ingress:

Ingress is a set of rules that allow external traffic to reach the cluster services.
Creating ingress:
- Example ingress-definition.yml:
```
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: my-app-ingress
spec:
  rules:
    - host: myapp.com
      http:
        paths:
          - path: /
            backend:
              serviceName: my-app-service
              servicePort: 80
```
- The host property is the domain name that the ingress will listen for requests on.
- The path property is the path that the ingress will listen for requests on.
- The serviceName property is the name of the service that the ingress will forward requests to.
- The servicePort property is the port on the service that the ingress will forward requests to.
- Once the .yml file is created, it can be used to create an ingress:
```
$ kubectl create -f <file name>.yml
```
- See list of ingresses:
```
$ kubectl get ingresses
```
- See detailed info about an ingress:
```
$ kubectl describe ingress <ingress name>
```
- To access the ingress from outside the cluster, use the node IP address and the node port:
```
$ curl <node IP address>:<node port>
```
- To access the ingress from inside the cluster, use the cluster IP address and the port:
```
$ curl <cluster IP address>:<port>
```

Volumes:

Volumes are used to store data that is not ephemeral.
Volumes are created in the cluster and are mounted to the pods.
Types of volumes:
- EmptyDir: a temporary volume that is created when a pod is created and is deleted when the pod is deleted.
- HostPath: a volume that is mounted from the host machine to the pod.
- PersistentVolume: a volume that is created in the cluster and is mounted to the pods.
- PersistentVolumeClaim: a claim for a persistent volume.
Creating a volume:
- Example volume-definition.yml:
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-app-volume
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /data/my-app
```
- The capacity property is the size of the volume.
- The accessModes property is the access mode of the volume.
- The hostPath property is the path on the host machine where the volume will be created.
- Once the .yml file is created, it can be used to create a volume:
```
$ kubectl create -f <file name>.yml
```
- See list of volumes:
```
$ kubectl get pv
```
- See detailed info about a volume:
```
$ kubectl describe pv <volume name>
```

Namespaces:

Namespaces are used to isolate resources in the cluster.
Namespaces are created in the cluster and are used to group resources.

Creating a namespace:

Example namespace-definition.yml:

apiVersion: v1
kind: Namespace
metadata:
  name: my-app-namespace

Once the .yml file is created, it can be used to create a namespace:
```
$ kubectl create -f <file name>.yml
```
See list of namespaces:
```
$ kubectl get namespaces
```

See detailed info about a namespace:

$ kubectl describe namespace <namespace name>

Clusters:

We have already understood clusters at the very beginning of this blog series.
A cluster is just a set of nodes (machines) that run containerized applications i.e. k8s pods.
A cluster can be created using a cloud provider or using a single node.
Try creating cluster and playing around with it on your local machine using minikube or kubeadm or you can get started with the services offered by cloud providers like AWS (EKS), GCP (GKE) or Azure (AKS).

Well done and hearty congratulations Sailor!!!🥁📯
You are hereby commissioned Ensign and are now ready to join the fleet!🎖️🎖️🎖️
To be an explorer and a force for good! To venture out into the great sea!🌅 To fight monsters 🦑 and explore uncharted lands!🏞️

Hope this series was fun!
Feel free to check the references below to take your journey of building with Kubernetes further ahead and put your newly acquired skills to the test!
Cheers and until next time!🍻

References:

Bite-Sized Kubernetes Part 5 - Services

Hrittik Bhattacharjee — Wed, 08 Mar 2023 19:57:37 +0000

Heave Ho!☸️

In Part 4 we learnt about deployments in kubernetes.
Moseying along now, to Services!🏴‍☠️

OBJECT	DESCRIPTION
Pods	The lowest level, single instance of an application
ReplicaSets	The next level, manages a set of pods
Deployments	The next level, manages a set of ReplicaSets
👉 Services	The next level, manages a set of deployments
Ingress	The next level, manages a set of services
Volumes	The next level, manages a set of ingress
Namespaces	The next level, manages a set of volumes
Cluster	The highest level, manages a set of namespaces

Services:

K8s services enable the pods to communicate with the outside world.
K8s services also enable the pods to communicate with each other.
Services types:
- NodePort service: a service that listens for requests on a port on the k8s node and forwards them to the pods
- ClusterIP service: a service that creates a virtual IP address that is accessible only within the cluster, for communication between various services within the cluster.
- Load Balancer service: a service that creates a load balancer in the cloud provider that forwards requests to the pods accordingly to balance load.

NodePort Service:

Target port: the port on the pod that the service forwards requests to.
Node port: the port on the k8s node that the service listens for requests on.
Port: the port on the service that it listens on.
The service has its own IP address, called the cluster IP address of the service.

Creating a NodePort service:

Example service-definition.yml:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
  labels:
    app: my-app
    type: my-type
spec:
  type: NodePort
  ports:
    - targetPort: 8080
      port: 80
      nodePort: 30080
  # selector identifies the pods that the service will forward requests to
  selector:
    app: my-app
    type: my-type

The type property can be set to NodePort or ClusterIP or LoadBalancer depending on the type of service we're creating.
Once the .yml file is created, it can be used to create a service:
```
$ kubectl create -f <file name>.yml
```
See list of services:
```
$ kubectl get services
```

See detailed info about a service:

$ kubectl describe service <service name>

To access the service from outside the cluster, use the node IP address and the node port:
```
$ curl <node IP address>:<node port>
```
To access the service from inside the cluster, use the cluster IP address and the port:
```
$ curl <cluster IP address>:<port>
```

If there are multiple nodes in the cluster with their own pods, the service created can be accessed from all the nodes in the cluster.

ClusterIP Service:

A service that creates a virtual IP address that is accessible only within the cluster, for communication between various services within the cluster.
It groups together a set of pods and exposes them as a single service e.g. a service for all pods running the frontend app, a service for all pods running the backend app, for the database pods, redis pods etc.

Creating a ClusterIP service:

Example service-definition.yml:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
  labels:
    app: my-app
    type: my-type
spec:
  type: ClusterIP
  ports:
      # target port: the port on the pod that the service forwards requests to
      # port: the port on the service that it listens on
      # no need to specify nodePort since this is a ClusterIP service
    - targetPort: 8080
      port: 80
  selector:
    app: my-app
    type: my-type

Commands are same as the ones above for NodePort service.

LoadBalancer Service:

A service that creates a load balancer in the cloud provider that forwards requests to the pods accordingly to balance load.

Creating a LoadBalancer service:

Example service-definition.yml:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
  labels:
    app: my-app
    type: my-type
spec:
  type: LoadBalancer
  ports:
    - targetPort: 8080
      port: 80
  selector:
    app: my-app
    type: my-type

Commands are same as the ones above for NodePort service.

You're doing great, Sailor! Captin Ahab would be proud!👨🏼‍✈️
Keep going! We'll look at "Ingress", "Volumes", "Namespaces" and revisit "Clusters" in the next and final part of this series!

Ahead Flank!!!🚀

Bite-Sized Kubernetes Part 4 - Deployments

Hrittik Bhattacharjee — Wed, 08 Mar 2023 19:43:09 +0000

Blimey!☸️

In Part 3 we looked at ReplicaSets in kubernetes.
Moving right along to Deployments!🌊

OBJECT	DESCRIPTION
Pods	The lowest level, single instance of an application
ReplicaSets	The next level, manages a set of pods
👉 Deployments	The next level, manages a set of ReplicaSets
Services	The next level, manages a set of deployments
Ingress	The next level, manages a set of services
Volumes	The next level, manages a set of ingress
Namespaces	The next level, manages a set of volumes
Cluster	The highest level, manages a set of namespaces

Deployments:

K8s deployments are a higher-level abstraction that are built on top of ReplicaSets.
K8s deployments help in rolling updates and rollbacks.
K8s deployments are one level above ReplicaSets in the k8s hierarchy.
Creating deployments:
The .yml definition of a deployment is exactly similar to that of a ReplicaSet except for the kind property.
- Example deployment-definition.yml:
```
apiVersion: apps/v1
kind: Deployment

# all else is same as ReplicaSet
```
- Once the .yml file is created, it can be used to create a deployment:
```
$ kubectl create -f <file name>.yml
```
- See list of deployments:
```
$ kubectl get deployment
```
- The deployment will automatically create a ReplicaSet and the ReplicaSet will create the pods.
- See list of ReplicaSets:
```
$ kubectl get replicaset
```
- See list of pods:
```
$ kubectl get pods  
```
- See detailed info about a deployment:
```
$ kubectl describe deployment <deployment name>
```
- Scale up or down:
  - We can scale up the number of pods by updating the replicas property in the .yml file and then run the kubectl replace command:
```
$ kubectl replace -f <file name>.yml
```
  - Or we can use the kubectl scale command:
```
$ kubectl scale deployment <deployment name> --replicas=<number of replicas>
```
To see all k8s objects created i.e. pods, ReplicaSets, deployments, etc.:
```
  $ kubectl get all
```
Rollouts (updates) and rollbacks in deployments:
- To see rollout status:
```
$ kubectl rollout status deployment <deployment name>
```
- To see rollout history:
```
$ kubectl rollout history deployment <deployment name>
```
- Deployment strategies:
- Recreate: the default strategy
  - this will delete all the pods and then create new pods
  - this is not recommended for production
- RollingUpdate: the recommended strategy
  - this will update the pods one by one
  - this is the recommended strategy and the default strategy for kubectl apply command
- To update a deployment:
```
$ kubectl edit deployment <deployment name>
```
- After updating the .yml file e.g. updating the app version (image tag), run the kubectl apply command to trigger a new rollout:
```
$ kubectl apply -f <file name>.yml
```
- The k8s deployment will create a new ReplicaSet and the new ReplicaSet will create new pods following wither of the deployment strategies.
- To rollback a deployment:
```
$ kubectl rollout undo deployment <deployment name>
```

You're unstoppable!
Let's look at "Services" next. See ya in Part 5!

Flank Speed!!!🚢

Bite-Sized Kubernetes Part 3 - ReplicaSets

Hrittik Bhattacharjee — Tue, 07 Mar 2023 21:41:04 +0000

Aye Aye!☸️

In Part 2 we looked at pods in kubernetes.
Let us now venture further with Controllers and ReplicaSets!🌊

OBJECT	DESCRIPTION
Pods	The lowest level, single instance of an application
👉 ReplicaSets	The next level, manages a set of pods
Deployments	The next level, manages a set of ReplicaSets
Services	The next level, manages a set of deployments
Ingress	The next level, manages a set of services
Volumes	The next level, manages a set of ingress
Namespaces	The next level, manages a set of volumes
Cluster	The highest level, manages a set of namespaces

Controllers and ReplicaSets:

A controller is a k8s object that is responsible for managing a set of pods.
Replication controller:
- A controller that is responsible for managing a set of pods.
- It ensures that the specified number of pods are running at any given time.
- It is responsible for creating new pods if the number of pods falls below the specified number.
- It is responsible for deleting pods if the number of pods exceeds the specified number.
- It is responsible for updating the pods if the pod template is changed.
- It helps to ensure that multiple pods are running at all times, thus guaranteeing "high availability" of the application.
- It is also responsible for load balancing and scaling the number of pods up and down.
- Replication controller can span across multiple nodes.
Replication controller is a legacy object, and is replaced by ReplicaSet

Creating replication controllers:

Example rc-definition.yml:

apiVersion: v1
kind: ReplicationController
metadata:
  name: my-app-rc
  labels:
    app: my-app
    type: my-type
spec:
  # the template is the pod template that will be used to create the pods
  # all the contents of the pod-definition.yml file can be copied here, except the apiVersion and kind
  template:
    metadata:
      name: my-pod
      labels:
        app: my-app
        type: my-type
    spec:
      containers:
      - name: my-container
        image: my-image-name:my-image-tag
  # the number of replicas that should be running at any given time
  replicas: 5

Once the .yml file is created, it can be used to create a replication controller:
```
$ kubectl create -f <file name>.yml
```
See list of replication controllers:
```
$ kubectl get replicationcontroller
```
See list of pods (those created by the replication contrller will have the name of the replication controller, here my-app-rc, followed by a hash suffix):
```
$ kubectl get pods  
```

Creating ReplicaSets:

Example rs-definition.yml:

apiVersion: apps/v1 # not v1
kind: ReplicaSet
metadata:
  name: my-app-rs
  labels:
    app: my-app
    type: my-type
spec:
  # the template is the pod template that will be used to create the pods
  # all the contents of the pod-definition.yml file can be copied here, except the apiVersion and kind
  template:
    metadata:
      name: my-pod
      labels:
        app: my-app
        type: my-type
    spec:
      containers:
      - name: my-container
        image: my-image-name:my-image-tag
  # the number of replicas that should be running at any given time
  replicas: 5
  # selector is needed for the ReplicaSet, not needed for replication controller
  # this identifies the pods that it is managing
  # this is because ReplicaSet can also manage pods that were created manually or already created pods 
  # i.e. those that were not a part of the ReplicaSet pod creation process
  # this ReplicaSet will only manage the pods that have the labels app=my-app and type=my-type
  selector:
    matchLabels:
      app: my-app
      type: my-type

Once the .yml file is created, it can be used to create a ReplicaSet:
```
$ kubectl create -f <file name>.yml
```
See list of ReplicaSets:
```
$ kubectl get replicaset
```
See list of pods (those created by the ReplicaSet will have the name of the ReplicaSet, here my-app-rs, followed by a hash suffix):
```
$ kubectl get pods  
```

Edit a ReplicaSet:

$ kubectl edit replicaset <replicaset name>

# opens up vi editor
# press i to enter insert mode, make necessary changes
# press 'esc' to exit insert mode
# type ':wq!' to save and exit

# then delete all the pods managed by the ReplicaSet and then the ReplicaSet will create new pods with the updated pod template

Scaling up or down:
- We can scale up the number of pods by updating the replicas property in the .yml file and then run the kubectl replace command:
```
$ kubectl replace -f <file name>.yml
```
- Or we can use the kubectl scale command:
```
$ kubectl scale --replicas=<number of replicas> -f <file name>.yml
```
- Delete a ReplicaSet and all pods managed by it:
```
$ kubectl delete replicaset <replicaset name>
```

Great going sailor, Posiedon watches over ya!🔱
Now that you understand ReplicaSets, let us move on to "Deployments" in Part 4.

Heave Ho!!!🚣🏻

Bite-Sized Kubernetes Part 2 - Pods

Hrittik Bhattacharjee — Mon, 06 Mar 2023 22:30:44 +0000

Arr!☸️

In Part 1 we were introduced to the basics of kubernetes and took a brief look at the k8s "objects".
Onward now with our expedition with Pods, the smallest object in k8s.

OBJECT	DESCRIPTION
👉 Pods	The lowest level, single instance of an application
ReplicaSets	The next level, manages a set of pods
Deployments	The next level, manages a set of ReplicaSets
Services	The next level, manages a set of deployments
Ingress	The next level, manages a set of services
Volumes	The next level, manages a set of ingress
Namespaces	The next level, manages a set of volumes
Cluster	The highest level, manages a set of namespaces

Pods:

K8s does not deploy the containers directly on the worker nodes.
The containers are encapsulated into a kubernetes object, known as 'pod'.
A pod is a single instance of an application.
Usually a pod contains a single container, but it can contain multiple containers, and these containers are not the same containers.
For example, a pod can contain a container running the application, and another container running a sidecar process or helper application.
Containers inside the pod share the same network namespace, and can communicate with each other using localhost, and can share the same storage space.

Commands:

  # deploy a container by creating a pod
  $ kubectl run <pod name> --image=<image name>

  # list all pods
  $ kubectl get pods

  # list detailed info about all pods
  $ kubectl get pods -o wide

  # describe a pod
  $ kubectl describe pod <pod name>  

  # delete a pod
  $ kubectl delete pod <pod name>

Creating pods:
- The .yml file must contain 4 top-level fields/properties i.e. apiVersion, kind, metadata and spec.
- apiVersion: the version of the k8s API that is being used e.g. v1, apps/v1
- kind: the type of object that is being created e.g. Pod, Service, Deployment, ReplicaSet
- metadata: data that helps to uniquely identify the object e.g. name, labels
  - name can only have a string value
  - labels can have any kind of key-value pairs
- spec: the specification of the object
  - containers: the list of containers that will be launched in the pod
  - name: the name of the container
  - image: the image that will be used to launch the container
- Example pod-definition.yml:
```
apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  labels:
    app: my-app
    type: my-type
spec:
  containers:
  - name: my-container
    image: my-image-name:my-image-tag
```
- Once the .yml file is created, it can be used to create a pod using the kubectl create command:
```
$ kubectl create -f <file name>.yml
```
- View detailed info about the pod:
```
$ kubectl describe pod <pod name>
```
- Delete the pod:
```
$ kubectl delete pod <pod name>
```
- Update the pod with an updated .yml file e.g. with a new image, etc.:
```
$ kubectl apply -f <file name>.yml
```

Great job sailor!
You now know what pods are, hopefully you found this post an interesting and useful read.
Onwards now to "Controllers and ReplicaSets" in Part 3 which will be out soon!

Haul Wind!!!⛵

Bite-Sized Kubernetes Part 1 - Introduction & Overview

Hrittik Bhattacharjee — Mon, 06 Mar 2023 22:14:34 +0000

Ahoy Sailor!☸️

Learning Kubernetes can be daunting!
"Cluster"... "Deployments"... "Services"... what?!

As a newcomer to these concepts one is faced with either of two choices:

Watch a 20-hour long Udemy course
Dive into the docs which is probably longer than the King James Bible. And with a million links leading to an altogether new concept.

So you end up with a couple of half-finished courses, thousands of tabs of the docs pages open, some youtube videos, but mostly a great deal of confusion and regret!

Source: https://9gag.com/gag/amPPxpX

Sooooo we decided to write a series of blog posts to help a young cadet like yourself, get abreast quickly with the important concepts in kubernetes, in bite-sized posts with only need-to-know "points" to grasp the essentials. Our goal here is to choose the path of least resistance to set sail!

Feel free, of course, to move on after you're done here, to the official documentation and/or a detailed course, or get your hands dirty and deploy your own apps, or maybe even get certified. But assuredly, whatever you choose, you'll be able to go in with a certain level of confidence!

Kubernetes Overview

A kubernetes or k8s "cluster" consists of a set of k8s "nodes" i.e. machines.
- K8s cluster: set of k8s nodes grouped together.
- K8s node: the physical/virtual machine on which k8s software and tools are installed.
There are 2 types of nodes in a k8s cluster:
- K8s worker node: machine where the containers will be launched by k8s.
- K8s master node: responsible for managing the worker nodes.
The master node is the node with the k8s "control plane" components installed, we'll understand this in more detail.
The master node is responsible for the orchestration of containers on the worker nodes.
Kubernetes comprises of the following main components:
- API server
  - The API server is the front-end for the Kubernetes control plane.
  - It exposes the Kubernetes API and allows us to interact with the k8s cluster.
- etcd service
  - etcd is a distributed key-value store that stores all the data used to manage the cluster.
  - It is used to store the configuration data, metadata and the current state of all the k8s objects in the cluster.
  - it is responsible for implementing logs within the cluster.
- kubelet
  - The kubelet is an "agent" that runs on each node in the cluster.
  - It makes sure that containers are running in a pod.
- container runtime
  - The container runtime is the underlying software that is responsible for running containers e.g. docker.
- controller
  - It is responsible for making sure that the specified number of pods are running at any given time and bring up new containers.
- scheduler
  - It is responsible for making sure that the containers are running on the right node.
The master node has the kube-apiserver installed, worker nodes have the kubelet agent installed.
All info about worker nodes is stored in a key-value store on the master i.e. etcd.
The controller and scheduler exist also, on the master.
The container runtime like docker runs on the worker nodes.

Some basic commands:

# run 1000 instances of my-app
$ kubectl run --replicas=1000 my-app

# scale it up to 5000 instances
$ kubectl scale --replicas=5000 my-app

# update these 5000 instances in a rolling upgrade
$ kubectl rolling-update my-app --image=<image name>:<image tag>

# rollback updates
$ kubectl rolling-update my-app --rollback

# deploy an app on a cluster
$ kubectl run <image name>

# see info about the cluster
$ kubectl cluster-info

# list all nodes in the cluster
$ kubectl get nodes

We will now, over the next few posts, explore the "objects" in kubernetes, e.g. pods, deployments, services, etc.
These are the entities in the k8s architecture that we will be working with to deploy an application on k8s.

Following are the k8s objects that we'll be looking at:

OBJECT	DESCRIPTION
Pods	The lowest level, single instance of an application
ReplicaSets	The next level, manages a set of pods
Deployments	The next level, manages a set of ReplicaSets
Services	The next level, manages a set of deployments
Ingress	The next level, manages a set of services
Volumes	The next level, manages a set of ingress
Namespaces	The next level, manages a set of volumes
Cluster	The highest level, manages a set of namespaces

In Part 2 we shall start by taking a look at "pods" in kubernetes.
Thank you for reading, hope you're excited!

Anchors Aweigh!!!⚓

React Hooks by Example - Part 2

Hrittik Bhattacharjee — Sat, 11 Feb 2023 14:15:52 +0000

Learn (more) Hooks = Make (more) Money!🤑

We're back to make more Dinero!💵💵💵
Let's explore some of the less commonly used, but nonetheless super-important hooks in react!

The code for all the examples can be found at this Code Sandbox.
This is Part 2 of a three-part series, and it covers useReducer, useRef, useMemo, useCallback, useImperativeHandle and useLayoutEffect!

useReducer

The useReducer can be used as an alternative to useState.
useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values or when the next state depends on the previous one."

Example:

// /src/UseReducerExample.js

import { useReducer } from "react";
import { Link } from "react-router-dom";

const bankBalance = { counter: 0 };

function reducer(state, action) {
  switch (action.type) {
    case "make 1 $":
      return { counter: state.counter + 1 };
    case "spend 1 $":
      return { counter: state.counter - 1 };
    default:
      throw new Error();
  }
}

export default function UseReducerExample() {
  const [state, dispatch] = useReducer(reducer, bankBalance);

  return (
    <>
      <h1>
        <Link to={"/"}>
          Dinero!
        </Link>
      </h1>
      <h2>
        {state.counter >= 0 ? "You have" : "You lost"} {Math.abs(state.counter)}{" "}
        💵
      </h2>

      <button onClick={() => dispatch({ type: "spend 1 $" })}>Spend 1 $</button>
      <button onClick={() => dispatch({ type: "make 1 $" })}>Make 1 $</button>
    </>
  );
}

In the above example:
- The useReducer hook accepts a reducer function and an data which you want to save to state, here, { counter: 0 }.
- The useReducer hook returns a state object containing this data, and a dispatch function.
- When dispatch is called with an action here, { type: "spend 1 $" },
- It passes the state and this action to the reducer function.
- Depending on the action type, it will return some value and this value will be saved to the state here, state.counter
- The updated value of the state can then be accessed inside the component.
See it in action here and the code at this sandbox!

useRef

The useRef hook can be used to reference a given value, and it will be stored in its .current property between component re-renders, and can be changed.
A common use-case is to access DOM elements directly.
It is important to note that mutating .current will not cause a re-render.

Example:

// /src/UseRefExample.js

import { useRef } from "react";
import { Link } from "react-router-dom";

export default function UseRefExample() {
  let counter = 0;
  const refAmt = useRef(null);

  const updateAmt = () => {
    console.log(refAmt.current);

    counter += 1;
    console.log(`You actually have ${counter} 💵`);
  };

  return (
    <>
      <h1>
        <Link to={"/"}>
          Dinero!
        </Link>
      </h1>
      <h2 ref={refAmt}>You have {counter} 💵</h2>
      <button onClick={updateAmt}>Get 1 $</button>
    </>
  );
}

In the above example:
- We create a ref, refAmt.
- in the <h2> element we specify ref={refAmt}, so now refAmt.current points to the <h2> element.
- On clicking the button, we can open the console and see that,
- The value of counter is increasing.
- But refAmt.current (which points to the <h2> element) is not being updated with the new value of counter.
See it in action here and the code at this sandbox!

useMemo

the useMemo hook takes a function (that ideally returns something) and an array of dependencies.
It will only re-compute the return value if one or more of the dependencies has changed.
This helps to optimizae expensive computations on each render, that may not necessarily need to be re-computed.
If no array is provided, a new value will be computed on every render.
Every value referenced inside the function should also appear in the dependencies array.
Side effects should be in useEffect, not useMemo.

Example:

// /src/UseMemoExample.js

import { useState, useMemo } from "react";
import { Link } from "react-router-dom";

function calculationRes(constant) {
  const result = constant ** 2;
  console.log(`The calculated result is: ${result}`);
  return result;
}

export default function UseMemoExample() {
  const [counter, setCounter] = useState(0);
  const [constant] = useState(1000000);
  const calculation = useMemo(() => calculationRes(constant), [constant]);

  return (
    <>
      <h1>
        <Link to={"/"}>
          Dinero!
        </Link>
      </h1>
      <h2>You have {counter} 💵</h2>
      <button onClick={() => setCounter(counter + 1)}>Get 1 $</button>
      {calculation}
    </>
  );
}

In the above example:
- The function calculationRes runs once, the result is memoized and result is logged in console.
- On clicking on the button, the state counter changes and hence the component re-renders.
- But on subsequent renders, result is not logged to console.
- This is because the value of result has not changed since the value of the variable constant has not changed, which was in the dependency array for calculationRes.
See it in action here and the code at this sandbox!

useCallback

The useCallback hook is very similar to the useMemo hook, the only difference being that useMemo returns a memoized value, and useCallback returns a memoized function.
A common use-case is when the function needs to be passed down nested child components.
The example above can be referred to, as an example of useCallback by just replacing:

const calculation = useMemo(() => calculationRes(constant), [constant]);
with
```
const calculation = useCallback(() => calculationRes(constant), [constant]);
```
See it in action here and the code at this sandbox!

forwardRef and useImperativeHandle

As we have seen above, the useRef hook can be used to access DOM elements.
We can wrap the component exposing this ref, inside forwardRef and then the parent component would have access to this ref.

Example of forwarding refs:

import { useRef, forwardRef } from "react";

function ChildComponent(props, ref) {
  return (
    <>
      <h1 ref={ref} {...props}>{"💵💵💵💵💵💵💵💵💵💵"}</h1>
    </>
  );
}

ChildComponent = forwardRef(ChildComponent);

export default function UseImperativeHandleExample() {
  const moneyRef = useRef(null);

  return (
    <>
      <ChildComponent ref={moneyRef} />
    </>
  );
}

In the above example:
- The parent component UseImperativeHandleExample uses the useRef hook to create a ref object.
- This ref is pointed to ChildComponent.
- ChildComponent is wrapped inside forwardRef and hence we can assign this ref object to a DOM element inside it, here, the <h1> element.
- Now, the parent component UseImperativeHandleExample will have access to the ref to the <h1> element inside ChildComponent.
Now, if we need to modify the behavious of this ref, based on say, some user action, this is where the useImperativeHandle hook comes in handy!

The above example can be modified like so:

// /src/UseImperativeHandleExample.js

import { useRef, forwardRef, useImperativeHandle } from "react";
import { Link } from "react-router-dom";

function ChildComponent(props, ref) {
  const h1Ref = useRef(null);

  useImperativeHandle(ref, () => ({
    seeReferencedEl: h1Ref.current
  }));

  return (
    <>
      <h1>
        <Link to={"/"}>
          Dinero!
        </Link>
      </h1>
      <h1 ref={h1Ref} {...props}>
        {"💵💵💵💵💵💵💵💵💵💵"}
      </h1>
    </>
  );
}

ChildComponent = forwardRef(ChildComponent);

export default function UseImperativeHandleExample() {
  const moneyRef = useRef(null);

  const seeReferencedElement = () => {
    console.log(moneyRef.current?.seeReferencedEl);
  };

  return (
    <>
      <ChildComponent ref={moneyRef} />
      <button onClick={seeReferencedElement}>See ref in console</button>
    </>
  );
}

In the above example:
- Inside the UseImperativeHandleExample component, moneyRef.current points to ChildComponent as we saw in the forwardRef example previously.
- But in this example, we assign a new ref object h1Ref to the <h1> element inside ChildComponent.
- Using the useImperativeHandle hook, we assign this new h1Ref to the seeReferencedEl property of ChildComponent's ref.
- So now, inside the UseImperativeHandleExample component, moneyRef.current.seeReferencedEl points to the <h1> element inside ChildComponent.
See it in action here and the code at this sandbox!

useLayoutEffect

The useLayoutEffect is similar to useEffect, except one key difference.
It runs (synchronously) after the elements have been loaded into the DOM but before they are painted to the UI.
"Use this [hook] to read layout from the DOM and synchronously re-render".
A common use-case is to measure layout and change the position of elements based on it.

Example:

// /src/UseLayoutEffectExample.js
import { useRef, useEffect, useLayoutEffect } from "react";
import { Link } from "react-router-dom";

export default function UseLayoutEffectExample() {
  const refAmt = useRef(null);

  useEffect(() => {
    console.log("useEffect called!");
  }, []);

  useLayoutEffect(() => {
    console.log("useLayoutEffect called");
  }, []);

  return (
    <>
      <h1>
        <Link to={"/"} style={styles.linkStyle}>
          Dinero!
        </Link>
      </h1>
      <h2 ref={refAmt}>You have 1000000 💵</h2>
    </>
  );
}

In the above example:
- We see that "useLayoutEffect called" is logged first, since the useLayoutEffect runs synchronously
- Then the DOM is visually updated.
- Then "useEffect called!" is logged, since useEffect runs asynchronously.
See it in action here and the code at this sandbox!

Hope you had great fun learning hooks, and heading to the Buggati store soon for some Sunday shopping!
Stay tuned for Part 3 where we look at more hooks🤘
Cheers!

BONUS! Redis Commands Cheat Sheet Part 4 - Transactions, Bit Data, Pub/Sub and Geospatial Data

Hrittik Bhattacharjee — Sun, 05 Feb 2023 20:24:09 +0000

Following are some of the commonly used Redis commands and data structures, use this list as a quick cheat sheet or a ready reference for your day-to-day Redis usage as needed 😄

This is a BONUS Part 4 of this series, containing commands pertaining to Transactions, Bit Data, Pub/Sub and Geospatial Data in Redis!

Transactions

# each transaction is atomic - either it completes, nor not
# command execution is single threaded in redis
# new command will execute after previous command is completed and will wait till it is either finished or failed
# but there are exceptions - e.g. async non-blocking commands like `UNLINK`
# transaction: a set of commands that are guaranteed to be atomic
  # all commands in a transaction are serialized and executed sequentially
  # this guarantees that all the commands are executed in a single, isolated operation
  # another connectoin cannot make a change during the execution of a transaction
  # in transaction, all commands are executed or none are

# commands:

# mark the start of a transaction block
# Subsequent commands will be queued for atomic execution using EXEC
> MULTI

# executes all previously queued commands (issued after MULTI) in a transaction and restores the connection state to normal
> EXEC

# flushes all previously queued commands (issued after MULTI) in a transaction and restores the connection state to normal
> DISCARD

# example:
> MULTI
OK
> ...command 1
QUEUED
> ...command 2
QUEUED
> ...command 3
QUEUED
> EXEC

# optimistic concurrency control or optimistic blocking:
  # observe changes in one/more keys
  # abort transaction if observed key(s) have changed

# declare interest in one/more keys
> WATCH key [key ...]

# when EXEC is called, the transaction will fail if any 'watched' keys have been modified

# WATCH has to be called before the transaction is started, i.e. before MULTI
# multiple WATCH commands can be called subsequently, the effects are cumulative
# watches are local to the current client connection
# all keys are automatically 'unwatched' after EXEC (EXEC will return (nil)) 

# forget about all 'watched' keys
> UNWATCH

Bit Data

Bit Fields:

# bit fields can be used to get, set or increment a value in a bit field
# bitfield commands allows manipulation of one/more variable length integers within a string datatype

> BITFIELD key
    [GET type offset]
    [SET type offset value]
    [INCRBY type offset increment]
    [OVERFLOW WRAP | SAT | FAIL]

# 'type' can be - i (signed) or u (unsigned), followed by the size
# e.g. u8, i16, etc.
# can have a max size of i63 and u64

# set an unsigned 8-bit value, at bit offset 0, to 42
> BITFIELD mykey SET u8 0 42

# get the unsigned 8-bit value, at bit offset 0
> BITFIELD mykey GET u8 0
1) (integer) 42

# BITFIELD can also be used to increment values
> BITFIELD myfield incrby u8 0 1
2) (integer) 43

> TYPE mykey
string
> OBJECT ENCODING mykey
"raw" # not "embstr"

Bit Arrays:

# bit arrays allow manipulation of individual bits within a string datatype

> GETBIT key offset

> SETBIT key offset value

# no need to specify 'type' for bit array commands
# bitfields are preferred over bit arrays, since commands have greated flexibility

# count the no. of "set" bits within a range
> BITCOUNT key [start end]

# BITCOUNT uses a "byte offset" not "bit offset" unlike all the other commands

# perform AND/OR/XOR/NOT and store the result at a new 'destination' key
> BITOP operation destination key [key...]

# find the index of the first set/unset bit within a given offset range
> BITPOS key bit [start end]

Pub/Sub

# simple pub/sub
  # post a message to the given channel
  > PUBLISH channel message

  # when a message is published with the PUBLISH command, redis guaranteeS the order of messages in a single node

  # listen for messgaes on a channel(s)
  > SUBSCRIBE channel [channel ...]

  # stop listening for messgaes on a channel(s)
  > UNSUBSCRIBE [channel [channel ...]]

# patterned pub/sub
  # subscribes the client to the given patterns
  # Supported glob-style patterns:
    # h?llo subscribes to hello, hallo and hxllo
    # h*llo subscribes to hllo and heeeello
    # h[ae]llo subscribes to hello and hallo, but not hillo
  > PSUBSCRIBE pattern [pattern ...]

  # un-subscribes the client from the given patterns
  # when no patterns are specified, the client is unsubscribed from all the previously subscribed patterns
  > PUNSUBSCRIBE [pattern [pattern ...]]

# introspection/admin of the pub-sub mechanism can be done using the PUBSUB command
> PUBSUB subcommand [argument [argument ...]]
  # list currently active channels
  # if no pattern is specified, all the channels are listed
  > PUBSUB CHANNELS [pattern]

  # return the number of "unique" patterns that are subscribed to by clients (that are performed using the PSUBSCRIBE command)
  # note that this isn't the count of clients subscribed to patterns, but the total number of unique patterns all the clients are subscribed to
  > PUBSUB NUMPAT

  # return the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels
  > PUBSUB NUMSUB [channel [channel ...]]

  # list the currently active shard channels
  # an active shard channel is a Pub/Sub shard channel with one or more subscribers
  > PUBSUB SHARDCHANNELS [pattern]

Geospatial data

# we can create a geo-spatial index, using a "key" and the "value" comprising of - *unique name of point (member)*, *latitude* and *longitude*
# geo-spatial data is encoded as "geo-hash" - 52 bit integer value
# geo-spatial data is stored as sorted sets

# commands:

# add one or more geospatial items to the geospatial index (key)
# adds the specified geospatial items (longitude, latitude, name) to the specified key
# options:
  # XX: only update elements that already exist, never add elements
  # NX: don't update already existing elements, always add new elements
> GEOADD key [NX | XX] longitude latitude member [longitude latitude member ...]
> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2

# data is stored into the key as a sorted set, in a way that makes it possible to query the items with the GEOSEARCH command
# there is no GEODEL command because you can use ZREM to remove elements

# see all the computed geo-hashes for a given geospatial index (key) i.e. the computed 52-bit integer values
> ZRANGE key 0 -1 WITHSCORES

# see the geo-hashes for specific member(s) in a given geospatial index 
# the command returns 11-character geo-hash strings, not the 52-bit integers
> GEOHASH key member [member ...]

# see the longitude and latitude for specific member(s) in a given geospatial index 
> GEOPOS key member [member ...]

# query a geospatial index to fetch members inside an area of a box or a circle
> GEOSEARCH key 
  <FROMMEMBER member | FROMLONLAT longitude latitude>
  <BYRADIUS radius <M | KM | FT | MI> | BYBOX width height <M | KM | FT | MI>> 
  [ASC | DESC] [COUNT count [ANY]] [WITHCOORD] [WITHDIST] [WITHHASH]

# The query's center point is provided by one of these mandatory options:
  # FROMMEMBER: use the position of the given existing <member> in the sorted set
  # FROMLONLAT: use the given <longitude> and <latitude> position

# the query's shape is provided by one of these mandatory options:
  # BYRADIUS: similar to GEORADIUS, search inside circular area according to given <radius>
  # BYBOX: search inside an axis-aligned rectangle, determined by <height> and <width>

# matching items are returned unsorted by default, to sort them, use one of the following two options: ASC or DESC

# all matching items are returned by default, to limit the results to the first N matching items, use the COUNT <count> option

# the command optionally returns additional information using the following options:
  # WITHDIST: also return the distance of the returned items from the specified center point, the distance is returned in the same unit as specified for the radius or height and width arguments
  # WITHCOORD: also return the longitude and latitude of the matching items
  # WITHHASH: also return the raw geohash-encoded sorted set score of the item

# GEOSEARCHSTORE is similR GEOSEARCH, but stores the result in destination key
> GEOSEARCHSTORE destination source 
  <FROMMEMBER member | FROMLONLAT longitude latitude> 
  <BYRADIUS radius <M | KM | FT | MI> | BYBOX width height <M | KM | FT | MI>> 
  [ASC | DESC] [COUNT count [ANY]] [STOREDIST]

# return the distance between two members in the geospatial index
> GEODIST key member1 member2 [M | KM | FT | MI]

React Hooks by Example - Part 1

Hrittik Bhattacharjee — Sat, 04 Feb 2023 20:58:34 +0000

Learn Hooks = Make Money!🤑

Let's jump right in!
Oh wait, what are hooks?

React docs has this to say

"Hooks are a new addition in React 16.8. They let you use state and other React features without writing a class"

Honestly though, you're definitely better off learning hooks there, but in case you prefer a less bloated source in more of a go-to, no-BS spirit, read on!
Okay let's make some money!

The code for all the examples can be found at this Code Sandbox.
This is Part 1 of a three-part series, and it covers the OG hooks; useState, useEffect and useContext!😎

useState

The useState hook is used to store and update dynamic data in the application, i.e. "State".
Create a state variable and a function to update said state value:
```
const [state, setState] = useState(initialState);
```
Update the value of the state variable:
```
setState(newState);
```

Example:

// /src/UseStateExample.js 

import { useState } from "react";

export default function UseStateExample() {
  const [counter, setCounter] = useState(0);

  return (
    <div className="UseStateExample">
      <h1>Dinero!</h1>
      <h2>You have {counter} 💵</h2>
      <button onClick={() => setCounter(counter + 1)}>Get 1 $</button>
    </div>
  );
}

In the above example,
- The state variable counter is initialized to 0 using the useState hook.
- When the button is clicked, the setter function setCounter runs and increments the value of counter by 1.
See it in action here and the code at this sandbox!

useEffect

The useEffect hook takes a callback function and an optional dependency array, as arguments.
It is used to run some logic inside a callback function, when the value of any of the variables in a specified dependency array changes.
If the dependency array is empty, then the function runs once when the component is initialy loaded.
If you need to run some logic before the component is unmounted, this can be done by returning a function from the callback to useEffect.

Example:

// /src/UseEffectExample.js

import { useEffect, useState } from "react";

export default function UseEffectExample() {
  const [counter, setCounter] = useState(0);

  useEffect(() => {
    if (counter >= 1000000) {
      alert("Congratulations! You're a Millionaire");
    }
  }, [counter]);

  return (
    <div className="UseEffectExample">
      <h1>Dinero!</h1>
      <h2>You have {counter} 💵</h2>
      <button onClick={() => setCounter(1000000)}>Become a Millionaire!</button>
    </div>
  );
}

In the above example:
- The callback to useEffect will run each time the value of counter changes.
- When counter >= 1000000, an alert will be displayed!
See it in action here and the code at this sandbox!

useContext

React's Context API allows you to share data between components without having to prop-drill them down the hierarchy, i.e. without having to pass data down to each child component. The useContext hook allows us to do this.

We can create a Context in the top-level component like so:

const CashContext = createContext("one million dollars");

And we can wrap the child components inside a Provider, and they will have access to the value:

function App(props) {
  return (
    <CashContext.Provider value={"one million dollars"}>
      <ChildComponent1 />
    </CashContext.Provider>
  );
}

We can then use the useContext hook inside nth level child components to access this value passed to the Provider:

function ChildComponent1(props) {
  return (
    <div>
      <ChildComponent2 />
    </div>
  );
}

function ChildComponent2() {
  const cash = useContext(CashContext);

  return (
    <div>{cash}</div>
  );
}

Note: the below example illustrates how Context can be used to access and update values from within child components, which is a pretty useful pattern.

Example:

// /src/context/emojiContext.js

import { createContext } from "react";

export const emojis = {
  "heavy-dollar-sign": "💲",
  "dollar-banknote": "💵",
  "money-bag": "💰"
};

export const EmojiContext = createContext({
  emoji: emojis["heavy-dollar-sign"],
  setEmoji: () => {}
});

// --------------------------------------------------------
// /src/App.js

import "./styles.css";
import { useState } from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";
import { emojis, EmojiContext } from "./context/emojiContext";
import UseContextExample from "./UseContextExample";

export default function App() {
  const [emoji, setEmoji] = useState(emojis["heavy-dollar-sign"]);
  const emojiValue = { emoji, setEmoji };

  return (
    <div className="App">
      <EmojiContext.Provider value={emojiValue}>
        <BrowserRouter>
          <Routes>
            <Route path="use-context" element={<UseContextExample />} />
          </Routes>
        </BrowserRouter>
      </EmojiContext.Provider>
    </div>
  );
}

// --------------------------------------------------------
// /src/UseContextExample.js

import { emojis, EmojiContext } from "./context/emojiContext";
import { useContext } from "react";

export default function UseContextExample() {
  const { emoji, setEmoji } = useContext(EmojiContext);

  const getRandom = () => {
    if (emoji === emojis["heavy-dollar-sign"]) {
      return emojis["money-bag"];
    } else {
      return emojis["heavy-dollar-sign"];
    }
  };

  return (
    <>
      <h1>Dinero!</h1>
      <h2>You have {emoji}</h2>
      <button onClick={() => setEmoji(getRandom())}>
        Click to get something else
      </button>
    </>
  );
}

In the above example:
- We create a Context in emojiContext.js and export it.
- Import it into App.js and wrap the child components inside the Provider.
- The "value" passed to the Provider are the state variable and setter function.
- In UseContextExample.js we use the useContext hook to access and update the value as needed.
See it in action here and the code at this sandbox for emojiContext.js, App.js and UseContextExample.js!

Hope this was fun and you're sleeping on stacks of cash by now!
Stay tuned for Part 2 and 3 where we look at more hooks🤘
Cheers!

Redis Commands Cheat Sheet Part 3 - Sets and Sorted Sets

Hrittik Bhattacharjee — Sat, 28 Jan 2023 21:20:39 +0000

Following are some of the commonly used Redis commands and data structures, use this list as a quick cheat sheet or a ready reference for your day-to-day Redis usage as needed 😄

This is Part 3 of this series, containing commands pertaining to Sets and Sorted Sets in Redis.

Sets

# add one/more elements (members) to a set
# ignores duplicates - returns 0 for duplicates since they will not be added
> SADD key member [member ...]

# get number of members, or cardinality, in a set
> SCARD key

# get all members of a set
# inefficient
> SMEMBERS key

# iterate over members of a set
# more efficient than SMEMBERS
> SSCAN key cursor [MATCH pattern] [COUNT count]

# determine if a given value is a member of a set
# returns:
#   - 1 if the element is a member of the set.
#   - 0 if the element is not a member of the set, or if key does not exist
> SISMEMBER key member

# remove one/more members by value
# specified members that are not a member of this set are ignored
# if 'key' does not exist, it is treated as an empty set and this command returns 0
# error is returned when the value stored at 'key' is not a set
# the return value indicates how many elements were removed
> SREM key member [member ...]

# remove and return one/multiple random member from the set
# default value of 'count' is 1
> SPOP key [count]

# union, intersection, difference of multiple sets stored at a specific key
> SUNION key [key ...]
> SINTER key [key ...]
> SDIFF key [key ...]

# union, intersection, difference of multiple sets stored at a specific key - and store the resulting set in a new set at a 'destination' key
> SUNIONSTORE destination key [key ...]
> SINTERSTORE destination key [key ...]
> SDIFFSTORE destination key [key ...]

Sorted Sets

# add one/more members to sorted set, or update its score if member already exists
# for oprions, see: https://redis.io/commands/zadd/
> ZADD key score member [score member ...] [NX | XX] [GT | LT] [CH] [INCR]

# increment score of a member
# decremebt score by using negative value for 'ncrement'
> ZINCRBY key increment member

# iterate over sorted set, from lowest score to highest score
> ZRANGE key start-index stop-index [WITHSCORES]
> ZRANGE "subway:red-line" 0 -1 WITHSCORES

# iterate over sorted set, from highest score to lowest score
> ZREVRANGE key start-index stop-index [WITHSCORES]

# WITHSCORES includes the score of the members in the output

# return all the elements in the sorted set at key with a score between min and max, from lowest score to highest score
> ZRANGEBYSCORE key min max [WITHSCORES]

# return all the elements in the sorted set at key with a score between min and max, from highest score to lowest score
> ZREVRANGEBYSCORE key min max [WITHSCORES]

# 'min' and 'max' can be -inf and +inf
# by default, the interval specified by 'min' and 'max' is inclusive
# it is possible to specify an exclusive interval by prefixing the score with the character '('
# example:
> ZRANGEBYSCORE zset (1 5 # return all elements with 1 < score <= 5
> ZRANGEBYSCORE zset (5 (10 # return all the elements with 5 < score < 10 (5 and 10 excluded)

# when all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering
> ZRANGEBYLEX key min max

# 'min' and 'max' can be - and +
# '(' is exclusive
# '[' is inclusive
# example:
> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
> ZRANGEBYLEX myzset - [c # returns a, b and c
> ZRANGEBYLEX myzset - (c # returns a and b

# find index (rank) of a member in a sorted set, from lowest score to highest score
# scores ordered from low to high, i.e. member with the lowest score has rank 0
> ZRANK key member

# find index (rank) of a member in a sorted set, from highest score to lowest score
# scores ordered from high to low, i.e. member with the highest score has rank 0
> ZREVRANK key member

# get score of a given member
> ZSCORE key member

# count the members with scores within the given values
# includes members with scores equl to 'min' and 'max'
> ZCOUNT key min max 

# remove one/more members from a sorted set
> ZREM key member [member ...]

# get number of elements (cardinality) in a sorted set
> ZCARD key

# set operations - union, intersection, difference on sorted sets
> ZUNION numkeys key [key ...]
> ZINTER numkeys key [key ...]
> ZDIFF numkeys key [key ...]

> ZUNIONSTORE destination numkeys key [key ...] [AGGREGATE <SUM | MIN | MAX>]
> ZINTERSTORE destination numkeys key [key ...] [AGGREGATE <SUM | MIN | MAX>]
> ZDIFFSTORE destination numkeys key [key ...]

# for the above commands, it is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments
# when AGGREGATE is SUM: the resulting set will contain the sum of the score of an element across the inputs where it exists (default)
# when AGGREGATE is MIN or MAX: the resulting set will contain the minimum or maximum score of an element across the inputs where it exists

# commands for set operations on sorted sets, can work between sets as well as sorted sets

# remove all members in a sorted set within the given scores
# min and max are inclusive by default, exclusive if appended with a '('
# min and max can be -inf and +inf
> ZREMRANGEBYSCORE key min max 

# remove all members in a sorted set within the given indexes
# start and stop are inclusive
> ZREMRANGEBYRANK key start stop

# remove all members in a sorted set within the given lexicographical range
# min and max are inclusive if appended with a '[', exclusive if appended with a '('
# min and max can be - and +
> ZREMRANGEBYLEX key min max

Hope you found this useful! Save the post for reference, here's Part 1 and Part 2 of the series.

Do follow espelar.dev we're working on some pretty cool stuff and have exciting content for you in the works.😊
Cheers!

Redis Commands Cheat Sheet Part 2 - Hashes and Lists

Hrittik Bhattacharjee — Fri, 27 Jan 2023 23:53:48 +0000

Following are some of the commonly used Redis commands and data structures, use this list as a quick cheat sheet or a ready reference for your day-to-day Redis usage as needed 😄

This is Part 2 of this series, containing commands pertaining to Hashes and Lists in Redis.

Hashes

# create a hash
> HSET key field value [field value ...]
> HSET player:1000 name Artexius race Elf level 5
(integer) 3

# returns the number of fields saved in the hash, so 3 in the above case

# if field does not exist, HSET will create the field and set it's value as specified

# to set a field value only if it does not yet exist
> HSETNX key field value

# get all fields and values of the hash
> HGETALL key
> HGETALL player:1000

# get the value of a specific field in the hash
> HGET key field
> HGET player:1000 level

# get the value of a multiple specific fields in the hash
> HMGET key field [field ...]
> HMGET player:1000 level name race

# get all field names for a key
> HKEYS key

# get all field values for a key
> HVALS key

# update a field in the hash
# HSET overwrites the values of specified fields that exist in the hash. If key doesn't exist, a new key holding a hash is created
> HSET field
> HSET player:1000 level 15

# set a field in the hash only if field does not yet exist
> HSETNX key field value

# delete a field(s) in the hash
> HDEL key field [field ...] 
> HDEL player:1000 level

# increment the value of a hash field
> HINCRBY key field increment
> HINCRBYFLOAT key field increment

# determine if a hash field exists
> HEXISTS key field

# returns 1 if exists, 0 if does not

# iterate over fields that match a pattern
> HSCAN key cursor [MATCH pattern] [COUNT count]

# the first HSCAN called with cursor 0
# this returns a new cursor that can be used in subsequent iterations
# HSCAN Is more efficient than HGETALL

Lists

# push elements (to right side) of list
> RPUSH key element [element ...]

# push elements (to left side) of list
> LPUSH key element [element ...]

# pop elements (from left side) of list
# default, the command pops a single element from the beginning of the list
# but when provided with the optional count argument, the reply will consist of up to count elements, depending on the list's length
> LPOP key [count]

# pop elements (from right side) of list
> RPOP key [count]

# get a range of elements from the list 
> LRANGE key start stop

# if you have a list of numbers from 0 to 100, LRANGE list 0 10 will return 11 elements, that is, the rightmost item is included
# -1 is rightmost value

# check length of the list
> LLEN key

# if key does not exist, it is interpreted as an empty list and 0 is returned
# error is returned when the value stored at key is not a list

# return element at a specified index
> LINDEX key index

# add an element before/after an element
> LINSERT key BEFORE|AFTER pivot-element new-element

# set value at a specified index
> LSET key index value

# remove the first 'count' occurrences of elements equal to 'element' from the list stored at key
# the 'count' argument influences the operation in the following ways:
#   - 'count' > 0: Remove elements equal to 'element' moving from head to tail
#   - 'count' < 0: Remove elements equal to 'element' moving from tail to head
#   - 'count' = 0: Remove all elements equal to 'element'
> LREM key count element

# trim list to a specified range
> LTRIM key start stop

# example: 
> LTRIM foobar 0 2 # only the first three elements of the list will remain in the list

Hope you found this useful! Save the post for reference, here's Part 1 of the series. Part 3 will be out soon!

Do follow espelar.dev we're working on some pretty cool stuff and have exciting content for you in the works.😊
Cheers!

Redis Commands Cheat Sheet Part 1 - Keys and Strings

Hrittik Bhattacharjee — Fri, 27 Jan 2023 23:42:57 +0000

Following are some of the commonly used Redis commands and data structures, use this list as a quick cheat sheet or a ready reference for your day-to-day Redis usage as needed.😄

This is Part 1 of this series, containing commands pertaining to Keys and Strings in Redis.

Keys



# SET: store a value for a given key name
# NX or XX allows us to check for "only if does not exist" or "only if exists" while setting, respectively
# PX is used to set TTL for a key in milliseconds
# EX is used to set TTL for a key in seconds
> SET key value [NX | XX] [EX seconds | PX milliseconds | EXAT unix-time-seconds | PXAT unix-time-milliseconds | KEEPTTL]
> SET customer:1000 fred

# options of the SET command:
#   EX seconds -- Set the specified expire time, in seconds.
#   PX milliseconds -- Set the specified expire time, in milliseconds.
#   EXAT timestamp-seconds -- Set the specified Unix time at which the key will expire, in seconds.
#   PXAT timestamp-milliseconds -- Set the specified Unix time at which the key will expire, in milliseconds.
#   NX -- Only set the key if it does not already exist.
#   XX -- Only set the key if it already exist.

# GET: return a value for a given key name
> GET key
> GET customer:1000

# keys and scan: get a list of existing key names, or to iterate over keys that match a pattern
# keys:
#   - blocks until complete
#   - never use in production
#   - useful for debugging
# scan:
#   - also blocks but returns only a handful of keys at a time, 
#   - then returns a slot reference (or, cursor) that can then be used to continue more iterations
#   - safe for production
> KEYS customer:1*

# returns customer:1000, customer 1500 etc. cus they match the pattern 1*

> SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]
> SCAN 0 MATCH customer:1* COUNT 1000
# may or may not return results
# but returns the next slot reference to be used in the next command

# e.g. if it returns the slot reference 14848, then the next SCAN command will be
> SCAN 14848 MATCH customer:1* COUNT 1000

# COUNT is optional, it may be used to return more keys per call, but the more the COUNT, the longer it will block

# removing keys
# DEL: 
#   - remove the key and the memory associated with the key
#   - blocking operation
# UNLINK: 
#   - the key will no longer exist
#   - the memory associated with the key value is claimed by an async process, so non-blocking
> DEL key [key ...]
> UNLINK key [key ...]
> UNLINK customer:1000

# returns the number of keys removed

# when SET is used on a key name that does not exist, the key is automatically created
# however, to set the key value only if the key exysts, use EXISTS
> EXISTS key [key ...]
> EXISTS customer:1000

# if the same existing key is mentioned in the arguments multiple times, it will be counted multiple times. 
# So if somekey exists, EXISTS somekey somekey will return 2.

# setting TTL for a key
> EXPIRE key seconds
> PEXPIRE key milliseconds
> EXPIREAT key timestamp
> PEXPIREAT key milliseconds-timestamp

# viewing TTL for a key
# in seconds
> TTL key
# in milliseconds
> PTTL key

# removing TTL for a key
> PERSIST key

# PX or EX can be used to set TTL for key at the time of creation

# TTL of a "persisted" key is -1

# SCAN basic usage example
# SCAN is a cursor based iterator
# this means that at every call of the command, the server returns an updated cursor that the user needs to use as the cursor argument in the next call
# an iteration starts when the cursor is set to 0, and terminates when the cursor returned by the server is 0
# commands `SCAN, SSCAN, HSCAN and ZSCAN` all work very similarly
# the default `COUNT` value is 10
> scan 0
1) "17"
2)  1) "key:12"
    2) "key:8"
    3) "key:4"
    4) "key:14"
    5) "key:16"
    6) "key:17"
    7) "key:15"
    8) "key:10"
    9) "key:3"
    10) "key:7"
    11) "key:1"
> scan 17
1) "0"
2)  1) "key:5"
    2) "key:18"
    3) "key:0"
    4) "key:2"
    5) "key:19"
    6) "key:13"
    7) "key:6"
    8) "key:9"
    9) "key:11"

Strings



# SET can be used to create a string
> SET key value
> SET user:101:time-zone UTC-8

# sets the value "UTC-8" for the key user:101:time-zone

# GET can be used to retrieve a string
> GET key
> GET user:101:time-zone

# JSON responses can be serealized as a string and stored (cached) as a value for a key
# when caching data it is common to set an expiry time using the `EX` option for seconds
# after expiry, the key will be deleted along with its value
> SET key:1000 '{ "somehing": 1000 }' EX 7200

# check remaining TTL for a key/string using the TTL command
> TTL key:1000

# integer manipulation commands:
# using INCR and INCRBY commands can be used to increment a key's value by 1 or a specified number
# if key does not exist, it will be created and incremented appropriately
> INCR key
> INCRBY key increment

# if the number is negative, value will be decremented

# there is also the DECR and DECRBY command
> DECRBY key decrement

# for floating point incremet
> INCRBYFLOAT key increment

# what if the value of a key is a string?
> SET key:1 1000
OK
> GET key:1
"1000"
> DECRBY key:1 1
(integer) 999
> GET key:1
"999"
> TYPE key:1
string

# so the DECRBY command casted the string value to integer and performed numerical operation on it
# but the value still remains a string

# the encoding of the value cn be checked using the OBJECT ENCODING command
> OBJECT ENCODING key
> OBJECT ENCODING key:1
"int"

# so in the example above, the value is a string, but what is stored withing the string datatype is an integer value

# redis supports polymorphism
> SET key:1 "hello"
OK
> OBJECT ENCODING key:1
"embstr" # i.e. a text value

> DECRBY key:1 10
(error) ERR # since the encoded vaue is not an integer anymore

Hope you found this useful! Save the post for reference, Parts 2 and 3 will be out soon!

Do follow espelar.dev we're working on some pretty cool stuff and have exciting content for you in the works.😊
Cheers!