DEV Community: Ahmed Gulab Khan

A Fundamental Guide To Docker For Beginners

Ahmed Gulab Khan — Fri, 18 Mar 2022 16:16:23 +0000

In my previous article, I had gone over what is Docker and why do we need it. I recommend you go over that article to understand what Docker is and the need to containerize your applications using Docker

Docker

To begin with, Docker is a tool used for developing, shipping, and running applications inside loosely coupled isolated environments called containers. Containers are lightweight processes that include all the dependencies or libraries that your application needs to run without interfering with the other containers running on the same host machine. The advantage of using containers is that your application runs the same way on any machine irrespective of its OS or conflicting dependencies on the host machine.

Now, let's discuss the main components that Docker comprises of

The Docker Architecture

Docker Engine
The Docker Engine is the core containerization technology responsible for creating and managing all the containers and other Docker objects. It acts as a client-server application consisting of:

The Docker Daemon, which is a daemon process that runs in the background, keeps listening for any API requests and manages the Docker objects accordingly
A set of APIs to communicate with the Docker daemon
The Docker CLI client helps users to communicate with the docker daemon and carry out the user's requests by using these Docker APIs

Docker Objects

All the files and individual components that are managed by the Docker engine like images, containers, dockerfiles, volumes, and networks are called objects in the Docker context. Let's discuss each one of these objects and understand what they represent

Dockerfile: A Dockerfile is a text file with instructions and commands that a user intends to perform as part of building a docker image. Dockerfile is first used to build an image, which is then used to create the container itself. A simple Dockerfile would look something like this

FROM ubuntu
RUN apt-get update
RUN apt-get install –y nginx
CMD ["echo","Image created"]

Docker Image: A Docker image is just a template that includes all the set of instructions and commands from the Dockerfile, and this in turn is used to create the actual container. We can use the same docker image to run the same set of instructions and create multiple docker containers on the same host given they run on different ports
Docker Container: A Docker container is the actual instance that is based on the docker image. It packages all the dependencies, libraries that an application needs and runs it in loosely coupled isolation.

Now that we understand what dockerfiles, images, and containers stand for, let's understand what the Dockerfile cited above does

FROM ubuntu: This statement tells docker which base image to use while building your current image. In this example, we are the ubuntu image, which is pulled from the configured docker registry while building the image. It is required that you specify the FROM command to tell docker which base image your current image is based on
RUN apt-get update: Runs the update command on the ubuntu system
RUN apt-get install -y nginx: Installs the nginx server on the system
CMD ["echo","Image created"]: Prints "Image created" message on the terminal

Docker Volume: By default, the data related to a container is not persisted when the container is terminated or restarted. Volumes in docker help store the container-related data inside the host machine's file system which is then managed by Docker
Docker Network: For the individual containers to communicate with each other or to communicate with the host machine, docker provides the concept of networking. The different network drivers that can be used are - bridge (default), host, overlay, ipvlan, macvlan, and none (disables all networking)

Docker Registries

Docker registries are a place where you can store all your docker images. The official registry of Docker i.e; Docker Hub is a public registry that allows any user to pull or push images to the registry. It is also possible to create your own private registry. Docker Hub is set as the default registry when you first install Docker and all the pull and push commands you run in order to upload or download your images use Docker Hub

Docker Compose

So you have created a few dockerfiles, built images based on these dockerfiles, and also ran containers using these images. But using this approach, it becomes difficult to manage all the containers, their configuration, and the network links between individual containers to establish communication, this is where Docker compose comes into the picture.

Docker Compose is a container orchestration tool that is used to run multi-container applications on a single host machine. Docker compose helps users to start multiple dependent containers by using just a single file and a single command. This single file is used to maintain all the configuration, network links, volume, and port mappings for the required containers of your application and is usually written in YAML format

Docker Swarm

Docker Swarm, similar to Docker compose is a container orchestration tool that makes it simpler to manage multiple containers that run on multiple host machines. This group of machines is called a cluster and each of them needs to have Docker running on them. Individual machines that make up the cluster are referred to as nodes and all the activities of the cluster are controlled by a node which is referred to as the swarm manager

References

Follow for more articles related to Docker and Software Engineering in general :)

What Is Docker And Why Do We Need It?

