Before getting started with this guide, make sure you've read through my previous tutorial on AWS EC2. It covers the essentials of creating and configuring an EC2 instance. You'll learn how to navigate the AWS Management Console, select the right instance type, configure security groups, and more.

This foundational knowledge will make sure you're fully prepared to launch your website effortlessly with the help of user data scripts.

So, grab a coffee, and let’s dive into this fun and simple guide. By the end, you’ll be able to launch your own website without breaking a sweat.

Table of Contents

• What We'll Cover

• Step 1: Launch Your EC2 Instance

• Step 2: Wait… The Script Did Everything Already?

• Step 3: Access Your Website

• Wrapping Up

• Want more?

What We’ll Cover:

Today, we’re going to:

• Launch an EC2 instance (Don’t worry, it’s easier than it sounds).

• Use a user data script to automate setting up a web server.

• Download a CSS template and host it on your instance.

You might be wondering: why a user data script? Imagine it as a to-do list for your EC2 instance. When the instance boots up, it runs through this list and sets everything up automatically. It’s like having a personal assistant that handles all the tedious setup tasks. Sounds good, right?

Step 1: Launch Your EC2 Instance

First things first, head over to your AWS Management Console. This is where all the magic happens.

Log in to AWS and head to the AWS Console. If you don’t already have an account, don’t worry, you can just sign up – it's free for basic usage.

Now here are the steps you’ll follow to launch the instance:

• In the console, type EC2 in the search bar and click on the EC2 service.

• Click the big Launch Instance button.

• Give your instance a cool name like "Webserver".

• Choose Your AMI: Select the Amazon Linux 2 AMI (free-tier eligible). It’s lightweight, fast, and perfect for our use case.

• Instance Type: Go for the t2.micro (it’s free for most use cases, and we love free things, right?).

• User Data Script: Now, this is where things get good. Scroll down to Advanced Details, and in the User Data field, paste in the following script. This script will handle everything from installing Apache to downloading and unzipping a fancy CSS template.

