We've all been there, scrambling at 3 AM trying to figure out why the server crashed. The worst part? Finding out your users knew about the problem before you did.

Monitoring shouldn't be complicated, but most solutions are either expensive enterprise tools or a patchwork of scattered scripts that barely work together. That's where the Prometheus stack comes in.

I discovered this setup after years of juggling different monitoring tools that never quite clicked. Prometheus handles the data collection, Grafana makes it beautiful and actionable, Alertmanager notifies you before things spiral, and Node Exporter watches your system's every heartbeat.

The best part? It's all free, open-source, and actually works the way you'd expect it to.

In this guide, I'll show you exactly how to set up this entire monitoring stack from scratch. No fluff, no assumptions, just a clear path to building something that'll genuinely make your life easier.

By the end, you'll have real-time dashboards, smart alerts, and the kind of visibility that turns firefighting into routine maintenance.

Let's build it.

Prerequisites

Before we begin, ensure you have:

• Ubuntu 24.04.3 or similar Linux distribution (commands may vary slightly for RHEL/CentOS)

• Root or sudo access

• Minimum 2GB RAM and 2 CPU cores (for testing; scale up for production)

• Basic command-line knowledge

• Firewall access to ports: 9090 (Prometheus), 9093 (Alertmanager), 9100 (Node Exporter), 3000 (Grafana)

Update your system first:

bash

sudo apt update && sudo apt upgrade -y

In my case I did not include sudo because I am already withing the root directory so there is no need for that.

Architecture Overview

Before we start installing things, let's understand how these pieces fit together. Think of it like building a house, you need to know what each room does before you start hammering nails.

How It All Works Together

1. Node Exporter - The Data Collector

• Runs on your server and continuously monitors system metrics

• Exposes this data on port 9100 in a format Prometheus understands

• Think of it as a health monitor strapped to your server's wrist

2. Prometheus - The Brain

• Actively scrapes (pulls) metrics from Node Exporter every 15 seconds

• Stores everything in its efficient time-series database

• Runs queries and evaluates alert rules you define

• The central nervous system of your monitoring stack

3. Alertmanager - The Notification Hub

• Receives alerts from Prometheus when something crosses a threshold

• Groups similar alerts together (no spam!)

• Routes notifications to the right people via email, Slack, PagerDuty, etc.

• Your smart assistant that knows when and how to wake you up

4. Grafana - The Dashboard

• Connects to Prometheus and queries the stored metrics

• Transforms boring numbers into beautiful, interactive visualizations

• Lets you create custom dashboards to monitor exactly what matters

• Your mission control center

The Data Flow (A Real Example)

Let's say your CPU usage spikes:

1. Node Exporter detects CPU at 95% and exposes this metric

2. Prometheus scrapes it and sees: node_cpu_usage = 95%

3. Prometheus checks your rule: "Alert if CPU > 80% for 5 minutes"

4. After 5 minutes, Prometheus fires an alert to Alertmanager

5. Alertmanager sends you an email: "High CPU on server-01"

6. You open Grafana, see the CPU graph spiking, and investigate

7. You fix the issue before users even notice

This happens automatically 24/7, while you sleep. Pretty sweet, right?

Ports Reference (Quick Cheat Sheet)

Now that you understand the architecture, let's get our hands dirty and start building.

Installing Prometheus

Step 1: Create a dedicated user

sudo useradd --no-create-home --shell /bin/false prometheus

Step 2: Download Prometheus

Check for the latest version at prometheus.io/download. At the time of writing:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz
tar -xvf prometheus-2.47.0.linux-amd64.tar.gz
cd prometheus-2.47.0.linux-amd64

Step 3: Install binaries and create directories

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir -p /etc/prometheus
sudo mkdir -p /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Step 4: Copy configuration files

sudo cp -r consoles /etc/prometheus/
sudo cp -r console_libraries /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/consoles
sudo chown -R prometheus:prometheus /etc/prometheus/console_libraries

Step 5: Create Prometheus configuration

sudo nano /etc/prometheus/prometheus.yml

Add this basic configuration:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - localhost:9093

rule_files:
  - "first_rules.yml"
  - "second_rules.yml"

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Set ownership:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Step 6: Create systemd service