Ahmed Gulab Khan — Thu, 17 Mar 2022 16:42:21 +0000

In this article, we shall be going through a brief introduction to what Docker is and why we need it. But first, let’s define the problem statement and see how Docker solves it

The Problem Statement

Let’s consider that you’re working on an application which requires multiple technologies to be used for developing the different components like the Frontend, Backend, Database etc… Everything seems to be good, but while you’re working with all these technologies on your machine, most often there arises a problem where one technology needs one version of a dependency and some other technology needs a different one to work. Adding to this, it might also happen that your application may not work the same way on someone else’s machine or when you deploy it to different environments with different OS or hardware, it fails to run.

In order to solve all these frequent problems we use something called virtualization, let’s discuss this in more detail

The Solution: Virtualization

Virtualization is a process whereby a software is used to create an abstraction layer over computer hardware that allows the hardware elements of a single computer to be divided into multiple virtual computers. The main idea of virtualization would be to isolate the components of our application and their dependencies into individual self-contained units that can run anywhere without any dependency or OS conflicts.

Now that we know what virtualization means, we can use it in order to solve our above stated problem. There are two ways to achieve this by leveraging the concept virtualization:

1. Virtual Machines
A Virtual Machine is essentially an emulation of a real computer that executes programs like a real computer. Virtual machines run on top of a physical machine using a Hypervisor. A hypervisor, in turn, runs on a host machine.

A Hypervisor is a piece of software, firmware, or hardware that a virtual machine runs on top of. The host machine provides the virtual machines with resources, including RAM and CPU. These resources are divided between virtual machines and can be distributed based on the applications that run on individual virtual machines.

Even though, virtual machines have solved the problem by now making our applications to run in isolation, with their own set of dependencies/libraries and OS requirements, the main issue here is that they’re very heavy since each virtual machine has it’s own Guest operating system thereby consuming a higher portion of the host machine’s resources and so take up a lot of time to start or create. This is where containers come to the rescue.

2. Containers
Containers are a light-weight, more agile way of handling virtualization, and since they don’t use a software like hypervisor, you can enjoy faster resource provisioning and speedier availability of new applications. Unlike virtual machines which provide a hardware level virtualization, containers provide an operating-system level virtualization due to which they’re very simple and easy to work with.

Since containers are lightweight, they consume a lot less resources of the host machine compared to virtual machines. You can easily share containers while you work, and be sure that everyone you share with gets the same container that works in the same way irrespective of version conflicts between dependencies or OS.

Now, What is Docker?

Docker is a tool which helps in developing, shipping, and running your applications on containers and enables you to separate your applications from your infrastructure so you can deliver software quickly.

It provides the ability to package and run an application in an isolated environment i.e; containers. The isolation and security allows you to run many containers simultaneously on a given host.

Some basic Docker terminology

Docker Engine
The Docker Engine is the core containerization technology responsible for creating and managing all the containers and other Docker objects. It acts a client-server application consisting of:

The Docker Daemon, which is a daemon process that runs in the background, keeps listening for any API requests and manages the Docker objects accordingly
A set of APIs in order to communicate with the Docker daemon
The Docker CLI client which helps users to communicate with the docker daemon and carry out the user’s requests by using these Docker APIs

Docker Image
A Docker image is just a template which includes a set of instructions or commands that are used in order to create the actual container. We can use the same docker image to create multiple docker containers

Docker Container
A Docker container is the actual instance which is based off of an image, and packages all the dependencies, libraries that an application needs and runs it in loosely coupled isolation

References

Follow for more articles related to Docker and Software Engineering in general :)

9 Insanely Helpful Kafka Commands Every Backend Developer Must Know

Ahmed Gulab Khan — Fri, 11 Mar 2022 14:15:01 +0000

In this article, I'm going to list out the most popular Kafka CLI commands you should know as a Developer. Before we begin, I'd recommend you to go over this article in order to get a brief understanding of what Kafka is and how it works.

If you want to setup Kafka locally, you can check this article out which helps you setup both Kafka and Zookeeper locally in just 3 simple steps. And for running the below commands, I'm going to use the same Kafka setup as mentioned in that article. Which means that the Kafka version being used here would be 0.10.1.0 built for the Scala version 2.11.

Now without any further delay, let's go through the list of commands

