DEV Community: TUNDE OGUNMODEDE

Computer Networking Fundamentals: IP Addresses, DNS, and Network Communication

TUNDE OGUNMODEDE — Fri, 09 Oct 2026 13:36:03 +0000

Computer networking allows devices to communicate and exchange data. Whether you're accessing a website, connecting to a remote server, or deploying cloud infrastructure, networking concepts determine how that communication happens.

Understanding these fundamentals is essential for working with Linux, cloud platforms, and DevOps tools.

This guide covers network communication, IP addressing, routing, DNS, and related concepts.

1. Local Area Networks (LANs) and Ethernet

A Local Area Network (LAN) connects devices within a limited geographical area, such as a home, office, or data centre.

Devices on a LAN can communicate with one another and share resources, depending on how the network is configured.

Ethernet is a widely used technology for wired networking. Wi-Fi provides a common alternative for wireless LAN connections.

Although Ethernet is commonly associated with LANs, the terms are not interchangeable: a LAN describes the network's scope, while Ethernet describes a networking technology.

MAC addresses

A Media Access Control (MAC) address is an identifier associated with a network interface.

For example:

00:1A:2B:3C:4D:5E

MAC addresses are used in local network communication, particularly when Ethernet frames are delivered between devices on the same network segment.

A MAC address and an IP address serve different purposes:

MAC address: Used for link-layer delivery within a local network.
IP address: Used for addressing and routing packets across IP networks.

A device's MAC address is not necessarily permanent or globally unique in every practical situation. Software can change or randomize it, and virtual machines can have their own virtual MAC addresses.

2. How Devices Share a Network

When multiple devices share a communication medium, rules are needed to coordinate transmission.

Two important concepts are CSMA/CD and CSMA/CA.

CSMA/CD

Carrier Sense Multiple Access with Collision Detection (CSMA/CD) was used by traditional shared, half-duplex Ethernet networks.

The process works broadly as follows:

A device listens to determine whether the medium is available.
If the medium is idle, it begins transmitting.
If a collision occurs, the device detects it.
The devices stop transmitting and wait for a randomly selected interval before trying again.

This waiting mechanism is called exponential backoff. The waiting period is selected from an increasingly large range as collisions recur, helping reduce repeated collisions.

Traditional shared Ethernet relied on this approach. Modern switched, full-duplex Ethernet generally doesn't use CSMA/CD because devices have dedicated full-duplex links.

CSMA/CA

Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) is associated with Wi-Fi.

Because wireless devices cannot reliably detect every collision while transmitting, Wi-Fi uses mechanisms designed to reduce the likelihood of collisions.

These mechanisms include waiting for the channel to become available and using randomized backoff periods.

Bandwidth

Bandwidth describes a network link's data-carrying capacity, commonly measured in bits per second.

For example, a connection rated at 100 Mbps has a nominal capacity of 100 megabits per second.

However, actual throughput may be lower because of protocol overhead, congestion, interference, and other conditions.

3. Collision Domains and Network Switches

A collision domain is a portion of a network in which simultaneous transmissions could interfere with one another under the relevant networking technology.

In traditional shared Ethernet, devices sharing the same medium belonged to the same collision domain.

Ethernet switches changed this arrangement.

A switch forwards Ethernet frames based on MAC addresses. Each switch port generally creates a separate collision domain, and modern full-duplex connections avoid the traditional Ethernet collision problem.

This is one reason switched Ethernet performs better than older shared-medium Ethernet.

Don't confuse a collision domain with a broadcast domain. They describe different things, and VLANs are commonly used to divide switched networks into separate broadcast domains.

4. Routing and Packet Delivery

When one device communicates with another across different IP networks, routers help move packets toward their destinations.

What is a packet?

A packet is a formatted unit of data carried by a network-layer protocol such as IP.

An IP packet contains information such as source and destination IP addresses, along with the data being transported.

Routers examine packet headers and use routing information to determine where packets should be forwarded next.

Packets belonging to the same communication may take different paths, depending on network conditions and routing decisions.

What is a hop count?

A hop is one step along a route through a network, typically involving a router forwarding a packet.

Hop count refers to the number of hops along a route or the number of router hops a packet traverses.

For example, if a packet passes through three routers before reaching its destination, it has traversed three router hops.

In IPv4, the Time to Live (TTL) field is reduced by routers as the packet is forwarded. When it reaches zero, the packet is discarded.