sudo nano /etc/systemd/system/prometheus.service

Add:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

Step 7: Start Prometheus

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus
sudo systemctl status prometheus

Verify it's running:

curl http://localhost:9090

This output simply means that prometheus is up and accessible on http://localhost:9090

Installing Node Exporter

Step 1: Create dedicated user

sudo useradd --no-create-home --shell /bin/false node_exporter

Step 2: Download Node Exporter

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar -xvf node_exporter-1.6.1.linux-amd64.tar.gz
cd node_exporter-1.6.1.linux-amd64

Step 3: Install binary

sudo cp node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Step 4: Create systemd service

sudo nano /etc/systemd/system/node_exporter.service

Add:

[Unit]
Description=Node Exporter
After=network.target

[Service]
Type=simple
User=node_exporter
ExecStart=/usr/local/bin/node_exporter
Restart=on-failure

[Install]
WantedBy=multi-user.target

Step 5: Start Node Exporter

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter
sudo systemctl status node_exporter

Verify metrics:

curl http://localhost:9100/metrics

Installing Alertmanager

Step 1: Create dedicated user

sudo useradd --no-create-home --shell /bin/false alertmanager

Step 2: Download Alertmanager

cd /tmp
wget https://github.com/prometheus/alertmanager/releases/download/v0.26.0/alertmanager-0.26.0.linux-amd64.tar.gz
tar -xvf alertmanager-0.26.0.linux-amd64.tar.gz
cd alertmanager-0.26.0.linux-amd64

Step 3: Install binaries and create directories

sudo cp alertmanager /usr/local/bin/
sudo cp amtool /usr/local/bin/
sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager
sudo chown alertmanager:alertmanager /usr/local/bin/amtool

sudo mkdir -p /etc/alertmanager
sudo mkdir -p /var/lib/alertmanager
sudo chown alertmanager:alertmanager /etc/alertmanager
sudo chown alertmanager:alertmanager /var/lib/alertmanager

Step 4: Create Alertmanager configuration

sudo nano /etc/alertmanager/alertmanager.yml

Add this basic yaml configuration:

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'web.hook'
receivers:
  - name: 'web.hook'
    webhook_configs:
      - url: 'http://127.0.0.1:5001/'
inhibit_rules:
  - source_match:
      severity: 'critical'
    target_match:
      severity: 'warning'
    equal: ['alertname', 'dev', 'instance']

Set ownership:

sudo chown alertmanager:alertmanager /etc/alertmanager/alertmanager.yml

Step 5: Create systemd service

bash

sudo nano /etc/systemd/system/alertmanager.service

Add:

[Unit]
Description=Alertmanager
Wants=network-online.target
After=network-online.target

[Service]
User=alertmanager
Group=alertmanager
Type=simple
ExecStart=/usr/local/bin/alertmanager \
  --config.file=/etc/alertmanager/alertmanager.yml \

[Install]
WantedBy=multi-user.target

Step 6: Start Alertmanager

sudo systemctl daemon-reload
sudo systemctl start alertmanager
sudo systemctl enable alertmanager
sudo systemctl status alertmanager

Access the CLI:

bash

curl http://localhost:9093

The output shows that both Prometheus and Alertmanager are running properly on my system.
Prometheus is active on port 9090, and Alertmanager is responding on port 9093, which makes my monitoring and alerting setup to be working as expected.

Installing Grafana

Step 1: Add Grafana repository

sudo apt-get install -y software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -

Step 2: Install Grafana

sudo apt-get update
sudo apt-get install -y grafana

Step 3: Start Grafana

sudo systemctl daemon-reload
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo systemctl status grafana-server

Step 4: Access Grafana

Open your browser and navigate to:

http://your-server-ip:3000

Default credentials:

• Username: admin

• Password: admin

You'll be prompted to change the password on first login.

Configuring Prometheus

Verify Prometheus targets

Open Prometheus UI:

http://your-server-ip:9090

Navigate to Status > Targets. You should see:

• prometheus (localhost:9090) - UP

• node_exporter (localhost:9100) - UP

Setting Up Alerting Rules

Step 1: Create Alert rules file

bash

sudo nano /etc/prometheus/alert_rules.yml

Add these yaml rules:

groups:
  - name: system_alerts
    interval: 30s
    rules:
      - alert: InstanceDown
        expr: up == 0
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Instance {{ $labels.instance }} down"
          description: "{{ $labels.instance }} of job {{ $labels.job }} has been down for more than 5 minutes."

      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 30
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High CPU usage on {{ $labels.instance }}"
          description: "CPU usage is above 80% (current value: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: 100 * (1 - ((node_memory_MemAvailable_bytes) / (node_memory_MemTotal_bytes))) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High memory usage on {{ $labels.instance }}"
          description: "Memory usage is above 85% (current value: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: 100 - ((node_filesystem_avail_bytes{mountpoint="/",fstype!="rootfs"} * 100) / node_filesystem_size_bytes{mountpoint="/",fstype!="rootfs"}) > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Disk space low on {{ $labels.instance }}"
          description: "Disk usage is above 90% (current value: {{ $value }}%)"

      - alert: HighNetworkTraffic
        expr: rate(node_network_receive_bytes_total[5m]) > 100000000
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High network traffic on {{ $labels.instance }}"
          description: "Network receiving more than 100MB/s"

Step 2: Configure Alert manager with Gmail

Gmail requires an App Password (not your regular password). Here's how to get it:

1. Go to your Google Account: your prefered google account

2. 

   Click on security on the left sidebar

3. 

   Enable 2-Step Verification if not already enabled

4. 

   Click on the search button and search for app passwords

5. 

   Generate a new password for “Mail” which is what I choose to name this app.

6. 

   Copy the 16-character password

7. 

   Replace ‘Your_App_Password_here’ in the alertmanager.yml with this password without spaces, just fill in the 16 character password that was generated together.

   Run this command:

    sudo nano /etc/alertmanager/alertmanager.yml
   

    global:
      resolve_timeout: 5m
      smtp_smarthost: 'smtp.gmail.com:587'
      smtp_from: 'jhonvictor0077@gmail.com'
      smtp_auth_username: 'jhonvictor0077@gmail.com'
      smtp_auth_password: 'cypjkodrvlztsprk'
      smtp_require_tls: true
   
    route:
      group_by: ['alertname', 'instance']
      group_wait: 10s
      group_interval: 10s
      repeat_interval: 12h
      receiver: 'email-notifications'
   
    receivers:
      - name: 'email-notifications'
        email_configs:
          - to: 'jhonvictor0077@gmail.com'
            headers:
              Subject: 'ALERT: {{ .GroupLabels.alertname }} on {{ .GroupLabels.instance }}'
            html: |
              <h2>Alert Details</h2>
              <p><strong>Alert:</strong> {{ .GroupLabels.alertname }}</p>
              <p><strong>Instance:</strong> {{ .GroupLabels.instance }}</p>
              <p><strong>Severity:</strong> {{ .CommonLabels.severity }}</p>
              <p><strong>Summary:</strong> {{ range .Alerts }}{{ .Annotations.summary }}{{ end }}</p>
              <p><strong>Description:</strong> {{ range .Alerts }}{{ .Annotations.description }}{{ end }}</p>
              <p><strong>Started at:</strong> {{ range .Alerts }}{{ .StartsAt }}{{ end }}</p>
   
    inhibit_rules:
      - source_match:
          severity: 'critical'
        target_match:
          severity: 'warning'
        equal: ['alertname', 'instance']
   

Set ownership:

bash

sudo chown prometheus:prometheus /etc/prometheus/alert_rules.yml

Step 4: Validate configuration

promtool check config /etc/prometheus/prometheus.yml
promtool check rules /etc/prometheus/alert_rules.yml

We should get the above result after running the commands.

Step 5: Reload Prometheus

sudo systemctl restart prometheus

Verify alerts in Prometheus UI: Alerts tab

Creating Grafana Dashboards

Step 1: Add Prometheus data source