1. List all the Kafka topics

bin/kafka-topics.sh --list --zookeeper localhost:2181

2. Create a topic

Creates a Kafka topic named my-first-kafka-topic with partitions and replication factor both set as 1

bin/kafka-topics.sh --create --topic my-first-kafka-topic --zookeeper localhost:2181 --partitions 1 --replication-factor 1

For simplicity, I have set the partitions and the replication factor as 1 for the topic, but you can always play around with this configuration. If you don't know what partitions and replication factor mean in the Kafka context, I'd recommend you to go through this article in order to get a good understanding

3. Describe a topic

Describes the topic mentioned in the command

bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-first-kafka-topic

4. Update topic Configuration

Update the configuration of the mentioned topic (my-first-kafka-topic in this case). Here, we are updating the property cleanup.policy to be compact, the compression.type to be gzip and the retention.ms to be 3600000

bin/kafka-configs.sh --zookeeper localhost:2181 --alter --entity-type topics --entity-name my-first-kafka-topic --add-config cleanup.policy=compact,compression.type=gzip,retention.ms=3600000

5. Delete a topic

Deletes the topic mentioned in the command

bin/kafka-topics.sh --delete --zookeeper localhost:2181 --topic my-first-kafka-topic

6. Produce messages to a topic

Opens a prompt where you can type any message and hit enter to publish it to the mentioned topic.

bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my-first-kafka-topic

You can keep typing any number of messages and hit enter after every message to publish all the typed messages sequentially. If you're done you can exit using Ctrl+C

7. Consume messages from a topic

Consume messages from the mentioned topic

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-first-kafka-topic

The above command only starts consuming messages from the topic from the instant the command is executed and none of the previous messages are consumed. When you do not specify the Consumer Group for the consumer, Kafka automatically creates a random Consumer Group called console-consumer- for the consumer. And every time you run the above command a new random consumer group is created for the consumer.

Consume messages from the mentioned topic where the consumer belongs to the mentioned Consumer Group (my-first-consumer-group in this case)

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-first-kafka-topic --consumer-property group.id=my-first-consumer-group

8. Consume messages from a topic from the beginning

From the above point we see that irrespective of whether our consumer belongs to a random consumer group or a consumer group created by us, the messages are only consumed from the instant that the consumer starts, and no previous messages are consumed. The --from-beginning argument makes sure that when a consumer group is created, it starts consuming all the messages from beginning.

Consume messages from the mentioned topic from the beginning

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-first-kafka-topic --from-beginning

Note: Once we run the above command, we see that a random consumer group is created and our consumer falls under this random consumer group, so the messages are consumed from the beginning. Now if we run the above command once again, a new random consumer group is created once again and the new consumer falls under this new consumer group and all the messages are consumed again from the beginning. If we only want our consumer to consume the messages from the start when we first start the consumer (i.e; the first time the consumer group is created and our consumer joins this consumer group), then we have to make sure that we keep using the same consumer group in the above command the next time we start our consumer; this way our consumer only consumes messages from the start the first time it starts up, and in the case when this consumer is restarted, the messages are only consumed from the last committed offset but not from the very beginning. So, it is important that you specify a consumer group, since if it's not specified a random consumer group is created each time the above command is run and the messages are consumed from the very beginning every single time

Consume messages from the mentioned topic where the consumer belongs to the mentioned Consumer Group

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-first-kafka-topic --consumer-property group.id=my-first-consumer-group --from-beginning

9. List all the Consumer Groups

bin/kafka-consumer-groups.sh --list --bootstrap-server localhost:9092

More Kafka articles that you can go through:

Follow for the next Kafka blog in the series. I shall also be posting more articles talking about Software engineering concepts.

3 Simple steps to set up Kafka locally using Docker

Ahmed Gulab Khan — Fri, 04 Mar 2022 12:09:34 +0000

In this article, let’s go over how you can set up Kafka and have it running on your local environment. For this, make sure that you have Docker installed on your machine.

If you want to get a brief understanding of Kafka and how it works, I’d recommend you go through this article, as it’d help you get a good understanding of Kafka and some basic kafka terminology.

Now, Let’s get started with setting up Kafka locally using Docker

1. Download and Install Kafka:

With Docker installed, you can follow the below steps in order to download the spotify/kafka image on your machine and run the image as a docker container

