DEV Community: vansh bhardwaj

How to Build a Kubernetes Cluster Using kubeadm

vansh bhardwaj — Sat, 14 Dec 2024 16:03:33 +0000

Introduction to Kubernetes and kubeadm

Kubernetes (K8s) is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It provides a framework to run distributed systems resiliently, offering features like scaling, failover, and service discovery. Setting up a Kubernetes cluster is a fundamental step for developers and DevOps engineers aiming to manage containerized applications at scale. One of the most efficient ways to create and manage a Kubernetes cluster is by using kubeadm, a tool designed to bootstrap Kubernetes clusters.

In this guide, we will set up a Kubernetes cluster with one master node and one worker node using kubeadm on AWS EC2 instances.

Requirements for Kubernetes Cluster

Master Node: We will use a t2.large instance.
Worker Node: We will use a t2.medium instance.
Operating System: Ubuntu 20.04 or newer (64-bit).
Network: Open port 6443 on the master node (used by Kubernetes API Server).
Memory Requirements:
Master Node: Minimum 2 CPUs and 2 GB RAM (recommended 4 GB RAM).
Worker Node: Minimum 2 CPUs and 2 GB RAM.
Tools Required: Docker, kubeadm, kubelet, kubectl.

Steps to Set Up the Kubernetes Cluster

Step 1: Set Up AWS EC2 Instances

Launch two EC2 instances:
Master Node: Use a t2.large instance.

Worker Node: Use a t2.medium instance.

Use Ubuntu as the OS.
Open the necessary ports ( port 6443 on the master node)

Step 2: Update and Upgrade Both Nodes

Run the following commands on both the master and worker nodes to update the system:

sudo apt update sudo apt upgrade -y

Step 3: Install Docker on Both Nodes

Docker is required to manage containers in Kubernetes. Install it using the following commands:

sudo apt install docker.io -y sudo systemctl start docker sudo systemctl enable docker sudo usermod -aG docker $USER sudo reboot

Step 4: Install kubeadm, kubelet, and kubectl on Both Nodes

These tools are essential for setting up and managing the Kubernetes cluster:

Add the Kubernetes signing key:

sudo curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.31/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

Add the Kubernetes repository:

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.31/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Update the package list:

sudo apt update

Install kubeadm, kubelet, and kubectl:

sudo apt install -y kubelet kubeadm kubectl

Step 5: Initialize the Master Node

On the master node, run the following commands:

Switch to the root user:

sudo su

Initialize the cluster:

kubeadm init

Set up the kubeconfig for kubectl:

export KUBECONFIG=/etc/kubernetes/admin.conf

Set up a pod network using Weave Net:

kubectl apply -f https://github.com/weaveworks/weave/releases/download/v2.8.1/weave-daemonset-k8s.yaml

Step 6: Add the Worker Node to the Cluster

On the master node, generate the join command:

kubeadm token create --print-join-command

The output will be similar to:

kubeadm join 172.31.84.246:6443 --token jcgr7p.8x2yqehcg0jbsk80 --discovery-token-ca-cert-hash sha256:cfd5cce76dfe4330f0cd8fed5feed709bdb0efcf1fa0656f188475e3bda7563f

Copy this command and use it on the worker node to join the cluster.

Now, on the worker node, run the following commands:

Switch to the root user:

sudo su

Reset pre-flight checks

kubeadm reset pre-flight checks

Use the join command generated earlier to connect the worker node to the cluster:

kubeadm join 172.31.84.246:6443 --token jcgr7p.8x2yqehcg0jbsk80 --discovery-token-ca-cert-hash sha256:cfd5cce76dfe4330f0cd8fed5feed709bdb0efcf1fa0656f188475e3bda7563f --v=5

Note -> Append “--v=5” at the end, this ensures we use version 5 to join kubeadm

We should get the following output “This node has joined the cluster”

Step 7: Verify the Cluster

On the master node, verify that the worker node has successfully joined the cluster:

kubectl get nodes

You should see an output like this:

NAME STATUS ROLES AGE VERSION ip-172-31-47-111 Ready <none> 2m38s v1.31.1 ip-172-31-84-246 Ready control-plane 33m v1.31.1

Step 8: Deploy an Application (Nginx)

To test the cluster, deploy an Nginx pod:

kubectl run nginx --image=nginx --restart=Never

Check the pod status:

kubectl get pods

You should see an output like this:

NAME READY STATUS RESTARTS AGE nginx 1/1 Running 0 3m44s

On the worker node, you can verify the pod using Docker commands:

docker ps ctr -n k8s.io containers list crictl ps

Note -> Kubernetes 1.20+ deprecated Docker as the default container runtime (June 23) in favor of containerd or CRI-O. If your worker node is using containerd or cri-o, docker ps won’t show running containers. Instead, you can check the running containers using:

For containerd: ctr -n k8s.io containers list
For cri-o: crictl ps

Conclusion

Setting up a Kubernetes cluster using kubeadm is a straightforward process that involves:

Preparing the nodes by installing necessary tools like Docker and kubeadm.
Initializing the master node and setting up the control plane.
Joining worker nodes to the cluster using a token.
Verifying the cluster and deploying applications to test the setup.

With Kubernetes, you now have the ability to deploy, scale, and manage containerized applications efficiently. This setup serves as a foundation for experimenting with advanced Kubernetes features and workloads.

About Me

Hi, I’m Vansh. I’m Building stuff on the web. Exploring Cloud and DevOps. Passionate about creating and scaling solutions. Let’s connect on Twitter: [heyyvanshh].

DevOps: The Art of Delivering Software with Speed and Precision

vansh bhardwaj — Sun, 19 Nov 2023 15:17:05 +0000

In the rapidly evolving landscape of software development, the need for efficient and reliable delivery practices has never been more critical. DevOps is rooted in the idea of collaboration, communication, and integration between teams. Traditionally, teams operated in silos, leading to inefficiencies, delays, and a lack of agility in software delivery. DevOps breaks down these barriers, fostering a culture of collaboration, automation, shared responsibilities, and continuous improvement.

Let’s understand the following terms in detail:

Collaboration

DevOps promotes collaboration not only between development and operations but across all stakeholders involved in the software development lifecycle. Effective communication and collaboration lead to better decision-making, faster issue resolution, and a more streamlined development process.

Automation

Automation is a cornerstone of DevOps. By automating manual processes, organizations can reduce errors, increase efficiency, and accelerate the delivery pipeline. Continuous Integration (CI) and Continuous Deployment (CD) are key components of automation, enabling developers to integrate code changes seamlessly and deploy them automatically.

Continuous Integration and Continuous Deployment (CI/CD)

CI/CD practices enable developers to integrate code changes frequently and deploy them automatically to production or staging environments. This ensures that software is always in a deployable state, reducing the time between code commits and production releases.

Monitoring and Feedback

DevOps emphasizes continuous monitoring of applications and infrastructure. Real-time feedback enables teams to identify issues early in the development process, leading to quicker resolution and improved overall system reliability.

DevOps is more than just a set of practices; it is an art form that transforms how organizations deliver software. By fostering collaboration, automation, and a culture of continuous improvement, DevOps enables teams to achieve faster software delivery, increased collaboration, improved quality, enhanced scalability, and greater stability and reliability.

Faster time to market:

DevOps accelerates the software delivery lifecycle, allowing organizations to release features and updates more quickly. This speed to market is crucial in today’s competitive business environment.

Increased Collaboration and Communication:

By breaking down organizational silos, DevOps fosters a culture of collaboration and open communication, leading to improved efficiency and problem-solving.

Improved Quality:

Automation, continuous testing, and continuous monitoring in the DevOps pipeline contribute to higher software quality. Issues are identified and resolved earlier in the development process, reducing the likelihood of defects reaching production.