This helps prevent packets from circulating indefinitely because of routing loops.

5. Circuit Switching and Message Switching

Different communication systems use different methods to move information.

Circuit switching

Circuit switching establishes a dedicated communication path or circuit between endpoints for the duration of a connection.

Traditional telephone networks are a familiar example.

The reserved path provides predictable communication resources, but those resources may remain allocated even when no data is being sent.

Message switching

Message switching forwards complete messages from one intermediate system to another.

Each intermediate system receives and stores the message before forwarding it toward the destination. This is often called a store-and-forward approach.

Unlike circuit switching, message switching doesn't require a dedicated end-to-end circuit.

Modern IP networks generally use packet switching instead: data is divided into packets that can be forwarded independently.

6. IP Addresses: IPv4 and IPv6

An IP address identifies a network interface at the IP layer and supports communication across interconnected networks.

There are two major versions of IP: IPv4 and IPv6.

IPv4

IPv4 uses 32-bit addresses.

Because each bit has two possible values, IPv4 provides:

[
2^{32} = 4,294,967,296
]

possible address values—approximately 4.3 billion.

An IPv4 address is commonly written as four decimal numbers separated by periods.

For example:

192.168.1.10

Each number represents eight bits and ranges from 0 to 255.

IPv6

IPv6 uses 128-bit addresses.

It provides:

[
2^{128}
]

possible address values, offering an enormously larger address space than IPv4.

An IPv6 address is commonly written in hexadecimal groups separated by colons.

For example:

2001:db8::1

The 2001:db8::/32 block is reserved for documentation and examples; it is not intended for ordinary public deployment.

IPv6 was developed partly to address IPv4 address exhaustion and includes other protocol improvements.

Static and dynamic IP addresses

IP addresses can also be classified by how they are assigned.

Static IP: An address configured to remain fixed, unless an administrator or system changes it.

Dynamic IP: An address assigned automatically, commonly through DHCP, and potentially changed over time.

These terms describe address assignment, not IP versions. Either IPv4 or IPv6 can use static or dynamic configuration.

For example, a cloud server may need a stable public IP address so that users or other systems can reach it consistently.

7. Congestion Control

Network congestion occurs when the volume of traffic exceeds the capacity available along a network path.

This can result in packet loss, increased latency, and reduced throughput.

Congestion control helps prevent senders from overwhelming the network.

TCP, for example, uses congestion-control algorithms to adjust its sending behaviour in response to network conditions.

Congestion control is not the same as load balancing.

Congestion control regulates traffic to reduce or respond to overload.
Load balancing distributes traffic across multiple resources or paths to improve resource utilization, performance, or availability.

Both can help improve network performance, but they solve different problems.

8. TCP/IP, ICMP, and BGP

These protocols serve different purposes within network communication.

TCP/IP

TCP/IP refers to the family of protocols used for communication across IP networks.

IP handles addressing and packet forwarding. TCP provides a reliable, ordered byte stream between applications running on communicating hosts.

Other transport protocols, such as UDP, provide different delivery characteristics.

ICMP

The Internet Control Message Protocol (ICMP) supports error reporting and diagnostic functions associated with IP communication.

For example, ping commonly uses ICMP Echo Request and Echo Reply messages to test reachability.

ICMP is not the same as TCP. They perform different functions.

BGP

The Border Gateway Protocol (BGP) is used to exchange routing information between autonomous systems.

An autonomous system is a network or group of networks managed under a common routing policy.

BGP helps large networks, including internet service providers and major organizations, determine how traffic can reach destinations across the internet.

9. The Internet of Things (IoT)

The Internet of Things (IoT) describes physical devices connected to networks so they can collect, exchange, or act on data.

Examples include:

Smart home sensors.
Industrial monitoring equipment.
Connected security cameras.
Environmental monitoring devices.
Wearable devices.

These devices often communicate with cloud platforms that store information, process data, and provide monitoring or control interfaces.

Networking knowledge is important for IoT because devices need appropriate addressing, connectivity, security, and reliable communication.

10. DNS: The Domain Name System

The Domain Name System (DNS) translates domain names into information that applications can use, including IP addresses.

For example, when a user accesses a website using a domain name, DNS resolution can help determine the IP address associated with that name.

DNS is often described as the internet's phonebook, but it is more accurately a distributed, hierarchical naming system.