Download spotify/kafka image using docker

docker pull spotify/kafka

Create the docker container using the downloaded image

docker run -p 2181:2181 -p 9092:9092 --name kafka-docker-container --env ADVERTISED_HOST=127.0.0.1 --env ADVERTISED_PORT=9092 spotify/kafka

What the above steps do is — a. Download the spotify/kafka image and b. Using this image, create a docker container named kafka-docker-container (you can name the container anything you prefer) with ports 2181, 9092 of your machine mapped to 2181, 9092 of the container.

One nice thing about the spotify/kafka docker image is that it comes with both Kafka and Zookeeper configured in the same image, so you don’t have to worry about having to configure and start Kafka and Zookeeper separately.

With that, you have Kafka running on your machine and open to listening and storing messages from producers which can then be consumed by the consumers.

2. Create your very first Kafka topic:

Since, there are currently no topics present on the Kafka broker, you can go ahead and create one to see if everything works as expected

To use the Kafka CLI, you have to:

Open your terminal and exec inside the kafka container

docker exec -it kafka-docker-container bash

Once in the container, goto the below path

cd /opt/kafka_2.11-0.10.1.0/

Here 2.11 is the Scala version and 0.10.1.0 is the Kafka version that is used by the spotify/kafka docker image

Create a topic

bin/kafka-topics.sh —create —topic my-first-kafka-topic —zookeeper localhost:2181 —partitions 1 —replication-factor 1

The above command would have created your first topic with the name my-first-kafka-topic in your kafka container.

For simplicity, I have set the partitions and the replication factor as 1 for the topic, but you can always play around with this configuration. If you don’t know what partitions and replication factor mean in the Kafka context, I’d recommend you to go through this article in order to get a good understanding.

3. List all the Kafka topics:

After you’ve created the topic as mentioned above, you can run the below command in order to list all the topics present on your locally running Kafka container:

bin/kafka-topics.sh —list —zookeeper localhost:2181

And if everything goes well, you should be able to see the topic you just created being listed after you run the above command.

More Kafka articles that you can go through:

Follow for the next Kafka blog in the series. I shall also be posting more articles talking about Software engineering concepts.

Kafka Partitions and Consumer Groups

Ahmed Gulab Khan — Mon, 28 Feb 2022 10:34:58 +0000

In my previous article, we had discussed how Kafka works and went through some basic Kafka terminology. In this article we would go over how Partitions and Consumer Groups work in Kafka.

If you haven’t gone through my previous article or if you’re new to Kafka, I recommend you to go through it as it’d help you get a basic understanding of how Kafka works.

You can find the complete article with some common Q&A's here

So, what is a Partition?

Before talking about partitions we need to understand what a topic is. In Kafka, a topic is basically a storage unit where all the messages sent by the producer are stored. Generally, similar data is stored in individual topics. For example, you can have a topic named “user” where you only store the details of your users, or you can have a topic named “payments” where you only store all the payment related details. A topic can be further subdivided into multiple storage units and these subdivisions of a topic are known as partitions.

By default a topic is created with only 1 partition and whatever messages are published to this topic are stored in that partition. If you configure a topic to have multiple partitions then the messages sent by the producers would be stored in these partitions such that no two partitions would have the same message/event.

All the partitions in a topic would also have their own offsets (If you don’t know what an offset is, I recommend you check out this article where I have discussed about it)

As an example, a producer producing messages to a kafka topic with 3 partitions would look like this:

Now, what is a Consumer Group?

A bunch of consumers can form a group in order to cooperate and consume messages from a set of topics. This grouping of consumers is called a Consumer Group. If two consumers have subscribed to the same topic and are present in the same consumer group, then these two consumers would be assigned a different set of partitions and none of these two consumers would receive the same messages.

Note: Consumer Groups can help attain a higher consumption rate, if multiple consumers are consuming from the same topic.

Now, let’s go through a few scenarios to better understand the above concepts

Scenario 1: Let’s say we have a topic with 4 partitions and 1 consumer group consisting of only 1 consumer. The consumer has subscribed to the TopicT1 and is assigned to consume from all the partitions. This scenario can be depicted by the picture below:

Scenario 2: Now let’s consider we have 2 consumers in our consumer group. These 2 consumers would be assigned to read from different partitions — Consumer1 assigned to read from partitions 0, 2; and Consumer2 assigned to read from partitions 1, 3.

Note: Kafka assigns the partitions of a topic to the consumer in a consumer group, so that each partition is consumed by exactly one consumer in the consumer group. Kafka guarantees that a message is only ever read by a single consumer in the consumer group.

Since the messages stored in individual partitions of the same topic are different, the two consumers would never read the same message, thereby avoiding the same messages being consumed multiple times at the consumer side. This scenario can be depicted by the picture below:

But, what if the number of consumers in a consumer group is more than the number of partitions? Check out Scenario 3

Scenario 3: Let’s say we have 5 consumers in the consumer group which is more than the number of partitions of the TopicT1, then every consumer would be assigned a single partition and the remaining consumer (Consumer5) would be left idle. This scenario can be depicted by the picture below:

Okay, and what if you want multiple consumers to read from the same partition? Check out Scenario 4

Scenario 4: If you want to assign multiple consumers to read from the same partition, then you can add these consumers to different consumer groups, and have both of these consumer groups subscribed to the TopicT1. Here, the messages from Partition0 of TopicT1 are read by Consumer1 of ConsumerGroup1 and Consumer1 of ConsumerGroup2. This scenario can be depicted by the picture below:

You can check out my previous article Apache Kafka: Basic Terminology

Follow me for the next Kafka blog in the series. I shall also be posting more articles talking about Software engineering concepts.

Apache Kafka: Basic terminology

Ahmed Gulab Khan — Sat, 26 Feb 2022 14:46:56 +0000

In this blog post I’ll be giving a brief and basic introduction regarding Apache Kafka and the terminology that would be necessary to know in order to get started with Kafka.

You can check out the full article here

Kafka — What is it?

In a nutshell, Kafka is a distributed system that allows multiple services to communicate with each other via its queue based architecture. With that out of the way, let’s get to know about some basic Kafka terminology. Let’s get started ;)

Broker: A Broker is a server which has Kafka running on it and is responsible for the communication between multiple services. Multiple brokers would form a Kafka cluster.
Event: The messages that are produced to or consumed from the Kafka broker are called events. These messages are stored in the form of bytes in the broker’s disk storage.
Producer and Consumer: The services that produce these events to Kafka broker are referred to as Producers and those which consume these events are referred to as Consumers. It could also be possible that the same service can both produce and consume messages from Kafka.
Topic: In order to differentiate the type of events stored in Kafka, topics are used. In short, a topic is like a folder in a file system where only events or messages related to a specific type are stored. For example: “payment-details”, “user-details”, etc.
Partition: A topic can be further divided into partitions in order to attain higher throughput. It is the smallest storage unit which holds a subset of data of a topic.
Replication Factor: A replica of a partition is a backup of that partition. The replication factor of a topic decides how many replicas of a partition in that topic should be maintained by the Kafka cluster. A topic with partition as 1 and replication factor as 2 would mean that two copies of the same partition with same data would be stored in the Kafka cluster.
Offset: To keep a track of which events have already been consumed by the consumer, an index pointing to the latest consumed message is stored inside Kafka, this index is called the offset and helps keep a track of which events have already been consumed by the consumer. So if a consumer were to go down, this offset value would help us know exactly from where the consumer has to start consuming events. A producer producing messages to a kafka topic with 3 partitions would look like this:

Zookeeper: Zookeeper is an extra service present in the Kafka cluster that helps maintain the cluster ACLs, , stores the offsets for all the partitions of all the topics, used to track the status of the Kafka broker nodes and maintain the client quotas (how much data a producer/consumer is allowed to read/write)
Consumer Group: A bunch of consumers can join a group in order to cooperate and consume messages from a set of topics. This grouping of consumers is called a Consumer Group. If two consumers have subscribed to the same topic and are present in the same consumer group, then these two consumers would be assigned a different set of partitions and none of these two consumers would receive the same messages. Consumer Groups can help attain higher consumption rate, if multiple consumers are subscribed to the same topic.

You can check out the next article of the Kafka series here

Follow for the next Kafka blog in the series. I shall also be posting more articles talking about Software engineering concepts.

What even is GitHub Codespaces?