Enhanced Scalability:

DevOps practices, such as Infrastructure as Code, make it easier to scale infrastructure and applications based on demand, ensuring optimal performance during peak periods.

Greater Stability and Reliability:

Continuous monitoring and feedback loops in the DevOps pipeline contribute to increased system stability and reliability. Issues are proactively addressed, minimizing downtime and enhancing the user experience.

As technology continues to advance, the principles of DevOps will remain essential in meeting the evolving demands of the software development landscape. Embracing DevOps is not just a choice; it’s a necessity for organizations striving to stay competitive in today’s fast-paced digital world.

7 UI Design Fundamentals for Developers

vansh bhardwaj — Thu, 23 Sep 2021 23:01:13 +0000

Hello everyone, my name is Vansh and I'm a frontend developer. A lot of people have asked me this question,"Do I need to learn design to be Front end developer?"

Before I answer this question first you need to understand that many companies do have in-house UX/UI designers, who will do the designing part and build mockups while you can concentrate on the development part. It's our task to give life to mockups, to make them interactive.

But what if you don't have a designer or you're building some side project for yourself, and when you have one, they're not always available because they have a lot of work or maybe if some mockups are missing.
So you cannot always be dependent on a designer to make minor changes to the design as well.
And you having a design sense is of considerable value for you and your team.

See I'm not saying you need to be a designer nor we are here to replace them.
But it wouldn't hurt for you to pick up some designing skills as well.
And it definitely helps to have a creative eye and develop knowledge esthetics.

So in this blog post, I'm going to share how you can build interfaces/apps that look good by just following these 7 UI fundamentals.

Let's Jump in!

White space
Color
Contrast
Scale
Alignment
Typography
Visual Hierarchy

1. White Space

The first UI fundamental we are going to discuss is the white space.

White space is the empty space between the elements in your UI.
it's just a void of space but that gives your UI a structure.

let's look at an example

we can see the right side container is much more readable and looks good from the left container.

By using just 3 CSS properties, padding, margin and line-height, you can significantly improve the appearance of your text.

2. Alignment

Alignment is the process of ensuring that every element is positioned correctly in relation to other elements.

Visual alignment is one of the foundations of design, we humans prefer visually aligned objects.

First, let's look at this UI

We can see here are 4 elements, logo, headline, text and button,
and they all seem to be off a little bit in terms of their alignment.

Again, with just 3 properties: margin, transform and text-align we can solve this.

we can see now it looks much better because everything is aligned properly.

3. Contrast

Contrast is defined as being in a 'strikingly' different state from something else.
While building UIs we should keep in mind if users can clearly see and distinguish all the necessary details on the screen or page.

Look at the first image where there is a grey subheading and grey text on a button, we can see there is hardly any contrast from the background, it's hard to read text, especially on the button.

Now if we increase the contrast, using a darker color for text and white on top of the button, we can see it's much more readable.

Lack of readability can be a serious reason why users are not retained even with attractive products.

4. Scale

Scale is the size of elements that must be carefully considered. Leveraging the scale of different elements, you can greatly improve a design.

Let's look at this example, we can work on the scale on this UI.

First of all, cards are too small for this given layout. Also, there isn't much difference between headline and subheadline beneath it. Also, we can increase the size of the Hex color code.

In our second UI, our cards look much more filled out and better with the space around them, we also increased the size of the heading and subheading and it looks much better than the previous.

5. Typography

Typography isn't just the font but it is the art that involves arranging a typeface in various combinations of font, size, and spacing.

Typography requires the understanding of other fundamentals, along with a few other considerations like how to effectively choose fonts, their size, spacing and a few more.

If we look at our first UI, we can see there's a lot going wrong in terms of typography. First, there are 3 fonts used which are unnecessary. second, we are not really sure where to look at or which text is really important so we need to fix the scale as well.

In our second UI, we are sticking to just 1 font family, increased the font size of headings and decreased the size of cite that is 'John Doe' which is not really important and now it looks so much better.