It does not store every website in one central location.

How DNS resolution works

Consider a DNS lookup for an address record associated with a domain.

Several components may participate in finding the answer.

1. Recursive resolver

The recursive resolver receives the query on behalf of the client. If it doesn't already have a usable cached answer, it can query other DNS servers to obtain one.

2. Root nameserver

A root nameserver directs the resolver toward the appropriate top-level domain (TLD) nameservers.

3. TLD nameserver

A TLD nameserver directs the resolver toward the authoritative nameservers for the domain.

For example, a .com TLD nameserver can provide a referral for a domain ending in .com.

4. Authoritative nameserver

The authoritative nameserver holds the DNS records for the domain and can return the requested information.

The resolver can then return the answer to the client and cache it when appropriate.

This is a simplified description: the exact process depends on the query, existing cached data, and the DNS configuration.

DNS caching

DNS caching temporarily stores DNS answers so they can be reused for subsequent queries.

If a resolver already has a valid cached answer, it may return that answer without repeating the entire lookup process.

Caching reduces unnecessary queries and can improve response times.

What is DNS Time to Live (TTL)?

A DNS record's Time to Live (TTL) specifies how long a DNS answer can generally remain cached before it needs to be refreshed.

For example, a DNS record with a TTL of 3,600 seconds can ordinarily be cached for up to one hour.

A shorter TTL can allow changes to be reflected sooner after caches expire, but it can also increase DNS query traffic.

A longer TTL can reduce repeated queries, although changes may take longer to be reflected by clients using cached answers.

Important distinction: DNS TTL is different from the TTL field in an IPv4 packet. DNS TTL governs caching time, while IPv4 TTL limits how many router hops a packet can traverse before being discarded.

Conclusion

Computer networking combines several technologies and protocols to enable communication between devices.

Understanding LANs, MAC and IP addressing, routing, packet delivery, TCP/IP, and DNS provides a foundation for troubleshooting connectivity and understanding how applications reach network services.

These concepts also underpin cloud networking, where engineers configure virtual networks, subnets, routing tables, IP addresses, DNS records, and security controls.

A solid understanding of networking fundamentals makes it easier to reason about what happens when a service becomes unreachable, a DNS lookup fails, or traffic cannot reach its destination.

References for Further Reading

Cloud and DevOps Fundamentals: Git, Terraform, CI/CD, and SSH

TUNDE OGUNMODEDE — Sat, 03 Oct 2026 11:58:06 +0000

Cloud engineering involves more than creating servers. It also requires understanding how infrastructure is managed, how software changes are delivered, how systems are monitored, and how servers are accessed securely.

Several tools and practices support this work, including Git, Infrastructure as Code (IaC), Continuous Integration and Continuous Delivery (CI/CD), containers, observability, Terraform, and SSH.

This article introduces these concepts and explains how they fit into a cloud engineering workflow.

1. Version Control with Git

Git is a distributed version control system that tracks changes to files over time. It allows developers to review previous changes, experiment with new features, and collaborate without losing the history of a project.

Git is widely used in software development and infrastructure projects.

Core Git concepts

Working directory

The working directory is where you view and modify project files.

For example, when you edit a Bash script or Terraform configuration, you're changing files in your working directory.

Staging area

The staging area allows you to select the changes you want to include in your next commit.

git add main.tf

This stages the changes to main.tf.

Local repository

The local repository stores the project's Git history, including commits and branch information.

To record staged changes:

git commit -m "Add Terraform configuration"

Remote repository

A remote repository is a version of the repository hosted elsewhere, such as on GitHub. It allows you to share your work and collaborate with other people.

Common commands include:

git push
git pull

git push sends local commits to a remote repository, while git pull fetches and integrates changes from a remote repository.

Branches

Branches allow you to develop features or make changes independently of another branch.

For example:

git switch -c add-monitoring

This creates and switches to a new branch named add-monitoring.

Pull requests

A pull request is a proposal to merge changes from one branch into another. It gives team members an opportunity to review and discuss the changes before they are integrated.

Merging

Merging integrates changes from one branch into another. For example, a feature branch may be merged into the main branch after review.

Why Git matters in cloud engineering

Infrastructure configurations are files too. By storing Terraform configurations and scripts in Git, you can track infrastructure changes, review proposed modifications, and recover earlier versions of your configuration.