• 

    #!/bin/bash
  
    # Update the instance and install necessary packages
    yum update -y
    yum install -y httpd wget unzip
  
    # Start Apache and enable it to start on boot
    systemctl start httpd
    systemctl enable httpd
  
    # Navigate to the web root directory
    cd /var/www/html
  
    # Download a CSS template directly
    wget https://www.free-css.com/assets/files/free-css-templates/download/page284/built-better.zip
  
    # Unzip the template and move the files to the web root
    unzip built-better.zip -d /var/www/html/
    mv /var/www/html/html/* /var/www/html/
  
    # Clean up unnecessary files
    rm -r /var/www/html/html
    rm built-better.zip
  
    # Restart Apache to apply changes
    systemctl restart httpd
  

  • Configure Your Security Group: You want the world to be able to see your site, right? So, make sure to allow HTTP (port 80). This will let your website be accessible to anyone with the link.

• Launch Your Instance: After double-checking everything, click Launch. AWS will ask you to choose a key pair (which you’ll need if you want to SSH into your instance later). If you don’t have one, create a new key pair.

Boom! Your EC2 instance is launching. Grab a snack, it’ll be ready in a few minutes.

Step 2: Wait…The Script Did Everything Already?

Yes, that’s right! Thanks to the user data script, all the heavy lifting is done for you.

Here’s what just happened behind the scenes:

• Apache Web Server was installed and started.

• A CSS template called “Built Better” was downloaded directly into the server.

• The template was unzipped and placed in the web directory.

All of this happened while you were sipping your coffee.

Step 3: Access Your Website

The exciting part is finally here! Let’s see your website in action.

• Find Your Instance’s Public IP:

  • Head to your EC2 Dashboard, and you’ll see your running instance.

    Copy the Public IPv4 Address.

• Open Your Browser:

  • In the address bar, type: http://your-public-ip (replace your-public-ip with the one you just copied).

  • Hit enter, and… Voilà! Your website is live, looking all professional with the “Built Better” CSS template.

Wrapping Up

Let’s take a moment to appreciate what you’ve accomplished:

• Launched an EC2 instance ✔️

• Automated the setup using a user data script ✔️

• Hosted a slick website using a CSS template ✔️

You’ve just dipped your toes into the world of AWS and cloud hosting. It’s not as intimidating as it sounds, right? If you enjoyed this, keep exploring AWS – the possibilities are endless. Until next time, happy coding and hosting!

Want more?

Follow me on Twitter or connect on LinkedIn for more awesome cloud tips and tricks. I’m always sharing helpful content and would love to hear about your cloud journey!

You can follow me on

• Twitter

• LinkedIn

Containers and Docker are technologies that have revolutionized how software is built, tested, and deployed.

Whether you're new to the world of tech or just looking to understand the basics of Docker, this article will guide you through the essentials.

Table of Content

• What Are Containers?

• What is Docker?

• Why Docker?

• Docker Architecture

• Docker’s Container Runtime: containerd

• How to Create a Simple Container Using Docker

• Wrapping Up

What Are Containers?

Before diving into Docker, let’s first understand containers. Imagine that you’re working on a project, and your application works perfectly on your laptop. But when you try to run the same application on a different machine, it fails. This is often due to differences in environments: different operating systems, installed software versions, or configurations.

Containers solve this problem by packaging an application and all its dependencies like libraries, frameworks, and configuration files into a single, standardized unit. This ensures that the application runs the same no matter where it's deployed, whether on your laptop, a server, or in the cloud.

Key features of containers:

• Lightweight: Containers share the host system's kernel, unlike virtual machines (VMs) that require separate OS instances, making them faster and more efficient.

• Portable: Once built, a container can run consistently across various environments.

• Isolated: Containers run in isolated processes, meaning that they don’t interfere with other applications running on the same system.

What is Docker?

Now that we understand containers, let’s talk about Docker, the platform that has made containers mainstream.

Docker is an open-source tool designed to simplify the process of creating, managing, and deploying containers. Launched in 2013, Docker has rapidly become the go-to solution for containerization due to its ease of use, community support, and powerful ecosystem of tools.

Key Concepts in Docker

1. Docker Images: Think of a Docker image as a blueprint for your container. It contains everything needed to run the application, including code, libraries, and system dependencies. Images are built from a set of instructions written in a Dockerfile.

2. Docker Containers: A container is a running instance of a Docker image. When you create and start a container, Docker launches the image into an isolated environment where your application can run.

3. Dockerfile: This is a text file that contains the steps needed to create a Docker image. It’s where you define what your container will look like, including the base image, application code, and any additional dependencies.

4. Docker Hub: Docker Hub is a public registry where developers can share and access pre-built images. If you're working on a common application or technology stack, chances are that there’s already an image available on Docker Hub, saving you time.

5. Docker Compose: For applications that require multiple containers (for example, a web server and a database), Docker Compose allows you to define and manage multi-container environments using a simple YAML file.

Why Docker?

Docker's popularity stems from its ability to solve a variety of challenges developers face today:

• Consistency Across Environments: Developers can "build once, run anywhere," ensuring the same application works the same way in different environments, from local development to production.

• Speed: Docker containers are fast to start and stop, making them ideal for testing and deployment pipelines.

• Efficient Use of Resources: Since containers share the host system's resources more effectively than virtual machines, they reduce overhead and allow for greater density in deployments.

• Version Control for Your Applications: Docker allows you to version control not only your code but also the environment in which your code runs. This is particularly useful for rolling back to previous versions or debugging issues in production.

Docker Architecture

When you first start using Docker, you may treat it as a box that "just works." While that’s fine for getting started, a deeper understanding of Docker’s architecture will help you troubleshoot issues, optimize performance, and make informed decisions about your containerization strategy.

Docker's architecture is designed to ensure efficiency, flexibility, and scalability. It’s composed of several components that work together to create, manage, and run containers. Let’s take a closer look at each of these components.

Docker Architecture: Key Components

Docker’s architecture is built around a client-server model that includes the following components

• Docker Client

• Docker Daemon (dockerd)

• Docker Engine

• Docker Images

• Docker Containers

• Docker Registries

1. Docker Client

The Docker Client is the primary way users interact with Docker. It’s a command-line tool that sends instructions to the Docker Daemon (which we’ll cover next) using REST APIs. Commands like docker build, docker pull, and docker run are executed from the Docker Client.

When you type a command like docker run nginx, the Docker Client translates that into a request that the Docker Daemon can understand and act upon. Essentially, the Docker Client acts as a front-end for interacting with Docker’s more complex backend components.

2. Docker Daemon (dockerd)

The Docker Daemon, also known as dockerd, is the brain of the entire Docker operation. It’s a background process that listens for requests from the Docker Client and manages Docker objects like containers, images, networks, and volumes.

Here’s what the Docker Daemon is responsible for

• Building and running containers: When the client sends a command to run a container, the daemon pulls the image, creates the container, and starts it.

• Managing Docker resources: The daemon handles tasks like network configurations and volume management.

• The Docker Daemon runs on the host machine and communicates with the Docker Client using a REST API, Unix sockets, or a network interface. It’s also responsible for interacting with container runtimes, which handle the actual execution of containers.

3. Docker Engine

The Docker Engine is the core part of Docker. It’s what makes the entire platform work, combining the client, daemon, and container runtime. Docker Engine can run on various operating systems, including Linux, Windows, and macOS.

There are two versions of the Docker Engine

• Docker CE (Community Edition): This is the free, open-source version of Docker that’s widely used for personal and smaller-scale projects.

• Docker EE (Enterprise Edition): The paid, enterprise-level version of Docker comes with additional features like enhanced security, support, and certification.

The Docker Engine simplifies the complexities of container orchestration by integrating the various components required to build, run, and manage containers.

4. Docker Images

A Docker Image is a read-only template that contains everything your application needs to run—code, libraries, dependencies, and configurations. Images are the building blocks of containers. When you run a container, you are essentially creating a writable layer on top of a Docker image.

Docker Images are typically built from Dockerfiles, which are text files that contain instructions on how to build the image. For example, a basic Dockerfile might start with a base image like nginx or ubuntu and include commands to copy files, install dependencies, or set environment variables.

Here’s a simple example of a Dockerfile

dockerfileCopy codeFROM nginx:latest
COPY ./html /usr/share/nginx/html
EXPOSE 80

In this example, we’re using the official Nginx image as the base and copying our local HTML files into the container’s web directory.

Once the image is built, it can be stored in a Docker Registry and shared with others.

5. Docker Containers

A Docker Container is a running instance of a Docker Image. It’s lightweight and isolated from other containers, yet it shares the kernel of the host operating system. Each container has its own file system, memory, CPU allocation, and network settings, which makes it portable and reproducible.

Containers can be created, started, stopped, and destroyed, and they can even be persisted between reboots. Because containers are based on images, they ensure that applications will behave the same way no matter where they’re run.

A few key characteristics of Docker containers:

• Isolation: Containers are isolated from each other and the host, but they still share the same OS kernel.

• Portability: Containers can run anywhere, whether on your local machine, a virtual machine, or a cloud provider.

6. Docker Registries

A Docker Registry is a centralized place where Docker Images are stored and distributed. The most popular registry is Docker Hub, which hosts millions of publicly available images. Organizations can also set up private registries to store and distribute their own images securely.

Docker Registries provide several key features:

• Image Versioning: Images are versioned using tags, making it easy to manage different versions of an application.

• Access Control: Registries can be public or private, with role-based access control to manage who can pull or push images.

• Distribution: Images can be pulled from a registry and deployed anywhere, making it easy to share and reuse containerized applications.

Docker’s Container Runtime: containerd

One important recent development in Docker’s architecture is the use of containerd. Docker used to have its own container runtime, but now it uses containerd, a container runtime that follows industry standards and is also used by other platforms like Kubernetes.

1. containerd is responsible for

   • Starting and stopping containers

   • Managing storage and networking for containers

   • Pulling container images from registries

By separating the container runtime from Docker’s higher-level functionality, Docker has become more modular, allowing other tools to use containerd while Docker focuses on user-facing features.

How to Create a Simple Container Using Docker

Pull the Linux Image

Start by pulling the alpine image from Docker Hub. The alpine image is a minimal Linux distribution, designed to be lightweight and fast.

Run the following command:

docker pull alpine

This will download the alpine image to your local system.

Run the Container

Create and start a container using the alpine image. We’ll also launch a terminal session inside the container.

docker run -it alpine /bin/sh

Here’s what each option means:

• docker run: Creates and starts a new container.

• -it: Allows you to interact with the container (interactive mode + terminal).

• alpine: Specifies the image to use.

• /bin/sh: Specifies the command to run inside the container (a shell session in this case).

Explore the Container

Once the container is running, you’ll see a shell prompt that looks something like this

/ #

This indicates you are inside the Alpine Linux container. You can now run Linux commands. For example:

Check the current directory:

pwd

List files in the directory:

ls

Output: A minimal directory structure, as Alpine is a lightweight image.

You can also install a package (Alpine uses apk as its package manager):

apk add curl

Exit the Container

When you're done exploring, type exit to close the session and stop the container

bashCopy codeexit

Access the Container After It’s Stopped

If you want to access the container again after stopping it, you can use this command to list all containers (including stopped ones):

docker ps -a

You’ll see a list of containers with their IDs and statuses, then you can start the stopped container:

docker start <container-id>

You can attach to the container's shell using this command:

docker exec -it <container-id> /bin/sh

If you no longer need the container, you can remove it

1. Stop the container (if it’s still running):

    docker stop <container-id>
   

2. Remove the container:

    docker rm <container-id>
   

Key Docker Commands Recap

Wrapping Up

Now that you've got a foundational understanding, it's time to put your knowledge to use. Start experimenting with Docker, build your first container, and explore its vast ecosystem.

You'll soon see why Docker has become a cornerstone of modern DevOps and software engineering.

You can follow me on

• Twitter

• LinkedIn

In this guide, I’ll show you how to host a website using a pre-designed template from CSS templates directly on your EC2 instance.

Before we dive into this guide, make sure you’ve gone through my previous blog on how to launch and connect to an EC2 instance. If you haven’t set up an EC2 instance yet, head over to that post first to get your instance up and running. Once that’s done, you’re all set to proceed!

Step 1: Download the "Built Better" Template

For this tutorial, we’ll use the Built Better template, which is free and easy to set up.

Head over to this link and download the template.

Right-click on the download button and select "Copy clean link". We’ll use this link to download the template directly into your EC2 instance.

Step 2: Download the Template Directly to Your EC2 Instance

Now that you have the link to the template, let’s download it straight to your EC2 instance using wget.

Log in to your EC2 instance via SSH or MobaXterm (as covered in my previous blog) and navigate to the /var/www/html directory where your website files will be stored:

cd /var/www/html

Use the wget command followed by the copied link to download the "Built Better" template directly into your EC2 instance:

sudo wget https://www.free-css.com/assets/files/free-css-templates/download/page284/built-better.zip

Note: After downloading, it's a good idea to check the file name to ensure it matches the file used in the subsequent commands. You can do this by running the ls command:

ls

Step 3: Unzip the Template Files

Now that the template has been downloaded, it’s time to extract it. Install the unzip utility if it’s not already installed:

sudo dnf install unzip -y

Then unzip the template:

sudo unzip built-better.zip -d /var/www/html/

After unzipping, make sure to check the folder name where the files were extracted from. You can do this by listing the contents of the /var/www/html directory:

ls /var/www/html/

In this case, the unzipped contents are located inside a folder named html. This folder contains all the template files. If the folder name is different in your case, adjust the following steps accordingly.

First, move the files from the html folder to the root /var/www/html/ directory:

sudo mv /var/www/html/html/* /var/www/html/

Then remove the unnecessary folder:

sudo rm -r /var/www/html/html

Lastly, remove the ZIP file:

sudo rm built-better.zip

Step 4: Set Up the Web Server to Host Your Template

If you haven’t already, make sure your Apache HTTPD web server is installed and running. You can follow these steps to ensure your server is ready:

Install Apache (if not installed):

sudo yum install httpd -y

Start the Apache service:

sudo systemctl start httpd

Enable Apache to start on boot:

sudo systemctl enable httpd

Now your web server should be up and running, ready to serve your template.

Step 5: Test Your Website

Now for the exciting part seeing your site live! Open a browser and navigate to your EC2 instance’s public IP address. You should now see the Built Better template live and ready to go.

Here’s how to check:

• Find your EC2 instance’s public IP from the AWS EC2 dashboard.

• Enter the IP in your browser, like so: http://your-ec2-public-ip

• Your website should now be live with the Built Better template! 🎉

Wrapping Up

Congratulations! You’ve successfully hosted a professional-looking website using the Built Better CSS template on your EC2 instance.

With just a few steps, you’ve moved from launching an EC2 instance to hosting a fully styled website, all using the AWS powerful cloud infrastructure.

You can follow me on

• Twitter

• LinkedIn

Don’t worry – it’s simpler than it sounds, and I promise to walk you through it step-by-step with a bit of fun along the way.

By the end of this guide, you’ll feel like a cloud wizard, casting spells that make servers appear out of thin air (well, out of Amazon’s data centers, but you get the point).

Ready? Let’s dive in!

Table Of Content

• What Is EC2?

• What is HTTPD?

• Step 1: How to Launch Your EC2 Instance

• Step 2: How to Connect to Your EC2 Instance

• Step 3: How to Install and Start HTTPD (Apache Web Server)

• Step 4: How to Host Your Custom Web Page

• Wrapping Up

What Is EC2?

Think of EC2 (Elastic Compute Cloud) as a hotel room in the cloud. Instead of booking a physical server to store your website, you’re renting one from Amazon’s magical cloud infrastructure. This room (or instance) comes with all the amenities you need to host a website. Today, we’ll install HTTPD (a web server software) in our “room” to make our website live. 🏨✨

What is HTTPD?

• At its core, HTTPD stands for Hypertext Transfer Protocol Daemon. Let’s break that down:

• Hypertext Transfer Protocol (HTTP): This is the standard protocol used on the web. When you type a URL into your browser or click a link, you’re using HTTP to tell the server, “Hey, send me this web page!”

• Daemon (D): A daemon is just a fancy term for a background process that runs continuously on a server. In this case, the daemon is responsible for responding to requests from web browsers (like Chrome or Firefox) and sending back the appropriate content.

• So, HTTPD is a program that listens for incoming HTTP requests (like when you visit a webpage) and serves back the data (HTML, CSS, images, and so on) needed to display that page.

HTTPD vs. Apache2: Different Names, Same Game

Depending on your Linux distribution, you may encounter different names for the same basic software:

• On RPM-based distributions (like Red Hat, CentOS, or Fedora), it’s called httpd.

• On Debian-based distributions (like Ubuntu or Debian itself), it’s referred to as apache2.

Let’s look at the steps you can use to launch your EC2 instance, and how to set up a web server using HTTPD.

Step 1: How to Launch Your EC2 Instance

First things first, let’s launch our EC2 instance. You’ll need an AWS account—signing up is free, and AWS offers a free tier, so this won’t cost you a dime for small-scale experiments.

Head over to the AWS Management Console and log in. From the search bar, type “EC2” and click on EC2 Dashboard.

Create a new instance by clicking on the orange Launch Instance button.

Next, choose the Amazon Machine Image (AMI) by selecting the Amazon Linux AMI, which is free-tier eligible and super reliable. Don’t forget to give your instance a unique name!

Adding a "Name" tag with a value like "MyFirstInstance" or "ProductionServer" helps you keep track of multiple instances while adding a personal touch to your cloud workspace.

Also, remember to check the default username for the AMI you select. Since you’ve chosen Amazon Linux, the default username is ec2-user. Keep this in mind for connecting to your instance later!

Select an Instance Type: The t2.micro is your best buddy here again, free-tier eligible and perfect for our needs.

Key Pair for SSH Access: Here’s where it gets important to have a .pem file to securely connect to your instance. This file, also known as a key pair, acts like the secret key to your cloud “hotel room,” allowing you to log in via SSH.

If you already have a .pem file for a previously created key pair, go ahead and choose that from the dropdown menu.

If you don’t have a .pem file, no worries! Create a new key pair by clicking Create New Key Pair, and download the .pem file to your computer. Make sure to store this file safely—you’ll need it to log in, and if you lose it, you won’t be able to access your EC2 instance!

Why is this file important? The .pem file is your private key, and AWS uses it to verify that you are the rightful owner trying to connect to the instance. You won’t get access without it, just like how you can’t get into a hotel room without the key.

Configure Security Group: AWS EC2 security groups are like virtual firewalls that control traffic in and out of your instance, ensuring only specific types of access. To allow web visitors, set up an HTTP rule on port 80, and for secure server logins, enable SSH on port 22 with restricted IPs.

You can reuse security groups across instances, making configuration easier and more consistent. Regularly review these settings to keep your instance secure and organized.

Launch the instance: Boom! You’ve just launched your very own server in the cloud.

Wait a minute or two for your instance to come online. Now that we have our EC2 instance running, let’s move to the next step of `setting up our web server.

Step 2: How to Connect to Your EC2 Instance

To connect, we’ll use the .pem file (key pair) we created earlier. If you’re on a Mac or Linux machine, this is super simple with SSH. For Windows folks, I recommend using MobaXterm—it’s a user-friendly terminal with SSH built-in.

If you’re new to connecting EC2 instances using MobaXterm, I’ve written a detailed guide in my previous blog post. You can check it out here, where I show how to set up and connect to an EC2 instance using MobaXterm.

For now, here’s a quick overview of the connection process using SSH:

ssh -i "your-key.pem" ec2-user@your-ec2-public-ip

Replace "your-key.pem" with the name of your key pair and "your-ec2-public-ip" with the public IP of your instance (you can find this in the EC2 dashboard).

If you’ve connected successfully, congratulations! 🎉 You’re inside your cloud server.

Step 3: How to Install and Start HTTPD (Apache Web Server)

Alright, time to install our web server software (HTTPD)! We’ll be using Apache, one of the most popular web servers around. Don’t worry, you don’t need a degree in IT to get this working.

After you successfully connect to your EC2 instance from MobaXterm, you should be all set to start the installation. You’re just a few commands away from having your web server up and running!

It’s always good practice to make sure your server is up to date. To update your server, run:

sudo dnf update -y

Next, we’ll install HTTPD (Apache):

sudo dnf install httpd -y

Then start the HTTPD service. Run this command to get the server running.

sudo systemctl start httpd

Next, enable it to start on boot so that every time your EC2 instance reboots, your web server comes back to life automatically.

sudo systemctl enable httpd

Time to test it out! Open your browser and type in your instance’s public IP. If you see the Apache test page, give yourself a high-five. 🖐️ You’ve just launched a web server!

Step 4: How to Host Your Custom Web Page

Now, let’s get creative! Instead of the default web server message, let’s host your very own custom web page in just one step. This will allow you to display a unique message on your site in no time.

Run the following command in your EC2 instance to create and display a simple, personalized web page:

echo "Welcome to the Cloud! You’re now hosting your own custom web server 
using AWS EC2 and Apache!" > /var/www/html/index.html

What does this command do?

• The echo command outputs the text: "Welcome to the Cloud! You’re now hosting your own custom web server using AWS EC2 and Apache!".

• The > symbol redirects this output to a file.

• /var/www/html/index.html is the path to the file where the message is saved. This file is the homepage of your web server.

By running this command, you're replacing the default Apache test page with your custom message.

Now, select your EC2 instance, and you’ll find its public IP address. Open your browser, enter that IP, refresh the page, and boom! Your custom message is live on the site. 🎉

Feel free to modify the text to make it uniquely yours!

Wrapping Up

And there you have it – you’ve just launched an EC2 instance and set up a simple web server using HTTPD! With these steps, you’ve not only spun up a server in the cloud but also configured it to be accessible to the world. By following along, you’ve learned the essentials of creating instances, setting up security groups, connecting via SSH, and installing Apache to serve up web content.

Keep exploring EC2’s features, and don’t hesitate to test new configurations and ideas. Each step adds to your cloud skills, bringing you one step closer to mastering AWS. So keep building, experimenting, and, most importantly, enjoying the journey. Happy cloud computing!

You can follow me on

• Twitter

• LinkedIn

Table of Contents

• Why MobaXterm?

• Step 1: Install MobaXterm

• Step 2: Get Your EC2 Instance Public IP and Key Pair

• Step 3: Open MobaXterm and Start a New SSH Session

• Step 4: Enter SSH Session Details

• Step 5: Attach Your .pem Key Pair

• Step 6: Connect to Your EC2 Instance

• Step 7: Troubleshooting Common Issues

• Wrapping Up

Why MobaXterm?

You may be wondering why we’re using MobaXterm over other SSH tools. Well, for starters, it’s super beginner-friendly, and it combines a bunch of powerful tools in one. You can use it to transfer files, run scripts, or even open multiple sessions simultaneously.

Plus, it’s like the Swiss Army knife for remote connections. Whether you’re working with AWS, Google Cloud, or even a Raspberry Pi at home, MobaXterm can do it all.

Step 1: Install MobaXterm

If you’re not already familiar with MobaXterm, it’s basically used for all things remote access. You can download it here for free. Installation is super easy – just download, click, and install.

Once you have it set up, fire up MobaXterm and get ready for the fun part.

Step 2: Get Your EC2 Instance Public IP and Key Pair

Before we continue, there are two key pieces of information you’ll need:

Public IP Address: This is the unique address AWS assigns to your EC2 instance. To find it, go to the EC2 Dashboard in AWS, select your running instance, and grab the Public IPv4 Address (it looks like 13.123.45.67).

Your .pem File: This is the private key file you downloaded when you created your EC2 instance. If you didn’t save it, you may have to create a new key pair because AWS only lets you download it once. (No pressure – just don’t lose it this time!)

Step 3: Open MobaXterm and Start a New SSH Session

Time to work some magic with MobaXterm! Open the app, and you’ll see an intuitive interface. Don’t let all the buttons scare you, just focus on the top left where it says Session.

Here’s what to do next:

• Click Session (you’ll feel powerful just pressing that button).

• In the new window, select SSH as the session type.

Step 4: Enter SSH Session Details

It’s time to fill in the details that’ll connect MobaXterm to your EC2 instance. Here’s what you need to know:

• Remote Host: Enter the Public IP Address of your EC2 instance here. Remember, you grabbed that from the EC2 Dashboard earlier.

• Username: If you’re using Amazon Linux, your default username is ec2-user. If you’re on Ubuntu, it’s ubuntu.

Step 5: Attach Your .pem Key Pair

MobaXterm makes it super easy to use your .pem key file for authentication (no converting to .ppk necessary, like you’d have to with other tools).

Here’s how to attach your .pem file:

• Head over to the Advanced SSH Settings tab.

• Check the Use private key option.

• Click Browse and find your .pem file on your computer.

• Select the file and hit OK.

It’s like giving MobaXterm the secret key to unlock your EC2 instance.

Step 6: Connect to Your EC2 Instance

Now that you’ve filled in all the details, click OK to start your session. If everything’s been set up correctly, you should see a terminal pop up, and MobaXterm will work its magic to connect you to your EC2 instance.

🎉 And just like that, you’re in! You should see a terminal window connected to your instance, and now you can start typing commands like a pro.

Step 7: Troubleshooting Common Issues

We all know that tech doesn’t always behave. Here are some common problems you might run into—and how to solve them:

• Connection Timed Out: This could be due to your instance’s security group settings. Make sure your EC2 security group allows inbound traffic on port 22 (the SSH port) from your IP address.

• Authentication Failed: Ensure you’re using the correct username (ec2-user for Amazon Linux, ubuntu for Ubuntu).

Wrapping Up

And there you have it! Connecting to your EC2 instance using MobaXterm with your .pem keypair is as simple as following these steps. It’s not rocket science—but it kind of feels like it, doesn’t it? Now that you’ve got your EC2 instance up and running, the sky’s the limit.

So, go on, take what you've learned here, explore, experiment, and, most importantly, have fun with it! Until next time, happy cloud computing! ☁️

You can follow me on

• Twitter

• LinkedIn

Spoiler alert: the cloud is much more than that, and it’s a crucial part of what powers our digital world today. So grab a coffee (or tea), get comfy, and let’s dive into the cloudy realm of cloud computing together.

Table of Contents

• Table of Contents

• So, What Exactly is the Cloud?

  • A Fun Metaphor

• Types of Clouds

• Cloud Service Models (IAAS, PAAS, SAAS)

• What is AWS?

  • Why Do People Love AWS?

  • AWS Cloud Architecture

  • Key Components of AWS Cloud Architecture

  • Shared Responsibility Model

• AWS Regions, Availability Zones, Edge Locations & Local Zones

  • Latency

  • Ways to Access AWS Services

• AWS Calculator

• Wrap Up

So, What Exactly is the Cloud?

Simply put, the cloud is a network of remote servers around the world that store data, run applications, and power services, so you don’t have to. Think of it as renting a storage unit, except it’s online, more flexible, and can do a lot more than just store things.

Cloud computing is all about accessing these resources over the internet (instead of a physical computer or server that you have to maintain yourself).

For instance, when you upload a photo to Instagram or stream a show on Netflix, you’re accessing files that are stored in the cloud. Instagram and Netflix don’t store all of that data on your phone or laptop – they rely on massive, secure cloud servers to hold it all. Convenient, right?

A Fun Metaphor

Imagine that you’re opening a bakery. You’d need a physical location, ovens, ingredients and employees. That’s a huge investment! Now, let’s say there’s a bakery service that provides all of these essentials without you having to own any of them. You just “pay as you bake.” That’s the cloud in a nutshell.

Instead of investing in and maintaining a fleet of servers (which, by the way, take up tons of space, energy, and attention), you rent what you need, use it, and leave the maintenance to the cloud provider. This approach means you can “scale” (make or serve more) without additional investments, making your life much easier and your work far more flexible.

Types of Clouds

Let’s take it a step further with three types of cloud setups. Knowing these will help you understand the different flavors of cloud services:

1. Public Cloud: Imagine renting shared spaces in a massive online “building,” like AWS (Amazon Web Services), Microsoft Azure, or Google Cloud. Here, anyone can rent space or resources, and it’s great for flexibility and cost efficiency.

2. Private Cloud: Picture your own bakery setup where only your team has access. Companies set up private clouds for maximum control and privacy. Think of banks or government agencies, they often use private clouds for security reasons.

3. Hybrid Cloud: This one’s a mix! It’s like having a private room in a larger shared building, where you can access resources both privately and publicly, depending on your needs. This flexibility is a favorite for businesses looking for the best of both worlds.

Cloud Service Models (IAAS, PAAS, SAAS)

• Cloud service models are the ways in which cloud services are delivered to users, each model offering varying levels of control, flexibility, and management. The three primary cloud service models are IaaS (Infrastructure as a Service), PaaS (Platform as a Service), and SaaS (Software as a Service). Each serves different needs depending on the level of infrastructure, platform, or application services that an organization requires.

On-Premises

• Imagine that you’re throwing a pizza party, and you want complete control. You buy the ingredients, make the dough, set up the toppings, and bake the pizza in your oven at home. This is on-premises (or “on-prem” for short). You’re responsible for everything, ingredients, cooking, cleaning, and managing the equipment. It’s the same in the tech world. With on-premises computing, companies manage and maintain their own servers, networks, and storage systems, usually in their own data centers.

• This traditional approach gives companies total control but also comes with the responsibility of managing everything: hardware maintenance, software updates, data backups, and security. For some companies, this is worth it for the peace of mind of keeping everything in-house. But for others, all this control can be exhausting and expensive.

Infrastructure as a Service (IaaS)

• If on-premises is a pizza from scratch, IaaS (Infrastructure as a Service) is like renting a pizza kitchen that’s already equipped with ovens, counters, and tools. All you have to do is bring your ingredients and start cooking. In cloud terms, this means a provider like AWS rents out virtual machines, storage, and networks so you can install them on your operating systems, databases, and applications.

• How It Works: In an IaaS model, AWS or another provider offers the computing power, storage, and networking resources you need, but you’re still in control of what software and applications run on them. This gives you flexibility without the hassle of managing physical hardware.

• Why Choose IaaS?

  • Scalability: You can increase or decrease resources based on your needs, like adding more “ovens” when demand is high.

  • Cost Savings: You avoid the expense of purchasing and maintaining hardware.

  • Flexibility: You get the foundation, but you still control what you build on top, giving you lots of freedom to customize.

Platform as a Service (PaaS)

• Let’s say you want to get closer to pizza bliss without worrying about managing the kitchen. With PaaS (Platform as a Service), you’re given a ready-made cooking station—fully stocked with dough, sauce, and toppings. You only have to choose your toppings and make the pizza your way.

• In tech terms, a PaaS provider manages the underlying infrastructure, including the operating system, servers, storage, and networks. All you need to do is focus on your application code and let the provider handle the rest. AWS Elastic Beanstalk, for example, allows you to deploy and manage applications without getting bogged down in server configurations.

• Why Choose PaaS?

  • Speed: You skip the setup and go straight to the cooking part, perfect for developers focusing on building and deploying applications.

  • Managed Environment: The provider handles the OS, updates, security patches, and scaling, so you don’t have to worry.

  • Focus on Code: It’s ideal if you want to focus on creating your app, not managing infrastructure.

Software as a Service (SaaS)

• Now, if you’re in the mood for ultimate convenience, why not just order pizza delivery? With SaaS (Software as a Service), you don’t have to worry about the kitchen, the ingredients, or even baking. Instead, your pizza arrives hot and ready to eat.

• In cloud terms, SaaS is a fully managed software application hosted by the provider and accessible via the internet. Examples include applications like Gmail, Dropbox, or Microsoft 365. You simply log in and start using the service—no installation, updates, or maintenance needed.

• Why Choose SaaS?

  • Convenience: Like pizza delivery, it’s ready for immediate consumption, saving you setup and maintenance time.

  • Accessibility: Since it’s internet-based, you can access it from anywhere.

  • Automatic Updates: The provider handles updates, so you always have the latest features.

What is AWS?

• Amazon Web Services, or AWS, is a cloud platform by Amazon that provides a wide range of computing resources, from storage to databases, virtual machines, and AI services. Imagine being able to rent a massive virtual data center without actually needing to buy, set up, or maintain any physical hardware. Sounds great, right? That’s the beauty of AWS. You can launch resources in minutes and pay only for what you use, making it incredibly cost-effective.

Why Do People Love AWS?

• AWS offers a variety of services, making it an all-you-can-eat buffet of tech tools. If you’re building a new app, running a website, or storing data, AWS can handle it all. Plus, it’s reliable, secure, and scalable, which means that you can start small and grow big without having to make drastic changes.

AWS Cloud Architecture

• Think of AWS Cloud Architecture as the framework or “blueprint” that defines how an application is built and how it interacts with different services on the AWS platform. Just like a city’s infrastructure needs roads, buildings, utilities, and a way to manage traffic, an AWS cloud architecture consists of various components that keep everything running smoothly. These components include networking, compute power, storage, databases, and security services.

• At its core, AWS Cloud Architecture is designed to help businesses create reliable, scalable, and secure applications without having to build everything from scratch. AWS offers a wide array of tools and services that fit together like puzzle pieces, making it easy to create a customized, efficient cloud environment.

Key Components of AWS Cloud Architecture

• To really understand AWS Cloud Architecture, let’s look at some of its essential components. Each piece has a specific role, and together, they make up a solid, high-functioning cloud environment.

1. Compute

Every cloud-based application needs processing power to run its code, handle user requests, and process data. This is where compute services come in.

• Amazon EC2 (Elastic Compute Cloud): Think of EC2 as the powerhouse behind your app. EC2 instances are virtual servers that can be customized to fit your app’s needs—just like choosing between a laptop, a desktop, or a supercomputer based on your work requirements.

• AWS Lambda: AWS Lambda is the star of serverless computing, letting you run code without managing any servers. It’s perfect for small tasks that don’t require constant resources. For example, if you want to automatically resize photos every time they’re uploaded, Lambda can handle that with ease!

2. Storage

All apps need a place to store their data—think files, user profiles, or transaction records. AWS provides several storage options to meet a wide range of needs.

• Amazon S3 (Simple Storage Service): S3 is like an expandable cloud-based filing cabinet where you can store and retrieve virtually unlimited amounts of data. It’s highly secure and accessible, making it a popular choice for data storage.

• Amazon EBS (Elastic Block Store): EBS works like a hard drive attached to an EC2 instance, making it ideal for applications that need high-performance storage.

3. Databases

For many applications, data needs to be stored in a structured way, so AWS provides several database options to suit different data types.

• Amazon RDS (Relational Database Service): RDS handles structured data like customer records or order information. You can set up databases like MySQL or PostgreSQL, and AWS takes care of maintenance and backups.

• Amazon DynamoDB: For high-traffic applications that need quick access to data, DynamoDB offers fast, flexible NoSQL storage that scales automatically.

4. Networking

To keep everything connected and ensure data flows securely, AWS offers networking services that act as the “highways” of your cloud architecture.

• Amazon VPC (Virtual Private Cloud): VPC creates a secure virtual network where you can control who accesses your resources. It’s like having your own private space in AWS’s giant data center.

• AWS CloudFront: CloudFront is a Content Delivery Network (CDN) that speeds up content delivery by caching it closer to users. So, if your app has users all around the world, CloudFront ensures they get the best experience possible by reducing loading times.

5. Security and Identity

AWS takes security seriously, and with tools like AWS Identity and Access Management (IAM) and AWS Shield, you can manage access to resources and protect your architecture from security threats.

• IAM (Identity and Access Management): IAM allows you to create and manage permissions for each user and service, so you can control who can do what. This ensures your data stays safe and only the right people have access.

• AWS Shield: For those worried about DDoS attacks, Shield provides protection by automatically filtering harmful traffic.

Putting It All Together: How AWS Cloud Architecture Works

So, how do all these pieces work together? Imagine building an online store on AWS:

1. Compute (EC2/Lambda): Your store’s backend runs on EC2 instances, handling requests and processing orders. A Lambda function might handle smaller tasks, like sending confirmation emails.

2. Storage (S3): Product photos and user-uploaded files are stored in S3, keeping them secure and accessible.

3. Database (RDS): Customer details, order information, and product listings are stored in an RDS database, so you can easily track orders and manage inventory.

4. Networking (VPC & CloudFront): VPC keeps your network secure, and CloudFront speeds up the delivery of your site to customers around the globe.

5. Security (IAM & Shield): IAM controls user access, ensuring only authorized staff can access sensitive data. Shield guards against DDoS attacks, keeping your site up and running even in high-traffic situations.

Shared Responsibility Model

• Imagine renting a house, and AWS owns the house and makes sure that the structure is safe and secure. The roof is solid, the doors lock, and the plumbing works. But when it comes to what happens inside—the furniture, who has keys, and how you keep it clean—that’s your job as the tenant.

• In cloud terms, AWS takes care of the infrastructure, making sure the servers are protected and that their data centers are secure. But the data you put on AWS, the applications you run, and the security settings you choose are your responsibility. It’s a team effort where AWS keeps the cloud safe, and you keep what’s in it secure.

Breaking Down the Shared Responsibility Model

The Shared Responsibility Model is divided into two main parts: Security of the Cloud (that’s AWS’s job) and Security in the Cloud (that’s on you).

1. Security of the Cloud

AWS is like the security guard for the entire cloud environment. Here’s what AWS is responsible for:

• Data Center Security: AWS is in charge of the physical security of its data centers. They have strict access controls, security cameras, and even biometric scanning to make sure only authorized personnel can enter. No need to worry about anyone physically accessing your data!

• Hardware and Software Maintenance: AWS takes care of maintaining, patching, and updating the underlying hardware and software. This includes managing the physical servers, storage devices, and networking equipment that power AWS services.

• Network Security: AWS ensures that the networking infrastructure is protected from threats. They deploy firewalls, DDoS protection, and other measures to keep malicious actors out.

Think of AWS’s responsibility as creating and maintaining a highly secure cloud platform. This means that you can count on AWS to keep the data centers running smoothly, provide reliable servers, and handle infrastructure-level threats.

2. Security in the Cloud

Now, here’s where you come in. While AWS provides a secure infrastructure, you’re in charge of what you do with it. Your responsibilities include:

• Data Protection: You decide how your data is encrypted and who can access it. For example, AWS provides options to encrypt your data at rest and in transit, but it’s up to you to turn on encryption and manage your encryption keys.

• Identity and Access Management (IAM): AWS’s IAM service lets you control who has access to your AWS resources. It’s like having keys to different rooms in a house—some people may only need access to the kitchen, while others need access to every room. By setting roles and permissions, you decide who can do what.

• Configuring Security Groups: Security Groups are like firewalls for your AWS resources, controlling what can enter and leave. You decide what traffic is allowed and where it’s allowed to go. Think of it as creating security rules for your cloud environment.

• Application Security: If you’re running a web application on AWS, you’re responsible for securing the code and protecting against vulnerabilities, like SQL injection or cross-site scripting. AWS can’t know what’s in your code, so they leave application security in your capable hands.

• Regular Audits and Compliance: AWS offers tools to help with auditing, but you’re the one who needs to monitor and ensure compliance with industry standards. Regular audits can help you check that everything is running smoothly and according to your security needs.

AWS Regions, Availability Zones, Edge Locations & Local Zones

If you’ve dipped your toes into AWS, you’ve probably come across words like “Regions,” “Availability Zones,” “Edge Locations,” and “Local Zones.” And let’s be honest, they can sound a bit intimidating at first. But understanding these terms is key to building a successful application on AWS. It’s like getting a map before you venture into a theme park—knowing the layout makes the whole experience smoother and more enjoyable.

So, let’s take a fun tour of the AWS “cloud park” and see how these areas fit together!

1. AWS Regions

Imagine AWS as a theme park with entrances all over the world. Regions are like the different main entrances to this massive park. Each Region is a fully equipped area of AWS infrastructure located in a specific part of the world. There are over 34 Regions globally, each providing a complete set of services and facilities.

Choosing a Region is like choosing which entrance to start your journey. If most of your customers are in Europe, you might pick a Region closer to them, like Frankfurt or London. This helps reduce latency, meaning that users experience faster load times and smoother interactions.

2. Availability Zones (AZs)

Once you’re inside a Region (entrance), you’ll find Availability Zones, or AZs, which are like the different sections of the theme park. Each AZ is a separate, independent data center close to others within the same Region but with its own unique power, cooling, and network sources. This setup provides redundancy, a critical factor for high availability and reliability.

Here’s why this is important: Imagine running an application that needs to be online 24/7. If you host it in just one AZ, and that AZ has a power issue, your app might go down. But by setting up your app across multiple AZs (say, on both “Adventure Land” and “Fantasy Land” floors), if one zone experiences a problem, the others will keep your application up and running, creating a seamless experience for users.

3. Edge Locations

Next, let’s move on to Edge Locations, which are like the pop-up stands you see throughout the park, serving everything from maps to quick snacks. Edge Locations are strategically placed “mini AWS stations” that deliver cached data close to your users, no matter where they are.

AWS’s Content Delivery Network, Amazon CloudFront, operates through these Edge Locations. So, if you have a video or website image that people in Japan and South Africa need to access, CloudFront delivers it from the closest Edge Location instead of the central server. This shortens load times and provides a faster, more responsive experience. Edge Locations are perfect for apps with heavy media needs, as they ensure content loads quickly and efficiently.

4. Local Zones

Finally, we have Local Zones. These are like the VIP zones within the park, giving visitors near-instant access to certain attractions. Local Zones are smaller clusters of AWS infrastructure, set up closer to specific cities to provide ultra-low latency for applications that need rapid response times.

Let’s say you’re running a gaming app, and you want players in Los Angeles to experience minimal lag. Using a Local Zone in Los Angeles gives those users immediate access to your application, keeping the experience fast and smooth. Local Zones are ideal for services that require high-speed processing in metropolitan areas like online gaming, media production, and virtual reality.

Putting It All Together: Planning Your AWS Adventure

To design your application architecture, think about where your users are and what kind of experience you want them to have. Here’s a quick guide to help you plan:

• Regions: Pick a Region close to your primary user base to minimize latency. This helps provide a faster, more responsive experience for users.

• Availability Zones (AZs): Use multiple AZs within a Region to build a resilient, high-availability application. This way, if one zone goes down, others will keep your app running.

• Edge Locations: For content-heavy applications, like streaming services or e-commerce sites, use CloudFront’s Edge Locations to cache and deliver content quickly, no matter where users are.

• Local Zones: For applications needing ultra-low latency in specific cities, Local Zones bring AWS infrastructure closer to users, creating a near-instant experience for high-demand applications.

You can find latest numbers about regions, AZs, edge locations and local zones here

Latency

• In simplest terms, latency is the delay between a user’s action and a web application’s response to that action. Imagine it like a digital echo—say something, and there’s a tiny pause before you hear it back. Latency is measured in milliseconds (ms), and the lower the latency, the faster your connection feels.

• Example: Let’s say you’re browsing a website from your home in New York, but the server hosting the website is located in Sydney. Your request has to travel all the way to Sydney, and the server’s response has to travel all the way back to you. Even though data travels fast (really fast!), the distance still creates a delay. And that delay? That’s latency.

Why Does Latency Matter?

• A little bit of latency might not seem like a big deal, but when it adds up, it can make for a frustrating user experience. Have you ever tried to play a multiplayer video game only to get that dreaded “lag” just as you’re about to win? Or maybe you’ve waited an extra couple of seconds for a video to load? High latency is often the culprit here.

• Low Latency = Fast, Responsive Experience

• High Latency = Delays and Frustration

• When latency is high, every interaction with an app feels delayed, which can drive users away. This is why companies like AWS invest in minimizing latency by building infrastructure close to users worldwide.

AWS and Latency: How Does AWS Minimize Latency?

• AWS takes latency seriously, and its infrastructure is designed to keep latency as low as possible for users worldwide. Here’s how AWS tackles latency head-on:

• Regions and Availability Zones (AZs): AWS has data centers called Regions and AZs spread across the globe. By choosing a Region close to your primary user base, you can reduce latency by minimizing the distance data has to travel.

• Edge Locations and Amazon CloudFront: AWS has Edge Locations worldwide that work with Amazon CloudFront, its Content Delivery Network (CDN). Think of Edge Locations as data hotspots in popular areas—by caching content in these locations, AWS makes sure users get the fastest load times possible, no matter where they’re located.

• Local Zones: For applications that need ultra-low latency in specific cities, AWS Local Zones bring infrastructure closer to metropolitan areas, providing lightning-fast access for applications that can’t afford any lag.

A Latency Analogy: Ordering Pizza

• Let’s break it down with a pizza analogy. Imagine ordering a pizza from a restaurant:

• Low Latency: The pizza place is just a few blocks away, so you get your pizza piping hot in no time.

• High Latency: Now imagine the pizza place is on the other side of town. Your pizza arrives late and lukewarm because of the long journey. That’s high latency!

In AWS terms, having a Region or Edge Location close to users is like ordering pizza from a nearby shop instead of one across town. The shorter the distance, the less time you spend waiting for your “pizza” (or, in this case, your data) to arrive.

Ways to Access AWS Services

When you’re diving into AWS, you’ll quickly realize that there’s a lot going on behind the scenes. But getting into AWS and accessing its suite of cloud services isn’t complicated—it’s actually quite user-friendly. AWS provides several ways for you to interact with its services, whether you prefer clicking buttons, typing commands, or even writing code. It’s like a big virtual house with multiple front doors—choose the one that suits you best!

1. AWS Management Console: The Point-and-Click Option

If you’re a visual person, the AWS Management Console is going to feel like home. The console is a web-based interface that lets you manage your AWS resources through a series of friendly, clickable dashboards. Imagine it as the AWS “control room,” where you can launch and manage services with just a few clicks.

The AWS Console is ideal for beginners and those who want a clear, intuitive way to explore services. It’s also perfect for anyone setting up infrastructure without needing deep technical knowledge—no command-line skills required!

What you can do with the AWS Console:

• Launch and manage EC2 instances (virtual servers)

• Set up S3 storage buckets

• Configure IAM (Identity and Access Management) roles for security

• Access billing and cost management tools to keep an eye on your budget

Best for: Visual learners, beginners, and anyone who prefers a simple, no-code approach to managing AWS.

2. AWS Command Line Interface (CLI): For the Command Lovers

If you’re comfortable with typing commands, the AWS CLI is your best friend. The AWS CLI is a command-line tool that lets you manage AWS services through typed commands in your terminal or command prompt. It’s a powerful option for those who prefer speed and efficiency or want to automate tasks without relying on a graphical interface.

With the CLI, you can script entire workflows, automate processes, and manage resources from any device with a terminal. Plus, it’s often faster to type a single command than to click through multiple pages in the console!

Example command:

aws ec2 describe-instances

This command lists all your running EC2 instances. With a few lines of code, you can check your resources, scale services up or down, and even handle complex configurations without ever opening a browser.

Best for: Power users, developers, sysadmins, and anyone who loves efficiency and automation.

3. AWS SDKs: For the Coders and Developers

If you’re a developer who wants to integrate AWS services directly into your code, AWS SDKs (Software Development Kits) are here to help. AWS provides SDKs for multiple programming languages, like Python, JavaScript, Java, and Ruby, allowing you to interact with AWS from within your applications.

The SDKs are like AWS “plug-ins” that you add to your code, allowing you to access services, automate processes, and build applications that directly communicate with AWS resources. For example, with the AWS SDK for Python (Boto3), you can write code to upload files to S3, run queries on DynamoDB, or trigger Lambda functions.

Example with Boto3 in Python:

import boto3

s3 = boto3.client('s3')
s3.upload_file('file.txt', 'mybucket', 'file.txt')

In just a few lines, this code uploads a file to an S3 bucket. Pretty cool, right?

Best for: Developers who want to integrate AWS functionality directly into their applications.

4. AWS CloudFormation: The Blueprint Builder

If you’re interested in automating infrastructure setup and configuration, AWS CloudFormation is your go-to tool. CloudFormation allows you to create a “blueprint” (a JSON or YAML file) that defines the AWS resources and configurations you want. AWS then uses this blueprint to set everything up for you, saving you the time and effort of doing it manually.

With CloudFormation, you can create and manage “stacks” of resources—think EC2 instances, S3 buckets, databases, and more—by writing a single template. This setup is ideal for deploying applications in a consistent and repeatable way.

Example CloudFormation snippet:

Resources:
  MyBucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: 'my-example-bucket'

This simple code creates an S3 bucket named “my-example-bucket.” Once you’ve set up a template, you can deploy it again and again, making it easy to replicate infrastructure across different environments.

Best for: DevOps engineers, architects, and teams who need an automated, repeatable infrastructure setup.

5. AWS APIs: Direct Access for Ultimate Flexibility

If you’re looking for full control and direct access to AWS services, AWS APIs are the way to go. AWS provides APIs for almost every service, which means that you can interact with AWS directly by making HTTP requests, without needing to rely on the AWS Console, CLI, or SDKs.

APIs allow developers to call AWS services programmatically—sending requests, retrieving responses, and performing operations from within any environment that can make HTTP requests. They’re perfect for building customized solutions, automating workflows, and integrating AWS services into existing systems or third-party applications.

Example AWS API Call: Using an HTTP request, you can retrieve information about an S3 bucket or initiate a Lambda function. Here’s a quick example of what an API request might look like to list objects in an S3 bucket:

GET /mybucket?list-type=2 HTTP/1.1
Host: s3.amazonaws.com
Authorization: AWS4-HMAC-SHA256 ...

With the right permissions and authentication, this API call allows you to fetch data about the objects in an S3 bucket directly.

Benefits of Using AWS APIs

• Direct Integration: APIs allow you to access AWS services from any system, language, or platform that supports HTTP requests.

• Lightweight and Flexible: Since APIs don’t require SDKs or extra tools, they’re an efficient, minimalistic option.

• Ideal for Automation: APIs are great for creating custom workflows and automating interactions with AWS services, especially for DevOps teams or developers managing complex systems.

Best for: Advanced developers, system integrators, and teams needing custom or platform-independent ways to interact with AWS.

Comparison Table

Here’s an updated table including AWS APIs for easier reference:

AWS Calculator

The AWS Pricing Calculator isn’t just a budgeting tool, it’s your cloud co-pilot, helping you explore the potential of AWS without the financial surprises. Whether you’re experimenting with a single EC2 instance or planning a multi-service, enterprise-scale setup, this calculator can break down costs, project your savings, and give you peace of mind with a well-rounded view of your expenses.

So, next time you're thinking, "What will this cloud project really cost?", take the AWS Calculator for a spin. You might just discover a way to achieve big things in the cloud without stretching your budget!

Wrap Up

And there you have it, a tour through the world of AWS and what it can mean for you or your projects. Whether you’re just dipping your toes into cloud waters or strategizing a multi-cloud empire, AWS offers tools and flexibility to support your journey.

So, go on, take what you've learned here, explore, experiment, and, most importantly, have fun with it! Until next time, happy cloud computing! ☁️

You can follow me on:

• Twitter

• LinkedIn

In this detailed guide, we'll explore the features of Master Boot Record (MBR) disk partitioning using the parted command on Linux.

Additionally, we'll cover the process of adding a new hard disk in VMware, as well as how to format and mount a newly created partition using mkfs and fstab, respectively.

Table Of Contents

Here's what we'll cover in this comprehensive guide:

• Overview of MBR

• Introduction to Parted Utility

• How to Identify Disks

• How to Launch Parted

• How to Create a New MBR Partition Table

• How to Create Primary Partitions

• How to Display Partition Information

• How to Format the Partition with mkfs

• How to Automate Mounting with fstab

• How to Mount a Partition

• How to Create Logical Partitions

• Wrapping Up

Overview of MBR

MBR is a legacy partitioning scheme used on BIOS-based systems, with a 512-byte sector at the beginning of the storage device which contains partition information and the bootloader.

The 512 bytes of the MBR are organized as follows:

• Master Boot Code (446 bytes): This section contains the executable code responsible for loading the operating system. It locates the active (bootable) partition and passes control to its boot sector.

• Partition Table (64 bytes): The next 64 bytes are reserved for the partition table, which can describe up to four primary partitions or three primary partitions and one extended partition.

• MBR Signature (2 bytes): The last two bytes contain a signature (0x55AA), indicating that this is a valid MBR.

Introduction to the Parted Utility

parted is a command-line utility designed for creating, resizing, and managing disk partitions on Linux systems.

It offers a comprehensive set of features for handling disk-related tasks and is widely used due to its flexibility and robust capabilities. The primary goals of parted include:

• Partition Creation and Resizing: parted enables users to create new partitions on a disk, resize existing partitions, and adjust the allocation of disk space.

• File System Support: It supports various file systems, including ext2, ext3, ext4, FAT, NTFS, and more, allowing users to choose the file system that best suits their needs.

• Partition Table Manipulation: parted facilitates the management of partition tables, including creating, modifying, and deleting partitions within these tables.

• Sector-level Operations: The utility operates at the sector level, allowing for precise control and manipulation of disk structures.

How to Install Parted

You can install parted on your system using this command:

yum install parted

Before creating partition we need to add new disk to our virtual machine. I am using VMware. Go on and start RHEL virtual machine.

First we need to go to Player option on top left corner and then to the Manage option. Using that option, you can select virtual machine settings.

Add new hard disk in VMware

Click on "add to new hard disk". Then select hard disk and keep pressing on next until it asks for disk capacity. For learning purposes, add only 5 GB disk.

Continue clicking next until you get to the finish option.

Adding virtual hard disk - 1

Adding virtual hard disk - 2

Adding virtual hard disk - 3

We are focusing on creating partition, so we'll not focus on parts which are not needed for partition.

Next, restart your virtual machine to reflect the newly added hard disk.

How to Identify Disks

Identifying disks is a crucial step in the process of disk partitioning as it ensures that you are working with the correct storage device on your system.

Use the lsblk command to display information about block devices, including hard drives and partitions.

lsblk

Look for the disk you want to partition. Disk names are typically in the format /dev/sdX, where 'X' is a lowercase letter representing the disk. For example, /dev/sda, /dev/sdb, etc.

How to Launch Parted

Open a terminal and launch parted for the target disk:

parted /dev/sdX

This initiates the parted utility with elevated privileges and directs it to focus on the specified storage device (/dev/sdX).

Once executed, the user enters the parted interactive mode for the specified device, enabling the configuration and management of partitions on that particular storage device.

How to Create a New MBR Partition Table

If the disk is unpartitioned, create a new MBR partition table using this command:

(parted) mklabel msdos

This instructs parted to create a new MBR partition table on the currently selected storage device. This action will remove any existing partition information on the device, effectively starting with a clean slate for partitioning.

It's important to note that this command should be used with caution, as it erases the existing partition table and all associated data on the device.

How to Create Primary Partitions

You can create a primary partition with specified filesystem type, start, and end:

(parted) mkpart primary [filesystem-type] [start] [end]

• mkpart: This is the parted command used to create a new partition. The term "mkpart" stands for "make partition."

• primary: This specifies the type of partition to be created. In this case, it's a primary partition. Primary partitions are the basic partitions on a disk, and they can be used to install an operating system or store data.

• [filesystem-type]: Replace this placeholder with the desired filesystem type for the partition. Common filesystem types include ext4, ntfs, fat32, and so on.

• [start] and [end]: These placeholders represent the starting and ending points of the partition, specified in megabytes (MB) or as a percentage of the total disk size. For example, you might define the partition to start at 1 GB and end at 10 GB.

How to Display Partition Information

Use this command to verify the partition layout:

(parted) print free

When you enter (parted) print free in the parted interactive mode, it will provide a summary of the free space available on the selected disk, including details such as the starting and ending points of the unallocated space, its size, and any constraints on creating new partitions within that space.

Here's the output:

(parted) print free
Model: ABC Storage Device
Disk /dev/sdX: 1000GB
Sector size (logical/physical): 512B/4096B
Partition Table: msdos
Disk Flags:

Number  Start   End     Size    Type  File system  Flags
        32.3kB  1049kB  1017kB  Free Space
 1      1049kB  256MB   255MB   primary  ext4         boot
 2      256MB   512MB   256MB   primary  linux-swap
 3      512MB   1000GB  1000GB  primary  ntfs

Press ctrl + d to get out of parted.

How to Format the Partition with mkfs

After partitioning, format the partition with a desired filesystem (for example: ext4)

mkfs.[filesystem-type] /dev/sdX1

This tells the system to create a file system of the specified type on the designated partition. After executing this command, the chosen file system will be created on the partition, and it will be ready to store files and data.

How to Automate Mounting with fstab

You can find the UUID of the partition using this command:

sudo blkid /dev/sdX1

Edit /etc/fstab to include an entry for automatic mounting, and make sure filesystem-type is as same as filesystem type of mkfs.[filesystem-type]

The /etc/fstab file, short for "file systems table," is a crucial configuration file on Unix and Unix-like operating systems, including Linux. It is used to define how storage devices (such as hard drives and partitions) should be mounted into the file system.

The primary purpose of the /etc/fstab file is to specify how various storage devices should be mounted during the system's startup process.

UUID=[your-uuid] /dir-to-mount-path [filesystem-type] defaults 0 0

Here's an example:

UUID=127854Vd344HHttRpq977739 /kedar ext4 defaults 0 0

UUID=127854Vd344HHttRpq977739: This part specifies the Universally Unique Identifier (UUID) of the block device or partition to be mounted. The UUID is a unique identifier assigned to the filesystem, ensuring a consistent reference even if the device names change. In this case, the UUID is "127854Vd344HHttRpq977739."

/kedar: This part indicates the mount point, which is the directory in the file system where the device specified by the UUID will be attached. In this example, the mount point is "/kedar."

ext4: This specifies the type of the file system on the device. In this case, it's "ext4," which is a commonly used file system on Linux.

defaults: The "defaults" option is a shorthand for a set of commonly used mount options. It includes options like read/write access and allows executing binaries from the file system. If more specific options are needed, they can be listed explicitly.

0: This field represents the dump option. It is used by the dump command to determine whether the file system should be backed up. A value of 0 indicates that no automatic backups are required.

0: The last field represents the pass option. It is used by the fsck (file system check) utility to determine the order in which file systems are checked at boot time. A value of 0 indicates that the file system should not be checked.

This /etc/fstab entry directs the system to mount a device, identified by the specified UUID and formatted as ext4, onto the "/kedar" directory during the boot process. The mount is performed with default options, and there is no requirement for automatic backups or file system checks.

Here are some reasons to use UUID instead of partition name

• Device names (e.g., /dev/sda1) can change, especially in systems with multiple storage devices or when hardware configurations are modified. UUIDs remain constant.

• During the boot process, multiple storage devices may be detected simultaneously. UUIDs eliminate the possibility of race conditions, where the operating system may assign different names to the same physical device in different boot instances.

• If device names are used in /etc/fstab and names change due to hardware changes, it may lead to mounting errors or data corruption. UUIDs ensure the correct device is always mounted.

• UUIDs are more human-readable and less prone to typos than device names, making the /etc/fstab file easier to read and maintain.

• UUIDs remain the same when moving a storage device from one system to another, ensuring correct mounting without modifying /etc/fstab for the new system.

Here's an example /etc/fstab entry using UUID:

UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /mnt/data ext4 defaults 0 2

Replace xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx with the actual UUID of the partition.

How to Mount a Partition

Once everything is done, we will mount partition on one of your directory.

mount -av

If this returns a "successfully mounted" message on kedar directory, then your partition has mounted on kedar directory.

Now every time you turn on your system, the specified partition will automatically be mounted on the "/kedar" directory, ensuring seamless access to its contents throughout your computing sessions.

This persistent mount configuration is facilitated by the entry in the /etc/fstab file, providing a consistent and reliable attachment of the partition during the system's startup process.

How to Create Logical Partitions

Logical partitions are a key concept in disk partitioning, especially in systems using the Master Boot Record (MBR) partitioning scheme.

MBR allows for a maximum of four primary partitions, and to overcome this limitation, one of the primary partitions can be designated as an extended partition.

Within the extended partition, multiple logical partitions can then be created.

Identify the Disk

Begin by identifying the disk where you want to create logical partitions. You can use the lsblk or fdisk -l commands to list the available disks and their partitions

lsblk

Launch Parted for the Disk

Use the parted command to launch the interactive interface for the chosen disk (replace 'X' with the appropriate disk identifier):

parted /dev/sdX

Create an Extended Partition

If not already created, you need to establish an extended partition within which the logical partitions will reside.

This step is essential as logical partitions can only exist within an extended partition. Assume the free space is from 50% to 100% of the disk:

(parted) mkpart extended 50% 100%

Create Logical Partitions

Now, within the extended partition, you can create logical partitions. The following example creates a logical partition using ext4 file system from 0% to 25% of the extended partition.

You can also give size using MB format. For that you need to know the free space. You can do that using print free command inside parted.

(parted) mkpart logical ext4 0% 25%

You can repeat this step to create additional logical partitions with different sizes or file systems.

Partitioning Scheme Numbering Convention

In the Master Boot Record (MBR) partitioning scheme, the numbering convention for logical partitions within an extended partition typically starts from 5. This is because the four primary partitions (if they exist) are assigned numbers 1 to 4, and logical partitions are numbered starting from 5.

Here's a common numbering scheme:

• Primary Partition 1: /dev/sdX1

• Primary Partition 2: /dev/sdX2

• Primary Partition 3: /dev/sdX3

• Primary Partition 4: /dev/sdX4

• Extended Partition: /dev/sdX4 (the extended partition is counted as one of the four)

• Logical Partition 5: /dev/sdX5

• Logical Partition 6: /dev/sdX6

• Logical Partition 7: /dev/sdX7, and so on.

Wrapping Up

Thank you for exploring how MBR disk partitioning works with me today. You can dive deeper into the realm of Linux expertise and stay tuned for more insightful content in my future tutorials.

You can follow me on:

• Twitter

• LinkedIn

It is vital to familiarize yourself with the boot process for various reasons. First of all, having a solid understanding of booting process is crucial for effectively addressing boot issues, enhancing system performance, and efficiently controlling various components of system startup.

For example, it'll help you identify and resolve problems that may arise during the boot process, such as hardware malfunctions or incorrect configurations.

Also, gaining a thorough understanding of the boot process can help you personalize your startup configurations. This includes the ability to select the specific programs or services that are launched upon startup, ultimately affecting both the overall system performance and user satisfaction.

Table Of Contents

Here's what we'll cover in this comprehensive guide:

• High level overview of the booting process

• Understanding the boot process in depth

• POST (Power-On Self-Test)

• Understanding BIOS/UEFI

• MBR (Master Boot Record)

• GPT (GUID Partition Table)

• GRUB (Grand Unified Boot Loader)

• Initrd (Initial RAM Disk) Image

• Kernel

• RootFS

• Init Process

• System Daemons

• Wrapping Up

High Level Overview of the Booting Process

Initializing Hardware

During the boot process, the computer's firmware (such as BIOS or UEFI) takes charge and sets up all the necessary hardware components, including the processor, memory, storage devices, and peripherals. This crucial initialization stage guarantees that these components are fully prepared for the operating system's use.

Loading the Operating System

Once the hardware has been initialized, the boot process commences with loading the operating system. This step usually consists of loading the kernel and initializing crucial OS services into memory.

Launching System Services

As the operating system starts up, it activates a range of system services and drivers. These essential components ensure the smooth operation of the computer, enabling tasks such as managing network connections, processing input/output operations, and maintaining security measures.

User Interaction

At long last, the boot process reaches its peak by greeting you (the user) with a login screen or desktop environment, granting full access to the computer and its various applications.

Understanding the Boot Process in Depth

Booting Process

POST (Power-On Self-Test)

When a computer is first turned on, there is a vital process that takes place known as the Power-On Self-Test, or POST for short. This diagnostic testing sequence is conducted by the system's firmware, whether it be BIOS or UEFI, as a crucial step in the booting sequence.

Its main purpose is to verify that all essential hardware components are functioning properly before handing control over to the operating system. In short, POST is a crucial step in ensuring that a computer is ready to operate at its full potential upon startup.

Stages and Functions of POST

Initialization

When the computer is turned on, the system's firmware (BIOS or UEFI) takes control.

The firmware begins by initializing critical hardware components like the CPU, RAM, chipset, and other essential devices.

Power-On Self-Test (POST)

The POST sequence begins immediately after initialization. It checks various hardware components by sending test signals and commands to them.

It checks the CPU, RAM (memory), storage devices (hard drives, SSDs), graphics cards, peripherals (keyboard, mouse), and other connected hardware.

Each component is tested to ensure it responds correctly and operates within acceptable parameters.

1. The CPU is checked by verifying its operating frequency and executing a simple test.

2. The RAM is tested by writing and reading data to verify its integrity.

3. Storage devices are checked for presence and basic functionality.

4. Peripherals might be tested by checking if they respond to commands.

Any failure during the POST process results in error messages or audible beeps that indicate which component failed the test.

Error Handling

If an error is detected during POST, the system typically halts and displays an error message, or it might emit a series of audible beeps (known as beep codes) indicating the nature of the issue.

Error codes or messages generated during POST are crucial for diagnosing hardware problems. They help in identifying the failing component or area causing the issue.

Completion and Handover

Once the POST sequence completes without detecting any critical errors, the firmware determines that the hardware is functioning correctly.

The firmware proceeds to initialize other system components and search for a boot device to load the operating system.

Understanding BIOS/UEFI

BIOS and UEFI are two essential firmware interfaces responsible for initializing hardware components, running system diagnostics, and supporting the startup of the operating system on a computer. These interfaces are vital players in the boot process of a system.

BIOS

For decades, BIOS has been a dominant firmware interface, stored on the motherboard's chip. Its crucial role is to activate and oversee hardware during the boot-up phase.

As soon as the computer is switched on, the BIOS assumes command and executes the Power-On Self-Test (POST) to ensure the essential hardware components – including the RAM, CPU, and storage devices – are all functioning properly.

After the POST is successfully completed, the BIOS will then proceed to search for the boot device, using a predetermined boot order that was previously set in the BIOS settings. This boot order typically includes popular devices such as hard drives, solid-state drives, optical drives (CD/DVD), USB drives, and network interfaces.

Once the boot device has been identified, the BIOS proceeds to search for either the Master Boot Record (MBR) or the GUID Partition Table (GPT) on the storage device. These contain the crucial initial boot loader code. The BIOS then dutifully passes the reins to the designated boot loader, such as GRUB for Linux operating systems.

UEFI (Unified Extensible Firmware Interface)

UEFI is a more modern and versatile replacement for BIOS. It provides more advanced features and capabilities than BIOS.

UEFI is firmware that resides on the motherboard and is responsible for initializing hardware and booting the operating system.

Similar to BIOS, UEFI starts with the hardware initialization and system checks. But UEFI supports more modern hardware standards and allows for faster boot times compared to traditional BIOS.

UEFI includes a boot manager, which is more sophisticated than the boot loaders used in BIOS systems. It understands different file systems, allowing the system to boot from drives formatted with newer file systems like GPT. It uses EFI boot partitions to store bootloaders and related information.

UEFI introduced Secure Boot, a security feature that verifies the digital signatures of boot loaders and operating system kernels during the boot process. This helps prevent the loading of unauthorized or malicious code during boot time.

Differences between BIOS and UEFI

• BIOS uses the Master Boot Record (MBR) method, while UEFI uses the GUID Partition Table (GPT) method.

• UEFI is more flexible and supports larger storage capacities, modern hardware, and faster boot times compared to BIOS.

• UEFI introduces Secure Boot, enhancing system security by verifying the authenticity of bootloader and OS components.

MBR (Master Boot Record)

The Master Boot Record (MBR) plays a vital role in the storage structure of a disk. It is closely linked to BIOS-based systems and serves as the catalyst for the initial booting process.

Structure of MBR

The MBR is located in the first sector of a storage device (usually the first 512 bytes of a hard drive or SSD). It's in a fixed location, the LBA (Logical Block Address) 0.

The Master Boot Record (MBR) if of 512 bytes in size. It consists of three components:

MBR Structure: Boot signature, partitions, and bootstrap code

1. The primary boot loader information occupies the initial 446 bytes.

2. Following that, the partition table information fills the subsequent 64 bytes.

3. Lastly, the MBR validation check, also known as the magic number, resides in the final 2 bytes.

A partition table is a small database that holds information about the disk's partitions. This table can store information for up to four primary partitions or three primary partitions and one extended partition.

Each entry in the partition table consists of

1. Starting and ending addresses of each partition.

2. Partition type (such as FAT, NTFS, Linux filesystem, and so on).

3. Bootable flag indicating which partition is the active/bootable partition.

Function of MBR

The MBR boot code's primary function is to locate and load the active/bootable partition's boot loader. It reads the partition table to identify which partition holds the bootable flag and executes the boot loader code from that partition.

The boot loader (for example, GRUB) subsequently takes over and presents a boot menu if configured, allowing the user to choose an operating system to load. It then loads the selected OS's kernel and initiates its booting process.

Limitations of MBR

MBR has limitations in supporting only four primary partitions or three primary partitions and one extended partition, which can further contain multiple logical partitions. This restricts the number of partitions usable on a disk.

MBR uses 32-bit addressing, limiting disk sizes to 2 terabytes (TB). Larger disks cannot be fully utilized under MBR due to this limitation.

It also lacks built-in security features, making it susceptible to boot sector viruses or malicious code overwriting the boot loader.

GPT (GUID Partition Table)

The GUID Partition Table (GPT) is a partitioning scheme used on modern storage devices and is closely associated with UEFI-based systems. It replaced the older Master Boot Record (MBR) partitioning scheme due to its numerous advantages and capabilities, especially in conjunction with UEFI firmware.

Structure of GPT

GPT is a partitioning scheme that defines the layout of partitions on a storage device. Unlike MBR, which has limitations regarding disk size and partition count, GPT offers more flexibility and scalability.

Each partition in a GPT disk is identified by a unique GUID (Globally Unique Identifier). This allows for up to 128 partitions per disk (though practical limitations might apply based on the operating system and system firmware).

GPT disks contain a Protective MBR to maintain compatibility with legacy systems that may not recognize GPT partitions. This Protective MBR tells older systems that the disk is in use and prevents them from overwriting or modifying the GPT partitions.

GPT stores partition entries in a table located at the beginning and end of the disk. This redundancy enhances data integrity and provides backup information about the partition layout.

GUID partition table scheme diagram

Function of GPT

UEFI requires a specific partition known as the UEFI System Partition (ESP), which is a primary component of the GPT scheme. The ESP contains bootloaders, firmware executables, and other necessary files for the boot process.

UEFI firmware uses information stored in the GPT to locate the UEFI boot loader. The boot loader is stored in the ESP and is specified in the firmware's boot configuration data.

UEFI firmware understands GPT and can read the partition information directly from the GPT header. It uses this information to identify the bootable partition and load the UEFI boot loader from the ESP.

GPT and UEFI work together to support Secure Boot functionality. Secure Boot uses information from GPT to verify the digital signatures of bootloaders and OS components, ensuring a secure boot process.

GPT supports disk sizes larger than 2TB, addressing the limitations of the MBR partitioning scheme. It efficiently manages partitions on larger disks and provides scalability for future storage needs.

GRUB (Grand Unified Boot Loader)

GRUB stands for Grand Unified Boot Loader. It's a widely used boot loader in the Linux world, responsible for managing the boot process of a computer.

A boot loader is a program that loads the operating system into the computer's memory during the startup process. GRUB is specifically designed for Unix-like operating systems, especially Linux.

GRUB's primary function includes locating the kernel of the chosen operating system and loading it into memory. It also manages the initial RAM disk (initrd/initramfs) that assists the kernel during the boot process.

GRUB uses a configuration file (grub.cfg or menu.lst) where users can define boot options, specify kernel parameters, and customize the appearance of the boot menu. This allows users to modify boot settings or add specific parameters for the operating system to use during startup.

During the installation of Linux distributions, GRUB is usually installed in the Master Boot Record (MBR) of the hard drive or the EFI system partition (for systems using UEFI). This allows GRUB to take control during boot-up and present its menu interface.

Initrd (Initial RAM Disk) Image

An Initial RAM Disk (initrd), also known as an Initial RAM filesystem (initramfs), is a temporary file system loaded into memory during the boot process of a computer before the main operating system takes over. It's an essential component in modern Linux booting.

The primary purpose of the initrd is to provide a minimal set of tools, drivers, and utilities necessary to mount the root file system. It contains essential drivers for storage controllers, file systems, and other hardware components that the kernel might need to access the actual root file system.

During boot-up, the boot loader (such as GRUB) loads the Linux kernel into memory. The kernel then decompresses itself and, if configured to use an initrd, loads the initrd image as a temporary root file system into a predetermined memory location.

Once the initrd is in place, the kernel executes the code within the initrd. This code performs various tasks like loading essential drivers (for example, for disk controllers, file systems, and so on), initializing hardware, and performing necessary checks to prepare the system to transition to the actual root file system.

After the kernel initializes and detects hardware, the initrd's job is largely complete. It hands control over to the main kernel, which then unmounts the initrd and mounts the actual root file system (specified by the bootloader or kernel parameters).

Traditionally, initrd was used, but modern systems often use initramfs (a more flexible successor). Initramfs is a cpio archive that is uncompressed into a RAM disk at boot time. It's more versatile, allowing for a more modular approach to including essential files and drivers.

Kernel

The kernel is the core of the operating system, managing hardware resources, providing abstractions, and controlling interactions between hardware and software.

After the initrd image completes its tasks, the kernel takes control. It initializes the system hardware, mounts the root file system, and begins the user-space initialization process.

The kernel uses information provided by the initrd to mount the actual root file system (for example, ext4, XFS) specified in the boot parameters.

RootFS

The Root File System (rootfs) is a critical component in the booting process of an operating system. It is the top-level directory hierarchy of the file system and contains essential system files and directories.

In the context of the booting process, the root file system is the initial file system that the operating system kernel mounts during the boot sequence.

The root file system is the starting point for the entire file system hierarchy. It is mounted by the kernel during the boot process, and all other file systems are mounted as subdirectories of the root file system.

The bootloader, such as GRUB in many Linux systems, is configured to specify the location of the root file system. This information is crucial for the kernel to know where to find the core files and directories needed to start the operating system.

The root file system can be of different types, such as ext4, XFS, or other supported file systems. The choice of the file system type depends on the system administrator's preferences and requirements.

In some cases, especially in complex storage scenarios (for example, RAID or LVM configurations), an initial RAM disk (initramfs) is used. The initramfs provides necessary modules and tools for the kernel to initialize and mount the root file system. Afterward, the kernel switches to the actual root file system.

The root file system contains critical directories such as /bin, /etc, /sbin, and /lib. These directories house essential binaries, configuration files, system libraries, and scripts required for system operation.

The root file system is typically a persistent file system stored on a storage device like a hard drive or an SSD. It retains data and configurations across reboots, ensuring a consistent environment for the operating system.

The stability and functionality of the operating system depend on the successful initialization and mounting of the root file system. It provides the foundation for the entire operating system environment.

Init Process

The init process, short for initialization, is a fundamental part of the booting process in Unix-like operating systems, including many Linux distributions. Its primary responsibility is to initialize the system and bring it to a functional state by starting various system services and user-space processes.

After the kernel has loaded and initialized, it hands over control to the init process. The kernel command-line parameters or configuration files specify the process to which control should be transferred.

Traditional Unix systems used the init process with different runlevels, where each runlevel represented a different system state. But modern Linux systems, including those based on Red Hat Enterprise Linux (RHEL), have transitioned to using systemd, which serves as a replacement for init and introduces a more flexible and efficient approach to managing system initialization.

On modern Linux systems like RHEL, systemd has become the default init system. It initializes the system in parallel, improving boot times and system responsiveness. systemd reads its configuration from unit files located in directories such as /etc/systemd/system and /usr/lib/systemd/system.

The init process, whether traditional init or systemd, is responsible for starting system services and daemons. These services provide essential functionality to the operating system, such as networking, logging, and hardware-related services.

System Daemons

System daemons, also known as background processes or services, play a vital role in the booting process and ongoing operation of Unix-like operating systems, including those based on Red Hat Enterprise Linux (RHEL). These daemons are specialized programs that run in the background, providing essential services to the system and users.

A daemon is a background process that runs independently of user interaction. Daemons perform specific tasks, such as managing hardware, handling system events, or providing network services.

During the boot process, the init or systemd process is responsible for starting system daemons. These daemons are configured to launch automatically at specific runlevels (in the case of traditional init) or as defined in systemd unit files.

Daemons are typically initialized by the init or systemd process as part of the system startup. The initialization process may involve reading configuration files, setting up communication channels, and allocating resources.

Examples of system daemons include:

• Network services: Daemons like sshd for secure shell access, httpd for web services, and dhcpd for dynamic host configuration protocol.

• Logging services: rsyslogd or syslog-ng for handling system logs.

• Time synchronization: ntpd for Network Time Protocol (NTP) synchronization.

• Printing services: cupsd for Common Unix Printing System.

• Hardware management: udev for device management and acpid for Advanced Configuration and Power Interface events.

The init or systemd process manages dependencies between daemons. It ensures that daemons relying on specific resources or services are started in the correct order to satisfy these dependencies.

systemd, in particular, introduces parallel initialization, meaning that multiple daemons and services can be started simultaneously, improving boot times by taking advantage of modern multi-core systems.

Once system daemons are initialized, the system is ready to handle user interactions. For example, network services are available, and users can log in or access various system resources.

Wrapping Up

Thank you for exploring booting process in RHEL with me today. You can dive deeper into the realm of Linux expertise and stay tuned for more insightful content in my future tutorials.

You can follow me on:

• Twitter

• LinkedIn

Some common tools for job scheduling in RHEL include:

• cron: A time-based job scheduler in Unix-like operating systems. Users can schedule repetitive tasks by creating entries in the crontab file, specifying when and how frequently these tasks should run.

• at: The at command allows users to schedule one-time jobs to be executed at a specified time in the future.

Table Of Contents

Here's what we'll cover in this comprehensive guide:

• What is a deamon?

• What is systemctl?

• Job Scheduling using at

• Job Scheduling using crontab

• Practical Exercises

• Wrapping Up

What is a Deamon?

In Red Hat Enterprise Linux (RHEL) and other Unix-like operating systems, a "daemon" is a background process that runs continuously, typically providing specific services or functionality to the operating system or applications.

Daemons are frequently responsible for handling various tasks such as hardware management, responding to network requests, executing scheduled tasks, and facilitating communication between different software components.

These tasks do not typically require direct user involvement and are usually carried out without user intervention.

Common examples of daemons include web servers (like Apache or NGINX), database servers (such as MySQL or PostgreSQL), and system services (like cron for scheduling tasks or systemd for managing various system services).

What is systemctl?

Systemctl is an essential in Red Hat Enterprise Linux (RHEL) that empowers users to control and oversee their systemd system and service manager with ease.

This command-line utility offers a seamless way to interface with the systemd init system, which plays a crucial role in booting the operating system, supervising services, and managing a range of system functionalities.

Let's take a closer look at what this tool can do:

Service Management

Starting and Stopping Services

• systemctl start service_name initiates a service. Here's an example:

systemctl start atd

The above command systemctl start atd is used in Linux systems to start the atd (which stands for "AT Daemon") service using the systemctl utility.

• systemctl stop service_name stops a service. Here's an example:

systemctl stop atd

By running systemctl stop atd, you're instructing the system to stop the atd service. As a result, any tasks or jobs scheduled to run using the at command will not be processed until the service is started again.

Enabling and Disabling Services

• systemctl enable service_name sets a service to start automatically at boot. Here's an example:

systemctl enable crond

This code sets the crond service to start automatically every time the system boots up. This ensures that the cron service, responsible for handling scheduled tasks, is active and ready to execute commands at their specified times without requiring manual intervention after each system restart.

• systemctl disable service_name prevents a service from starting automatically at boot. Here's an example:

systemctl disable crond

Executing above command removes the configuration that enables the crond service to start up automatically when the system boots. As a result, after a system reboot, the crond service will not be initiated automatically. Users will need to manually start the service if they want to use cron for scheduling tasks.

Viewing Service Status

Checking Service Status

• systemctl status service_name displays the current status and information about a service. Here's an example:

systemctl status crond

This provides information about whether the crond service is running, stopped, or encountering any issues. It typically includes details such as whether the service is active or inactive, when it was last started or stopped, and any error messages or warnings related to its operation.

Displaying All Services

• systemctl list-units --type=service lists all active services. Here's an example:

systemctl list-units --type=service

This provides a comprehensive list of all services—both active and inactive—managed by systemd on the system. This output includes information such as the unit name, load status, active status (whether it's running or not), and description of each service.

All possible Service Management systemctl commands are listed below. You can explore all of them on your own to get a better understanding of how they work.

systemctl start <service>: Starts a service.

systemctl stop <service>: Stops a service.

systemctl restart <service>: Restarts a service.

systemctl reload <service>: Reloads configuration for a service without stopping it.

systemctl status <service>: Displays the current status and information about a service.

systemctl enable <service>: Enables a service to start automatically at boot.

systemctl disable <service>: Disables a service from starting automatically at boot.

systemctl is-active <service>: Checks if a service is currently running.

systemctl is-enabled <service>: Checks if a service is enabled to start at boot.

systemctl is-failed <service>: Checks if a service has failed.

System Control

Rebooting and Shutting Down

• systemctl reboot restarts the system. Here's an example:

systemctl reboot

This shuts down the operating system, terminating all running processes and services, and then starts the boot process again. It brings the system back to a fresh start.

• systemctl poweroff shuts down the system. Here's an example:

systemctl poweroff

This triggers a series of actions that include shutting down all running services and processes in an orderly manner, saving any necessary data, and finally turning off the system.

Suspending and Hibernating

• systemctl suspend puts the system into a suspend state. Here's an example:

systemctl suspend

This triggers the system to enter a suspended state. In this state, the system effectively halts most operations, including the CPU and other hardware components, to conserve power.

But it keeps the current system state in memory (RAM) so that when it's resumed, the system can quickly return to its previous state without a full boot-up process.

• systemctl hibernate puts the system into hibernation. Here's an example:

systemctl hibernate

It saves everything you're doing on your computer onto the hard drive and then turns off the computer completely. When you start it up again, it brings back exactly what you were working on before, just like you left it. This is different from "suspend," which keeps your work in a low-power mode but still on.

Viewing System Information

Displaying System Logs

• journalctl views system logs and journal entries. Here's an example:

journalctl

This displays logs that include system messages, kernel messages, service logs, and other events recorded by the system.

• journalctl -u <unit> displays logs for a specific unit. Here's an example:

journalctl -u crond

You'll see logs that are related to the crond service specifically. This includes messages, errors, or other information logged by the crond daemon, which is responsible for managing scheduled tasks using the cron job scheduler.

• journalctl --since=<time> shows logs since a specific time. Here's an example:

journalctl --since "2024-01-01 08:00:00"

This retrieves and displays system logs that have been generated or recorded after January 1st, 2023, at 8:00 AM. This helps in narrowing down the logs to view system events or messages that occurred from that specific point in time onwards, and can help you troubleshoot or analyze recent system activity.

These commands of systemctl are enough to start a job scheduling module. You can always explore more systemctl commands on your own.

Job Scheduling using at

The at command is used for scheduling one-time tasks or commands that will be carried out at a designated future time. This feature is especially useful for automating tasks that you need to complete at a later time, so you don't have to remember to do them later.

To use at, you'll need to check the following:

• Ensure that the at daemon (atd) is running for at jobs to execute. You can use the systemctl command to check if atd is running or not. If not, you can use systemctl to start it (and you can see how to do that in the systemctl section in this tutorial).

• Permissions might be restricted for non-admin users to use at, depending on system settings.

• If you are manipulating something in a file, make sure you have Read-Write-Execute permission for that same file.

Syntax of at

at <time>

Examples of using the at command

Let's see how the at command works in practice with a few examples.

First, here's how you can display a message at a specific time:

at 15:35

Now let's say you need to give commands that will run automatically at 15:35:

echo "Meeting in 30 minutes" >> sample.txt

Press Ctrl + D to finish entering commands and schedule the job. This will print "Meeting in 30 minutes" in sample.txt file at 15:35.

Perhaps you have a script named backup.sh and you want it to run at 2 AM. Here's how you'd do that:

at -f backup.sh 02:00

This code schedules the backup.sh script to run at 2:00 AM. The contents of backup.sh will be executed as if they were entered directly into the terminal at that specified time.

You can also use the following command to see a list of pending at jobs:

atq

The atq command helps you view and manage a list of pending at jobs, letting you easily reference scheduled tasks and their execution times.

Here's some example output of the atq command:

10    Wed Jan 12 03:00:00 2023 a user123

• The first column represents the job number.

• The second column shows the scheduled execution time for each job.

• The third column denotes the priority level ('a' in this case).

• 'a' is usually the default priority level assigned to at jobs, and as the letters move down the alphabet ('b', 'c', 'd', and so forth), the priority level decreases.

• The fourth column displays the username of the user who scheduled the job (if available).

Here's how to remove a job:

atrm 10

The above code removes the at job with the ID number '3' from the at queue, preventing it from being executed at its scheduled time. You can find job Id by atq command. Job Id is in the 1st column of output.

at.allow and at.deny

The files at.allow and at.deny are used to control access for users to schedule jobs using at. These files are typically located in /etc/ in RHEL.

The at.allow file specifies the list of users who are allowed to use the at command to schedule jobs. If this file exists, only users listed in it can schedule at jobs. If the file doesn't exist, it behaves as if it's empty, allowing all users unless restricted by at.deny.

The at.deny file specifies the list of users who are denied access to use the at command. If this file exists and a user is listed in it, that user won't be able to schedule at jobs.

If both at.allow and at.deny exist, at.allow takes precedence. If neither exists, only the superuser (root) can schedule at jobs.

Managing Access – summary and recap

• If at.allow exists, only users listed in this file can use at.

• If at.deny exists but at.allow doesn't, users not listed in at.deny can use at.

• If neither at.allow nor at.deny exists, by default, only the superuser (root) can use at.

Examples of at.allow and at.deny

Let's say you want to restrict at usage to specific users:

Create an at.allow file like this:

sudo touch /etc/at.allow 
sudo echo "user1" >> /etc/at.allow 
sudo echo "user2" >> /etc/at.allow

This allows only user1 and user2 to schedule at jobs.

Alternatively, you can use the at.deny file like this:

sudo touch /etc/at.deny 
sudo echo "user3" >> /etc/at.deny

This denies access to user3 from using at.

Job Scheduling using crontab

Cron enables users to schedule recurring actions and commands at specific times, dates, or intervals. This powerful job scheduler stores all the scheduling information in a special file known as the crontab.

Basic crontab Commands

• crontab -e: Opens the user's crontab file in an editor to add or edit cron jobs.

• crontab -l: Lists the user's cron jobs.

• crontab -r: Removes all of the user's cron jobs.

A few things to note about crontab:

• Each user can have their own crontab.

• The cron daemon (crond) must be running for cron jobs to execute.

• Always use absolute paths for scripts and commands within cron jobs.

crontab Format

The crontab file has five fields followed by the command/script to execute. Here's what it looks like:

* * * * * command_to_execute
- - - - -
| | | | |
| | | | +----- Day of the week (0 - 7) (Sunday is 0 or 7)
| | | +------- Month (1 - 12)
| | +--------- Day of the month (1 - 31)
| +----------- Hour (0 - 23)
+------------- Minute (0 - 59)

If you forgot the crontab format, you can always run cat /etc/crontab command and it will display the format for you.

Examples of using crontab

Run a script every hour

crontab -e

The above command will open the editor with Vim or any other you have set. In that editor, you'll write the job based on the crontab format just like below:

0 * * * * /path/to/script.sh

• 0 represents the minute field. In this case, it's set to 0, indicating that the cron job will trigger when the minute is 0, that is at the start of every hour.

• * (asterisks) indicates that every possible value for that field is valid. So, * * * * * means the job will run every minute of every hour, every day, every month, and every day of the week.

• Putting it all together, the cron job 0 * * * * /path/to/script.sh signifies that the script located at /path/to/script.sh will run every hour at the beginning of the hour (when the minute is 0).

Run a command at specific times

First run crontab -e.

0 15 * * * command_to_execute

• 0 represents the minute field. In this case, it's set to 0, indicating that the cron job will trigger at the start of the hour.

• 15 represents the hour field. It's set to 15, which means the job will execute at the 15th hour of the day, that is 3:00 PM.

* * * * *: The asterisks denote every possible value for each time-related field. In this case:

• * for the day of the month and month fields means it applies to every day of every month.

• * for the day of the week field means it applies to every day of the week.

• command_to_execute represents the command or script that will be executed at the specified time. This placeholder should be replaced with the actual command you want to run at 3:00 PM daily.

Run a job every weekday

First do crontab -e.

0 9 * * 1-5 command_to_execute

The above code specifies that the command_to_execute will run at 9:00 AM from Monday to Friday. This cron job is useful for scheduling tasks that should only run on weekdays at a specific time.

Run a job every 15 minutes

First do crontab -e.

*/15 * * * * command_to_execute