1. Log in to Grafana (http://localhost:3000)

2. 

   Go to Configuration (gear icon) > Data Sources

3. 

   Click Add data source

4. Select Prometheus

5. 

   Set URL to: http://localhost:9090

6. 

   Click Save & Test

Step 2: Import Node Exporter dashboard

1. Click + (plus icon) > Import

2. 

   Enter dashboard ID: 1860 (Node Exporter Full)

3. 

   

   Click Load

4. Select your Prometheus data source

5. Click Import

You now have a fully functional comprehensive system monitoring dashboard!

Testing and Verification

Test 1: Verify all services are running

sudo systemctl status prometheus
sudo systemctl status node_exporter
sudo systemctl status alertmanager
sudo systemctl status grafana-server

All the services should be enabled and running, just as shown above.

Test 2: Check Prometheus targets

Navigate to: http://localhost:9090/targets

All targets should show UP status.

Test 3: Trigger a test alert

Create artificial high CPU load:

bash

stress --cpu 4 --timeout 600

Install stress if needed:

sudo apt-get install -y stress

After 5 minutes, you should see the HighCPUUsage alert fire in:

• Prometheus UI (Alerts tab)

• Alertmanager UI (http://your-server-ip:9093)

• Your configured notification channel of which in my case, I used a gmail account (jhonvictor0077@gmail.com)

Test 4: Verify Grafana visualization

1. Open your Grafana dashboard

This was just before we triggered an alert.

2. Check that your metrics are updating in real-time

This was gotten after we triggered an alert. Interestingly, just as we also configured gmail to always notify us when something is up with our monitoring stack, an email notification was also gotten.

5. Monitoring Best Practices

• Keep Prometheus focused: Don't overload with too many targets

• Use service discovery for dynamic environments

• Set appropriate retention: Default is 15 days; adjust based on needs

• Label wisely: Don't use high-cardinality labels (user IDs, timestamps)

• Alert thoughtfully: Too many alerts = alert fatigue

Troubleshooting

Issue: Service won't start

Check logs:

bash

sudo journalctl -u prometheus -f
sudo journalctl -u node_exporter -f
sudo journalctl -u alertmanager -f
sudo journalctl -u grafana-server -f

Common causes:

• Configuration syntax errors

• Port already in use

• Permission issues

• Missing directories

Issue: Targets showing as DOWN

Check connectivity:

bash

curl http://localhost:9100/metrics
curl http://localhost:9090/-/healthy

Check firewall:

sudo ufw status

Verify configuration:

promtool check config /etc/prometheus/prometheus.yml

Issue: No data in Grafana

Verify data source:

• Check Prometheus URL in Grafana

• Test connection in data source settings

• Verify Prometheus is collecting metrics

Check time range:

• Ensure time range in Grafana matches available data

• Prometheus default retention is 15 days

Issue: Alerts not firing

Check alert rules:

promtool check rules /etc/prometheus/alert_rules.yml

Verify in Prometheus UI:

• Go to Alerts tab

• Check if rules are loaded

• Check evaluation status

Check Alertmanager:

curl http://localhost:9093/-/healthy

Issue: High memory usage

Reduce scrape frequency:

global:
  scrape_interval: 30s  # Increase from 15s

Reduce retention:

--storage.tsdb.retention.time=15d

Limit time series:

• Remove unnecessary targets

• Reduce metric cardinality

• Use relabeling to drop unused metrics

Conclusion

This project successfully implemented a complete monitoring and alerting system using Prometheus, Node Exporter, Alertmanager, and Grafana on a Linux environment. We configured real-time metric collection, set up intelligent alert rules with a 30% CPU threshold, and established email notifications through Gmail SMTP integration.

The setup process involved troubleshooting critical issues like hostname resolution and ensuring proper communication between Prometheus and Alertmanager. Each component now works seamlessly together: Node Exporter collects system metrics, Prometheus monitors and evaluates alert conditions, Alertmanager routes notifications, and Grafana provides visual dashboards for data interpretation.

This lightweight and modular infrastructure is ideal for both learning purposes and production environments. The skills gained, including configuration management, alert threshold tuning, and service integration, are directly applicable to real-world DevOps scenarios. This monitoring solution provides the foundation needed to maintain system reliability, respond proactively to issues, and ensure optimal infrastructure performance.

Static websites are a type of website that offers fixed content, irrespective of user interaction or data, having each page coded in HTML, CSS, and sometimes JavaScript. Unlike dynamic websites, this type of website does not have server-side processing; it is secure, fast, lightweight, and also easy to host.
For businesses and developers, hosting a static website with Amazon S3 (Simple Storage Service) may be the perfect fit and an extremely cost-effective approach. With S3, you will be able to upload static files (HTML, CSS, JavaScript, images, etc.) and serve them directly to the internet without needing a web server.

The Key Characteristics of AWS S3 include:

• Scalable storage: Automatically scales to handle any amount of data.

• High Availability: Your website is available with 99.99% uptime.

• Cost-effective: Pay-as-you-go service, perfect for small and large businesses.

• Static Website Hosting: Directly hosts HTML/CSS/JS files.

• Secure: Provides fine-grained access control and encryption.

Amazon Web Services (AWS) makes it easy and affordable to host static websites with Amazon S3 (Simple Storage Service). Whether you're launching a personal portfolio, a documentation hub, or a sleek landing page, S3 delivers fast, reliable, and scalable performance—no servers, no stress.

This blog serves as a guide to help you launch your static website on the AWS Cloud storage platform — S3.

Prerequisites
There are some basic tools we need to set up to successfully host our static website on AWS, and they are:

• Visual Studio Code. You can download it by clicking on this link (VS code)

• An active AWS account

• The folder containing files (HTML, CSS, and JavaScript) for your website.

  With that being said, let’s dive right into it. First off, we are going to create an S3 storage Bucket that will house our static website.

Step 1: Create an S3 Storage Bucket
We need to navigate to the S3 section on AWS to create our bucket

Once we click on the create button, it will take us to another interface where we will give our bucket a name that is globally unique, choose the policy we wish to set for our bucket, and then create the bucket afterwards.

So here, you give your bucket a name that is globally unique.

In this section, we will need to uncheck the ‘Block all public access’ box. The reason for unchecking this box is so that whoever we give the object URL after we have uploaded folders into the bucket can access the content of that bucket.

We have to check the ‘acknowledge that the current settings might result in this bucket and the objects within becoming public’ box.

Afterwards, we scroll all the way down and click on the create bucket button.

Once we are done creating our bucket, we can then upload our object into the S3 bucket.

Step 2: Upload your Website files to the S3 Bucket

Click into the bucket that has already been created

Use either of the upload buttons to upload the website folder to the bucket

After selecting the files, it will show the actual size of all the content and items in that file, then you click on the upload button.

It usually takes a minute or two to upload this size of folder on the S3 bucket; the time spent to upload folders could vary based on the size of the folder or file.

After successfully uploading our folder, we need to click the cancel button to proceed.

Step 3: Enable the Static Website Hosting and Set Bucket Policy for Public Access

First, click on the properties button, then scroll down to where you have Static website hosting.

Click on the edit button

Select enable under Static website hosting, and also select Host a static website under Hosting type.

Fill in index.html and error.html respectively to enter the document file, then save. Now S3 recognizes this bucket as a website.

Furthermore, we will head over to the permission section

Now that our website folder has been uploaded to the bucket, we will need to edit the permission for this bucket so that it can be accessible to whoever we send the object URL to.

Under the Bucket policy, we will click the edit button then fill in the JSON rule for this permission and save it.

Where we have the highlighted name as victordevbucket, edit it and fill in your own bucket name.
Below, is the JSON rule that we used to establish access to this bucket.

NOTE: JSON (JavaScript Object Notation) is the format used to write rules. It is a lightweight, easy-to-read way to structure data using key-value pairs.

So, when we say “JSON in a bucket policy,” we mean a set of access rules written in JSON format that tells the cloud service who can do what with your bucket.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::victordevbucket/*"
    }
  ]
}

After filling in the JSON rule, we save and go ahead to access our website.

Step 4: Accessing the Website
Now, we will go back to our object, and click on the index.html button

Navigate to the Object URL, copy the url and paste it in your web browser — Voilà! you have you website Live .

SUMMARY

Using the AWS S3 to host a static website provides a high-quality, and affordable solution for developers and businesses who want to serve powerful content on the web quickly. In this blog, we have covered how painless and stress free it is to serve static sites (such as an HTML/CSS/JavaScript single-page app or a static blog) from an S3 bucket without having to manage traditional servers. Backed by flexible and endless scalability, high availability, and integration with services such as Cloudfront and Route 53, AWS S3 makes it easy for users to securely deploy globally available websites with a small investment profile. S3 is fast, durable, and scalable, whether you’re building a small personal site, a global production system, or anything in between.

The Linux command line can be quite intimidating at first glance, but believe me, after you’ve used it for a little while, you’ll wonder how you’d ever lived without it. Whether you are navigating directories, viewing files, or creating new users or groups, these commands will quickly become your go-to commands.

With that being said, let’s unlock the ultimate power of Linux and control the command line like never before.

Linux Commands

1. Administrative User
   An administrative user is also called a superuser, or a root user. This user has all the administrative rights and privileges in the Linux system. With a super user, there is no limitation to accessing the database or making changes in terms of administration, control, operations, etc.

   Example:

   • Type sudo su - in the terminal

   • You will be prompted to fill in your password. The password will be invisible, so you’ll just have to type and click the Enter button.

   • After you have logged in successfully, you will notice that your command line changed from $ to #, and also have root@ before your name. What this means is that you transitioned from being a substitute user to being a root user.

     

2. Package Management

   Package management is the process of installing, updating, configuring, and removing software packages on a Linux system.

   • Let’s run apt update. What this command does is that it gives us a list of all the software available for an update, and gives us the number of software available for update.

   • After that, run apt upgrade. This command upgrades all the software packages in your Linux system, and this takes approximately 40 minutes if you are a new Linux user on the Ubuntu distribution.

     When you see a prompt that states, ‘Do you want to continue? [Y/n]‘ click ‘y‘ and enter.

     

3. Create a Directory/Folder

   Directories, which can also be referred to as folders, serve as an essential organizational structure for managing files efficiently. Benefits of a directory include: organizing files in a structured manner, access control for users, hierarchical system, backup and recovery, among others. Directories can be likened to folders in the file manager of a Windows operating system.

   mkdir <name of directory or folder>
   cd <name of directory or folder>“ command is used to change or open a directory.

   

4. Create a text file
   touch <file name>.txt is a command used to create an empty file.
   Moreover, we have discussed creating folders and entering those folders using the commands mkdir and cd, respectively. So we created a few folders within a directory in the image below.

5. List Contents
   There are a few commands that are commonly used to list content in the Linux system.
   ls - command is used to list content in a directory
   ls -l command is used to give detailed information such as permissions, owner, size and date in a long format.
   ls -r command list content in a reversed order.

   

6. Open text editor
   The text editor just as the name implies, is used to edit text files within the terminal so if you don’t have the tool, you need to install it using the command apt install vim to install it.

After the text editor tool has been successfully installed, we can open the text editor using the command vim <filename>.txt.

Once we enter this command, the text editor file will open within the terminal.
Example:

Once this opens up, the next right thing to do is to click on the letter i because you can do literally nothing till you click the insert button. Afterwards, you can type as much as you want in here.
To save your typed document in this text file, you need to:

• click on the esc button on the top left corner of your keyboard.

• then insert :wq and click enter. That way you will save the text file and return to the terminal’s command interface.

7. 

   Read-only Files
   The cat command is used to view a text file, but it cannot be edited.
   cat <filename>.txt

8. 

   History Command
   The history command shows a list of all the commands that have been previously ran in the terminal.

   

9. Adding User
   The command sudo adduser <username> is used to add another user to our virtual machine; however, this does not automatically grant the user root privileges on this machine, unless you specifically decide to do so.

   

   You will be prompted to add the root user’s password for this user to be added.
   Note: On the Linux system, passwords are always invisible when typed and entered.
   Afterwards, we can go ahead and set a password for the user.

While setting the password, we need to make sure that all our passwords are up to 8 small letters. If you get this prompt, you don’t have to worry, just repeat the password, and it will be set successfully.

Moreover, we will be prompted to add this new user’s details to the system to be able to add this new user to the system.

So this is the process of adding a new user to the system or an organization, as the case may be.

10. Switch User
    We use the su - <username> command to switch users within the Linux system.

    

    Now this is the current user logged on the system at the moment. We are going to run the command su - dora so that our user can change from victor to dora. Kindly note that the name of the virtual machine was named ‘Victor‘ and the user was also named Victor, which is the reason we have Victor appearing twice on the system.

    

    However, before we can successfully log in as ‘dora‘, we will need to use Dora’s password to log in.

    

    We have successfully switched users from Victor to Dora.
    Apparently, Linux is case sensitive. In some cases, you may not be able to create a username that begins with a Capital letter. In some cases, you may need to alternate small letters.

11. Fetch user details
    The command line to fetch a user’s details is getent passwd <username>
    Example
    getent passwd dora

    

    The result of the command that we ran shows Dora’s details, which include her full name, work number, and room number.

12. Lock and Unlock User
    As a system administrator with root privileges, you can use these commands to lock a user’s account and also unlock a user’s account.
    The command-line to lock a user’s account is sudo usermod -L <username>
    Example

Now we locked Dora’s account, denying the user from accessing the account, then we used the command line su - dora to log in to Dora’s account, but it failed to log in, because it has been locked.
Now, let’s unlock the account.
We will run the command sudo usermod -U dora to unlock Dora’s account.

After unlocking Dora’s account, we used the command line su - dora to switch to Dora’s account, and now we have successfully logged into Dora’s account.

13. Delete User’s Account
    To delete a user’s account from the system, run sudo userdel <username>
    To delete a user’s account and email messages, run the command sudo userdel -r <username>
    Example:

    

    After we ran the command, it gave this response because this user does not have any saved email messages on the account.
    Now we ran the “getent passwd dora” command to fetch details about this user, but it came back empty because this user no longer exists.

Running Shell Scripts

What is a shell script?
A Shell script is a file that contains a sequence of shell commands that are executed in order.
Meanwhile, a shell is a program that provides a text-based interface for users to interact with the operating system.

Popular shells include:

Advantages of Using Shell Scripting
Shell scripting is used for the following:

• Automate repetitive tasks (backups, updates, deployments)

• Configure system settings

• Run multiple commands as a single program

• Schedule jobs with tools like cron

• Quickly test logic or prototypes

  To run a shell script, you must start with Shebang, which is represented as #!/bin/bash.
  Examples:
  #!/bin/bash

  read -p “Enter your age: “age”

  if [ $age -ge 28 ];then (the ‘if’ command in this example states that if the age is greater than or equal to 28, then it should give the response in the first ‘echo’)

  echo “How time flies! Should I hope to get invited to your wedding soon because you are long overdue for marriage?.”

  else (in this example, the ‘else’ command will propel the second ‘echo’ to take effect if the age stated in the ‘if’ command is lower than 28)

  echo “I’ve known you to always be a brilliant one, so you should definitely focus on your studies.”

  fi

  We vim into the text environment using vim <filename>.sh

  

  Then we save and exit using the esc botton, then :wq to go back into the terminal.
  To execute an actionable command within the terminal, we must change mode directly from the terminal using the command sudo chmod u+x .sh. Afterwards, we run the command ./<filename>.sh to execute it.

  

13. How to Create a Group
    Basically, the command sudo addgroup <group name> is used to create groups in the Linux distro. However, we can also use sudo groupadd <group name> to create a group. These two have slight differences in their functionalities.
    The first command, which is sudo addgroup <group name> is the higher than the second command because this command is used to create an interactive group, unlike the second command, sudo groupadd <group name> that is used to create a group that is just meant to follow commands and duties assigned to various users within that group.
    Example:

    

    16. How to Add Users to a Group
        The command sudo usermod -aG <group name> <username> is used to add a user to a group.
        Example
        So we will run the command sudo usermod -aG cloud-develops rex to add an already existing user with the username ‘rex’ to the group that was created earlier.

        

        Furthermore, to list all the groups in a system, we use the command getent group, or cat /etc/group, to fetch details about a group, we use the command getent group <group name>, to see groups that a user belong to, we use the comand groups <username>.

        

Conclusion
Mastering the Linux command line isn’t just about memorizing every single instruction rather, it cuts across building confidence through consistent practice, hence enabling the user to dot his ‘i’s and slash his ‘T’s. The simple commands we just explored are the building blocks of something much greater, which includes: control, customization, and creativity in your computing experience. Like learning a new language, fluency and mastery come from hands-on use. The terminal is more than just a black screen; it’s my canvas.