Version control makes infrastructure work more transparent and repeatable.

2. Infrastructure as Code (IaC)

Infrastructure as Code is the practice of defining and managing infrastructure through machine-readable configuration files rather than relying entirely on manual setup.

Instead of repeatedly clicking through a cloud provider's console to create servers and networks, you describe the desired infrastructure in configuration files.

These files can be version-controlled, reviewed, reused, and applied consistently.

For example, a Terraform configuration can describe an AWS EC2 instance, including its instance type and other settings.

Why IaC is useful

IaC can help teams:

Reproduce infrastructure environments.
Reduce repetitive manual configuration.
Review infrastructure changes before applying them.
Track configuration history in Git.
Standardize infrastructure across development and production environments.

IaC does not automatically guarantee that every deployment will be identical. Results also depend on the configuration, provider behaviour, external dependencies, and the state of the environment.

The main advantage is that infrastructure becomes defined and managed through explicit, reviewable configuration.

3. Continuous Integration and Continuous Delivery/Deployment (CI/CD)

CI/CD describes practices and automation used to integrate, test, and deliver software changes.

The abbreviation has two main components.

Continuous Integration (CI)

Continuous Integration involves regularly integrating code changes into a shared codebase.

Automated checks may run when changes are pushed or a pull request is opened. These checks can include:

Running tests.
Checking code quality.
Validating configuration files.
Building an application.

The goal is to detect problems early, before changes progress further through the delivery process.

Continuous Delivery and Continuous Deployment

Continuous Delivery automates the process of preparing software for release. A production deployment may still require human approval.

Continuous Deployment goes further: changes that pass the required checks can be released automatically to production.

A simplified pipeline might look like this:

A developer pushes a change to Git.
An automated pipeline runs tests.
The application is built and validated.
The deployment process prepares or releases the application.
Monitoring helps identify problems after deployment.

CI/CD reduces repetitive work and helps teams deliver changes more consistently. However, automation is only as reliable as the tests, deployment procedures, and safeguards behind it.

4. Observability: Understanding What's Happening Inside a System

Observability is the ability to understand a system's internal state by examining the information it produces.

When an application becomes slow or fails, engineers need evidence to investigate the cause rather than relying on guesses.

Three commonly discussed observability signals are logs, metrics, and traces.

Logs

Logs are records of events produced by an application or system.

For example:

2026-10-09 10:32:00 ERROR Database connection failed

A log entry may help an engineer identify what happened and when it occurred.

Metrics

Metrics are numerical measurements collected over time.

Examples include:

CPU utilization.
Memory usage.
Request rate.
Error rate.
Request latency.

Metrics can help engineers identify trends, unusual behaviour, and performance problems.

For example, a steady increase in memory usage may indicate a resource leak or growing workload.

Traces

Distributed traces follow a request as it passes through multiple components of an application.

Imagine an application request moving through an API, a payment service, and a database. A trace can help show which part of that journey contributed most to the delay.

Monitoring and observability

Monitoring commonly involves tracking predefined indicators and alerting when they cross certain thresholds.

Observability helps engineers investigate less predictable problems by examining system telemetry and relationships between events.

They complement each other: monitoring can tell you that something is wrong, while observability can help you investigate why.

Collecting data is only one part of the process. Teams also need suitable tools, useful dashboards, appropriate alerts, and a method for investigating what the data reveals.

5. Containers and Kubernetes

Applications often depend on specific libraries, configuration files, and runtime components. Differences between environments can cause an application to work on one machine but fail on another.

Containers help address this problem by packaging an application with its required dependencies and isolating its processes from the surrounding system.

What is a container?

A container is an isolated environment in which an application runs.

Containers commonly use images that package the application and its required components. The same image can be used across different environments, provided the necessary runtime and platform requirements are met.

Containers are generally lighter than traditional virtual machines because they share the host operating system's kernel rather than each requiring a separate guest operating system.

However, a container does not automatically guarantee identical behaviour everywhere. Environment variables, permissions, networking, storage, and other external dependencies can still affect how it runs.

What is Kubernetes?

Kubernetes is a container orchestration platform.

When an application runs across many containers and machines, managing each container manually becomes difficult. Kubernetes helps automate tasks such as:

Scheduling containers across available machines.
Restarting containers when they fail.
Scaling workloads.
Managing service discovery and networking.
Maintaining the desired number of application replicas.