This specifies that the command_to_execute will run at 0, 15, 30, and 45 minutes past every hour, every day, every month, and every day of the week. This cron job is useful for scheduling tasks that need to be executed in regular intervals, in this case, every 15 minutes.

cron.allow and cron.deny

You use these cron.allow and cron.deny files to control which users are allowed to use the cron service to schedule periodic jobs. These files are typically located in /etc/ in RHEL.

The cron.allow file specifies the list of users who are allowed to use the cron service to schedule jobs using crontab. If this file exists, only users listed in it can create crontab entries. If the file doesn't exist, it behaves as if it's empty, allowing all users unless restricted by cron.deny.

The cron.deny file specifies the list of users who are denied access to use the cron service. If this file exists and a user is listed in it, that user won't be able to create crontab entries. If both cron.allow and cron.deny exist, cron.allow takes precedence. If neither exists, only the superuser (root) can create crontab entries.

Managing access – summary

• If cron.allow exists, only users listed in this file can create crontab entries.

• If cron.deny exists but cron.allow doesn't, users not listed in cron.deny can create crontab entries.

• If neither cron.allow nor cron.deny exist, by default, only the superuser (root) can create crontab entries.

Example of using cron.allow and cron.deny

Let's say you want to restrict cron usage to specific users.

Create a cron.allow file:

sudo touch /etc/cron.allow 
sudo echo "user1" >> /etc/cron.allow 
sudo echo "user2" >> /etc/cron.allow

This allows only user1 and user2 to create crontab entries.

Alternatively, you can use the cron.deny file:

sudo touch /etc/cron.deny 
sudo echo "user3" >> /etc/cron.deny

This denies access to user3 from creating crontab entries.

Practical Exercises

Service Management with systemctl

• Review the current status of system services using systemctl.

• Start, stop, enable, or disable a service to understand their functionalities.

Scheduling Immediate Tasks with at

• Use at command to schedule an immediate one-time task (e.g., echoing a message, executing a command) to run a few minutes from the current time.

• Check the access permissions for at commands by understanding the functionality of at.allow and at.deny.

Setting Up at.allow and at.deny

• Create an at.allow file to specify users allowed to use at by listing usernames (if it doesn't exist).

• Create an at.deny file to restrict users from using at by listing usernames (if necessary).

• Try to schedule an at task using different user accounts to observe the effect of these files.

Recurring Tasks with cron

• Open the crontab using crontab -e.

• Schedule a task to run at a specific time each day or week using cron.

• Check the access permissions for cron commands by understanding the functionality of cron.allow and cron.deny.

Setting Up cron.allow and cron.deny

• Create a cron.allow file to specify users allowed to use cron by listing usernames (if it doesn't exist).

• Create a cron.deny file to restrict users from using cron by listing usernames (if necessary).

• Attempt to modify or create a cron job using different user accounts to observe the effect of these files.

Observation and Verification

• Monitor the status of scheduled tasks using respective commands (atq, crontab -l).

• Validate access restrictions and permissions for at and cron commands by observing user attempts and access denials.

Cleanup and Exploration

• Remove or modify the access control files (at.allow, at.deny, cron.allow, cron.deny) and observe the changes in command accessibility.

• Explore additional systemctl, at, and cron commands to deepen your understanding of task scheduling and access control.

Wrapping Up

Thank you for exploring the world of Red Hat Enterprise Linux (RHEL) administration with me today. You can dive deeper into the realm of Linux expertise and stay tuned for more insightful content in my future tutorials.

You can follow me on:

• Twitter

• LinkedIn

This guide will delve into several essential commands: chown, chgrp, chmod, and umask. The examples will showcase their functionality, variations, and practical applications.

Table Of Contents

Here's what we'll cover in this comprehensive guide

• ls -l – View File Permissions

• chown – Change File Ownership

• chgrp – Change File Group Ownership

• chmod – Modify File Permissions

• Access Control Lists

• The umask Command

• Practical Exercise

• Wrapping Up

ls -l – View File Permissions

In the world of Red Hat Enterprise Linux, using the ls -l command is like taking a peek into a directory's secret diary. It's a way to get a detailed, up-close look at what's inside, almost like flipping through a catalog with all the nitty-gritty details.

ls -l example

Running this command displays file permissions, ownership, and other details for files in the current directory.

ls -l /mydirectory

Here's the output:

OUTPUT

drwxr-xr-x 2 username group 4096 Jan 5 09:30 mydirectory

Let's break down this output part by part. Here's an illustration that shows what each part represents, and I'll go through it in detail below:

Detail output for ls -l command

• File Type and Permissions: The first column represents the file type and permissions. It consists of ten characters:

• The first character indicates the file type (- for a regular file, d for a directory, l for a symbolic link, and so on.).

• The next nine characters represent permissions for the owner, group, and others (read, write, execute).

• Number of Links: The second column shows the number of hard links to the file or directory.

• Owner and Group: The third and fourth columns display the owner and group associated with the file or directory.

• File Size: The fifth column indicates the size of the file in bytes.

• Last Modified Time: The sixth column shows the timestamp of the last modification.

• File or Directory Name: The final column lists the file or directory name.

chown – Change File Ownership

In Red Hat Enterprise Linux (RHEL), the mighty chown command stands for "change owner" and lets users to modify the ownership of files and directories. This versatile tool is a valuable resource for system administrators in effectively managing permissions and access control.

Syntax of chown:

chown [OPTIONS] [NEW_OWNER][:NEW_GROUP] FILE(s)/DIRECTORY(s)

Options:

• R, --recursive: Recursively change ownership of directories and their contents.

• v, --verbose: Display a message for each file processed.

Note: Only the root user or a user with appropriate permissions can use chown to change ownership.

chown examples:

Changing file ownership:

chown newowner myfile.txt

This will change the owner of a file to newowner.

Changing group ownership:

chown :newgroup myfile.txt

This command makes a file called myfile.txt join a new group named newgroup, and it doesn't mess with the person who owns the file. You can do this group change using a command called chown. Oh, and there's another special command just for switching groups that we'll talk about soon.

Changing both owner and group:

chown newowner:newgroup myfile.txt

This changes the owner to newowner and group to newgroup for the file myfile.txt.

Recursive change (applying changes to subdirectories):

chown -R newowner:newgroup /path/to/directory

The above command is instructing the system to change the ownership of all files and directories within the specified directory and its subdirectories to the specified new owner and group. This ensures that the operation is performed recursively across the entire directory structure.

Verbose mode:

chown -v newowner:newgroup myfile.txt

The command is instructing the system to change the ownership of the specified file, providing a detailed output of the modifications made. The detailed output is shown because we are using -v option with chown.

Ownership by UID/GID:

chown 1001:1002 myfile.txt

The command instructs the system to modify the ownership of the specified file, assigning it to a specific user and group identified by their respective numerical IDs (1001, 1002).

chgrp – Change File Group Ownership

The chgrp command in Red Hat Enterprise Linux (RHEL) is used to change the group ownership of files or directories. It's particularly useful when you want to modify only the group ownership without affecting the file's user owner or permissions.

Syntax of chgrp:

chgrp [OPTIONS] NEW_GROUP FILE...

chgrp examples:

Change group ownership of a file:

chgrp newgroup myfile.txt

This changes the group ownership of a file named myfile.txt to a group called newgroup.

Change group ownership of a directory recursively:

chgrp -R newgroup /path/to/directory

This modifies the group ownership not only of the specified directory but of all its contents recursively. This ensures that everything within that directory structure is now associated with the group named newgroup.

Change group ownership and verbosely display changes:

chgrp -v newgroup myfile.txt

This changes the group ownership of myfile.txt to newgroup but also provides a message confirming this action. This makes the process more transparent and informs you of the change as they happen.

chmod – Modify File Permissions

The ability to control file permissions is a crucial aspect of Red Hat Enterprise Linux (RHEL). The chmod command is a powerful tool for this purpose. By utilizing this command, you can specify the accessibility levels for reading, writing, and executing a file.

Syntax of chmod:

chmod [OPTIONS] MODE FILE...

Permissions:

• Read (r): Allows reading or viewing the contents of a file.

• Write (w): Permits modifying or deleting the file.

• Execute (x): Grants execution permission to a file (for scripts or binaries).

Numeric representation:

• 0: No permission.

• 1: Execute.

• 2: Write.

• 3: Write and execute. (2+1)

• 4: Read.

• 5: Read and execute. (4+1)

• 6: Read and write. (4+2)

• 7: Read, write, and execute. (4+2+1)

Symbolic representation:

• u: User/Owner.

• g: Group.

• o: Others.

• a: All (equivalent to ugo).

chmod examples:

Assign read and write Permissions for owner:

chmod 600 myfile.txt

After executing chmod 600 myfile.txt, the owner of myfile.txt will have full read and write access to the file (the 6 in **6**00), while the group and others will have no permissions whatsoever (the following two 0s in 6**00**).

Allow read and execute for owner, read for group, and no access for others:

chmod 540 script.sh

The owner of the file has both read and execute permissions (5). The group associated with the file has read-only access (4). Other users (those not in the owner group) have no permissions at all for the file (0).

Provide full permissions for all (Read, Write, Execute):

chmod 777 important_file.txt

The owner, the group, and all other users have complete access to read from, write to, and execute important_file.txt. This setting grants the broadest permissions possible, which might be risky for sensitive or important files due to unrestricted access.

Assign read and write permissions to the User:

chmod u+rw myfile.txt

The owner of myfile.txt (u) gains read and write permissions (rw), allowing them to both read from and write to the file.

Remove write permission for Others

chmod o-w myfile.txt

Others (users not in the owner group – o) lose their write permission on myfile.txt (-w). They'll be able to read the file but won't be allowed to modify it.

Access Control Lists

Access Control Lists (ACLs) in Red Hat Enterprise Linux (RHEL) are extensions of standard file permissions. They offer more granular control over who can access a file or directory by enabling you to set permissions for specific users or groups beyond the traditional owner, group, and others.

• Traditional permissions (read, write, execute) govern access based on owner, group, and others.

• ACLs extend this by allowing permissions for multiple users and groups.

In Red Hat Enterprise Linux (RHEL), getfacl and setfacl are commands used to manage Access Control Lists (ACLs) on files and directories.

Access Control List examples:

How to view ACLs:

getfacl filename

This retrieves and displays the ACL information for that specific file or directory. It provides a more comprehensive view of the access rights and permissions configured for that particular file in the system.

How to set ACLs:

Syntax:

setfacl -m u:username:permissions filename

Example:

setfacl -m u:john:rw important_file.txt

The code above modifies the ACL of important_file.txt, specifically granting read and write permissions to the user named john. This allows them to read from and write to the file without affecting other users' permissions.

Let's break down the code:

• setfacl: The command used to set ACLs.

• -m: This option stands for "modify" and is used to modify the existing ACLs of a file or directory without altering other permissions that might already be set.

• u:username:permissions: This part specifies the user, their username, and the permissions being granted or modified for that user.

• u: Indicates that the following entry pertains to a specific user.

• username: Represents the username of the user whose permissions are being modified.

• permissions: Denotes the specific permissions being assigned to the user.

The umask Command

In Red Hat Enterprise Linux (RHEL), umask stands for "user file creation mask." It's a command and a file mode creation mask that determines the default file permissions when a new file or directory is created.

It's represented as a three-digit octal number (for example, 022, 002, etc.).

Calculation: The umask value subtracts permissions from the maximum default permissions:

• For files: Start with 666 (rw-rw-rw-) and subtract the umask value.

• For directories: Start with 777 (rwxrwxrwx) and subtract the umask value.

Example of calculating umask

Let's consider an example where the umask value is 022.

For files:

• Default maximum permissions: 666 (rw-rw-rw-)

• Umask value: 022

• Subtracting the umask value (022) from the default file permissions (666):

• For the owner: 6 (rw) - 0 (no write) = 6 (rw-)

• For the group: 6 (rw) - 2 (no write) = 4 (r--)

• For others: 6 (rw) - 2 (no write) = 4 (r--)

After applying the umask (022), the resulting permissions for new files becomes 644 (rw-r--r--).

For directories:

• Default maximum permissions: 777 (rwxrwxrwx)

• Umask value: 022

• Subtracting the umask value (022) from the default directory permissions (777):

• For the owner: 7 (rwx) - 0 (no write) = 7 (rwx)

• For the group: 7 (rwx) - 2 (no write) = 5 (r-x)

• For others: 7 (rwx) - 2 (no write) = 5 (r-x)

After applying the umask (022), the resulting permissions for new directories becomes 755 (rwxr-xr-x).

So with a umask value of 022, new files will have default permissions of 644 (rw-r--r--) and new directories will have default permissions of 755 (rwxr-xr-x).

umask examples:

Check the current umask:

umask

Temporarily change the umask

umask [new_umask_value]

• The first digit represents the permissions removed for the file owner.

• The second digit represents the permissions removed for the group.

• The third digit represents the permissions removed for others (users not in the owner group).

Examples of umask values and their implications:

• 000: No permissions are removed, resulting in full read, write, and execute permissions for everyone (not recommended due to security implications).

• 022: Removes write permission for others, commonly used for ensuring others can read but not modify files created by the owner.

• 077: Removes all permissions for group and others, only allowing the owner full read, write, and execute permissions.

• 002: Similar to 022, but additionally allows group members to write to the files they create.

Permanent umask change

If you want or need to, you can change system-wide umask (which is permanent). Here's how to do that:

• For system-wide changes, modify the system configuration files like /etc/profile, /etc/bashrc, or shell-specific files.

• Edit the file using a text editor with administrative privileges:

 sudo nano /etc/profile

• Locate the line setting the umask value and adjust it accordingly.

• Save the file and exit the text editor.

You can also change user-specific umask (also permanent). Here's how to do that:

• For changes specific to a user, edit their initialization file (for example, ~/.bashrc, ~/.bash_profile, ~/.profile)

vim ~/.bashrc

• Add or modify the umask line as needed.

• Save the file and exit the text editor.

To confirm the changes, type this command:

umask

Practical Exercises

Here are some exercises to help you practice what we've covered here. Try to run through them on your own.

Viewing File Permissions:

• Use the ls -l command to view the detailed file permissions of files in your current directory.

• Interpret the output, understanding the file type, permissions, number of links, owner, group, file size, last modified time, and file/directory name.

Changing File Ownership:

• Create a file named example.txt using any text editor (for example, touch example.txt).

• Use the ls -l command to verify the ownership of example.txt.

• Use the chown command to change the ownership of example.txt to a different user (replace newowner with an actual username).

• Verify the ownership change using ls -l.

Changing File Group Ownership:

• Create another file named data.txt.

• Use the ls -l command to verify the group ownership of data.txt.

• Use the chgrp command to change the group ownership of data.txt to a different group (replace newgroup with an actual group name).

• Confirm the group ownership change using ls -l.

Modifying File Permissions:

• Create a third file named script.sh.

• Use the ls -l command to view the default permissions of script.sh.

• Use the chmod command to give the owner read and execute permissions, the group read permissions, and no permissions for others.

• Verify the permission changes using ls -l.

Setting ACLs:

• Create a directory named secure_folder.

• Use getfacl to view the ACLs of the directory.

• Use setfacl to grant read and write permissions to a specific user (replace john with an actual username).

• Verify the ACL changes using getfacl.

Understanding Umask:

• Check the current umask value using the umask command.

• Create a new file named confidential.txt.

• Use ls -l to view the default permissions of confidential.txt.

• Temporarily change the umask value to 027 using the umask command.

• Create another file named secret.txt and check its default permissions.

Permanent Change of Umask:

• For system-wide changes, modify the system configuration file (for example, /etc/profile, /etc/bashrc) to set a new default umask.

• For user-specific changes, edit the user's initialization file (for example, ~/.bashrc, ~/.bash_profile) to set a new umask.

• Verify the changes by creating a new file and checking its default permissions.

Wrapping Up

Thank you for exploring the world of Red Hat Enterprise Linux (RHEL) administration with me today.

We covered the core commands essential for precise file management in Red Hat Enterprise Linux, offering practical examples and exercises to reinforce understanding and proficiency.

You can dive deeper into the realm of Linux expertise and stay tuned for more insightful content in my future tutorials.

You can follow me on:

• Twitter

• LinkedIn

This is a critical component that's significant for both individual and complex network environments, as it's key to adeptly handle user accounts and groups.

In this guide, we'll dive into the fundamentals of user and group management within RHEL. You'll gain the knowledge and skills necessary to confidently create, modify, and optimize user accounts and groups, according to your specific security and operational needs.

You'll also learn the ins and outs of granting user permissions and implementing group-based access controls, and master the essential tools and proven methods for ensuring robust system integrity and regulating resource access.

Prerequisite

• Familiarity with basic Linux commands. You can read my previous tutorial on RHEL commands and key concepts if you need to brush up.

Table Of Contents

Here's what we'll cover in this comprehensive guide:

• useradd

• What is sudo?

• usermod

• What is /etc/login.defs?

• What is /etc/skel?

• What is /etc/shadow?

• groupadd

• groupmod

• Practical Exercise

• Wrapping Up

The useradd Command

The useradd command is an essential tool in RHEL for creating new user accounts. This command not only adds the user's information to the system files, but also sets up their home directory and default configurations.

Syntax of the useradd command:

useradd [options] username

What is sudo?

In the world of Linux/Unix, sudo stands for "Superuser Do." Essentially, it's a command that grants regular users the ability to run commands with full administrative or root permissions. This is especially useful for commands that may be restricted for regular users due to security reasons.

Examples:

Just a quick reminder – if you're not currently logged in as the root user, be sure to utilize sudo before using commands such as useradd that we'll be discussing in this tutorial. Consider sudo as a handy tool that grants you some of the root user's abilities. We'll go more in-depth on this topic in future tutorials.

At the moment, I am logged in as a root user. So I won't be using sudo before any commands.

Create a user:

useradd kedar

This command makes a new user called 'kedar' and sets up a home folder for them by default. Later on, we'll learn more about useradd and how we can change these defaults.

In RHEL, some values are already set when creating a user, but we'll explore them further in this tutorial.

Check a newly added user:

tail -1 /etc/passwd

/etc/passwd serves as a centralized repository containing essential information about user accounts. The output of the above command will be displayed in following way:

kedar:x:1001:1001:John Doe:/home/john:/bin/bash

If the user was added successfully, you will see the above output. Now there may be some changes, but it should look essentially the same.

Let's break this output down and try to understand it:

Breakdown of the above output

1. Username – the name of the user account.

2. Password Placeholder (Obsolete) – historically, this field contained an 'x' character, indicating that the encrypted password for the user was stored in the /etc/shadow file.

3. User ID (UID) – unique numerical identifier assigned to the user.

4. Group ID (GID) – the numerical identifier of the primary group associated with the user.

5. User Information (GECOS) – this field usually includes additional information like the user's full name, contact details, and so on.

6. Home Directory – the path to the user's home directory.

7. Login Shell – the default shell or program executed upon login for the user.

Once the user is created, we can set password for that user. This can be only done from a root account.

Set a password for a newly created account

passwd kedar

This will ask you to type password for the kedar user. Once the password is set you can login to kedar user using the GUI. Setting password is important if you want to login through the GUI.

Set different options for the user while creating a new user

Now that we know what options are available while creating a user, we can set them according to our needs.

1. User Id (-u)

useradd -u 1234 kedar

Above command with the -u option will set User Id to 1234 while creating the user kedar.

2. Primary Group (-g)

useradd -g 1232 kedar

If there is an existing group and you know the group Id or group Name, you can add that group as a primary group for the kedar user.

3. Secondary Group (-G)

useradd -G developers kedar

User kedar will be added to a secondary group called developers which already exists. We can add the user to multiple secondary groups.

Think of a secondary group in Linux as a coveted club membership for users. While they are automatically included in a primary group when working on the computer, joining secondary groups allows users to expand their membership and gain access to additional files and features.

Essentially, it's like being a part of multiple groups simultaneously, providing users with additional privileges and the ability to explore different parts of the system.

4. User Information

useradd -c "2 Month Intern" kedar

This adds more information to user kedar as "2 Month Intern". This will be displayed in the /etc/passwd file.

5. Home Directory

useradd -d /etc/kedar/home kedar

Now this will set the home directory to /etc/kedar/home for the kedar user. By default in RHEL, the home directory, if not specified, is /home/kedar.

6. Login Shell

useradd -s /bin/shell kedar

Here, the kedar user will have access to the shell which is in /bin/shell. This will give access to the shell to the user kedar.

The /bin/bash access pertains to a user's default shell upon logging into the system.

In the Linux world, the /bin/bash shell is commonly known as the Bash shell, short for "Bourne Again SHell," and is readily available on most Linux distributions. When a user is granted /bin/bash access, it means that upon login, they will be greeted with the Bash shell's command-line interface.

This powerful shell equips them with the ability to interact with the system, run commands, and execute Bash-specific scripts using its unique syntax and functionality.

Given its widespread usage, advanced capabilities, and compatibility with a variety of scripting languages and command-line tasks, the /bin/bash shell is a preferred option for many users as their default shell.

If you want to remove shell access from a particular user, you can set shell access like this: /sbin/nologin. This will restrict access to this user to logging into their account until shell access is set to /bin/shell.

useradd -s /sbin/nologin kedar

The usermod Command

The usermod command is super important in Linux. It helps admins easily change things about user accounts after they're made. This saves time because you don't have to delete and make the accounts again. It's a handy way to manage users without much hassle.

Syntax of the usermod command:

usermod [options] username

Examples:

Change username:

usermod -l newusername oldusername

This command changes the username from oldusername to newusername.

Change User ID (UID):

usermod -u <newUID> username

This command replaces <newUID> with the desired new UID for the user.

Change Group ID (GID):

usermod -g <newGID> username

This command replaces <newGID> with the desired new primary group ID for the user.

Add user to supplementary groups:

usermod -aG group1,group2 username

This command adds the user to additional supplementary groups (group1, group2, etc.).

Change home directory:

usermod -d /newhome username

This command changes the user's home directory to /newhome.

Change default shell:

usermod -s /bin/bash username

This command changes the default shell for the user to /bin/bash.

Set expiry date for account:

usermod -e YYYY-MM-DD username

This command sets an expiration date (YYYY-MM-DD) for the user's account.

You can explore more about this command using man usermod. You have the same options as with useradd to manipulate the information of a user when you use the usermod command.

What is /etc/login.defs?

The /etc/login.defs file is a crucial configuration file that sets default parameters for login, password policies, and user account creation. It can be found at the usual location, /etc/login.defs, and plays a key role in determining system-wide defaults for user management and authentication.

There is also a fixed range for user UIDs, as shown in the following table:

UID range table - Privileged users: 0-99, System users: 201-999, Normal users: 1000-60000

The directory /etc/login.defs contains a variety of default configurations. By accessing this directory, we can modify these settings to our liking.

This file contains several different options that we can adjust, some of which are listed below:

PASS_MAX_DAYS   90
PASS_MIN_DAYS   7
PASS_WARN_AGE   14
PASS_MIN_LEN    8

UID_MIN         1000
UID_MAX         60000
GID_MIN         1000
GID_MAX         60000

LOGIN_RETRIES   5
LOGIN_TIMEOUT   60
CREATE_HOME     yes
UMASK           077

ENCRYPT_METHOD  SHA512
CHFN_AUTH       yes
CHFN_RESTRICT   rwh
DEFAULT_HOME    /home

Now you know where the default settings come from when we create a user. You can change these settings according to your needs.

What is /etc/skel?

In Linux and similar systems, the /etc/skel/ folder is like a starter pack for new users. It's called "skel" short for "skeleton" because it sets up the basics for new users.

This folder contains a set of files and folders that are copied into a new user's home folder. Whenever a new user is made, these essential files from /etc/skel/ are automatically put into their home folder, making sure it has what they need to get started.

This helps set up a simple starting point for the user. It gives them basic configurations, default settings, and sometimes example files. This method ensures that every new user starts with a standard setup and the required files.

In the /etc/skel/ folder, you might find common files like .bashrc, .profile, and similar configuration files.

What is /etc/shadow?

The /etc/shadow file is a crucial component of Unix-based operating systems (like Linux), as it serves as a repository for encrypted user passwords and other password-related data. This enhanced security measure surpasses previous methods of storing passwords in the /etc/passwd file.

The /etc/shadow file contains crucial information pertaining to user account passwords. Each line in the file represents a particular user and is divided into multiple fields, each separated by a colon (:).

These fields typically include the username, the encrypted password (hashed using a cryptographic algorithm, not the actual password), the number of days since the last password change (starting from January 1, 1970), information about password expiry such as minimum and maximum age, and a warning period. It also specifies the number of days of inactivity allowed before the account is locked, and if the account has an expiration date.

Sample entry of /etc/shadow file

user:$6$PswrdHash$E7KLkQIGo7mxG5vDi7JelC5D8L0qbg38z1/WgNhAZDpCoe2GyGB6JefT9ftb/Rfm3uZOlFkktj/SkJTfSJziO.:18830:0:90:7:::

Where:

• user: Username

• $6$PswrdHash$E7KLkQIG...: Encrypted password hash

1. $1$ is MD5

2. $2a$ is Blowfish

3. $2y$ is Blowfish

4. $5$ is SHA-256

5. $6$ is SHA-512

6. $y$ is yescrypt

These symbols help identify the hashing algorithm used for each password hash stored in the /etc/shadow file. For instance, if you see a password hash starting with $6$, it indicates that SHA-512 encryption has been used for that particular password.

• 18830: Last password change date (days since Jan 1, 1970)

• 0: Minimum password age

• 90: Maximum password age

• 7: Password warning period

• Other fields for account inactivity and expiration

Access: In order to access and modify the /etc/shadow file, you must have root user permissions or specialized privileges granted.

Modification: For enhanced security, it is advised to use designated commands such as passwd, which handles password encryption and updates the /etc/shadow file effectively.

The groupadd Command

In RHEL, you use the groupadd command to create new groups on the system. It's a fundamental command for managing user groups, allowing system administrators to add groups, set their properties, and define their membership.

All default settings for groups are in /etc/login.defs. The /etc/login.defs file contains important settings, such as GID_MIN, which determines the minimum GID value for regular groups, and GID_MAX, which sets the maximum GID value. Additionally, SYS_GID_MIN and SYS_GID_MAX determine the minimum and maximum GID values for system groups.

These settings play a crucial role in the management of groups within the system.

Syntax of the groupadd command:

groupadd [options] groupname

Examples:

Creating a group:

groupadd developers

The above command create a new group named "developers".

Assigning a specific GID:

groupadd -g 1001 developers

This command creates a group with a specified GID (for example, GID 1001).

You can explore more options according to your needs using the man groupadd command. This will give you documentation of the groupadd command.

The groupmod Command

The groupmod command in RHEL is a valuable tool for system administrators, as it enables them to effortlessly modify existing group attributes.

With this powerful command, you can alter groups without the need for recreating them, making it a crucial asset for system maintenance.

Syntax of the groupmod command:

groupmod [options] groupname

Examples:

Change group name:

groupmod -n newgroupname oldgroupname

This command changes the group name from oldgroupname to newgroupname.

Change GID (Group ID):

groupmod -g <newGID> groupname

This command changes the group's GID to <newGID>.

Add group to supplementary groups:

groupmod -aG group1,group2 groupname

This command adds the group to additional supplementary groups (group1, group2, and so on).

Add users from a group:

groupmod -m -m user1,user2 developers

This will add user1 and user2 to the developers group.

Remove users from a group:

groupmod -M user1,user2 developers

This will remove user1 and user2 from the developers group.

You can explore more options according to your needs using the man groupmod command. This will give you documentation of the groupmod command.

Practical Exercise

Exercise 1: Basic User and Group Management

1. Creating Users and Groups

• Use useradd to create a new user named "testuser."

• Use groupadd to create a group named "testgroup."

• Ensure the user "testuser" is part of the group "testgroup."

Exercise 2: User Modifications

1. Modifying User Attributes

• Use usermod to change the default shell for "testuser" to /bin/bash.

• Modify the user's login name from "testuser" to "newuser" using usermod.

• Confirm the changes by checking /etc/passwd.

Exercise 3: Group Modifications

1. Group Modifications

• Use groupmod to rename "testgroup" to "newgroup."

• Change the GID (Group ID) of "newgroup" using groupmod.

• Add "newuser" to the "newgroup" using usermod.

Exercise 4: Advanced User and Group Management

1. Setting User and Group Limits

• Set password policies using parameters in /etc/login.defs.

• Configure group default settings like GID_MIN and GID_MAX in /etc/login.defs.

Exercise 5: Understanding /etc/shadow and /etc/skel

1. Exploring Password Storage and Defaults

• Examine the /etc/shadow file to understand the password storage format.

• Create a new user and observe their entry in /etc/shadow.

• Explore /etc/skel and understand its purpose by creating a new user and observing their home directory.

Exercise 6: Challenge

1. Managing Permissions and Access Control

• Set up directory permissions so that only "newuser" in "newgroup" can read/write to a specific folder.

• Experiment with chown and chmod commands to change ownership and permissions.

Exercise 7: Real-world Scenario

1. Creating Users with Specific Configurations

• Create a user named "admin" with a customized home directory (/opt/admin) and a specific default shell.

• Set a password policy that applies only to the "admin" user.

Wrapping Up

Thank you for exploring how to manage users and groups in RHEL with me today. You can dive deeper into the realm of Linux expertise and stay tuned for more insightful content in my future tutorials.

You can follow me on:

• Twitter

• LinkedIn

Let's dive into the core aspects of RHEL administration to help you understand these key topics that form the backbone of day-to-day operations. The only prerequisites are a desire to learn Linux and a willingness to code along at home and complete the exercises at the end.

Table Of Contents

Here's what we'll cover in this comprehensive guide:

• What is RHEL?

• No Need to Set Up Linux Locally

• Understanding Upstream & Downstream

• Essential RHEL Command Line Tools and Functions

• How the Linux File System Works

• Text Editors

• Practical Exercises

• Wrapping Up

What is RHEL?

RHEL is a popular member of the Linux distribution family. It stands out for its strong reliability, stability, and security capabilities.

Created by Red Hat, RHEL is specifically designed for enterprise usage, striking a helpful balance between innovative technologies and a commitment to dependability, extensive support, and seamless compatibility.

RHEL is a solid choice for businesses, organizations, and developers seeking a reliable operating system for high-priority tasks. It offers a robust base for server setups, data centers, cloud computing, and business applications, and is often a go-to option for mission-critical workloads.

No Need to Set Up Linux Locally

You don't need to set up Linux on your system to follow this guide. Instead, you can practice whatever you learn here on an interactive online platform.

You can visit this website to access a Linux playground where you can execute commands and explore Linux without installation.

Understanding Upstream & Downstream

Upstream

Upstream represents the original or source software from which derivatives or distributions are derived. For Red Hat Enterprise Linux (RHEL), Fedora serves as its primary source for updates and features.

RHEL integrates developments from Fedora's open-source platform into its enterprise-level distribution. Changes initiated within Fedora are systematically integrated into RHEL as part of its upstream progression.

Software upstream commonly includes the latest, experimental features and developments driven by the community. It forms the base for related projects, functioning as a testing area for trying out new functions

Downstream

Downstream refers to distributions or versions derived from the upstream source. These distributions typically incorporate modifications, adjustments, and additional features tailored to specific needs.

CentOS, a widely-used version that comes after RHEL, uses RHEL's code but without its branding and exclusive parts, providing a no-cost alternative.

Likewise, distributions such as Oracle Linux are also built from RHEL's codebase, but they make their changes and packaging adjustments.

Downstream serve different groups of users by taking the main features from the original source and tweaking them to fit specific needs, like stability, support, or particular uses.

Essential RHEL Command Line Tools and Functions

By learning the fundamental commands I outline below, you can navigate and manage your Linux environment with ease. These commands act as the foundation for a deeper understanding of Linux systems, and they'll empower you to expand your expertise and knowledge further.

echo

The echo command is used to show text or variables as output. It's a straightforward yet robust tool often used in scripting and working with command-line interfaces.

Syntax:

echo [OPTIONS] [STRING]

Examples:

Displaying text:

echo "Hello, World!"

This will print given text as it is on a user's screen.

Displaying variables:

name="John"
echo "Hello, $name"

We can directly declare a variable and assign a value to that variable. We can use $ in front of the variable name to print it using the echo command.

Escape Sequences:

Escape sequences are combinations of characters that are used to represent certain special characters or actions within strings. These sequences typically start with a backslash \ followed by a specific character or sequence of characters.

When the compiler or interpreter encounters an escape sequence within a string, it interprets it as a special instruction rather than a literal character.

• \n: Represents a newline character. When this sequence is encountered within a string, it signifies a line break.

• \t: Represents a tab character. It's used to create horizontal tabs or spaces within a string.

• \: Represents a single backslash character. Since the backslash is an escape character itself, using \ allows you to include a literal backslash in a string.

• \" : Represents a double quote or a single quote character respectively within a string. These are useful when you want to include quotes within a string that is itself enclosed in quotes.

We need to use the -e option along with the echo command to enable escape sequences. -e enables the interpretation of backslash escapes.

Examples:

Printing a new sentence on a new line:

echo -e "This is a new line.\nThis is another line."

Now both lines will be on a separate line rather than continuing one after another. You can try using other options from above.

whoami

whoami is used to display the username of the current user who is logged in to the system.

Example

whoami

Running whoami in a terminal will output the username of the current user. For instance, if you're logged in as "Kedar," it will display Kedar. It serves a specific purpose of showing the current user's identity and doesn't have additional options or variations.

cat

The cat command is used primarily to read, create, concatenate, and display the content of files. Its name is derived from "concatenate," which means to link things together.

Syntax:

cat [OPTIONS] [FILE(s)]

Examples:

Displaying file content:

cat filename.txt

This will display the contents of filename.txt in the terminal.

Concatenating multiple files:

cat file1.txt file2.txt > combined.txt

This code concatenates file1.txt and file2.txt and redirects their content to combined.txt.

Creating or appending to a file:

The output of cat can be redirected using > (create/overwrite) or >> (append) to store the content into a file.

To create a new file and add content to it, try this command:

cat > newfile.txt

This will allow you to type content into the terminal, and pressing Ctrl + D will save it to newfile.txt.

To append content to an existing file, try this:

cat >> existingfile.txt

Similar to the previous command, this allows you to add content to existingfile.txt.

Display line numbers along with the content:

We can show line number along with content using -n option with cat.

cat -n filename.txt

Display a dollar sign ($) at the end of each line:

We can show a $ at end of each line along with content using the -E option with cat like this:

cat -E filename.txt

touch

The touch command is used to create new, empty files or update the timestamps of existing files without changing their content.

Syntax:

touch [OPTIONS] [FILE(s)]

Examples:

Creating a new file:

touch newfile.txt

This command creates a new file named newfile.txt. If the file already exists, it updates the timestamp to the current time.

Creating multiple files:

touch file1.txt file2.txt file3.txt

This creates multiple files (file1.txt, file2.txt, file3.txt) simultaneously.

Also, we can create files with changing numbers or letters dynamically. We need to give the range of letters or numbers in curly braces:

touch file{1..3}.txt

This will create file1.txt, file2.txt and file3.txt.

ls

The ls command is used to list files and directories in a specified location.

Syntax:

ls [OPTIONS] [DIRECTORY/PATH_OF_DIRECTORY]

Examples:

List files in the current directory:

ls

This command lists all files and directories in the current working directory.

List files in a specific directory:

ls /custom/path

Replace /custom/path with the actual path to list files and directories in that specific directory.

List hidden files:

ls -a
ls -a /custom/path

The -a option shows all files, including hidden ones (those starting with a dot, for example .hiddenfile).

List all details of directory/files:

ls -l /custom/path

This provides a detailed, long listing format that gives more information about directories and files. You will learn more about the details which ls -l provides in an upcoming article.

Display Directory/File size:

ls -h /custom/path

Displays file sizes in a human-readable format (e.g., kilobytes, megabytes).

Show modified files first:

ls -t /custom/path

This command sorts files by modification time, showing the newest files first.

We can also use these options together like this:

ls -la /custom/path

This will list all files and directory along with hidden files (-a) and details information of files and directories (-l).

date

The date command is used to display or set the system date and time.

Syntax:

date [OPTIONS]

Examples:

Displaying the current date and time:

date

This will display the current date and time of your system.

Setting the date and time:

date MMDDhhmm[[CC]YY][.ss]

• MM: Month (01-12)

• DD: Day (01-31)

• hh: Hour (00-23)

• mm: Minute (00-59)

• CC: Century (optional, for years earlier than 2000)

• YY: Year (optional, 00-99)

• .ss: Seconds (optional, 00-61)

This command will let you set whatever date and time you want on your system.

Customizing date output:

date +"%A, %B %d, %Y"

Options

• %A = Full weekday name (for example, Sunday)

• %B = full month name (for example, January)

• %d = day of month (for example, 01)

• %Y = year

This will display Saturday, December 16, 2023. You can find more options for date using the man date command.

Note: If you want to find in-depth information about any command, use man your_command to get more information.

cal

The cal command is used to display a calendar for a specified month or year.

Syntax:

cal [OPTIONS] [MONTH] [YEAR]

Examples:

Displaying the current month's calendar:

cal

This command displays the calendar for the current month.

Displaying a specific month and year:

cal 12 2023

This command displays the calendar for December 2023.

Displaying a specific year:

cal 2023

Displaying Julian days:

"Julian days" refers to a simple way of counting days. Instead of using dates like January 1st or February 15th, Julian days just count the number of days that have passed since a specific starting point. This starting point is called the Julian Day Number (JDN), which began on January 1st, 4713 BC in the Julian calendar.

For example, January 1st, 4713 BC is Julian day 0. Each day after that is counted as Julian day 1, 2, 3, and so on. It's like a continuous count of days without worrying about months or years. It's a handy way for scientists, astronomers, and other professionals to keep track of time because it's a straightforward system of counting days.

cal -j 12 2023

This command displays the calendar for December 2023 along with the corresponding Julian days.

mkdir

You use this command to create new directories, organizing the file system structure efficiently. mkdir stands for Make Directory.

Syntax:

mkdir [OPTIONS] DIRECTORY_NAME(s)

Examples:

Creating a single directory:

mkdir new_directory

This command creates a new directory named new_directory in the current working directory.

Creating multiple directories:

mkdir dir1 dir2 dir3

This command creates multiple directories named dir1, dir2, and dir3 in the current working directory.

We can also make this command little bit more intresting. We can create n numbers of directories if you want them in a sequence of numbers (or letters) – like dir1, dir2, dir3, and so on – with the following syntax.

mkdir dir{1..5}

Now this will create dir1 up to dir5. We can also replace numbers with letters.

Creating nested directories:

mkdir -p parent/child/grandchild

The -p option creates nested directories. In this example, it creates a directory structure: parent → child → grandchild.

pwd

The pwd command stands for "print working directory." It displays the current directory path where you're located within the file system.

Example:

pwd

cd

The cd command is used to change the current working directory. cd stands for Change Directory.

Syntax:

cd [DIRECTORY_PATH]

Examples:

Changing to a specific directory:

cd /path/to/directory

This command changes the current directory to given path – for example, /path/to/directory.

Moving to a parent directory:

cd ..

.. refers to the parent directory, so this command moves one level up from the current directory.

Returning to the home directory:

cd

Typing cd without any arguments takes you to your home directory.

Switch to the previous directory:

cd -

This will take you to the previous directory that you were working on.

cp

The cp command is used to copy files and directories from one location to another.

Syntax:

cp [OPTIONS] SOURCE DESTINATION

Examples:

Copying a file to another location:

cp file.txt /path/to/destination/

This command copies file.txt to the specified destination directory (/path/to/destination/).

Copying multiple files to a directory:

cp file1.txt file2.txt file3.txt /path/to/destination/

This command copies multiple files (file1.txt, file2.txt, file3.txt) to the specified destination directory.

Copying a directory and its contents:

cp -r directory1 /path/to/destination/

The -r (or -R) option is used to copy directories recursively. This command copies directory1 and its contents to the specified destination.

mv

The mv command is used to move or rename files and directories from one location to another.

Syntax:

mv [OPTIONS] SOURCE DESTINATION

Examples:

Moving a file to another location:

mv file.txt /path/to/destination/

This command moves file.txt to the specified destination directory (/path/to/destination/). If the destination is a file name, it renames file.txt to that name.

Renaming a file:

mv old_name.txt new_name.txt

This command renames old_name.txt to new_name.txt.

Options:

• -i: Prompts before overwriting existing files.

• -u: Moves only when the source is newer than the destination file or when the destination file is missing.

nl

The nl command is used to add line numbers to files or text that's provided as input. It reads text from a file or standard input and by default numbers all the lines in the output, making it easier to reference and work with specific lines within the content.

Syntax:

nl [OPTIONS] [FILE]

Examples:

Numbering lines in a file:

nl filename

This command numbers all the lines in the specified file (filename) and outputs the result.

Numbering non-empty lines only:

nl -ba filename

This command numbers only non-empty lines (the -b option specifies the numbering style, where a denotes non-empty lines).

head

The head command outputs the beginning section of files or input streams.

Syntax:

head [OPTIONS] [FILE(s)]

Example:

Displaying the first n lines of a file:

head -n 10 filename

This command displays the first 10 lines of the specified file.

tail

The tail command displays the end section of files or input streams.

Syntax:

tail [OPTIONS] [FILE(s)]

Example:

Displaying the last n lines of a file:

tail -n 10 filename

This command displays the last 10 lines of the specified file.

grep

The grep command in Linux is a powerful utility used for searching text patterns within files or input streams. Its primary function is to scan a specified file or standard input line by line and print lines that match a specified pattern.

Syntax:

grep [OPTIONS] PATTERN [FILE(s)]

Examples:

Searching for a specific pattern in a file:

grep "pattern" filename

This command searches for the word "pattern" in the specified file (filename) and displays the lines containing that pattern.

Case-insensitive search in a file:

grep -i "pattern" filename

This command searches for "pattern" in the specified file (filename) regardless of whether it's in uppercase or lowercase.

Searching for multiple patterns in a file:

grep -e "pattern1" -e "pattern2" filename

This command searches for both "pattern1" and "pattern2" in the specified file (filename) and displays lines containing either of these patterns. You can also use different files for different pattern matching.

wc

The wc command stands for "word count," but its functionality extends beyond counting words. It's a versatile command-line utility used to count the number of lines, words, and characters in files or standard input streams.

Syntax:

wc [OPTIONS] [FILE(s)]

Examples:

Counting lines in a file:

wc -l filename

This command displays the number of lines in the specified file (filename).

Counting words in a file:

wc -w filename

This shows the count of words in the specified file.

Counting lines, words, and characters simultaneously:

wc filename

By default, this command displays the count of lines, words, and characters in the specified file.

Options and flags for wc:

• -l: Displays the number of lines.

• -w: Shows the count of words.

• -m: Outputs the count of characters.

• -c: Provides byte counts (equivalent to -m in most cases).

• -L: Displays the length of the longest line.

• -h: Provides human-readable output (e.g., 1.2K for 1200).

cut

The cut command in Linux is used to extract specific sections (columns or portions) of text from files or input streams based on delimiters like characters or fields.

Syntax:

cut [OPTIONS] [FILE(s)]

Examples:

Extracting specific columns from a file:

cut -d',' -f 1,3 filename.txt

This command extracts the first and third columns from a CSV file (filename.txt) where columns are delimited by a comma (-d',' specifies the delimiter).

Selecting a range of characters from a file:

cut -c 1-5 filename.txt

This command extracts characters 1 to 5 from each line of the specified file (filename.txt).

You can always find more options for any command using man you_command. This give give proper documentation for that specified command. man stands for manual.

Now that you've learned some commonly used RHEL commands, make sure to practice using them. You can start by working through the below exercise.

How the Linux File System Works

In Linux, the root directory / acts as the top level directory in the system hierarchy. It contains various subdirectories, each serving a specific function and storing the necessary system files.

Here is an overview of the primary directories in RHEL and their functions within the root directory:

Linux File System

Let's go over the function and purpose of each of these directories.

/bin (Binary)

• Function: contains essential executable binaries (commands) accessible to all users.

• Purpose: contains fundamental system commands like ls, cp, mv, rm, and so on.

/boot

• Function: holds files necessary for booting the operating system.

• Purpose: contains boot loader files, kernel images, and configuration files required during system boot-up.

/dev (Device)

• Function: represents device files.

• Purpose: provides access to physical and virtual devices such as hard drives, USB devices, terminals, and more.

/etc (Etcetera)

• Function: stores system-wide configuration files.

• Purpose: contains configuration files for various applications, services, and system settings.

/home

• Function: houses user home directories.

• Purpose: each user typically has a subdirectory within /home that contains their personal files, settings, and data.

/lib and /lib64

• Function: contains libraries required by programs at runtime.

• Purpose: stores shared library files used by system binaries and applications.

/mnt (Mount)

• Function: provides a mount point for temporarily mounting external devices.

• Purpose: used for mounting external storage devices such as USB drives, network shares, or additional file systems.

/opt (Optional)

• Function: reserved for optional or third-party software.

• Purpose: often used to install large, self-contained software packages that don’t conform to the standard Linux file system hierarchy.

/proc (Process)

• Function: virtual file system providing information about system processes.

• Purpose: offers a way to interactively examine and manipulate the system's internal state.

/root

• Function: home directory for the superuser (root).

• Purpose: contains the root user's files, settings, and configuration files.

/sbin (System Binary)

• Function: stores essential system administration binaries.

• Purpose: contains commands crucial for system administration, often requiring administrative privileges.

/srv (Service)

• Function: intended for data related to services provided by the system.

• Purpose: used for storing data and files used by various services running on the system.

/tmp (Temporary)

• Function: directory for temporary files.

• Purpose: contains temporary files created by various system processes and users. Files here are typically deleted on system reboot.

/usr (Unix System Resources)

• Function: holds user-related programs, libraries, and documentation.

• Purpose: contains a vast majority of user-accessible applications, system utilities, libraries, and documentation.

/var (Variable)

• Function: stores variable data such as logs, spool files, and temporary files.

• Purpose: contains data that varies frequently, including system logs, mail, print queues, and more.

Text Editors

There are various terminal-based text editors, each with its own strengths and functionalities. But Vim stands out among these editors due to its unparalleled versatility and robust feature set.

Vim's strength lies in its powerful modal editing, offering distinct modes for navigation, insertion, and executing commands, enabling swift and efficient text manipulation.

Additionally, Vim's syntax highlighting, support for multiple programming languages, and powerful search and replace capabilities make it a preferred choice for programmers and system administrators alike.

vim

Vim is a popular text editor among Linux users especially within the command line interface. Vim stands for "Vi IMproved" and is an enhanced version of the classic vi editor. It offers extensive features for editing, viewing, and manipulating text or code files.

In this section, we will delve into the world of Vim and how to use it in Linux. My goal is to acquaint you with some practical commands and features within Vim to help you easily manipulate text.

Here's how to open Vim in Linux:

vim [OPTIONS] [FILE(s)]

Modes in Vim:

In Vim, modes act as different operational states that dictate how you can engage with the editor. The key modes – Normal, Insert, and Visual – play a significant role in your editing process.

You'll start in Normal mode when you open Vim. From there, you can easily navigate, move the cursor, and execute commands. Switching to Insert mode give you a direct means of inputting and altering text. And Visual mode lets you select and manipulate text blocks.

These modes are critical in streamlining various editing tasks, and can help you become more efficient and accurate. Learning how to use and transition between these modes give you versatile control over text editing and makes you much more productive within the Vim environment.

• Normal Mode: Default mode for navigation and executing commands.

• Insert Mode: For typing and editing text.

• Visual Mode: For selecting and manipulating blocks of text.

Editing in Insert Mode:

Picture yourself opening a document in Vim, eager to insert new information. Simply hit the i key, and Vim will know you're ready to type at the current cursor position.

A notification at the bottom will alert you with -- INSERT -- signifying that you are officially in insert mode. Now you can input your desired additions. When you're done, hit the 'Esc' key to return to the default mode where you can then navigate and execute commands.

• Press i to enter insert mode and start typing.

• Press Esc to exit insert mode and return to command mode.

Saving and Exiting Vim:

Imagine that you've made some alterations to your document and now you're ready to save them before exiting Vim. Simply type :wq (which represents "write and quit") and hit 'Enter' to securely save your changes and leave Vim.

But what if you've made changes that you don't want to keep? In this situation, enter :q! and press 'Enter' to instruct Vim to quit without saving any modifications made since your last save.

By typing :wq and :q!, depending on your needs, you can confidently add content to your document and ensure that your work is either securely saved or discarded. These actions, paired with your ability to navigate Vim's different modes, make for a seamless and efficient editing experience.

• To save changes and exit, type :wq (write and quit) and press Enter.

• To exit without saving changes, type :q! and press Enter.

How to Edit Commands

Before you enter any command, press esc so that you are out of any mode that you were in.

In the editor, commands preceded by a colon (for example, :w) are utilized to carry out various actions, such as saving files. To save any modifications you've made, simply type :w and hit the 'Enter' key.

Similarly, commands like dd are designed for tasks such as erasing a line. To delete a line, make sure you are in the appropriate mode (Normal mode), then type dd by pressing the 'd' key twice in rapid succession. If you happen to find yourself in a different mode, simply press the 'esc' key to return to Normal mode.

Insert mode example:

• i: Enter insert mode before the cursor.

vim example.txt

• Use the arrow keys or 'h', 'j', 'k', 'l' to navigate to the end of the first line.

• Press 'i' to enter insert mode.

• Type your new sentence.

• Press 'Esc' to exit insert mode.

Deleting and changing text:

• dw: Delete from the cursor to the end of the word.

• dd: Delete entire line.

vim example.txt

• Move the cursor to the line you want to delete.

• Press dd.

Copy, cut, and paste:

• yy: Copy (yank) current line.

• yw: Copy from the cursor to the end of the word.

• p: Paste after the cursor.

• P: Paste before the cursor.

vim example.txt

• To copy a line: Move the cursor to the line you want to copy and press yy.

• To cut (delete) a line: Move the cursor to the line you want to cut and press dd.

• To paste the copied or cut line: Move the cursor to the desired location and press p to paste after the cursor or P to paste before the cursor.

Searching:

• /pattern: Search forward for "pattern".

• ?pattern: Search backward for "pattern".

• n: Move to the next search result.

• N: Move to the previous search result.

vim example.txt

• To search for a word like "example": Press / and then type example followed by Enter.

• To move to the next occurrence: Press n.

• To move to the previous occurrence: Press N.

Replace:

• :%s/old/new/g: Replace "old" with "new" globally in the entire file.

• :s/old/new/g: Replace "old" with "new" on the current line.

• :s/old/new/gc: Replace "old" with "new" with confirmation.

vim example.txt

• To replace all occurrences of "oldword" with "newword": Type :%s/oldword/newword/g and press Enter.

Saving:

• :w: Save changes.

• :wq or ZZ: Save changes and quit.

• :x: Save changes and quit (same as :wq).

vim example.txt

• To save changes made to the file: Type :w and press Enter.

Quitting:

• :q: Quit (only if there are no unsaved changes).

• :q!: Quit without saving changes.

vim example.txt

• To exit without saving changes: Type :q! and press Enter.

• To save changes and quit: Type :wq or ZZ and press Enter.

Practical Exercises

Now, to help you practice what you've learned, here are some exercises for you.

Let's say that you've been tasked with organizing and manipulating files and directories on a newly provisioned Red Hat Enterprise Linux system. Use the terminal to complete the following tasks:

Essential Command Line Tools & Functions:

• Use echo to display your name and a greeting message using variables and escape sequences.

• Use whoami to print the current user's name.

• Create a file named example.txt and display its contents using cat.

• Use touch to create three files: file1.txt, file2.txt, and file3.txt.

• Experiment with ls command variations: -a, -l, -h, -t, and combinations.

• Use date to display the current date and then customize the output to a specific format.

Linux File System Exploration:

• Use mkdir to create directories: /bin, /boot, /home, /etc, etc., and explain their functionalities in a document.

• Navigate to /var and list its contents.

• Use pwd to print the current directory path.

Text Editing with Vim:

• Create a file sample.txt.

• Open sample.txt using vim.

• Practice inserting text, deleting lines, copying and pasting, and saving changes.

File Operations:

• Copy sample.txt to a newly created directory /tmp using cp.

• Move sample.txt to the /var directory using mv.

• Remove sample.txt from the current directory using rm.

Inspecting File System Information:

• Use ls -l to view detailed information of a file in /usr/bin.

• Explain the output and file permissions in a document.

Basic Searches and Text Manipulation:

• Use grep to search for a specific word in a file.

• Perform a search-and-replace operation in example.txt using sed.

Advanced File Management:

• Create nested directories /opt/program/scripts using mkdir -p.

• Move file1.txt and file2.txt into /opt/program directory.

Reflection and Documentation:

• Reflect on your experience with each command in a document, explaining its usage and outcomes.

• Document any challenges faced and their solutions.

• Summarize the importance of each concept and command learned.

Remember, while performing these exercises, ensure you're in the correct directory and double-check commands involving file deletion or modification to prevent unintended actions.

Review Questions:

1. What command creates a new directory? Execute it.

2. How do you create multiple files at once? Demonstrate this.

3. What command moves files from one location to another? Move file1.txt and file3.txt to folderA.

4. How can you display the current date and time? Show the output.

5. Which command lists the contents of a directory in detail? Use it for the RHCSA_Practice directory.

6. Explain the purpose of creating nested directories.

7. What command renames a file? Rename file2.txt to important_file.txt.

8. How can you display only the hidden files in a directory? Show the hidden files in your current directory.

Wrapping Up

Thank you for exploring the world of Red Hat Enterprise Linux (RHEL) administration with me today. You can dive deeper into the realm of Linux expertise and stay tuned for more insightful content in my future tutorials.

You can follow me on:

• Twitter

• LinkedIn

There are multiple options you can go with to style a React application. But the CSS in JS technique is good approach, where you write the CSS code right in the JavaScript file. Styled-components takes this approach.

In this article, you will learn how to write CSS in JS.

Prerequisites

Before we go ahead with styled components, you should be familiar with React and CSS.

How to Create a Basic React App

Before getting started with styled components, let's start by creating a React app using create-react-app .

npx create-react-app APP_NAME

If you are not familiar with create-react-app, you can check here for more information.

Once you React boiler plate is set, remove all files from src folder except index.js and app.js.

This is how your files should look like when you are done with the above steps. Now it's time to clean up app.js and index.js. Now index.js and app.js will have some default boiler code. We need to remove unnecessary stuff from these files. After removing unnecessary stuff you app.js and index.js should look like code below in respective files.

App.js

function App() {
    return(
        <div>
            App
        </div>
    )
}

index.js

import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App'

const root = ReactDom.createRoot(document.getElementById('root'))
root.render(
    <>
        <App />
    </>
)

Now open the command line or press ctrl + (backtick) to open it and typenpm start` to start your React app.

Once your app is running successfully, stop your server using ctrl + c and install styled-components. The command to install styled-components is below:

npm install styled-components

Let's Style Our First Component

We will create a basic setup to help you learn styled components. In app.js, create a heading using an

tag, a paragraph using a tag and a button using the tag.App.js function App() { return ( <div> <h1>Styled Components</h1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <button>Click ME!</button> </div> ); } export default App;Before we style our component, we need to import styled-components into our app.js file:import styled from 'styled-components' function App() { return ( <div> <h1>Styled Components</h1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <button>Click ME!</button> </div> ); } export default App;Now we will create our custom component called H1 and use it instead of the tag with custom styling.const H1 = styled.h1` color: red; font-size: 4rem; ` First we need give a custom name of our choice. Then we'll start with styled.<HTML Tag Name> and wrap the style in backticks. Now when we use this custom component it will have the <HTML Tag Name> property with styling.import styled from 'styled-components' const H1 = styled.h1` color: red; font-size: 4rem; ` function App() { return ( <div> <H1>Styled Components</H1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <button>Click ME!</button> </div> ); } export default App;Voilà! Here we have our first custom styled component.NOTE: Always use uppercase letters to start your custom component name in React as it is React convention.Now if you inspect the page, you will see some gibberish class name. Styled components does this to avoid naming conflicts.Now let's style our button component:const DefaultButton = styled.button` background-color: #645cfc; border: none; padding: 10px; color: white; ` DefaultButton is our custom component name. After we style it, we can give it any HTML tag we desire so that this custom component will have that tag.Now we will use DefaultButton that we created above as our custom component in React.js – but behind the scenes it will be the button tag from HTML as we mentioned in styling using styled components.import styled from 'styled-components' const H1 = styled.h1` color: red; ` const DefaultButton = styled.button` background-color: #645cfc; border: none; padding: 10px; color: white; ` function App() { return ( <div> <H1>Styled Components</H1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <DefaultButton>Click ME!</DefaultButton> </div> ); } export default App;We can also keep our files clean by making a different file for each different component in styled components. Yes! We can do that in here.We will make new folder called components in src and create the files Title.js and Buttons.js to separate the styling for title and buttons.We will copy the H1 style and paste it into Title.js and copy DefaultButton style and paste it in Buttons.js.In Title.js we will export it as default. But in Buttons.js we will name the export because we will create multiple button styles in here.When we are exporting a component as default, then its import is a regular import as shown below:import H1 from './components/Title'But when the export is a named export (you can see the named export in Button.js in the above image), then while importing that component we have to wrap the component name in curly braces ({}) as shown below:import {DefaultButton} from './components/Buttons'Now our App.js looks like this:import H1 from './components/Title' import {DefaultButton} from './components/Buttons' function App() { return ( <div> <H1>Styled Components</H1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <DefaultButton>Click ME!</DefaultButton> </div> ); } export default App;Props in Styled ComponentsNow for those of you who know props from React, you're in luck – pops in styled components work similarly. If you don't know what props are, don't worry – I'll introduce them here.Now, we learned to create custom components in styled components. Those custom components can have attributes which we can access in components. It might be a bit confusing to beginners but let's see it in code:import H1 from './components/Title' import {DefaultButton} from './components/Buttons' function App() { return ( <div> <H1>Styled Components</H1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <DefaultButton>Click ME!</DefaultButton> <DefaultButton red>Click ME!</DefaultButton> </div> ); } export default App;In the above code, I created one more Default button. But can you see difference between those 2 buttons. Yes! We have something written after DefaultButton, which is red. It's called an attribute.Now by accessing the attribute in DefaultButton we can change the styling based on these attributes. Let's do it!import styled from 'styled-components' export const DefaultButton = styled.button` background-color: ${(props) => (props.red && 'red') || '#645cfc'}; border: none; padding: 10px; color: white; ` We are already in a template literal (backticks). So we can write JavaScript inside it. We used the dollar ($) sign and curly braces to write the JavaScript. In those curly braces we declared an arrow function which has a props parameter which can access attributes of custom components.So the arrow function says that if the red attribute is given, then the background-color should be red or else it should be a blueberry color.App.jsimport H1 from './components/Title' import {DefaultButton} from './components/Buttons' function App() { return ( <div> <H1>Styled Components</H1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <DefaultButton>Click ME!</DefaultButton> <DefaultButton red>Click ME!</DefaultButton> </div> ); } export default App;We can also destructure props by attribute name. Above, we gave DefaultButton an attribute of red and we accessed it with props.red.Instead of accessing it with props.red we could destructure the prop with {} and the attribute name. Refer to the below code to get a good understanding.import styled from 'styled-components' export const DefaultButton = styled.button` background-color: ${({red}) => (red && 'red') || '#645cfc'}; border: none; padding: 10px; color: white; ` Now we can access props directly as red rather that props.red.How to Extend Styles in Styled ComponentsWe know how to write custom styled components. But what if we want to use the DefaultButtons style that instead has 100% width of the button? We can do that using extended styles in styled components.It's simple: we just have to create a new component in Buttons.js . And we'll use styled.<html Tag>, instead of styled(DefaultButton). Now our new component will have added the styles of DefaultButton and some of new styles of its own.export const ExtendedButton = styled(DefaultButton)` display: block; width: 100vw; `App.jsimport H1 from './components/Title' import {DefaultButton, ExtendedButton} from './components/Buttons' function App() { return ( <div> <H1>Styled Components</H1> <p>Cillum culpa deserunt enim et eiusmod quis proident consequat tempor ipsum sunt esse.</p> <DefaultButton>Click ME!</DefaultButton> <ExtendedButton red>Click ME!</ExtendedButton> </div> ); } export default App;How to Nest Styles in Styled ComponentsWe can write more complex styles in React using one custom component. This will help you even more and make styling simple. Refer to the following code:import styled from 'styled-components' function App() { return ( <div> <Wrapper> <h1>Another heading</h1> <p>Another para</p> <button>Another button</button> </Wrapper> </div> ); } const Wrapper = styled.div` h1{ text-align: center; color: violet; } p{ font-size: 40px; } button{ background-color: pink; padding: 4px 8px; border: none; } ` export default App;When we implement the wrapper component, all paragraph tags inside the wrapper will have a font-size of 40px and the button will have background color of pink, padding as mentioned, and no border. This will help you tremendously when writing your code.How to Extend React ComponentsWe can also extend React components using styled components. It is pretty similar to nesting styles. Here's an example:import React from 'react' import styled from 'styled-components' const Newcom = () => { return ( <div> <h2>Heading 2</h2> <button>Click Me!</button> </div> ) } const Wrapper = styled(Newcom)` h2{ color: green; text-align: center; } button{ padding: 4px 10px; background-color: violet; border: none; } ` export default WrapperWhen we write styles using styled components, we have to just extend React components like extending styles. When we're extending styles, we write the name of the extended style. Here we will write the name of the component to extend as shown in the above code.But still it's not working. If we inspect we will see our HTML but with no class. In React components there is no class. So you need to add props to the React component and console.log() those props.You will see our gibberish class name with the key:value pair, like className : gibberish-classname. So now using that we will destructure the props and give a className to the div of that component of className. Refer to the below example:import React from 'react' import styled from 'styled-components' const Newcom = ({className}) => { return ( <div className={className}> <h2>Heading 2</h2> <button>Click Me!</button> </div> ) } const Wrapper = styled(Newcom)` h2{ color: green; text-align: center; } button{ padding: 4px 10px; background-color: violet; border: none; } ` export default WrapperEven after using styled components for styling you can use global styling.Just remember that if your global styling and styled component styling are the same, React will pick the styled component styling.CSS VariablesRepeating the same color is annoying. What if I have red in many places and now I want all that red changed to blue? It is a time consuming task to do manually, one by one.Luckily, CSS variables come to our rescue. Now create an index.css file in the src folder. Import it in index.js.import './index.css';Now we will write some CSS variable in index.css which are global styles accessible from everywhere. The most interesting thing is that we can have access to CSS variables in styled component as well.index.css:root{ --primary-color: #8F00FF }Now :root{} is just like selecting html{} in CSS. But :root{} has more specificity than html{}. We can now use this variable in our styled component:const Wrapper = styled(Newcom)` h2{ color: green; text-align: center; } button{ padding: 4px 10px; background-color: var(--primary-color); border: none; } ` How to Add a ThemeNowadays, light themes and dark themes are pretty popular. We can do this easily in styles components.First we need to import ThemeProvider from styled components. Then we will wrap the whole app in ThemeProvider with the theme attribute in which we will provide our theme. Then we can toggled it with React.import styled, {ThemeProvider} from 'styled-components' import Sample from "./components/Sample"; const baseTheme = { background: '#fff', color: '#222', } const darkTheme = { background: '#222', color: '#fff', } function App() { return ( <ThemeProvider theme={darkTheme}> <p>This is sample paragraph</p> </ThemeProvider> ); }Still, we don't get our dark theme. For that we need to add a new custom styled component. You can name it anything you want but, I'm gonna name it Container.In the container, we can access the theme and its properties and help the user change the background color and color of text. These are the only major things to switch in between dark and light mode.import styled, {ThemeProvider} from 'styled-components' import Sample from "./components/Sample"; const baseTheme = { background: '#fff', color: '#222', } const darkTheme = { background: '#222', color: '#fff', } const Container = styled.div` color: ${(props) => props.theme.color}; background-color: ${(props) => props.theme.background}; ` function App() { return ( <ThemeProvider theme={darkTheme}> <Container> <p>This is sample paragraph</p> </Container> </ThemeProvider> ); }Take a look at our Container. We are accessing the theme and changing the color and background-color when the theme changes. And here you go, a simple way to have themes on your next project.Animation in Styled ComponentsAnimation is important in frontend development. We will learn to implement animation in styled components with an example.First we have to import keyframes from styled-components. Once that's done we will use it to create animations.import styled, {keyframes} from 'styled-components' const spinner = keyframes` to{ transform: rotate(360deg); } ` const Loading = styled.div` width: 6rem; height: 6rem; border: 5px solid #ccc; border-radius: 50%; border-top-color: black; animation: ${spinner} 0.6s linear infinite; ` export default LoadingIn the above code, we have spinner in which we declared the animation and spinner is the animation name. In loading, we are using that spinner animation name so that Loading will use that animation. In loading I have use a shorthand property to declare the animation.How to Use as in Styled ComponentsIf I have a button and I give it an href attribute which we use to link to another website, it will not work. This is because the href attribute belongs to the anchor tag.import React from 'react' import {DefaultButton} from './components/Buttons' const App = () => { return ( <div> <DefaultButton href="https://www.google.com">Click</DefaultButton> </div> ) } export default AppBut in styles component using as we can make the given component act like an HTML tag provided as a value to as. Let's see it in action.import React from 'react' import {DefaultButton} from './components/Buttons' const App = () => { return ( <div> <DefaultButton as='a' href="https://www.google.com">Click</DefaultButton> </div> ) } export default AppNow DefaultButton is an anchor () tag. It will have text-decoration because in the default anchor tag it has text-decoration. But I am sure now you can work that out. When we click on our DefaultButton it will open Google.CSS and styled-componentsNow we can directly give styles to components using CSS as an object of the component called css props .import React from 'react' import styled from 'styled-components' const App = () => { return ( <div> <h2 css={`color: green`}>Hello World!!!</h2> </div> ) } export default AppBut the above code won't work. Because we need to import styled-components/macro to activate the styling method which uses Babel. Check out the complete code below:import React from 'react' import styled from 'styled-components/macro' const App = () => { return ( <div> <h2 css={`color: green`}>Hello World!!!</h2> </div> ) } export default AppCSS Helper Functions in Styled ComponentsWe have learned a lot about styled components. But there are more efficient ways to tackle some problems – and one of them is using a CSS helper function.Suppose you want a DefaultButton and a large DefaultButton. Based on what we've learned up until now, we would say we should give large as a prop and change the styling based on that prop.But think about it – we need to make changes to multiple properties. So a CSS helper function comes to our rescue.App.jsimport React from 'react' import styled from 'styled-components/macro' import {DefaultButton} from './components/Buttons' const App = () => { return ( <div> <DefaultButton>Hello</DefaultButton> <DefaultButton large>Hello</DefaultButton> </div> ) } export default AppButtons.jsimport styled, {css} from 'styled-components/macro' export const DefaultButton = styled.button` background-color: ${({red}) => (red && 'red') || '#645cfc'}; border: none; color: white; display: block; margin: 10px; ${({large}) => large? css` padding: 15px; font-weight: 800; ` : css` padding: 10px; font-weight: 400; `} ` Take a look at the above code. First we passed a prop as large from app.js in DefaultButton component. Then using the ternary operator in Button.js we styled the component. It says that if large is given a prop, implement the first styling or else implement the second styling. This follows the DRY (Don't Repeat Yourself) principle.Default Attributes (attrs) in Styled ComponentsWe have attributes on some elements in HTML. For example on button, we have type="submit" or type="button". But every time we have to set them manually.import React from 'react' import styled from 'styled-components' const Button = styled.button` border: none; padding: 5px 10px; background-color: #87CD11; margin: 10px; ` const App = () => { return ( <div> <Button type="button">Click!</Button> <Button type="submit">Submit</Button> </div> ) } export default AppHere, default attributes come in handy. We can pass an object or function to them. But if we pass objects to attributes, then they will be static. To have dynamic control, we will pass a function to the attribute.import React from 'react' import styled from 'styled-components' const Button = styled.button.attrs((props) => { return {type: props.type || "button"} })` border: none; padding: 5px 10px; background-color: #87CD11; margin: 10px; ` const App = () => { return ( <div> <Button>Click!</Button> <Button type="submit">Submit</Button> </div> ) } export default AppIn the above code, we set attributes to button. This says that if the type is given then it will set that type to the given props – or if no props are given it will set it to button by default.As a challenge, you can go ahead and use a CSS helper function to set a different style based on the type of button.Wrapping UpI hope you now understand how to use Styled Components in your projects. Do let me know what you think. Thank you for reading!You can follow me on:TwitterLinkedInInstagram

But before we dive into that, we need to make sure you understand what Synchronous code is and how it works.

What is Synchronous Code?

When we write a program in JavaScript, it executes line by line. When a line is completely executed, then and then only does the code move forward to execute the next line.

Let's look at an example of this:

let greet_one = "Hello"
let greet_two = "World!!!"
console.log(greet_one)
for(let i=0;i<1000000000;i++){
}
console.log(greet_two);

Now if you run the above example on your machine you will notice that greet_one logs first. Then the program waits for a couple of seconds and then logs greet_two. This is because the code executes line by line. This is called synchronous code.

This creates lot of problems. For example, if a certain piece of code takes 10 seconds to execute, the code after it won't be able to execute until it's finished, causing delays.

What is Asynchronous Code?

With asynchronous code, multiple tasks can execute at the same time while tasks in the background finish. This is what we call non-blocking code. The execution of other code won't stop while an asynchronous task finishes its work.

Let's see an example of asynchronous code:

let greet_one = "Hello"
let greet_two = "World!!!"
console.log(greet_one)
setTimeout(function(){
    console.log("Asynchronous");
}, 10000)
console.log(greet_two);

In the above example, if you run the code on your machine you will see greet_one and greet_two logged even there is code in between those 2 logs.

Now, setTimeout is asynchronous so it runs in background, allowing code after it to execute while it runs. After 10 seconds, Asynchronous will print because we set a time of 10 seconds in setTimeout to execute it after 10 seconds.

In this tutorial, we will study asynchronous JavaScript in detail so you can learn how to write your own asynchronous code. I just wanted to give you a taste of async JavaScript using in-built functions to whet your appetite.

How Callbacks Work in JavaScript

"A callback function is a function passed into another function as an argument, which is then invoked inside the outer function to complete some kind of routine or action." (MDN)

Let's look at a code example to see why using callbacks instead would be helpful:

function compute(action, x, y){
    if(action === "add"){
        return x+y
    }else if(action === "divide"){
        return x/y
    }
}

console.log(compute("add",10,5))   
console.log(compute("divide",10,5))

In the above example, we have two operations. But what if we want to add more operations? Then the number of if/else statements would increase. This code would be lengthy, so we use callbacks instead:

function add(x,y){
    return x+y
}

function divide(x,y){
    return x/y
}

function compute(callBack, x, y){
    return callBack(x,y)
}

console.log(compute(add, 10, 5))    // 2
console.log(compute(divide, 10, 5))

Now when we call compute with three arguments, one of them is an operation. When we enter in the compute function, the function returns a function with a given action name. It, in response, calls that function and returns the result.

Welcome to Callback Hell

Callbacks are great, but you don't want to use them excessively. If you do, you'll get something called "callback hell". This happens when you nest callbacks within callbacks many levels deep.

The shape of callback hell is like a pyramid and is also called the “pyramid of doom”. It makes the code very difficult to maintain and understand. Here's an example of callback hell:

setTimeout(() =>{
    console.log("One Second");
    setTimeout(() =>{
        console.log("Two Seconds");
        setTimeout(() =>{
            console.log("Three Seconds");
            setTimeout(() =>{
                console.log("Four Seconds");
                setTimeout(() =>{
                    console.log("Five Seconds");
                }, 1000)
            }, 1000)
        }, 1000)
    }, 1000)
}, 1000)

When one second has passed, the code logs "one seconds". Then there's another call which runs after one more second and logs "two seconds" and it goes on and on.

We can escape this callback hell using something call Promises in asynchronous JavaScript.

How Promises Work in JavaScript

A promise is placeholder for the future result of an asynchronous operation. In simple words, we can say it is a container for a future value.

When using promises, we don't need to relay on callbacks which helps us avoid callback hell.

Before showing you how promises work through code, I'll explain promises using the analogy of a lottery ticket.

Promises are like lottery ticket. When we buy a lottery ticket, it says we will get money if our outcome is right. This is like a promise. The lottery draw happens asynchronously, and if the numbers match, we receive the money which was promised.

Now let's look at a code example:

const request = fetch('https://course-api.com/react-store-products')
console.log(request);

The above code is using fetch for a request from an API. It returns a promise which will get a response from the server.

This is how a promise looks. It has a particular promise state and result. When a promise is created it runs asynchronously. When the given task is completed, then we say the promise is settled. After the promise is settled, we can have either a fulfilled or rejected promise state based on the outcome of the promise. We can handle these different states in different ways in our code.

How to Consume Promises

We can consume a promise using the then() method on the promise. Producing code is code that can take some time to complete. Consuming code is code that must wait for the result.

So if we consume a promise, this means that when we make a request, we wait for the result. Then after result arrives, we perform some operation on those results.

Let's continue using the above example to understand how we can consume a promise.

const request = fetch('https://course-api.com/react-store-products').then((response) =>{
    console.log(response);
    return response.json()
}).then((data) =>{
    console.log(data);
})

We make a request to the country API. Then, after the fetch request, we use the then() method to consume the promise. After that, we return a bunch of information like header, status, and so on (you can see it in the below output image).

So we specifically need data which we need to convert to JSON which returns a promise. The data which is returned when we make a API request gets returned in the form of a promise.

To handle that promise, we again use the then() method to log data from the response. Using multiple then() methods on a single request is called chaining promises.

How to Handle Rejected Promises

Consuming promises is good and all, but it's also very important to learn how to handle rejected promises. In real world situations, there could be times when our app crashes due to not handling rejected promises properly.

So let's take an example: we will put our promises in a function called call(). In HTML, we will create a button and add an event listener to it. When we click on the button it will call the call() function.

Here's what that looks like:

index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Promises</title>
</head>
<body>

    <button class="btn">Request</button>
    <script src="./script.js"></script>
</body>
</html>

script.js:

function call(){

    const request = fetch('https://course-api.com/react-store-products').then((response) =>{
        console.log(response);
        return response.json()
    }).then((data) =>{
        console.log(data);
    })

}

const btn = document.querySelector("button")
btn.addEventListener("click", function(){
    call();
})

Why are we doing this? We are setting the promise up to get rejected. Once we run this code, go to inspect and select the network tab. Set No throttling to offline and click on the button to send the request. You will get a rejected promise.

Once we click on the button, we will get error which is caused by no internet connection.

This situation can happen in the real world if a user's internet connection is slow. We are making an API request for which we need internet with decent speed. Sometimes the client might have an issue with their internet. This can lead to rejected promises which will throw an error which we haven't seen how to handle yet.

Now we will learn to handle this error. We used then() to consume our promises. Similar to that, we will chain the catch() method to that promise. Take a look at the following code:

function call(){

    const request = fetch('https://course-api.com/react-store-products').then((response) =>{
        console.log(response);
        return response.json()
    }).then((data) =>{
        console.log(data);
    }).catch((err) =>{
        alert(err);
    })

}

const btn = document.querySelector("button")
btn.addEventListener("click", function(){
    call();
})

Now the catch() method will get an error from the rejected promise and will display the message in an alert.

We get the error because we got a rejected promise which indicates that there is some issue. We can do whatever we want in the catch() block when we encounter an error.

Along with the catch() method, there is one more helpful method called finally(). We can chain it to promises which will run no matter whether the promise is accepted or rejected.

function call(){

    const request = fetch('https://course-api.com/react-store-products').then((response) =>{
        console.log(response);
        return response.json()
    }).then((data) =>{
        console.log(data);
    }).catch((err) =>{
        console.log(err);
    }).finally(() =>{
        console.log("Will always run");
    })

}

const btn = document.querySelector("button")
btn.addEventListener("click", function(){
    call();
})

We can use this finally() method for clearing things after the API call. There are many ways to use the finally() method.

How to Create a Promise

We know how to consume promises, but what about creating your own promises? You can do that using new Promise().

You might wonder - why do we need our own promises? Firstly, promises are asynchronous in nature. We can create any task to be asynchronous by creating our own promises. Wecan handle them using the then() and catch() methods that we learned in the above section.

Once you know how to create promises, you can make any piece of code asynchronous. Then it will not block code execution if the other code running is taking a long time to complete.

Let's see how this works using an example:

let lottery = new Promise(function(resolve, reject){
    console.log("Lottery is happening");

    setTimeout(() => {
        if(Math.random() >= 0.5){
            resolve("You Won!!!")
        }
        else{
            reject(new Error("Better luck next time"))
        }
    }, 5000);

})

First we created a promise using new Promise(). It will have a function with two arguments, resolve and reject.

We will call resolve when our task is successful, and reject when the task is unsuccessful. We will use the lottery terminology that I used to explain the concept of promises in the above section.

Let's say if Math.random() gives a value below or equal to 0.5, we will win the lottery. Otherwise we will lose the lottery. If the condition is not true, the code throws a new error for better understanding of the error in the console. So we can throw our own custom errors to the user for better understanding.

In the example above, if Math.random() is less than 0.5, that means the user lost the lottery. So we throw our custom error Better luck next time so that the user understands that they lost the lottery.

Now we will try to consume the promise that we created.

let lottery = new Promise(function(resolve, reject){
    console.log("Lottery is happening");

    setTimeout(() => {    
        if(Math.random() >= 0.5){
            resolve("You Won!!!")
        }
        else{
            reject(new Error("Better luck next time"))
        }   
    }, 5000);

})

lottery.then((response) =>{
    console.log(response);
}).catch((err) =>{
    console.log(err);
})

We consume the promise using the then() method. It will print the response that we provided in resolve(). If the promise is rejected we will catch the error in the catch() method. The error will come from the reject() argument that we mentioned in our own promise.

How to Consume Promises using Async/await

Consuming promises using the then() method can become messy sometimes. So we have an alternative method to consume promises called async/await.

Just keep in mind that async/await will be using the then() method behind the scenes to consume promises.

Why use async/await if we have the then() method? We use async/await because it's easy to use. If we start chaining methods to promises using the then() method the chain will be very long and gets complex with the addition of multiple then() methods. So async/await is simpler.

Here's how async/await works:

const fetchAPI = async function(){
    const res = await fetch('https://cat-fact.herokuapp.com/facts')
    const data = await res.json()
    console.log(data);
}
fetchAPI()
console.log("FIRST");

In the above code, we first call the fetchAPI() to see the async behavior of the function. Then it logs "FIRST". So according to asynchronous JavaScript, fetchAPI() should be running in the background and not block the execution of the code. As a result, "FIRST" logs and then the result of fetchAPI is displayed.

Now, if you want to handle asynchronous tasks in your functions, you have to make that function asynchronous using the async keyword before the function. Wherever promises are returned we have to use await before it to consume promises.

Now you might be thinking, how should we handle errors? For that we can use try...catch() to handle errors in async/await.

Error Handling with try...catch()

We can use try...catch() in vanilla JavaScript as well. But it can also help us handle errors in asynchronous JavaScript with async/await.

try...catch() is similar to the catch() method in then() using the catch() chaining method. Here we will try the code in the try block. If that runs successfully then there is no problem.

But if the code in the try block has an error, we can catch it in the catch block. We can check for errors in the try block and throw our custom error which will be caught in catch block. Once we catch the error in the catch block we can do whatever we want when we encounter an error.

Let's see how it works with the code example we've been using.

const fetchAPI = async function(){
    try{
        const res = await fetch('https://cat-fact.herokuapp.com/fact')
        if(!res.ok){
            throw new Error("Custom Error")
        }
        const data = await res.json()
        console.log(data);
    } catch(err){
        console.log(err);
    }
}


fetchAPI()
console.log("FIRST");

First, we wrap the asynchronous code in a try block. Then in the catch block we log the error. In the try block, if res.ok is false we throw our custom error using throw new Error which catch will get. Then we log it to the console.

How to Return Values from Async Functions

So far, we've learned about asynchronous code, the then() and catch() methods, and handling asynchronous code with async/await. But what if we want to return a value from an async function using async/await?

When you're working with asynchronous code, it's often necessary to return a value from an async function so that other parts of your program can use the result of the asynchronous operation.

For example, if you're making an HTTP request to fetch data from an API, you'll want to return the response data to the calling function so that it can be processed or displayed to the user.

Well, we can do that. Take a look at the below example:

const fetchAPI = async function(){
    try{
        const res = await fetch('https://cat-fact.herokuapp.com/facts')
        if(!res.ok){
            throw new Error("Custom Error")
        }
        const data = await res.json()
        console.log(data);
        return "Done with fetchAPI"
    } catch(err){
        console.log(err);
        throw new Error("Custom Error")
    }
}


console.log(fetchAPI())

If we log the fetchAPI we will get back a promise which is fullfilled. You know very well how to handle these promises. We will be doing it using the then() method.

const fetchAPI = async function(){
    try{
        const res = await fetch('https://cat-fact.herokuapp.com/facts')
        if(!res.ok){
            throw new Error("Custom Error")
        }
        const data = await res.json()
        console.log(data);
        return "Done with fetchAPI"
    } catch(err){
        console.log(err);
        throw new Error("Custom Error")
    }
}


fetchAPI().then((msg) =>{
    console.log(msg);
}).catch((err) =>{
    console.log(err);
})

Now when we run our program, we will see our returned msg from the try block using async/await logged in the console.

But what if there was an error in async/await? The fetchAPI with the then() method will still log it and it would be undefined.

To avoid this in the catch block again we throw a new error and use the catch() method to catch that error after the then() method.

Try changing the then() and catch() methods with async/await. This would be a good exercise for you to understand what you've learned in this article.

In JavaScript, there are two common ways to work with asynchronous operations: then/catch method chaining and async/await. Both methods can be used to handle promises, which are objects that represent the eventual completion (or failure) of an asynchronous operation.

then/catch method chaining is a more traditional way to handle asynchronous operations, while async/await is a newer syntax that provides a more concise and easier-to-read alternative.

How to Run Promises in Parallel

Let's say we want to make three requests for three different country capitals. We can do three different fetch calls, each of which will wait for the one above to complete.

const fetchAPI = async function(country1,country2,country3){
    try{
        const res1 = await fetch(`https://restcountries.com/v3.1/name/${country1}`)
        const res2 = await fetch(`https://restcountries.com/v3.1/name/${country2}`)
        const res3 = await fetch(`https://restcountries.com/v3.1/name/${country3}`)


        const data1 = await res1.json()
        const data2 = await res2.json()
        const data3 = await res3.json()
        console.log(data1[0].capital[0]);
        console.log(data2[0].capital[0]);
        console.log(data3[0].capital[0]);
        return "Done with fetchAPI"
    } catch(err){
        console.log(err);
        throw new Error("Custom Error")
    }
}


fetchAPI("canada", "germany", "russia")

In the above code, we are making three fetch calls, then converting them to json() and logging their capitals.

But if you hit inspect and see in the network tab, res2 is waiting for res1 to complete and res3 is waiting for res2 to complete.

This can negatively impact our application's performance. Because if a promise is waiting for another promise to complete it can negatively impact the performance of the website.

To overcome this performance issue, we can use something called **Promise.all** . It will call three fetch requests simultaneously, which in return will reduce our fetching time and improve our application's performance.

How to Use Promise.all()

With the help of Promise.all(), we can run multiple promises in parallel which will boost performance. The promise.all() takes an array as an argument which are promises and run them in parallel.

let promise1 = new Promise((resolve) =>{
    setTimeout(() =>{
       resolve("First Promise")
    }, 2000)
})

let promise2 = Promise.resolve("Second Promise")

let returnedPromises = Promise.all([promise1,promise2]).then((res) =>{
    console.log(res);
})

The result of using promise.all() is that both promises were running in parallel.

Wrapping Up

After reading this tutorial, I hope you have a better understanding of asynchronous JavaScript. Feel free to reach out to me for discussion and suggestions.

You can follow me on:

• Twitter

• LinkedIn

• Instagram

OOP was developed to make code more flexible and easier to maintain.

JavaScript is prototype-based procedural language, which means it supports both functional and object-oriented programming.

What are Classes and Objects in JavaScript?

What is a Class?

You can think of a class like a blueprint of a house. A class is not a real world object but we can create objects from a class. It is like an template for an object.

We can create classes using the class keyword which is reserved keyword in JavaScript. Classes can have their own properties and methods. We will study how to create a class in detail shortly. This is just a high level overview of a class.

Let's take an example. Below is a blueprint for a house (like a class).

Blueprint of House (Class)

What is an Object?

An object is an instance of a class. Now with the help of the house class we can construct a house. We can construct multiple houses with the help of same house class.

Example of Classes and Objects in Action

Let's take a simple example to understand how classes and objects work.

The below example has nothing to do with JavaScript syntax. It is just to explain classes and objects. We will study the syntax of OOP in JavaScript in a bit.

Consider a Student class. Student can have properties like name, age, standard, and so on, and functions like study, play, and do home work.

class Student{
 // Data (Properties)
 Name
 Age
 Standard

 // Methods (Action)
 study(){
 // Study
 }

 Play(){
 // Play
 }

 doHomeWork(){
 // Do Home Work
 }

}

With the help of the above class, we can have multiple students or instances.

Here's info for **Student - 01**:

// Student 1
{
Name = "John"
Age = 15
Standard = 9

study(){
 // Study
 }

 Play(){
 // Play
 }

 doHomeWork(){
 // Do Home Work
 }

}

Here's info for **Student - 02**:

// Student 2
{
Name = "Gorge"
Age = 18
Standard = 12

study(){
 // Study
 }

 Play(){
 // Play
 }

 doHomeWork(){
 // Do Home Work
 }

}

How Do We Actually Design a Class?

There is no perfect answer to this question. But we can get help from some OOP principles when designing our classes.

There are 4 main principles in OOP, and they are:

• Abstraction

• Encapsulation

• Inheritance

• Polymorphism

We will dive deep into these concepts in JavaScript below. But first, let's get a high level overview of these concepts to understand them better.

What Does Abstraction Mean in OOP?

Abstraction means hiding certain details that don't matter to the user and only showing essential features or functions.

For example, take a cell phone. We don't show details like verifyTemperature(), verifyVolt(), frontCamOn(), frontCamOff() and so on. Instead we provide essential features which matter to user like camera(), volumeBtn(), and others.

What Does Encapsulation Mean in OOP?

Encapsulation means keeping properties and methods private inside a class, so that they are not accessible from outside that class.

This will keep code that's outside the class from accidentally manipulating internal methods and properties.

What Does Inheritance Mean in OOP?

Inheritance makes all properties and methods available to a child class. This allows us to reuse common logic and to model real-world relationships. We will discuss inheritance in further section of this article with pratical example.

What Does Polymorphism Mean in OOP?

Polymorphism means having different and many forms. We can overwrite a method inherited from a parent class.

// Not actual JavaScript syntax
class User{
email 
password

login(providedPassword){
    // Login User
}

checkMessage(){
// Check any new message
}
}

// Not actual JavaScript syntax
class Admin inherit user{
email // Inherited Property
password // Inherited Property
permissions // Own Property

// Inherited Method
login(providedPassword){
    // Different Login User
}

// Inherited Method
checkMessage(){
// Check any new message
}

// Own Method
chechStats(){
// Check Stats
}
}

The Login method in Admin is different from the inherited class user.

Object-Oriented Programming in JavaScript

We have now discussed the basics of OOP. But OOP in JavaScript is bit different. We have an object linked to a prototype. Prototypes contain all methods and these methods are accessible to all objects linked to this prototype. This is called Prototypal Inheritance (or Prototypal Delegation).

What is Prototypal Inheritance in JavaScript?

You have likely already used Prototypal Inheritance without knowing it – for example, if you've used methods on arrays like push(), pop(), map() and so on (which are available on all arrays).

If we go to the official documentation we will see Array.prototype.map() because Array.prototype is a prototype of all array objects that we create in JavaScript. This is an example of prototypal inheritance that we are going to learn to implement.

Just like Array.prototype we will create our own prototypes and this will help you understand JavaScript inside out.

Prototype of an Array

How to Implement Prototypal Inheritance in JavaScript

There are three main ways to implement Prototypal Inheritance in JavaScript:

Using Constructor Functions

We can create objects from a function. With the help of a constructor function, built-in objects like arrays, sets, and others are actually implemented.

In JavaScript, a constructor gets called when an object is created using the new keyword. The purpose of a constructor is to create a new object and set its values for any existing object properties

Using ES6 Classes

Classes are an alternative to the constructor function syntax for implementing prototypal inheritance. We also call classes syntactic sugar.

Behind the scenes, classes work exactly like constructor functions. Prior to ES6, JavaScript had no concepts of classes. To mock a class, you often use the constructor or prototype pattern.

Using Object.create()

This is the easiest way to link an object to a prototype object. It is a method used to create a new object with the specified prototype object and properties.

The object.create() method returns a new object with the specified prototype object and properties.

Let's look at these in more detail now:

How to Implement Prototypal Inheritance with Constructor Functions in JavaScript

We will use a function to create prototypal inheritance. We will start by implementing a User function expression. Remember to always start the name of a constructor function with capital letter (standard convention).

function User(name){
    this.name = name;

    // never create function inside constructor function
    this.printName = function(){
        console.log(this.name);
    }

    console.log(this);
}


let kedar = new User("kedar")

Output

Prototype using constructor function

We created a constructor function in the above example. But what is the new keyword? With the help of the new keyword we can create an instance of that constructor.

When we create an instance of the constructor object, an empty object is created ({}). This empty object ({}) is then linked to the prototype.

We should never create a function inside of a constructor function. Because every time an instance is created, a new function is created with it which we created inside the constructor function. This will create major issues for performance.

The solution to this problem is prototypes. We can define a function on the prototype of an object directly. So the object created by using that constructor function will have access to that function.

Example:

function User(name){
    this.name = name;

    console.log(this);
}

User.prototype.printName = function(){
    console.log(this.name)
}


let kedar = new User("kedar")

Prototype using constructor function

In the above output, you can see the printName() method in the prototype of the User constructor function. This is the preferred way to create a function in a constructor function to optimize performance.

So now all objects created by this constructor function will have access to the printName() function.

We can access these functions with objectName.functionName() like this:

function User(name){
    this.name = name;

    console.log(this);
}

User.prototype.printName = function(){
    console.log(this.name)
}


let kedar = new User("kedar")
kedar.printName()

We can access the prototype of the constructor function with the following syntax:

console.log(User.__proto__)

The object prototype is the same as the constructor function prototype. Don't believe me? Check this out:

console.log(kedar.__proto__ === User.prototype) 
// True

console.log(User.prototype.isPrototypeOf(kedar))
// True

The prototype of User is the prototype used by its object and doesn't belong to User.

console.log(User.prototype.isPrototypeOf(User))
// False

We can also link a variable to prototype:

User.prototype.species = "Homo Sapiens"

Now this variable belong to prototype and not to object. We can check this by using hasOwnProperty().

Prototypal Inheritance of Built-in Objects

We have many methods available to use on arrays. How does this work?

The answer is prototypal inheritance. When we create a new array, every time it inherits from Array.prototype. That is how we have access to all those different methods.

const arr = [1,2,3,4,5]
console.log(arr)

Prototype of an Array

We can also attach our own method to Array.prototype so that whenever we create new array we will have access to that method.

const arr = [1,2,4,4,5,5]

Array.prototype.unique = function(){
    return [...new Set(this)]
}

console.log(arr.unique());

Prototype of an Array with custom unique() method added to prototype.

How to Implement Prototypal Inheritance with ES6 Classes in JavaScript

We can implement OOP using classes, but behind the scenes it uses prototypal inheritance. This method was introduced to make sense to people coming from other languages like C++ and Java.

We will implement the User classes from the above example:

// Class Expression
class User = class{

}

// Class Declaration
class User{

}

In the above example, we can see that there are 2 ways to implement a class in JavaScript. You can choose either one according to your preference.

Inside the class, the first thing we need to do is add a constructor method. The constructor can also take arguments.

class User{
    constructor(name){
        this.name = name
    }

    printName(){
        console.log(this.name);
    }
}

const kedar = new User("kedar")

Prototype using ES6 Class

Remember that whenever we create an object of a class, a constructor is invoked first. If there is no constructor, the default constructor is invoked which does nothing.

3 things to remember about classes

• Classes are not hoisted (if you don't know what hoisting is, read this guide)

• Classes are first-class citizens (If a programming language has the ability to pass a function as an argument – to treat functions as values and to return functions – it is said that the language has first-class functions and those function are called first-class citizens)

• Classes are executed in strict mode. (If you don't know what strict mode is, read this guide)

What are Setters and Getters?

These are simple methods of classes which will get and set a value. But from the outside they look like simple methods. Let's take a look at the below example.

class User{
    constructor(name){
        this._name = name
    }

    get getName(){
        console.log(this._name)
    }

    set setName(newName){
        this._name = newName
    }
}

const kedar = new User("kedar")
kedar.setName = "John"
kedar.getName

In above example, you can see the getter getName logs a name. Setters are used to set the value of an existing property. When setting a name using setter, we have to use (_) before the name of the property as a convention.

How to Use Static Methods

Static methods are bound to a class and not to the instances of class or object of the class. We can access static methods through classes only and not through the object of that class.

class User{
    constructor(name){
        this._name = name
    }

    static anonymous(){
        console.log("anonymous");
    }
}

const kedar = new User("kedar")
kedar.anonymous() // error
User.anonymous() // "anonymous"

We can directly create static methods inside classes using the static keyword before the method name. In the above example, notice that we can only call the static method on a class and not on a class object.

There is one more way to implement a static method:

class User{
    constructor(name){
        this._name = name
    }
}

User.anonymous = function(){
    console.log("anonymous");
}

const kedar = new User("kedar")
kedar.anonymous() // error
User.anonymous() // "anonymous"

How to Implement Prototypal Inheritance with Object.create() in JavaScript

The Object.create() static method creates a new object, using an existing object as the prototype of the newly created object.

const User = {
    init(name){
        this.name = name
    },

    printName(){
        console.log(this.name);
    }
}

let kedar = Object.create(User)
kedar.init("kedar")
kedar.printName()

The newly created object will inherit all the prototype object's properties. You can specify a second parameter to add new properties to the object, that the prototype lacked:

const newObject = Object.create(prototype, newProperties)

const User = {

    printName(){
        console.log(this.name);
    }
}

let properties = {
    name: {
        value:"John"
    }

}

let John = Object.create(User,properties)
John.printName()

How Inheritance Works in JavaScript

Inheritance enables you to define a class/object that takes all the functionality from a parent class/object and allows you to add more. Using class inheritance, a class/object can inherit all the methods and properties of another class. It is a useful feature that allows code reusability.

Now we will take a look at inheritance in the constructor function, ES6 classes, and Object.create().

Constructor Function

Let's understand constructor function inheritance by example. If you don't know how inheritance works at a high level, check out the section where we discussed "How Do We Actually Design a Class".

Example:

const User = function(name, password){

    this.name = name
    this.password = password
}

User.prototype.printName = function(){
    console.log(this.name);
}

const Admin = function(name, password){
    this.name = name
    this.password = password
}

Admin.prototype.Stats = function(){
    console.log("Stats");
}

const kedar = new Admin("kedar", 12345)
kedar.Stats()

In the above code, we have 2 constructor functions, and they have some similarities. Still we wrote it twice which violates the DRY (Don't Repeat Yourself) principle. To avoid repeating the same code, we use inheritance.

const User = function(name, password){

    this.name = name
    this.password = password
}

User.prototype.printName = function(){
    console.log(this.name);
}

const Admin = function(name, password, course){
    User.call(this, name, password)
    this.course = course
}

Admin.prototype = Object.create(User.prototype)

Admin.prototype.Stats = function(){
    console.log("Stats");
}

const kedar = new Admin("kedar", 12345, "JavaScript")
kedar.printName()

In the above code, first in the Admin (child) function we attached this to the User (parent) and called it with parameters. Once we did that, we were able to access the name and password fields. But we were not able to access the methods of the parent function. Because we need to connect the prototype of User and Admin.

For that, just after the child function, we pointed the Admin prototype to the User prototype which gave us access to the methods of the parent function (User).

Make sure to point the child (Admin) prototype to the parent (User) function immediately after the child (Admin) function. Because it returns an empty object and removes all methods on the child (Admin) function. So always create methods of the child (Admin) function after pointing the child (Admin) prototype to the parent (User) prototype.

Now let's see how our prototype chain looks:

Prototype Inheritance using constructor function

At the bottom there is an Object prototype. After that we can see there is a User prototype and at the top we see an Admin prototype.

ES6

It is super simple to implement inheritance using ES6 syntax. But remember ES6 uses constructor functions to implement inheritance behind the scenes.

class User{
    constructor(name, password){
        this.name = name
        this.password  =password
    }

    printName(){
        console.log(this.name);
    }
}

class Admin extends User{
    constructor(name, password, course){
        super(name, password)
        this.course = course
    }

    Stats(){
        console.log("Stats");
    }
}

const kedar = new Admin("kedar", 123456, "JavaScript")
kedar.printName()

So we have 2 classes, User and Admin. When we want to inherit, we simply add extends and the class we want to inherit from in-front of the child class similar to the syntax shown in the above code.

When we are done with that, in the constructor of the child class, we call the super() method to pass an argument to the parent class which is required. That's how we can implement inheritance in JavaScript using ES6 syntax.

We can also override the parent method by implementing a method with the same name in the child class.

class User{
    constructor(name, password){
        this.name = name
        this.password  =password
    }

    printName(){
        console.log(this.name);
    }
}

class Admin extends User{
    constructor(name, password, course){
        super(name, password)
        this.course = course
    }

    Stats(){
        console.log("Stats");
    }

    printName(){
        console.log("Child class " + this.name)
    }
}

const kedar = new Admin("kedar", 123456, "JavaScript")
kedar.printName()

Object.create()

Implementing inheritance in Object.create() is simple. Check out the code below:

const User = {
    printName(){
        console.log(this.name);
    },

    init(name, password){
        this.name = name
        this.password = password
    }
}

const Admin = Object.create(User)
Admin.init = function(name, password, course){
    User.init.call(this, name, password)
    this.course = course
}

Admin.stats = function(){
    console.log("Stats");
}

const kedar = Object.create(Admin)
kedar.init("kedar", 123456)
kedar.printName()
kedar.stats()

Prototype Inheritnace using Object.create()

First, we created a User function. Then we created an Admin pointing to User with the help of Object.create(). With the help of the Admin.init() method we called the init() method of User and passed values to the parent function.

How Encapsulation Works in JavaScript

Above, we looked at what encapsulation means at a very high level. Now we will look at an example to explain it more thoroughly.

Encapsulation can be defined as “the packing of data and functions into one component”. This is also known as grouping or bundling, and simply means to bring together data and the methods which operate on data. It can be a function, a class, or an object.

Encapsulation enables “controlling access to that component”. When we have the data and related methods in a single unit, we can control how is it accessed outside the unit. This process is called Encapsulation**.**

Protected properties

class User{
    constructor(name, password){
        this._name = name
        this._password = password
    }
}

const kedar = new User("kedar", 123456)
console.log(kedar._password);

A protected member is accessible within the class and any object that inherits from it. A protected value is shared across all layers of the prototype chain.

We used (_) in this._name , which is a protected property. We can still access this property outside of the class. This is just a convention programmers use.

If we know there is (_) in a property name we are not supposed to manipulate that property from outside the class.

class User{
    constructor(name, password){
        this._name = name
        this._password = password
    }

    get getName(){
        console.log(this._name)
    }
}

const kedar = new User("kedar", 123456)
kedar.getName

Private properties

class User{
    constructor(name, password){
        this.#name = name
        this._password = password
    }

    get getName(){
        console.log(this._name)
    }
}

const kedar = new User("kedar", 123456)
console.log(kedar.#name);

To implement a truly private property in JavaScript we have to use (#) before the property name or method. These private properties and methods will not be accessible from outside of class which will make them truly private.

This will help restrict accessing properties from outside of the class. If we want to access property from outside we have to make method which will only print properties without giving access to change value of that property.

class User{
    #name

    constructor(name, password){
        this.#name = name
        this._password = password
    }

    #printName(){
        console.log(this.#name);
    }

    PrintFromPrivateMethod(){
        this.#printName()
    }
}

const kedar = new User("kedar", 123456)
kedar.PrintFromPrivateMethod()

Wrapping Up

I hope you now understand how OOP works in JavaScript. Thank you for reading!

You can follow me on:

• Twitter

• LinkedIn

• Instagram