6. Color

Color is the first UI design fundamental that shapes the user's experience.
If you go to any website or app before you're able to process and even read anything your eyes are exposed to the colors, so color in terms of UI design is extremely important.

Different colors can have different meanings like green for instance can be associated with growth and wealth, red with loss or warmth, black for elegance and luxury and so on and so forth.

Before building UI be aware of your target audience for this particular app and what you need to project eliciting emotions

Another thing you should focus is on avoiding a bunch of colors in your UI design. Too many color destroy the quality of UI. Also, avoid colors that don't work well with each other and don't complement each other well.

7. Visual Hierarchy

Every element on a user interface has a level of importance. Some elements are more important than others. Visual hierarchy is how you establish this importance. The way we do it is by utilizing the above UI fundamentals that we have discussed.

If we look at this UI, this lacks visual hierarchy as we are not really sure where to look at first and our call-to-action button lacks enough contract as well.

Fixing this by scaling our heading and making call-to-action stand out, we have improved the visual hierarchy
Looks better than before? Right?

conclusion

There isn't one UI fundamental that is more important than the other.
They are all equally important in order to get the design right. If the design is lacking in one of these areas, it's really easy to notice that something is not quite right with the quality of the design.
So be sure to think about all these fundamentals the next time you need to build a user interface.

Good luck

Twitter

GitHub

10 VS Code extensions every Frontend Developer should use

vansh bhardwaj — Mon, 02 Aug 2021 15:21:40 +0000

Hello everyone, my name is Vansh and I'm a frontend developer. In this blog post, I would like to share 10 VS code extensions that every frontend developer should use. The purpose of using these extensions is to write faster, cleaner, and more consistent code. Let's Jump in!

1. Live server

It's irritating to save changes in the editor and then refresh the browser to see changes, right? thanks to live server , it enforces auto-reload and ensures that your changes are rendered immediately you save your work. It creates a local development server right in Visual Studio Code to serve your static and dynamic sites.

2. Mithril Emmet

Emmet is a web-developer’s toolkit that can greatly improve your HTML & CSS workflow . Emmet allow us to generate HTML code much quicker and easier than writing them out ourselves. This can greatly increase your speed in development.

3. ESLint

It Integrates ESLint into VS Code. If you are new to ESLint check the documentation.
It allows you to stick to standard practices like indentation and positioning.

4. Prettier

When writing code, a lot of time goes into formatting. Thanks to Prettier, it automates the task for you, removes original styling and puts on the consistent code style which makes code much more readable. It automatically tidy up the code every time the changes are saved.

5. Bracket pair colorizer

It colourizes and gives same colors to your opening and closing brackets.
It sometimes happens that at the end of your file or function, you have more than one or two closing brackets, and it’s not so easy to find the correct one of them. Use Bracket pair colorizer to know where your bracket opens and closes.

6. CSS Peek

CSS Peek helps to quickly find and check styles applied for selected class or id. It’s beneficial for developers who don’t like to switch between different files or split the screen or like to jump between HTML and CSS Back-and-forth.

7. JavaScript ES6 Code snippets

It provides Code Snippets for your JavaScript code and uses ES6 syntax.
Snippets are handy and can help to prevent lots of spelling bugs and can make coding much faster. To speed up your Javascript coding, use Javascript code snippets. It also supports TypeScript and JSX files.

8. Simple React snippets

As mentioned above, Snippets are handy and make coding faster. This extension is a collection of day-to-day React snippets and commands.

9. ENV

It is a simple extension, it adds formatting and syntax highlighting support for env files.

10. Debugger for Chrome

The Debugger for Chrome extension adds the Google Chrome browser debugger into your editor. It allows you to launch an instance of Chrome navigated to your app, or it can attach to a running instance of Chrome.
It supports setting breakpoints, stepping, debugging scripts, and more. If you are tired of switching from files in the code editor to debugging console in the browser, it’s a great plugin for you.