For example, you might configure a workload to run three replicas of an application. Kubernetes works to maintain that desired state.

The distinction: Containers provide an environment for running applications; Kubernetes helps manage containerized workloads at scale.

Kubernetes is a useful technology to understand, but you don't need to master it before learning the fundamentals of Linux, networking, and cloud infrastructure.

6. Terraform: Managing Infrastructure with Code

Terraform is an Infrastructure as Code tool that allows you to define infrastructure using configuration files.

Instead of manually creating resources in a cloud console, you describe what you want Terraform to manage.

For example, you can define an AWS EC2 instance in a Terraform configuration.

The Terraform workflow

A typical workflow has three important commands.

1. Initialize

terraform init

This initializes a Terraform working directory. Terraform downloads the required providers and prepares the directory for further operations.

Run it when setting up a new configuration or when initializing a project cloned from version control.

2. Plan

terraform plan

Terraform compares the desired configuration with its understanding of the existing infrastructure and produces a proposed execution plan.

Reviewing the plan helps you understand which resources Terraform intends to create, change, or destroy.

3. Apply

terraform apply

Terraform executes the proposed changes, subject to its planning and approval workflow.

For example, it may create an EC2 instance in AWS based on your configuration.

Always review the proposed changes before approving an apply operation, particularly when working with existing infrastructure.

Understanding a Terraform provider configuration

A Terraform configuration may contain the following block:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.92"
    }
  }

  required_version = ">= 1.2"
}

Let's break it down.

terraform is a Terraform configuration block.
required_providers declares the providers the configuration needs.
aws is the local name assigned to the provider in this configuration.
source = "hashicorp/aws" identifies the AWS provider in the Terraform Registry.
version = "~> 5.92" specifies a provider version constraint.
required_version = ">= 1.2" specifies the minimum Terraform CLI version permitted by the configuration.

The version constraints above are examples from the configuration in my notes, not recommendations to use those versions in every new project. Check the current Terraform documentation and provider registry when starting a new configuration.

The ~> 5.92 constraint allows compatible releases within the relevant version range; it does not mean Terraform will always install exactly version 5.92.

Why Terraform matters

Terraform makes it possible to define infrastructure in a repeatable and reviewable way.

Combined with Git, it also provides a history of configuration changes that can help engineers understand how infrastructure has evolved.

Before using Terraform to manage real resources, it's important to understand its state file, resource dependencies, provider configuration, and the costs associated with creating cloud resources.

7. SSH: Securely Accessing Remote Systems

SSH stands for Secure Shell. It is a protocol for securely connecting to and managing remote computers over a network.

Cloud engineers commonly use SSH to access Linux servers for administration, troubleshooting, and maintenance.

SSH typically uses TCP port 22 by default, although administrators can configure a different port.

What SSH provides

SSH supports several important capabilities.

Remote administration

An engineer can connect to a remote Linux server and execute commands.

For example:

ssh username@server-ip

Here, username is the account on the remote machine, and server-ip is the server's IP address or resolvable hostname.

Secure file transfer

Tools such as scp and sftp use SSH-related functionality to transfer files securely.

Authentication

SSH supports several authentication methods, including passwords and public-key authentication.

With public-key authentication, the user keeps a private key and configures the corresponding public key on the remote system. The server can verify that the client possesses the matching private key without requiring the private key itself to be sent to the server.

SSH also negotiates encryption keys to protect the session's communications. Public-key cryptography is not simply used to encrypt every piece of data transmitted during the session.

SSH tunnelling and port forwarding

SSH port forwarding allows traffic to travel through an SSH connection to reach another address and port.

For example, an engineer may need to access a service running on a remote server without exposing that service directly to the public internet.

A local forwarding example is:

ssh -L 8080:localhost:80 username@server-ip

This forwards connections to port 8080 on the local machine through the SSH connection to port 80 on the remote server's localhost.

The exact destination depends on the forwarding configuration. In this example, localhost:80 is interpreted from the remote server's perspective.

SSH tunnelling can help provide controlled access to services, but it does not automatically bypass every firewall or security restriction. The SSH server, network rules, authentication, and destination service must permit the connection.

Why SSH matters in cloud engineering

SSH is useful for:

Administering remote Linux servers.
Investigating application or system problems.
Transferring files securely.
Accessing services that should not be publicly exposed.
Establishing encrypted tunnels to permitted network destinations.

For cloud environments, access should be restricted to authorized users and trusted networks wherever practical. Private keys should be protected, and SSH access should follow the security controls of the environment.

8. Essential Linux Networking Commands

Cloud engineers frequently use Linux commands to inspect interfaces, addresses, and routing information.

Two particularly useful commands are ip addr and ip route.

`ip addr`

ip addr

This displays information about network interfaces and their IP addresses.

It can help answer questions such as:

Which network interfaces are available?
What IP addresses are assigned?
Is an interface up or down?

`ip route`

ip route

This displays the IPv4 routing table.

It helps you understand where the system sends traffic and which gateway it may use to reach destinations outside its local network.

For example, an output line such as:

default via 192.168.1.1 dev eth0

indicates that the default route uses 192.168.1.1 as its gateway through the eth0 interface.

The actual interface name and gateway will depend on the system's network configuration.

What about `ifconfig`?

ifconfig is an older utility used to inspect and configure network interfaces. On many modern Linux distributions, the ip command from the iproute2 package is preferred.

For example:

ip addr
ip route

These commands provide much of the interface and routing information beginners commonly seek with ifconfig.

What about `iwconfig`?

iwconfig is an older utility for inspecting and configuring wireless network interfaces.

Depending on the Linux distribution, it may not be installed by default. Modern Linux systems commonly use iw for wireless-specific operations.

The commands serve different purposes:

Command	Primary purpose
`ip addr`	Inspect network interfaces and IP addresses
`ip route`	Inspect routing information
`iwconfig`	Inspect or configure wireless interface settings using the older wireless tools
`iw`	Inspect or configure wireless devices using the modern wireless utility

A virtual machine may not expose a physical wireless interface to its guest operating system. For example, an Ubuntu VM using a virtual Ethernet adapter may not have access to the host Mac's Wi-Fi interface directly. In that case, iw or iwconfig may not show a wireless interface, even when the host computer is connected to Wi-Fi.

Conclusion

Cloud and DevOps engineering bring together tools and practices that make infrastructure easier to manage, software changes easier to deliver, and system behaviour easier to investigate.

The concepts covered here play different roles:

Git tracks changes to code and configuration.
Infrastructure as Code defines infrastructure in reusable files.
CI/CD automates testing and software delivery.
Observability helps engineers understand system behaviour.
Containers package applications and their dependencies.
Kubernetes orchestrates containerized workloads.
Terraform provisions and manages infrastructure.
SSH enables secure remote access and tunnelling.
Linux networking commands help troubleshoot interfaces, addresses, and routes.

These technologies become more useful when understood as parts of a workflow rather than as isolated tools.

For someone entering cloud engineering, the practical next step is to build small projects that combine these fundamentals—for example, managing a cloud server with Terraform, tracking the configuration in Git, and connecting to the server securely with SSH.

References

Bash Scripting Fundamentals: Commands, Variables, Loops, and Automation

TUNDE OGUNMODEDE — Sat, 26 Sep 2026 22:20:33 +0000

Commands, Variables, Loops, and Automation

Bash scripting allows you to automate repetitive tasks in Linux by combining commands into scripts that execute in sequence. Instead of repeatedly typing the same commands into a terminal, you can save them in a file and execute them whenever needed.

This is useful for everyday Linux administration, file management, system checks, and scheduled tasks.

This guide covers the fundamentals of Bash scripting, from creating your first script to working with loops, processing files, debugging, and scheduling automated tasks.

1. What Is a Bash Script?

A Bash script is a text file containing commands that the Bash shell can interpret and execute.

For example, instead of typing several commands individually, you can save them in a script and execute them together.

Create a file called hello.sh:

#!/bin/bash

echo "Hello, World!"
echo "Today is $(date)"

Let's break this down.

#!/bin/bash — The shebang identifies the interpreter to use when the script is executed directly.
echo — Prints text to standard output.
$(date) — Runs the date command and substitutes its output into the surrounding command.

To make the script executable, run:

chmod u+x hello.sh

Then execute it:

./hello.sh

The terminal will display the messages and the current date.

Why use scripts?

Scripts reduce repetitive work, make tasks easier to reproduce, and provide a foundation for automating system administration.

2. Variables and User Input

Variables allow scripts to store and reuse values.