Ahmed Gulab Khan — Sat, 05 Sep 2020 11:01:39 +0000

So GitHub has recently announced a new way for users to edit their code online, through something called the Codespaces, which is currently in beta. Here is an overview of what it's all about.

What is Codespaces?

According to GitHub, "Codespaces is an online dev environment which gives a complete Visual Studio Code like experience without leaving GitHub". This means that all the users who have signed up for Codespaces, can edit their code and get access to all the features of VS Code along with it's marketplace on GitHub itself.

Well currently Codespaces is in beta and you can sign up for early access here.

Is Codespaces available to everyone, and for all repositories?

Currently Codespaces is only available for a limited number of users and over time more users will start gaining access to it based on availability and sign up date.

While in beta, Codespaces will be available for the repositories that you own and public repositories. Additional support will be available as the beta progresses, but for now, Codespaces will not be available for private repositories that belong to organizations.

Pricing

Codespaces will be free for the limited beta, and GitHub is planning to make it a pay-as-you-go service in the future.

Codespaces vs Visual Studio Code

Codespaces sets up a cloud-hosted, containerized, and customizable VS Code environment. After set up, you can connect to a codespace through the browser or through VS Code.

For more information about Codespaces, and to know about the FAQ's related to Codespaces, you can go to this link.

Source - GitHub Codespaces

Restaurant reviews app made using Flutter and Firebase

Ahmed Gulab Khan — Thu, 03 Sep 2020 19:26:10 +0000

So, a couple of days ago I developed a food restaurant reviews app using Flutter and Firebase, and made it open-source by uploading the source code on my GitHub profile.

About the app

Foodspace is an app made using Flutter, where people can register and start exploring wide categories of restaurants present in their cities and also check the reviews and feedback for a specific restaurant. There is also a ‘likes section’ where all the restaurants liked by the user are displayed.

I was using the Zomato API for fetching details of these restaurants by place, and using the co-ordinates that I received from the API, created a map that shows a pointer which points to the location of the restaurant that you have clicked using flutter_map dependency.

Firebase was used to store the login credentials and all the restaurants any particular user has liked. Stored user login data using shared_preferences to avoid users to login everytime they close and reopen the app. Used firebase_auth for user authentication.

Here is the link to the source code: https://www.github.com/ahmedgulabkhan/Foodspace

If you like the project, you can star the repository on GitHub, or contribute to it by making Pull requests.

The final app looks something likes this

Dependecies used

introduction_screen
firebase_auth
google_sign_in
cloud_firestore
flutter_spinkit
shared_preferences
font_awesome_flutter
shimmer
flutter_map

I also made a medium article explaining how I implemented most of the things, you can check it out here.

Hope you like this project, would love to hear your feedback on this :).

GroupChatApp - A group chatting app using Flutter

Ahmed Gulab Khan — Sun, 16 Aug 2020 09:12:41 +0000

Hello guys, a few days ago I developed a group chatting app using Flutter and Firebase, and made it open-source by uploading the source code on my GitHub profile.

Here is the link to the Source code: https://github.com/ahmedgulabkhan/GroupChatApp

If you like the project, you can star the repository on GitHub, or contribute to it by making Pull requests.

Features

1. Sign in/Register

Users can register on the app by entering their Email, Full name and Password.
If already registered, they can simply sign in by entering Email and Password.
Used Firebase to implement sign in/register for users.

2. Creating Groups

After being successfully logged in, users can create a new group with any name.
When a user creates a group, they automatically become a member of the group.
All the groups that a user is a member of, are displayed on the user's home screen page.

3. Search for Groups

Users can also search for any content related groups created by other users.
If you come across a group and like the content, you can join the group and start chatting with other members of the group.

4. Chatting in groups

Only the members of a group can chat within the group.
All the chats related to a group will be private to that group.
All the details of a group are stored in a Firebase collection and all the messages related to that group are stored in the sub-collection of that group's collection.

5. Logout

Logout functionality implemented using Firebase.

In the journey of making this app, I learned a lot of new things. So, I decided to make this project open-source so that other people can also learn and benefit from it.

Source code/GitHub repo: https://github.com/ahmedgulabkhan/GroupChatApp

If you like the project, you can star the repo on GitHub by going to the above link.

Would love to hear your valuable feedback on this.