Consider this example:

#!/bin/bash

name="Wale"

echo "My name is $name"

Here, name is a variable containing the value Wale.

The $name expression retrieves that value.

Notice that there are no spaces around the = when assigning a value in Bash:

name="Wale"

This is different from:

name = "Wale"

The second example is not a valid variable assignment in Bash.

Accepting user input

The read command allows a script to receive input from the user.

#!/bin/bash

echo "What is your name?"

read -r name

echo "Hello, $name!"

When executed, the script waits for the user to enter a name and press Enter.

The entered value is stored in the name variable and displayed in the final message.

The -r option prevents read from treating backslashes as escape characters.

Passing arguments to a script

You can also supply values when executing a script.

Consider greeting.sh:

#!/bin/bash

echo "My name is $1"

Execute it with:

./greeting.sh Wale

Output:

My name is Wale

Here, $1 represents the first positional argument passed to the script.

For example:

$1 — First argument.
$2 — Second argument.
$3 — Third argument.

This allows scripts to accept different values without requiring interactive input.

3. Working with Files and Command Output

Linux commands can read from files and redirect their output into files.

Understanding these operations is essential for writing useful scripts.

Redirecting output

The > operator redirects command output into a file.

ls > output.txt

This writes the directory listing to output.txt.

Important: If the file already exists, > overwrites its contents.

To append output instead, use >>:

echo "Another entry" >> output.txt

This adds the new text to the end of the file without replacing the existing contents.

Reading file contents

The cat command displays a file's contents:

cat output.txt

By contrast:

ls output.txt

lists the file itself rather than displaying its contents.

Reading input from a file

The < operator redirects a file's contents into a command's standard input.

For example:

while IFS= read -r line
do
    echo "$line"
done < output.txt

This reads output.txt one line at a time and prints each line.

The expression:

done < output.txt

redirects the loop's standard input from the file.

This pattern is useful when processing text files line by line.

4. Understanding Loops

Loops allow a script to repeat commands without requiring you to write the same instructions multiple times.

Bash supports several types of loops, including while and for.

The `while` loop

A while loop continues executing as long as its condition is true.

#!/bin/bash

i=1

while [[ $i -le 5 ]]
do
    echo "$i"
    ((i += 1))
done

Output:

How it works:

i=1 initializes the variable.
[[ $i -le 5 ]] checks whether i is less than or equal to 5.
do marks the beginning of the commands to execute.
echo "$i" prints the current value.
((i += 1)) increments the variable by one.
done marks the end of the loop.

When i becomes 6, the condition is false and the loop stops.

Watch out: If the variable never changes in a way that makes the condition false, the loop may run indefinitely.

The `for` loop

A for loop is useful when iterating over a known sequence of values.

#!/bin/bash

for i in {1..5}
do
    echo "$i"
done

Output:

Here, {1..5} expands into the sequence of numbers from 1 to 5.

The loop assigns each value to i and executes the commands inside the loop.

Unlike the previous example, you don't need to increment the variable manually.

5. Using `case` for Multiple Conditions

The case statement allows a script to compare a value against several patterns and execute the commands associated with the first matching pattern.

For example:

#!/bin/bash

fruit="apple"

case "$fruit" in
    apple)
        echo "This is an apple."
        ;;
    orange)
        echo "This is an orange."
        ;;
    *)
        echo "This fruit is not recognized."
        ;;
esac

Output:

This is an apple.

Here's what the syntax means:

case "$fruit" in — Begins the comparison.
apple) — Matches the value apple.
;; — Ends that case and exits the case statement.
*) — Acts as the default pattern when no earlier pattern matches.
esac — Marks the end of the statement.

The case statement is useful when a script needs to respond differently to multiple possible inputs.

For example, it can process user choices, command-line options, or service names.

6. Debugging Bash Scripts

A script may fail because of incorrect syntax, unexpected input, or incorrect assumptions about how a command behaves.

Bash provides tools to help identify these problems.

Using `set -x`

Add this line near the beginning of your script:

#!/bin/bash
set -x

Bash will print commands and their expanded arguments to standard error as it executes them.

For example:

#!/bin/bash
set -x

name="Wale"
echo "Hello, $name"

The trace helps you see how Bash interprets and executes the commands.

You can also enable tracing for a particular section:

set -x

# Commands to investigate

set +x

The first command enables tracing, while the second disables it.

This is useful when you want to investigate a specific part of a script rather than trace every command.

Security note: Be careful when debugging scripts that handle passwords, access tokens, or other secrets. Tracing can expose sensitive values in terminal output or logs.

7. Scheduling Scripts with Cron

Some tasks need to run automatically at particular times.

For example, you might want a script to run every morning, periodically check a service, or perform a routine maintenance task.

On Linux systems that use cron, scheduled jobs can be managed with crontab.

Viewing scheduled jobs

Run:

crontab -l

This displays the current user's scheduled cron jobs.

To edit them, run:

crontab -e

Understanding cron syntax

A standard cron expression contains five fields:

* * * * *
│ │ │ │ │
│ │ │ │ └── Day of the week
│ │ │ └──── Month
│ │ └────── Day of the month
│ └──────── Hour
└────────── Minute

Each field controls when the scheduled command runs.

Example 1: Run a script every day at midnight

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

The five fields specify minute 0, hour 0, and every day, month, and weekday.

The script runs at midnight each day, according to the cron daemon's time settings.

Example 2: Run a script every five minutes

*/5 * * * * /path/to/script.sh

The */5 expression means every five minutes.

Practical consideration: When scheduling scripts, use appropriate file permissions and valid paths. Cron jobs may also need explicit environment variables or logging because they don't necessarily run with the same environment as your interactive terminal.

Conclusion

Bash scripting provides a practical way to automate tasks in Linux.

The fundamentals covered here—variables, user input, positional arguments, file redirection, loops, conditional selection, debugging, and scheduling—form a foundation for more advanced automation.

As scripts become more complex, these concepts can be combined to perform repetitive administrative tasks, process files, and support infrastructure operations.

The key is to understand what each command does, how the pieces fit together, and how to verify that a script behaves as expected.

DEV Community: TUNDE OGUNMODEDE

Computer Networking Fundamentals: IP Addresses, DNS, and Network Communication

1. Local Area Networks (LANs) and Ethernet

MAC addresses

2. How Devices Share a Network

CSMA/CD

CSMA/CA

Bandwidth

3. Collision Domains and Network Switches

4. Routing and Packet Delivery

What is a packet?

What is a hop count?

5. Circuit Switching and Message Switching

Circuit switching

Message switching

6. IP Addresses: IPv4 and IPv6

IPv4

IPv6

Static and dynamic IP addresses

7. Congestion Control

8. TCP/IP, ICMP, and BGP

TCP/IP

ICMP

BGP

9. The Internet of Things (IoT)

10. DNS: The Domain Name System

How DNS resolution works

DNS caching

What is DNS Time to Live (TTL)?

Conclusion

References for Further Reading

Cloud and DevOps Fundamentals: Git, Terraform, CI/CD, and SSH

1. Version Control with Git

Core Git concepts

Why Git matters in cloud engineering

2. Infrastructure as Code (IaC)

Why IaC is useful

3. Continuous Integration and Continuous Delivery/Deployment (CI/CD)

Continuous Integration (CI)

Continuous Delivery and Continuous Deployment

4. Observability: Understanding What's Happening Inside a System

Logs

Metrics

Traces

Monitoring and observability

5. Containers and Kubernetes

What is a container?

What is Kubernetes?

6. Terraform: Managing Infrastructure with Code

The Terraform workflow

Understanding a Terraform provider configuration

Why Terraform matters

7. SSH: Securely Accessing Remote Systems

What SSH provides

SSH tunnelling and port forwarding

Why SSH matters in cloud engineering

8. Essential Linux Networking Commands

ip addr

ip route

What about ifconfig?

What about iwconfig?

Conclusion

References

Bash Scripting Fundamentals: Commands, Variables, Loops, and Automation

Commands, Variables, Loops, and Automation

1. What Is a Bash Script?

2. Variables and User Input

Accepting user input

Passing arguments to a script

3. Working with Files and Command Output

Redirecting output

Reading file contents

Reading input from a file

4. Understanding Loops

The while loop

The for loop

5. Using case for Multiple Conditions

6. Debugging Bash Scripts

Using set -x

7. Scheduling Scripts with Cron

`ip addr`

`ip route`

What about `ifconfig`?

What about `iwconfig`?

The `while` loop

The `for` loop

5. Using `case` for Multiple Conditions

Using `set -x`