Forem: Aisalkyn Aidarova

Lab: next lab sre

Aisalkyn Aidarova — Fri, 17 Apr 2026 04:10:44 +0000

Current lab

You already have:

Network A
Network B
Router between them

Next lab

We will add these ideas:

Service separation
Monitoring
Controlled access
Failure testing
Basic reliability thinking

That is closer to SRE work.

Why this helps for SRE

An SRE does not only ask:

“Can these two PCs ping?”

An SRE asks:

Is the service reachable?
Who should be allowed to access it?
How do I know when it fails?
What happens if one link goes down?
How do I reduce blast radius?
How do I isolate problems quickly?

New lab goal

We will convert your current topology into this:

Left subnet = Clients / Users
Right subnet = Services / Servers
Router = traffic path between them
One PC on right side becomes Application Server
One PC on left or right side becomes Monitoring Node
Add ACL to control access
Test failure scenarios

Final design

Use your same 2-subnet lab, but rename the purpose.

Subnet 1

192.168.1.0/24

Role:

Users
Clients
Engineers’ laptops

Subnet 2

192.168.2.0/24

Role:

App server
Monitoring target
Internal services

Router interfaces

G0/0 → 192.168.1.1
G0/1 → 192.168.2.1

This matches the structure of your current lab, which already uses two routed networks.

What each part means in SRE terms

1. Client subnet

This represents:

users
internal engineers
systems sending requests

In real life:

office users
jump hosts
admin machines
frontend callers

2. Service subnet

This represents:

backend services
internal APIs
databases
monitoring targets

In real life:

app tier
DB tier
private service network

3. Router

This represents:

controlled traffic path
segmentation between environments

In real life, similar idea:

VPC routing
service boundaries
controlled network flow

4. ACL

This represents:

security policy
network restriction
blast-radius control

In real life:

security groups
network ACLs
firewall rules

5. Monitoring node

This represents:

observability
health checks
alert source

In real life:

Prometheus server
blackbox exporter
uptime monitoring

Lab roadmap

We will do it in this order:

Keep your current routing lab working
Turn PCs into roles
Add monitoring checks
Add access control
Simulate failure
Document what happened
Explain why this is SRE work

LAB: Next step after your subnetting lab

Step 1 — Keep the existing lab exactly as it is

From your current file, the router has:

enable
configure terminal

interface g0/0
ip address 192.168.1.1 255.255.255.0
no shutdown

interface g0/1
ip address 192.168.2.1 255.255.255.0
no shutdown

And the PCs use:

192.168.1.x on left
192.168.2.x on right
correct gateways

Do not change that yet.

Step 2 — Assign roles to devices

Use the devices you already have and rename them.

Left side

PC0 = Client-1
PC1 = Client-2
PC2 = Monitoring-Node

Right side

PC3 = App-Server
PC4 = DB-Server
PC5 = Backup-Server

This is still Packet Tracer, but now you are thinking like operations.

Step 3 — Verify baseline connectivity

From Client-1, test:

ping 192.168.1.11
ping 192.168.2.10
ping 192.168.2.11
ping 192.168.2.12

What this teaches

same subnet traffic uses switch
different subnet traffic uses router
baseline must be healthy before security or monitoring changes

SRE meaning

Before making changes, first confirm:

what is working
what is reachable
what “healthy” looks like

That is exactly how incident response starts.

Step 4 — Make one machine the “monitoring node”

Use PC2 as a monitoring machine.

From PC2, ping all service IPs:

ping 192.168.2.10
ping 192.168.2.11
ping 192.168.2.12

What this represents

This is basic service health checking.

What an SRE learns here

Monitoring is just repeated checking
If a server stops answering, that is a signal
You need one trusted point that checks services regularly

In real life

This becomes:

blackbox monitoring
ICMP checks
TCP checks
HTTP health endpoints

Step 5 — Add controlled access with ACL

Now we simulate a real policy:

Clients can access App-Server, but should not access DB-Server directly.

This is very important for SRE and production design.

Example rule

Allow:

192.168.1.0/24 → App-Server (192.168.2.10)

Deny:

192.168.1.0/24 → DB-Server (192.168.2.11)

Router config

On the router:

enable
configure terminal

access-list 101 permit icmp 192.168.1.0 0.0.0.255 host 192.168.2.10
access-list 101 deny icmp 192.168.1.0 0.0.0.255 host 192.168.2.11
access-list 101 permit ip any any

interface g0/0
ip access-group 101 in

What this means

clients may ping app server
clients may not ping DB server directly
everything else is allowed after that

Why this matters for SRE

An SRE thinks:

not every machine should reach every machine
databases should be protected
app tier and data tier should be separated

Step 6 — Test the policy

From Client-1:

ping 192.168.2.10
ping 192.168.2.11

Expected

ping to 192.168.2.10 should work
ping to 192.168.2.11 should fail

What this teaches

Security is part of reliability.

Why? Because secure boundaries reduce:

accidental damage
attack spread
wrong connections
noisy failures

Step 7 — Keep monitoring node more privileged

You may decide the monitoring node should still check both servers.

That teaches an important SRE concept:

Monitoring systems often need broader visibility than ordinary clients.

To simulate that, put the monitoring node in the allowed list.

Example, if PC2 is 192.168.1.12:

enable
configure terminal
no access-list 101

access-list 101 permit icmp host 192.168.1.12 host 192.168.2.10
access-list 101 permit icmp host 192.168.1.12 host 192.168.2.11
access-list 101 permit icmp 192.168.1.0 0.0.0.255 host 192.168.2.10
access-list 101 deny icmp 192.168.1.0 0.0.0.255 host 192.168.2.11
access-list 101 permit ip any any

interface g0/0
ip access-group 101 in

production traffic rules and monitoring rules are not always identical
observability often needs special access

Step 8 — Simulate a failure

Now we test the system when something breaks.

Option A: bring down service-side router interface

On router:

enable
configure terminal
interface g0/1
shutdown

What happens

all right-side services become unreachable
monitoring checks fail
client traffic fails

SRE lesson

This simulates:

service subnet outage
bad change
interface failure
network isolation incident

What to observe

From Monitoring-Node:

ping 192.168.2.10
ping 192.168.2.11
ping 192.168.2.12

All should fail.

Now restore:

enable
configure terminal
interface g0/1
no shutdown

This is a simple fail-and-recover drill.

Step 9 — Simulate partial failure

Instead of taking down the whole subnet, disconnect one service cable or power off one server PC.

What happens

one target fails
others stay healthy

SRE lesson

Learn to distinguish:

total outage
partial outage
isolated host issue

This is critical in troubleshooting.

Step 10 — Document expected behavior

Test	Expected result	Why
Client-1 to Client-2	Success	Same subnet
Client-1 to App-Server	Success	Routed and allowed
Client-1 to DB-Server	Fail	Blocked by ACL
Monitoring-Node to App-Server	Success	Monitoring allowed
Monitoring-Node to DB-Server	Success	Monitoring allowed
After G0/1 shutdown	Fail	Service subnet unavailable

This is how SREs think: define normal behavior before troubleshooting.

What this lab teaches about SRE work

1. Segmentation

Not every host should talk to every host.

2. Access control

Protect sensitive systems.

3. Monitoring

Continuously check service availability.

4. Failure testing

Break things on purpose and observe behavior.

5. Troubleshooting

Determine whether failure is:

network-wide
subnet-wide
service-specific
policy-related

6. Reliability mindset

A working network is not enough.
You need:

visibility
control
predictable behavior

Stage 1 — Basic routing

“Two networks communicate through a router.”

Stage 2 — Service roles

“One subnet acts like users, the other acts like services.”

Stage 3 — Monitoring

“One node continuously checks whether services are reachable.”

Stage 4 — ACL

“Not everybody is allowed to talk to everything.”

Stage 5 — Failure drill

“We intentionally break connectivity and confirm how the system behaves.”

Stage 6 — Recovery

“We restore service and confirm health again.”

That sequence is much closer to real SRE practice.

Very simple SRE interview explanation

You can say:

I would start with a routed two-subnet lab, then extend it by assigning service roles, adding monitoring checks, implementing ACL-based access control, and simulating failures. This helps demonstrate core SRE thinking: segmentation, observability, controlled access, outage detection, and recovery validation.

LAB: Subnetting with Router (2 Networks)

Aisalkyn Aidarova — Fri, 17 Apr 2026 03:34:19 +0000

🧠 PART 1 — WHAT YOU BUILT

LEFT side → Switch + PCs → Subnet 1
RIGHT side → Switch + PCs → Subnet 2
Middle → Router → connects them

👉 This is real-world design

🧠 PART 2 — WHY SUBNETTING IS IMPORTANT

❌ Without subnetting (one big network)

Too many devices
Broadcast storms
Slow network
No security separation

✅ With subnetting

You create smaller networks (subnets):

Benefit	Explanation
Performance	Less broadcast traffic
Security	Can control access
Organization	HR, IT, Finance separated
Scalability	Easy to grow

👉 Example (your lab):

Subnet 1 = Office A
Subnet 2 = Office B
Router = gate between them

🧠 PART 3 — SUBNET DESIGN (VERY IMPORTANT)

We define:

Subnet 1 (LEFT)

Network: 192.168.1.0/24
Gateway: 192.168.1.1

Subnet 2 (RIGHT)

Network: 192.168.2.0/24
Gateway: 192.168.2.1

💡 Explain `/24`

2^8 = 256

8 bits for hosts
256 IP addresses total
254 usable

🧠 PART 4 — CONFIGURATION (STEP-BY-STEP)

🔹 1. Configure Router

Open Router CLI:

enable
configure terminal

interface g0/0
ip address 192.168.1.1 255.255.255.0
no shutdown

interface g0/1
ip address 192.168.2.1 255.255.255.0
no shutdown

🔹 2. Configure PCs (VERY IMPORTANT)

LEFT PCs

PC	IP	Gateway
PC0	192.168.1.10	192.168.1.1
PC1	192.168.1.11	192.168.1.1
PC2	192.168.1.12	192.168.1.1

RIGHT PCs

PC	IP	Gateway
PC3	192.168.2.10	192.168.2.1
PC4	192.168.2.11	192.168.2.1
PC5	192.168.2.12	192.168.2.1

🧠 PART 5 — HOW IT WORKS (CRITICAL)

🔁 Same Subnet Communication

Example:

PC0 → PC1

✔ Goes through switch only
❌ Router NOT used

🌍 Different Subnet Communication

Example:

PC0 → PC3

Steps:

PC0 sees → destination is different subnet
Sends packet to default gateway (router)
Router checks routing table
Router forwards to subnet 2
PC3 receives

👉 THIS is the key concept:

Router = device that connects different networks

🧠 PART 6 — TESTING

🔹 Test same subnet

From PC0:

ping 192.168.1.11

✔ Should work

🔹 Test different subnet

ping 192.168.2.10

✔ Should work only if router configured correctly

🧠 PART 7 — WHAT HAPPENS IF NO ROUTER?

👉 “What if router is removed?”

Answer:

PC0 cannot reach PC3
Because different networks need routing

🧠 PART 8 — INTERVIEW LEVEL EXPLANATION

You can say:

Subnetting divides a large network into smaller logical networks to improve performance, security, and manageability. Devices within the same subnet communicate directly via Layer 2, while communication between subnets requires a Layer 3 device like a router.

🧪 BONUS TASK

Change subnet mask to /25
Create 4 subnets
Assign new IPs
Test connectivity

🧠 WHAT IS BROADCASTING?

Broadcast = one device sends data to ALL devices in the network

🔁 Example

PC1 → ALL PCs in same network

📦 Real case (VERY IMPORTANT)

When PC1 doesn’t know MAC address:

It sends:

“Who has 192.168.1.20?”

👉 This is ARP broadcast

🔹 What happens

Switch receives frame
Sends it to ALL ports (same VLAN only)

💡 Key rule

Broadcast stays inside the same subnet / VLAN

🔥 In your lab

VLAN 10 → broadcast stays inside VLAN 10
VLAN 20 → separate broadcast domain

🧠 WHAT IS MULTICASTING?

Multicast = one device sends data to a specific GROUP of devices

🔁 Example

Server → Only interested clients

📦 Real examples

Video streaming
Online classes
Stock market feeds

👉 Not everyone receives it — only subscribers

🔹 IP Range for Multicast

224.0.0.0 – 239.255.255.255

🧠 WHAT IS UNICAST (IMPORTANT TOO)

Unicast = one-to-one communication

🔁 Example

PC1 → PC2

✔ Most common
✔ Used in ping, web traffic, SSH

⚖️ DIFFERENCE (VERY CLEAR)

Type	Meaning	Example
Unicast	1 → 1	PC → Server
Broadcast	1 → ALL	ARP request
Multicast	1 → Group	Streaming

🧠 SIMPLE ANALOGY

Unicast → Phone call
Broadcast → Shouting in a room
Multicast → Talking to a group in a meeting

🔥 WHY BROADCAST IS IMPORTANT (AND DANGEROUS)

✅ Needed for:

ARP
DHCP discovery

❌ Problem:

Too many broadcasts =

👉 Network slowdown
👉 CPU overload
👉 “Broadcast storm”

🧠 HOW VLAN HELPS

👉 VLAN reduces broadcast

Instead of:

1 big network → 1000 devices receive broadcast

You get:

VLAN 10 → 100 devices
VLAN 20 → 100 devices

✔ Faster
✔ Cleaner

🧠 HOW ROUTER HANDLES IT

👉 Router does NOT forward broadcast

Example:

PC in VLAN10 sends broadcast ❌ Router blocks it ✔ VLAN20 never receives it

🧠 MULTICAST IN REAL NETWORKS

Used when:

You don’t want broadcast (too heavy)
You don’t want multiple unicast (too expensive)

Example:

Instead of:

Server → 100 users (100 separate streams)

Multicast:

Server → 1 stream → group receives

✔ Efficient

🔥 INTERVIEW ANSWER (SHORT)

Broadcast is one-to-all communication within a subnet or VLAN and is used for operations like ARP. Multicast is one-to-many communication where data is sent only to a specific group of devices. Unlike broadcast, multicast is more efficient because it avoids sending data to unnecessary devices.

In your Packet Tracer:

ARP request = broadcast
Ping = unicast
VLAN = controls broadcast domain

🔥 FINAL LINE (MEMORIZE)

Broadcast sends data to all devices in a network, multicast sends data to a selected group, and unicast sends data to a single device.

🧠 PART 1 — HOW COMMUNICATION REALLY WORKS

🔹 1. SAME NETWORK (NO VLAN)

Example:

PC1 (192.168.1.10) → PC2 (192.168.1.20)

What happens step-by-step:

PC1 checks:

“Is 192.168.1.20 in my network?” ✔ YES

PC1 sends ARP:

“Who has 192.168.1.20?”

Switch:

Broadcasts to all ports

PC2 replies with MAC
Switch learns:

MAC → Port mapping (MAC table)

Data flows directly

👉 Key:

Uses MAC address
Switch works at Layer 2
Router NOT used

🧠 2. DIFFERENT NETWORK (SUBNET)

Example:

PC1 (192.168.1.10) → PC3 (192.168.2.10)

What happens:

PC1 checks:
❌ “Different network”
PC1 sends packet to:

Default Gateway (Router)

Router:

Removes Layer 2 frame
Checks IP (Layer 3)
Decides where to send

Router forwards to subnet 2

👉 Key:

Uses IP address
Router is required

🧠 3. VLAN (WHY SWITCH BLOCKS)

Example:

PC1 → VLAN 10
PC2 → VLAN 20

What happens:

PC1 sends ARP
Switch checks VLAN
❌ Does NOT forward to VLAN 20

👉 VLAN = separate broadcast domain

🧠 FINAL RULE (MEMORIZE)

👉 Same VLAN → Switch
👉 Different VLAN → Router

🚀 PART 2 — FULL LAB (USING YOUR TOPOLOGY)

🎯 Goal

You will:

Create VLANs
Assign ports
Configure trunk
Configure router (inter-VLAN routing)
Enable DHCP
Add ACL security
Test everything

🧪 STEP 1 — VERIFY TOPOLOGY

You already have:

PCs ✔
Switch ✔
Router ✔

Make sure:

PCs connected to switch
Switch connected to router

🧪 STEP 2 — SWITCH CONFIGURATION

Click Switch → CLI:

🔹 Enter config mode

enable
configure terminal

🔹 Create VLANs

vlan 10
name HR

vlan 20
name IT

🔹 Assign Ports

Example (adjust to your ports):

interface fa0/1
switchport mode access
switchport access vlan 10

interface fa0/2
switchport mode access
switchport access vlan 10

interface fa0/3
switchport mode access
switchport access vlan 20

interface fa0/4
switchport mode access
switchport access vlan 20

🔹 Configure Trunk (IMPORTANT)

Port connected to router:

interface fa0/24
switchport mode trunk

🧪 STEP 3 — ROUTER CONFIGURATION

Click Router → CLI:

🔹 Enter config

enable
configure terminal

🔹 Router-on-a-Stick

interface g0/0.10
encapsulation dot1Q 10
ip address 192.168.10.1 255.255.255.0

interface g0/0.20
encapsulation dot1Q 20
ip address 192.168.20.1 255.255.255.0

interface g0/0
no shutdown

👉 This allows router to handle VLANs

🧪 STEP 4 — DHCP CONFIG

ip dhcp pool HR
network 192.168.10.0 255.255.255.0
default-router 192.168.10.1

ip dhcp pool IT
network 192.168.20.0 255.255.255.0
default-router 192.168.20.1

🔹 On PCs

Click PC
Desktop → IP Configuration
Select DHCP

🧪 STEP 5 — ACL (SECURITY)

🎯 Block HR → IT

access-list 100 deny ip 192.168.10.0 0.0.0.255 192.168.20.0 0.0.0.255
access-list 100 permit ip any any

🔹 Apply ACL

interface g0/0.10
ip access-group 100 in

🧪 STEP 6 — TESTING

✅ SAME VLAN

From VLAN10 PC:

ping 192.168.10.X

✔ Should work

❌ BLOCKED

From VLAN10:

ping 192.168.20.X

❌ Should fail

✅ ALLOWED

From VLAN20:

ping 192.168.10.X

✔ Should work

🧠 PART 3 — WHAT STUDENTS MUST UNDERSTAND

🔹 Switch Role

Forwards based on MAC
Works inside VLAN only

🔹 VLAN Role

Separates Layer 2 traffic
Creates isolated networks

🔹 Subnet Role

Defines IP structure
Enables routing

🔹 Router Role

Connects networks
Routes packets

🔹 DHCP Role

Assigns IP automatically

🔹 ACL Role

Controls traffic (security)

🔥 FINAL INTERVIEW ANSWER

Devices in the same VLAN communicate directly using Layer 2 switching. When devices are in different VLANs or subnets, communication requires a Layer 3 device such as a router. VLANs provide logical segmentation, subnetting provides IP structure, and routing enables communication between networks.

Sizes in Computers (VERY IMPORTANT FOUNDATION)

Aisalkyn Aidarova — Thu, 16 Apr 2026 03:36:12 +0000

NUMBER SYSTEMS & HEX ↔ DECIMAL

number systems and specifically how to convert between hexadecimal and decimal.

In computing and networking, we use different types of number systems. A number system is simply a way to represent numbers.

In everyday life, we use the decimal system, which is base 10. That means it uses digits from 0 to 9.

In computing, there are three other very important number systems:

Binary (base 2)
Octal (base 8)
Hexadecimal (base 16)

Hexadecimal is a positional number system with base 16. It uses 16 symbols:

0 to 9
A, B, C, D, E, F

The letters represent values:

```text id="hexmap"
A = 10
B = 11
C = 12
D = 13
E = 14
F = 15






Each position in a hexadecimal number represents a power of 16.

For example, a two-digit hex number has positions:



```text id="pos16"
16^1   16^0

🧪 EXAMPLE 1 — HEX → DECIMAL

Convert B6 to decimal.

Step 1: Write positional values.

```text id="ex1pos"
B 6
16^1 16^0




Step 2: Convert hex to decimal.



```text id="ex1conv"
B = 11
6 = 6

Step 3: Multiply by powers.

```text id="ex1math"
11 × 16 = 176
6 × 1 = 6




Step 4: Add results.



```text id="ex1sum"
176 + 6 = 182

So, B6 in hexadecimal equals 182 in decimal.

🧪 EXAMPLE 2 — HEX → DECIMAL

Convert A59C to decimal.

Step 1: Positions:

```text id="ex2pos"
A 5 9 C
16^3 16^2 16^1 16^0




Step 2: Convert values:



```text id="ex2conv"
A = 10
5 = 5
9 = 9
C = 12

Step 3: Multiply:

```text id="ex2math"
10 × 16^3 = 40960
5 × 16^2 = 1280
9 × 16 = 144
12 × 1 = 12




Step 4: Add:



```text id="ex2sum"
40960 + 1280 + 144 + 12 = 42396

So, A59C equals 42396 in decimal.

🔁 DECIMAL → HEXADECIMAL

Now we do the reverse.

We convert decimal to hexadecimal using division by 16.

🧪 EXAMPLE 3 — DECIMAL → HEX

Convert 256 to hexadecimal.

Step-by-step:

```text id="ex3steps"
256 ÷ 16 = 16 remainder 0
16 ÷ 16 = 1 remainder 0
1 ÷ 16 = 0 remainder 1




Now write remainders from bottom to top:



```text id="ex3result"
100

So:

256 = 100 (hex)

🧪 EXAMPLE 4 — DECIMAL → HEX

Convert 7562 to hexadecimal.

Step-by-step:

```text id="ex4steps"
7562 ÷ 16 = 472 remainder 10
472 ÷ 16 = 29 remainder 8
29 ÷ 16 = 1 remainder 13
1 ÷ 16 = 0 remainder 1




Convert remainders:



```text id="ex4conv"
10 = A
8 = 8
13 = D
1 = 1

Write bottom to top:

```text id="ex4result"
1D8A




So:

7562 = 1D8A (hex)

---

# 🧠 IMPORTANT RULES

### Hex → Decimal

👉 Multiply each digit by powers of 16 and add

### Decimal → Hex

👉 Divide by 16 repeatedly and collect remainders



“Hexadecimal is base 16, which means each position represents powers of 16. To convert from hex to decimal, we multiply each digit by its positional value and add the results. To convert from decimal to hex, we repeatedly divide by 16 and track the remainders.”

---

# 🧠 WHY THIS IS IMPORTANT (NETWORKING)

In networking:

* MAC addresses use hexadecimal
* IPv6 uses hexadecimal
* Memory addresses use hexadecimal

---

# 💻 PRACTICE 

### Convert to decimal:



```text id="practice1"
1A
2F
FF

Convert to hex:

```text id="practice2"
100
500
1024




---

# 🚀 INTERVIEW ANSWER

“Hexadecimal is a base-16 number system commonly used in computing. Conversion from hex to decimal involves multiplying digits by powers of 16, while conversion from decimal to hex uses repeated division by 16.”

---

# 🎯 FINAL SUMMARY

* Decimal = base 10
* Hex = base 16
* Hex uses 0–9 and A–F
* Use multiplication for hex → decimal
* Use division for decimal → hex





Everything in networking is based on **bits → bytes → IP**

---

## What is a BIT?

👉 A **bit** is the smallest unit of data



```text
bit = 0 or 1

0 = OFF
1 = ON

What is a BYTE?

👉 A byte = 8 bits

1 byte = 8 bits

Example:

10101010  → 1 byte

What is an OCTET?

👉 An octet = 8 bits (same as byte)

In networking, we say:

byte → general computing
octet → networking (IP addresses)

🎯 KEY IDEA

1 octet = 8 bits = numbers from 0 to 255

🎓 2. Why 0–255?

Because:

2^8 = 256

👉 So:

0 to 255 = 256 values

🎓 3. Structure of IP Address

Example:

192.168.1.10

This has 4 octets:

[192] [168] [1] [10]

Each one = 8 bits

Total:

4 × 8 = 32 bits

🎓 4. The “BOX METHOD” (This is what you asked)

This is how you convert numbers like 192 into bits

Step 1 — Draw boxes

Each octet has 8 boxes (bits)

128  64  32  16  8  4  2  1
[  ] [  ] [  ] [  ] [ ] [ ] [ ] [ ]

👉 These numbers are powers of 2

🎓 5. Example: Convert 192

We need to make 192 using these numbers

Step-by-step:

192 - 128 = 64 → use 128 → put 1
64 - 64 = 0   → use 64  → put 1

Remaining = 0 → rest are 0

Final boxes:

128  64  32  16  8  4  2  1
 1    1   0   0   0  0  0  0

Final answer:

192 = 11000000

🎓 6. Example: Convert 168

Step-by-step:

168 - 128 = 40 → 1
40 - 32 = 8   → 1
8 - 8 = 0     → 1

Boxes:

128  64  32  16  8  4  2  1
 1    0   1   0   1  0  0  0

Final:

168 = 10101000

🎓 7. Example: Convert 1

00000001

🎓 8. Example: Convert 0

00000000

🎓 9. Full IP in Binary

192.168.1.10 =
11000000.10101000.00000001.00001010

🎓 10. VERY SIMPLE MEMORY TRICK

👉 Think:

Big numbers → left side
Small numbers → right side

🎓 11. Shortcut Table (Memorize This)

Decimal	Binary
128	10000000
192	11000000
224	11100000
240	11110000
248	11111000
252	11111100
255	11111111

👉 These are used in subnet masks

🎓 12. Why This Matters

You need this to understand:

subnet mask
network vs host
AWS VPC
CIDR

🎓 FINAL SUMMARY

👉 bit = 0 or 1
👉 8 bits = 1 byte = 1 octet
👉 octet = 0–255
👉 IP = 4 octets = 32 bits
👉 boxes = powers of 2
👉 fill with 1s to reach number

SUBNET MASK (STRUCTURED + WITH CODE EXAMPLES), how a computer communicates in a network

Aisalkyn Aidarova — Thu, 16 Apr 2026 03:29:46 +0000

How a computer communicates locally and remotely, what information is required, and what networking devices are involved in these processes.

First, let us understand what information a computer must have in order to function properly in a TCP/IP network.

Every computer needs four key pieces of information:

MAC address
IP address
Subnet mask
Default gateway

The MAC address is the physical address of the device. It is a 48-bit hexadecimal number and uniquely identifies a network interface on the local network.

The IP address is the logical address used to identify the device on a network. This is what allows devices to communicate across networks.

The subnet mask is used to determine whether another device is in the same network or a different network. This is one of the most important concepts in networking.

The default gateway is the IP address of the router that is responsible for forwarding traffic outside the local network.

Now the question is: when does a computer use each of these?

To understand this, let us look at a scenario.

We have one computer, which we will call Computer A. Computer A wants to communicate with two other devices:

Computer B (inside the same network)
Computer C (outside the network, possibly on the internet)

The first thing Computer A does is use the subnet mask.

The subnet mask helps Computer A answer a very important question:

Is the destination in the same network or a different network?

If the answer is yes, meaning the destination is in the same network, then the communication is local.

If the answer is no, meaning the destination is in a different network, then the communication is remote.

Let us first look at local communication.

When Computer A determines that Computer B is in the same network, it does not use the router. Instead, it communicates directly through a switch.

However, to communicate, Computer A needs the MAC address of Computer B.

So the process is as follows:

First, Computer A sends an ARP request. ARP stands for Address Resolution Protocol. It is used to find the MAC address of a device using its IP address.

The ARP request is basically asking:

“Who has this IP address?”

Then Computer B responds with its MAC address.

After that, Computer A uses this MAC address to create a frame and sends data directly to Computer B.

This communication happens through a switch, which is a Layer 2 device.

In this situation, the default gateway is not used at all.

Now let us look at remote communication.

When Computer A determines that Computer C is not in the same network, it cannot send data directly.

Instead, it must send the data to the default gateway.

The default gateway is a router, which is a Layer 3 device.

The process is similar at the beginning.

Computer A uses ARP again, but this time it is not asking for Computer C’s MAC address.

Instead, it asks:

“What is the MAC address of my default gateway?”

The router replies with its MAC address.

Now Computer A sends the packet to the router.

The router then takes that packet and forwards it toward the destination network, eventually reaching Computer C.

So the key difference is:

In local communication, MAC addresses are used and the switch handles the communication.

In remote communication, IP addresses are used and the router handles the communication.

The subnet mask plays a critical role because it determines whether the communication is local or remote.

The default gateway is only used when the destination is outside the local network.

ARP is used in both cases to resolve IP addresses into MAC addresses.

Let us summarize everything.

A computer first uses the subnet mask to determine whether the destination is local or remote.

If the destination is local, the computer uses ARP to find the MAC address of the destination and sends the data through a switch.

If the destination is remote, the computer uses ARP to find the MAC address of the default gateway, sends the data to the router, and the router forwards the packet to the destination.

This is how communication works in a TCP/IP network.

💻 COMMANDS (ONLY CODE)

Check IP configuration

ipconfig /all

Test local communication

ping 192.168.1.2

Test remote communication

ping 192.168.2.1

Check ARP table

arp -a

Router configuration (interfaces)

enable
configure terminal

interface gigabitEthernet0/0
ip address 192.168.1.254 255.255.255.0
no shutdown

interface gigabitEthernet0/1
ip address 192.168.2.254 255.255.255.0
no shutdown

end

Verify router interfaces

show ip interface brief

A computer uses the subnet mask to determine whether communication is local or remote. For local communication, it uses ARP to resolve MAC addresses and communicates through a switch. For remote communication, it sends traffic to the default gateway, and the router forwards the packet using IP routing.

2. What is an IP Address?

An IP address is an identifier for a computer or device on a network. Every device has to have an IP address for communication purposes.

And to be specific, I'm talking about an IPv4 address.

An IPv4 address is a 32-bit numeric address, written as four numbers, separated by periods. Each group of numbers that are separated by periods is called an octet. The number range in each octet is from 0 - 255.

3. Network and Host Parts

An IP address consists of two parts. The first part is the network address and the second part is the host address.

The network address or network ID is a number that's assigned to a network. So every network will have a unique address.

The host address or host ID is what's assigned to hosts within that network such as computers, servers, tablets, routers, and so on. So every host will have a unique host address.

4. Subnet Mask

Now the way to tell which portion of the IP address is the network or the host, is where the subnet mask comes in.

A subnet mask is a number that resembles an IP address. And it reveals how many bits in the IP address are used for the network by masking the network portion of the IP address.

5. Binary (How Computers Understand)

Now in the world of computers and networks, IP addresses and subnet masks in this decimal format here are meaningless. And this is because computers and networks don't read them in this format and that's because they only understand numbers in a binary format, which are 1s and 0s. And these are called bits.

So the binary number for this IP address is this number here. And the binary number for this subnet mask is this number. And these are the numbers that computers and networks only understand.

6. How to Convert to Binary

So the next question is, how do we get these binary numbers from this IP address and this subnet mask?

So here we have an 8 bit octet chart. The bits in each octet are represented by a number. So starting from the right, the first bit has a value of 1 and then the number doubles with each step. So there's 2 then 4, 8, and so on, all the way up to 128.

Each bit in the octet can be either a 1 or a 0. If the number is a 1 then the number that it represents counts. If the number is a 0 then the number that it represents does not count.

So by manipulating the 1s and 0s in the octet you can come up with a number range from 0 - 255.

7. Example: Binary Conversion

So for example, the first octet in this IP address is 192.

128 + 64 = 192

192 = 11000000

Next octet is 168:

128 + 32 + 8 = 168

168 = 10101000

Next octet is 1:

1 = 00000001

Last octet is 0:

0 = 00000000

Final binary IP:

192.168.1.0 = 11000000.10101000.00000001.00000000

8. Subnet Mask in Binary

Now the subnet mask binary conversion is exactly the same way.

So in this subnet mask the first 3 octets are 255. So if we were to look at this subnet mask in binary form, the first 3 octets would be all 1s because when you count all the numbers in an octet it will equal 255.

255 = 11111111
0   = 00000000

255.255.255.0 =
11111111.11111111.11111111.00000000

9. How Subnet Mask Defines Network and Host

So here we have our IP address and subnet mask in binary form lined up together.

So the way to tell which portion of this IP address is the network part, is when the subnet mask binary digit is a 1 it will indicate the position of the IP address that defines the network.

So we'll cross out all the digits in the IP address that line up with the 1s in the subnet mask.

So the 1s in the subnet mask indicate the network address and the 0s indicate the host addresses.

10. Example: Network vs Host

IP:   192.168.1.10
Mask: 255.255.255.0

Network: 192.168.1
Host:                10

11. Advanced Mask Example (224)

Now what if the subnet mask was 224?

224 = 11100000

So:

Mask: 255.255.224.0

11111111.11111111.11100000.00000000

This means:

first 2 octets + part of 3rd = network
rest = host

12. Why Network + Host Exists

Now the reason for this is manageability. It's for breaking down a large network into smaller networks or subnetworks, which is known as subnetting.

13. Problem Without Subnetting

If all computers are in one network:

broadcast goes to everyone
network becomes slow
hard to manage

14. Routers

Networks are broken down and physically separated by using routers.

Broadcasts do not go past routers.

15. Subnetting

Subnetting is done by changing the subnet mask by borrowing some of the bits that were designated for hosts.

16. Borrowing Bits (IMPORTANT)

Original:

/24 → 255.255.255.0
Hosts = 254
Subnets = 1

Borrow 1 bit:

/25 → 255.255.255.128

Subnets = 2
Hosts per subnet = 126

Borrow 2 bits:

/26 → 255.255.255.192

Subnets = 4
Hosts = 62

Borrow 3 bits:

/27 → 255.255.255.224

Subnets = 8
Hosts = 30

Borrow 4 bits:

/28 → 255.255.255.240

Subnets = 16
Hosts = 14

Borrow 5 bits:

/29 → 255.255.255.248

Subnets = 32
Hosts = 6

Borrow 6 bits:

/30 → 255.255.255.252

Subnets = 64
Hosts = 2

Borrow 7 bits:

/31 → 255.255.255.254

Subnets = 128
Hosts = 0 usable

17. Important Rule

The more bits the network portion borrows from the host portion:

number of subnets doubles
number of hosts halves

18. Example: Business Case

We need 3 networks.

We borrow 2 bits → /26

255.255.255.192

This gives:

4 subnets (enough for 3)

19. Subnet Ranges Example

Step = 256 - 192 = 64

Subnets:
0
64
128
192

Ranges:

20. CIDR

CIDR = slash notation

/24 = 255.255.255.0
/25 = 255.255.255.128
/26 = 255.255.255.192

21. Final Summary

IP = identifier
Bits = 0 and 1
Subnet mask = divides network and host
1 = network, 0 = host
Subnetting = splitting networks
Borrow bits → more networks, fewer hosts

IP address and subletting

Aisalkyn Aidarova — Wed, 15 Apr 2026 01:39:35 +0000

🧠 PART 1 — What is an IP Address?

An IP address is a unique identifier for a device in a network.

Example:

192.168.1.10

Every IP has 2 parts:

[ NETWORK PART ] [ HOST PART ]

🔍 PART 2 — Network vs Host (MOST IMPORTANT)

Example:

IP: 192.168.1.10
Mask: 255.255.255.0 (/24)

👉 This means:

Network: 192.168.1
Host: .10

🧠 Rule

Subnet mask decides the split.

📊 PART 3 — Subnet Mask Explained (Power Concept)

Example:

255.255.255.0

Binary:

11111111.11111111.11111111.00000000

👉 Count 1s:

24 bits → NETWORK
8 bits → HOST

🔥 POWER RULE (THIS IS YOUR “POWER 8”)

👉 Number of hosts =

2^(host bits) - 2

Example:

For /24:

Host bits = 8

2^8 = 256
256 - 2 = 254 usable IPs

💡 WHY -2?

Because:

1 = Network address
1 = Broadcast address

📊 QUICK TABLE (VERY IMPORTANT FOR TEACHING)

Subnet	Host Bits	Total IPs	Usable
/24	8	256	254
/25	7	128	126
/26	6	64	62
/27	5	32	30
/28	4	16	14

🧠 PART 4 — What is Subnetting?

Subnetting = dividing one network into smaller networks.

Example:

192.168.1.0/24

Split into 2:

192.168.1.0/25
192.168.1.128/25

🔥 PART 5 — HOW SPLITTING WORKS

Example: /24 → /25

Borrow 1 bit

So:

2^1 = 2 subnets

Result:

Subnet	Range
192.168.1.0/25	1–126
192.168.1.128/25	129–254

🧪 PART 6 — LAB (VERY IMPORTANT)

🎯 Goal:

Understand:

network vs host
subnetting
IP allocation

🔧 LAB SETUP

Use ONE network:

192.168.1.0/24

STEP 1 — Split into 2 subnets

Subnet mask → /25

Now you have:

Subnet 1:

Network: 192.168.1.0
Range: 192.168.1.1 – 192.168.1.126
Gateway: 192.168.1.126 or .1

Subnet 2:

Network: 192.168.1.128
Range: 192.168.1.129 – 192.168.1.254
Gateway: 192.168.1.254 or .129

STEP 2 — Build in Packet Tracer

Devices:

1 Router
2 Switches
4 PCs (2 per subnet)

STEP 3 — Assign IPs

Subnet 1:

PC1 → 192.168.1.10
PC2 → 192.168.1.20
Gateway → 192.168.1.1
Mask → 255.255.255.128

Subnet 2:

PC3 → 192.168.1.130
PC4 → 192.168.1.140
Gateway → 192.168.1.129
Mask → 255.255.255.128

STEP 4 — Configure Router

enable
configure terminal

interface g0/0
ip address 192.168.1.1 255.255.255.128
no shutdown

interface g0/1
ip address 192.168.1.129 255.255.255.128
no shutdown
end

STEP 5 — TEST

Same subnet:

ping 192.168.1.20

✔ works

Different subnet:

ping 192.168.1.130

✔ works via router

🧠 PART 7 — EXPLAIN LIKE A PRO

👉 You can say:

“An IP address is divided into network and host portions based on the subnet mask. Subnetting allows us to split a large network into smaller networks. For example, a /24 network can be divided into two /25 subnets by borrowing one bit. Each subnet has its own range of usable IP addresses. This improves organization, scalability, and security.”

🔥 BONUS — VISUAL EXPLANATION (VERY POWERFUL)

Think:

/24 = one big apartment building
/25 = two floors
/26 = four floors

Each split:

2^n networks

packet tracer lab: subletting

Aisalkyn Aidarova — Tue, 14 Apr 2026 20:08:11 +0000

1. What is a subnet?

A subnet, or subnetwork, is a smaller network created from a larger IP network. Instead of putting every device into one big network, we divide the network into smaller logical groups.

For example, instead of placing all devices in one network like this:

192.168.1.0/24

we can separate devices into different networks like this:

192.168.1.0/24
192.168.2.0/24

Each of these is a separate subnet.

A subnet is a logical boundary. Devices inside the same subnet can communicate directly. Devices in different subnets cannot communicate directly unless a router or Layer 3 device routes traffic between them.

That is the key idea:

Same subnet = direct communication
Different subnet = router required

2. What does “segregation by subnet” mean?

Segregation means separating devices into different network groups based on purpose, role, department, security level, or location.

For example, a company may separate:

HR department
Finance department
Developers
Servers
Guests
Printers
Security cameras

Instead of allowing all of them to live in one big flat network, the company creates different subnets.

Example:

192.168.10.0/24  → HR
192.168.20.0/24  → Finance
192.168.30.0/24  → Developers
192.168.40.0/24  → Servers
192.168.50.0/24  → Guest Wi-Fi

This is network segregation.

3. Why do companies separate subnets?

Companies separate subnets because one large network creates many problems.

Security

If every device is in one subnet, every device is closer to every other device. If one machine is compromised, an attacker can move more easily across the network.

When networks are separated into subnets, companies can control communication between them using routers, ACLs, firewalls, and security policies.

Example:

Guest Wi-Fi should not access company servers
Finance should not be reachable by everyone
Test environment should not freely reach production

Performance

In one large subnet, broadcast traffic increases. More devices share the same broadcast domain. That can slow down the network.

Subnetting reduces unnecessary broadcast traffic.

Easier management

It is easier to identify devices and departments when each subnet has a purpose.

Example:

192.168.10.x = HR
192.168.20.x = Finance
192.168.30.x = IT

This makes troubleshooting easier.

Better control

Companies can decide:

which subnet can talk to which subnet
which ports are allowed
which applications are allowed
which users are isolated

Scalability

As a company grows, one big network becomes messy. Subnetting helps the network grow in a clean and organized way.

4. Real-world company example

Imagine a company has:

HR users
Finance users
Developers
Application servers
Database servers
Guest Wi-Fi

If all devices are in one network, then:

guests might reach internal systems
developers may access finance systems directly
malware can spread more easily
troubleshooting becomes harder

A better design is:

Subnet 1: 192.168.1.0/24   → Office Users
Subnet 2: 192.168.2.0/24   → Servers

Then the router controls traffic between them.

That is the idea you are building in Packet Tracer.

5. Important subnet terms

Network address

This identifies the subnet itself.

Example:

192.168.1.0/24

192.168.1.0 is the network address.

Host address

These are usable device IP addresses inside the subnet.

Example:

192.168.1.1
192.168.1.2
192.168.1.100

Broadcast address

This is the last address in the subnet, used for broadcast traffic.

For 192.168.1.0/24, broadcast is:

192.168.1.255

Subnet mask

The subnet mask tells us which part of the IP is the network portion and which part is the host portion.

Example:

255.255.255.0

This means /24.

Default gateway

This is the router interface IP used to leave the local subnet.

Example:

192.168.1.254

If a host wants to reach another subnet, it sends traffic to the default gateway.

6. Lab objective

In this lab, you will build two separate subnets and observe:

devices in each subnet
routing between subnets
why the router is required
how segregation improves control
how ACLs can block one subnet from reaching another

7. Lab topology

Subnet 1

Network: 192.168.1.0/24
Gateway: 192.168.1.254
Devices:
PC0 → 192.168.1.1
PC1 → 192.168.1.2
PC2 → 192.168.1.3

Subnet 2

Network: 192.168.2.0/24
Gateway: 192.168.2.254
Devices:
Laptop0 → 192.168.2.1
Laptop1 → 192.168.2.2
Laptop2 → 192.168.2.3

Router interfaces

GigabitEthernet0/0 → 192.168.1.254
GigabitEthernet0/1 → 192.168.2.254

8. Devices needed

Use these in Packet Tracer:

1 Router (1941)
2 Switches
3 PCs
3 Laptops
Copper straight-through cables

9. Build the topology

Step 1: Add devices

Place:

one router in the middle
one switch for subnet 1
one switch for subnet 2
three PCs on the left side
three laptops on the right side

Step 2: Cable connections

Connect:

PC0 to Switch1
PC1 to Switch1
PC2 to Switch1
Switch1 to Router Gig0/0

Connect:

Laptop0 to Switch2
Laptop1 to Switch2
Laptop2 to Switch2
Switch2 to Router Gig0/1

Use straight-through cables or automatic cable selection.

10. Configure subnet 1 hosts

On each PC, go to Desktop → IP Configuration.

PC0

IP Address: 192.168.1.1
Subnet Mask: 255.255.255.0
Default Gateway: 192.168.1.254

PC1

IP Address: 192.168.1.2
Subnet Mask: 255.255.255.0
Default Gateway: 192.168.1.254

PC2

IP Address: 192.168.1.3
Subnet Mask: 255.255.255.0
Default Gateway: 192.168.1.254

11. Configure subnet 2 hosts

Laptop0

IP Address: 192.168.2.1
Subnet Mask: 255.255.255.0
Default Gateway: 192.168.2.254

Laptop1

IP Address: 192.168.2.2
Subnet Mask: 255.255.255.0
Default Gateway: 192.168.2.254

Laptop2

IP Address: 192.168.2.3
Subnet Mask: 255.255.255.0
Default Gateway: 192.168.2.254

12. Configure the router

Open router CLI and type:

enable
configure terminal
interface gigabitEthernet0/0
ip address 192.168.1.254 255.255.255.0
no shutdown
exit
interface gigabitEthernet0/1
ip address 192.168.2.254 255.255.255.0
no shutdown
end

13. Verification lab

Test 1: Same subnet communication

From PC0, ping PC1:

ping 192.168.1.2

This should succeed.

Why? Because both devices are in the same subnet and can communicate directly through the switch.

Test 2: Across subnets

From PC0, ping Laptop0:

ping 192.168.2.1

This should also succeed if the router is configured correctly.

Why? Because the router connects both subnets and forwards traffic between them.

14. Explain what is happening during the ping

When PC0 tries to reach 192.168.2.1, it checks the destination.

PC0 sees that 192.168.2.1 is not in its own subnet, because PC0 belongs to 192.168.1.0/24.

So PC0 does not send traffic directly to Laptop0. Instead, it sends traffic to its default gateway:

192.168.1.254

That is the router interface.

The router receives the packet, checks its routing information, and forwards the packet to the second subnet through interface Gig0/1.

That is why default gateway is so important.

15. Show the importance of segregation

Now you can explain the design like this:

“In this lab, I created two separate subnets. Devices in subnet 1 use the 192.168.1.0/24 range. Devices in subnet 2 use the 192.168.2.0/24 range. The separation gives us better security, control, and organization. Instead of allowing every device to exist in one flat network, we created logical boundaries. The router provides controlled communication between these boundaries.”

That is a strong explanation.

16. Security control lab with ACL

Now show why segregation is powerful.

Without segregation, all devices are in one flat network and it is harder to control communication.

With separate subnets, the router can control traffic.

Goal

Block subnet 1 from reaching subnet 2.

In router CLI:

enable
configure terminal
access-list 100 deny ip 192.168.1.0 0.0.0.255 192.168.2.0 0.0.0.255
access-list 100 permit ip any any
interface gigabitEthernet0/0
ip access-group 100 in
end

17. Test security policy

From PC0:

ping 192.168.2.1

This should fail.

Why? Because the router is now blocking traffic from subnet 1 to subnet 2.

That is the real value of subnet segregation:
it allows traffic control between groups.

21. Interview-ready answer

Here is a polished answer:

“A subnet is a logical subdivision of an IP network. It groups devices into smaller broadcast domains. Companies use subnetting to improve security, reduce broadcast traffic, organize departments or services, and control communication between groups. In my lab, I created two subnets, configured router interfaces as gateways for each subnet, verified inter-subnet routing, and then applied an ACL to block one subnet from accessing the other. That demonstrated why segmentation is important in real environments.”

22. Simple real-life analogy

You can explain it like this:

“A large company building has many departments. If everyone works in one giant open room, it becomes noisy, unorganized, and insecure. Subnetting is like giving each department its own room. The router is like the controlled hallway between rooms. The ACL is like a security guard deciding who can pass.”

That makes the idea very easy to remember.

23. Short conclusion

Subnetting is not only about IP addresses. It is about design, control, and security.

When a company creates subnets, it is organizing the network in a smarter way. It separates traffic, reduces unnecessary communication, improves performance, and makes policy enforcement possible. That is why subnetting is so important in enterprise networking, cloud networking, and DevOps environments.

Install Packet Tracer (Mac) + First Network

Aisalkyn Aidarova — Mon, 13 Apr 2026 22:47:26 +0000

What is Packet Tracer

Cisco Packet Tracer is a network simulation tool created by Cisco.

It allows you to:

build networks (PCs, switches, routers)
connect devices using cables
assign IP addresses
test connectivity (ping)
troubleshoot network issues

Why it is used

to understand how networks actually work
to visualize communication between devices
to practice safely without real hardware
to build foundational networking skills used in cloud (AWS, Kubernetes)

STEP 1 — Create Cisco Account

Open:

👉 https://www.netacad.com/

Actions:

Click Sign Up
Create account (email + password)
Verify email
Log in

STEP 2 — Download Packet Tracer (Mac)

Open:

👉 https://www.netacad.com/resources/lab-downloads

Actions:

Scroll to Packet Tracer
Select macOS (.dmg)
Download file

STEP 3 — Install (Mac)

Open .dmg
Drag Packet Tracer → Applications
Open from Applications

If blocked:

System Settings → Privacy & Security → Open Anyway

STEP 4 — First Launch

Open Packet Tracer
Log in using Cisco account

STEP 5 — Interface Overview

Main components

Workspace → area to build network
Bottom panel → devices and tools

Device Types

PC (End Devices)

Represents a computer
Used to send/receive data

Switch

Connects devices in the same network
Operates inside one LAN

Router

Connects different networks
Enables communication between networks

Cables (Connections ⚡)

Used to connect devices physically
Use: Copper Straight-Through

STEP 6 — First Network Build

Add Devices

Add 2 PCs
Add 1 Switch

Connect Devices

Click ⚡ Connections
Select Copper Straight-Through

Connect:

PC0 → Switch
PC1 → Switch

STEP 7 — Configure IP Addresses

PC0

Open PC0 → Desktop → IP Configuration

Set:

IP Address: 192.168.1.1
Subnet Mask: 255.255.255.0

PC1

Set:

IP Address: 192.168.1.2
Subnet Mask: 255.255.255.0

STEP 8 — Test Connectivity

On PC0 → Command Prompt:

ping 192.168.1.2

Expected Result

Reply → network is working
Timeout → configuration issue

STEP 9 — Troubleshooting

Change PC1 IP:

192.168.2.2

Run ping again:

ping 192.168.1.2

Result

Communication fails

Reason

Devices are in different networks
No router present

STEP 10 — Fix

Change PC1 back:

192.168.1.2

Run ping again → success

RESULT

After completing this lab:

network devices can be added and connected
IP addressing is understood
connectivity can be tested using ping
basic troubleshooting is performed

PRACTICE

Task 1

Add 3 PCs
Connect to 1 switch
All must communicate

Task 2

Break IP configuration
Restore connectivity

This completes the first Packet Tracer lab.

NETWORK TROUBLESHOOTING LAB (DevOps)

Aisalkyn Aidarova — Mon, 13 Apr 2026 04:32:57 +0000

📘 PART 1 — HOW DEVOPS THINKS

When something “doesn’t work,” DevOps engineers follow a logical flow:

Do I have network connectivity?
Does DNS resolve correctly?
Is the server reachable?
Is the port open?
Is the application running?

We always troubleshoot layer by layer, not randomly.

🧪 PART 2 — CORE NETWORK COMMANDS

1. Check Your IP Address

ip a

🔍 How to read:

inet 192.168.x.x → your machine’s IP
127.0.0.1 → localhost
eth0, ens33 → network interfaces

✅ When to use:

No internet
Checking if machine has an IP

2. Check Connectivity (Ping)

ping google.com

🔍 How to read:

64 bytes from ... → connection is working
time=20ms → latency
Request timeout → no connection

✅ When to use:

Server not responding
Check internet access

3. Trace Network Path

traceroute google.com

🔍 How to read:

Each line = one hop
* * * → failure at that point

✅ When to use:

Ping works but app doesn’t
Identify where connection breaks

4. DNS Check

nslookup google.com

🔍 How to read:

Address: → resolved IP
Error → DNS issue

✅ When to use:

Domain not working
Suspected DNS problem

5. Advanced DNS Tool

dig google.com

🔍 How to read:

ANSWER SECTION → IP
status: NOERROR → success

✅ When to use:

Deep DNS troubleshooting

6. Test HTTP/HTTPS

curl http://example.com

🔍 Better version:

curl -I http://example.com

🔍 How to read:

200 OK → success
404 → not found
500 → server error
Connection refused → service down

✅ When to use:

API testing
Website issues

7. Check Open Ports

netstat -tulnp

🔍 How to read:

LISTEN → port is open
:80, :443 → ports
Process name → service

8. Modern Alternative

ss -tulnp

✅ When to use:

Same as netstat (preferred today)

9. Check Which Process Uses a Port

lsof -i :3000

🔍 Output shows:

Process name
PID
Port

10. Test Port Connectivity

Option 1 — Telnet

telnet google.com 80

Option 2 — Netcat (recommended)

nc -zv google.com 80

🔍 How to read:

succeeded → port open
failed → port closed

11. Check Routing

ip route

🔍 How to read:

default via → gateway (internet path)

12. Simple DNS Tool

host google.com

13. Download Test

wget http://example.com

🧪 PART 3 — HANDS-ON LAB

🔥 Task 1 — Check Network Connectivity

ping 8.8.8.8

👉 If this fails → network issue

🔥 Task 2 — Check DNS

nslookup google.com

👉 If this fails → DNS problem

🔥 Task 3 — Check Website Response

curl -I https://google.com

👉 Find the status code

🔥 Task 4 — Check Port Availability

nc -zv google.com 443

🔥 Task 5 — Check Local Service

Run your app:

node app.js

Then check:

ss -tulnp | grep 3000

🔥 Task 6 — Find Process Using Port

lsof -i :3000

🧪 PART 4 — REAL DEVOPS SCENARIO

❗ Problem:

“Application is not accessible”

✅ Step-by-step troubleshooting:

1. Check internet

ping 8.8.8.8

2. Check DNS

nslookup myapp.com

3. Check server

ping myapp.com

4. Check port

nc -zv myapp.com 443

5. Check HTTP

curl -I https://myapp.com

🧠 PART 5 — IMPORTANT INTERVIEW KNOWLEDGE

You MUST understand:

ping → connectivity
nslookup/dig → DNS
curl → HTTP
ss/netstat → ports
nc → port testing
traceroute → path

What is Status Code?

Aisalkyn Aidarova — Sat, 11 Apr 2026 17:24:50 +0000

When frontend calls backend, server responds with:

Status Code + Response

👉 Status code tells:

success
error
what happened

✅ 1xx — Informational (Rare)

Code	Meaning
100	Continue
101	Switching Protocols

👉 Usually not used in your API testing

✅ 2xx — SUCCESS (Most Important)

Code	Meaning	When used
200	OK	GET success
201	Created	POST success
202	Accepted	Request accepted (async)
204	No Content	Success but no response body

🔥 Examples

```http id="hwl2wr"
GET /users → 200 OK






```http id="tsmz92"
POST /users → 201 Created

```http id="21npr6"
DELETE /users/4 → 204 No Content




---

# ✅ 3xx — REDIRECTION

| Code | Meaning                    |
| ---- | -------------------------- |
| 301  | Moved Permanently          |
| 302  | Found (temporary redirect) |
| 304  | Not Modified               |

👉 Mostly browser-related, not common in API testing

---

# ✅ 4xx — CLIENT ERRORS (VERY IMPORTANT)

👉 Problem from **user/request side**

| Code | Meaning              | Example            |
| ---- | -------------------- | ------------------ |
| 400  | Bad Request          | Missing JSON field |
| 401  | Unauthorized         | No login/token     |
| 403  | Forbidden            | No permission      |
| 404  | Not Found            | Wrong URL or ID    |
| 405  | Method Not Allowed   | Wrong HTTP method  |
| 409  | Conflict             | Duplicate data     |
| 422  | Unprocessable Entity | Validation failed  |

---

### 🔥 Examples



```http id="33rrv1"
GET /users/999 → 404 Not Found

```http id="9flkqn"
POST without body → 400 Bad Request




---

# ✅ 5xx — SERVER ERRORS (VERY IMPORTANT)

👉 Problem from **backend/server**

| Code | Meaning               |
| ---- | --------------------- |
| 500  | Internal Server Error |
| 502  | Bad Gateway           |
| 503  | Service Unavailable   |
| 504  | Gateway Timeout       |

---

### 🔥 Examples



```http id="2lm9mt"
Database crash → 500

```http id="d4bf3k"
Server overloaded → 503




---

# 🔥 WHAT YOU SHOULD USE IN YOUR API

### Your current backend:

#### GET



```js id="tj9xjs"
res.json(users);

👉 Returns:

200 OK

POST

```js id="hcn8wp"
res.status(201).json(newUser);




👉 Correct:



```id="kxj6h8"
201 Created

PUT

```js id="c3yo0x"
res.json(user);




👉 Should be:



```id="h9n83j"
200 OK

DELETE

Right now:

```js id="bzgk4x"
res.send("User deleted");




👉 Better (production):



```js id="2p5b6q"
res.status(204).send();

🔥 INTERVIEW ANSWERS (IMPORTANT)

❓ What status code for POST?

201 Created

❓ What status code if user not found?

404 Not Found

❓ What status code for server error?

500 Internal Server Error

❓ What status code for successful GET?

200 OK

🔥 DEVOPS VIEW

You monitor APIs using status codes:

200 → healthy
4xx → client issue
5xx → system failure (critical alert)

🔥 QUICK CHEAT SHEET

200 → OK
201 → Created
204 → No Content
400 → Bad Request
401 → Unauthorized
403 → Forbidden
404 → Not Found
500 → Server Error

lab: how frontend and backend communicate

Aisalkyn Aidarova — Sat, 11 Apr 2026 14:54:26 +0000

Build a small user application:

Browser opens frontend from S3 static website
Frontend sends HTTP requests to backend on EC2
Backend returns JSON
You test API with Postman
You automate tests with Newman

Architecture

User Browser
    |
    v
S3 Static Frontend
    |
    | HTTP request
    v
EC2 Backend API (Node.js / Express)
    |
    v
JSON Response

What You Will Learn

API

An API is a way for one system to talk to another.

Example:

frontend asks backend: “give me users”
backend sends JSON back

HTTP

HTTP is the communication protocol used between:

browser and server
frontend and backend
Postman and backend
Newman and backend

Methods

GET = read data
POST = create data
PUT = update data
DELETE = remove data

These methods exist so systems can clearly say what action they want.

Final Project Structure

aws-api-lab/
├── backend/
│   ├── server.js
│   ├── package.json
│   └── Dockerfile
├── frontend/
│   └── index.html
├── postman/
│   └── collection.json
└── README-commands.txt

Part 1 — Backend API

1. Create `backend/package.json`

{
  "name": "aws-api-lab",
  "version": "1.0.0",
  "description": "Simple API lab for DevOps engineers",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "cors": "^2.8.5",
    "express": "^4.19.2"
  }
}

2. Create `backend/server.js`

const express = require("express");
const cors = require("cors");

const app = express();
const PORT = 3000;

app.use(cors());
app.use(express.json());

let users = [
  { id: 1, name: "Aisalkyn" },
  { id: 2, name: "DevOps Student" }
];

// Health check
app.get("/health", (req, res) => {
  res.status(200).json({ status: "ok" });
});

// GET - Read all users
app.get("/users", (req, res) => {
  res.status(200).json(users);
});

// GET - Read one user
app.get("/users/:id", (req, res) => {
  const userId = Number(req.params.id);
  const user = users.find(u => u.id === userId);

  if (!user) {
    return res.status(404).json({ message: "User not found" });
  }

  res.status(200).json(user);
});

// POST - Create user
app.post("/users", (req, res) => {
  const { name } = req.body;

  if (!name || typeof name !== "string" || !name.trim()) {
    return res.status(400).json({ message: "Name is required" });
  }

  const newUser = {
    id: users.length ? users[users.length - 1].id + 1 : 1,
    name: name.trim()
  };

  users.push(newUser);
  res.status(201).json(newUser);
});

// PUT - Update user
app.put("/users/:id", (req, res) => {
  const userId = Number(req.params.id);
  const { name } = req.body;

  const user = users.find(u => u.id === userId);

  if (!user) {
    return res.status(404).json({ message: "User not found" });
  }

  if (!name || typeof name !== "string" || !name.trim()) {
    return res.status(400).json({ message: "Name is required" });
  }

  user.name = name.trim();
  res.status(200).json(user);
});

// DELETE - Remove user
app.delete("/users/:id", (req, res) => {
  const userId = Number(req.params.id);
  const existingLength = users.length;

  users = users.filter(u => u.id !== userId);

  if (users.length === existingLength) {
    return res.status(404).json({ message: "User not found" });
  }

  res.status(200).json({ message: "User deleted" });
});

app.listen(PORT, "0.0.0.0", () => {
  console.log(`Server is running on http://0.0.0.0:${PORT}`);
});

This code is simple and working. It includes:

validation
proper status codes
health endpoint
all major HTTP methods

3. Create `backend/Dockerfile`

FROM node:20-alpine

WORKDIR /app

COPY package.json ./
RUN npm install

COPY server.js ./

EXPOSE 3000

CMD ["npm", "start"]

Part 2 — Frontend

Create `frontend/index.html`

Important: later you will replace YOUR-EC2-PUBLIC-IP with your real EC2 public IP.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>AWS API Lab</title>
</head>
<body>
  <h1>AWS API Lab</h1>

  <p>This frontend is hosted on S3 and talks to backend on EC2.</p>

  <button onclick="getUsers()">Get Users</button>
  <button onclick="createUser()">Create User</button>

  <h2>Users</h2>
  <pre id="output"></pre>

  <script>
    const API_BASE_URL = "http://YOUR-EC2-PUBLIC-IP:3000";

    async function getUsers() {
      try {
        const response = await fetch(`${API_BASE_URL}/users`);
        const data = await response.json();
        document.getElementById("output").textContent = JSON.stringify(data, null, 2);
      } catch (error) {
        document.getElementById("output").textContent = "Error: " + error.message;
      }
    }

    async function createUser() {
      try {
        const response = await fetch(`${API_BASE_URL}/users`, {
          method: "POST",
          headers: {
            "Content-Type": "application/json"
          },
          body: JSON.stringify({ name: "New AWS User" })
        });

        const data = await response.json();
        document.getElementById("output").textContent = JSON.stringify(data, null, 2);
      } catch (error) {
        document.getElementById("output").textContent = "Error: " + error.message;
      }
    }
  </script>
</body>
</html>

Part 3 — Postman Collection

Create `postman/collection.json`

Replace YOUR-EC2-PUBLIC-IP before running.

{
  "info": {
    "name": "AWS API Lab Collection",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "item": [
    {
      "name": "Health Check",
      "request": {
        "method": "GET",
        "header": [],
        "url": {
          "raw": "http://YOUR-EC2-PUBLIC-IP:3000/health",
          "protocol": "http",
          "host": ["YOUR-EC2-PUBLIC-IP"],
          "port": "3000",
          "path": ["health"]
        }
      }
    },
    {
      "name": "Get Users",
      "request": {
        "method": "GET",
        "header": [],
        "url": {
          "raw": "http://YOUR-EC2-PUBLIC-IP:3000/users",
          "protocol": "http",
          "host": ["YOUR-EC2-PUBLIC-IP"],
          "port": "3000",
          "path": ["users"]
        }
      }
    },
    {
      "name": "Create User",
      "request": {
        "method": "POST",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"Postman User\"\n}"
        },
        "url": {
          "raw": "http://YOUR-EC2-PUBLIC-IP:3000/users",
          "protocol": "http",
          "host": ["YOUR-EC2-PUBLIC-IP"],
          "port": "3000",
          "path": ["users"]
        }
      }
    },
    {
      "name": "Update User",
      "request": {
        "method": "PUT",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "body": {
          "mode": "raw",
          "raw": "{\n  \"name\": \"Updated User\"\n}"
        },
        "url": {
          "raw": "http://YOUR-EC2-PUBLIC-IP:3000/users/1",
          "protocol": "http",
          "host": ["YOUR-EC2-PUBLIC-IP"],
          "port": "3000",
          "path": ["users", "1"]
        }
      }
    },
    {
      "name": "Delete User",
      "request": {
        "method": "DELETE",
        "header": [],
        "url": {
          "raw": "http://YOUR-EC2-PUBLIC-IP:3000/users/2",
          "protocol": "http",
          "host": ["YOUR-EC2-PUBLIC-IP"],
          "port": "3000",
          "path": ["users", "2"]
        }
      }
    }
  ]
}

Part 4 — AWS Setup

Step 1: Launch EC2

Create one EC2 instance:

Ubuntu
t2.micro or t3.micro
allow:
- SSH 22 from your IP
- Custom TCP 3000 from anywhere for this lab
- or HTTP 80 if you later use Nginx reverse proxy

For this simple lab, open:

port 22
port 3000

Step 2: Connect to EC2

ssh -i your-key.pem ubuntu@YOUR-EC2-PUBLIC-IP

Step 3: Install Docker on EC2

sudo apt update
sudo apt install -y docker.io
sudo systemctl enable docker
sudo systemctl start docker
sudo usermod -aG docker ubuntu
newgrp docker
docker --version

Step 4: Upload backend files to EC2

From your local machine:

scp -i your-key.pem -r backend ubuntu@YOUR-EC2-PUBLIC-IP:/home/ubuntu/

Step 5: Build and run backend on EC2

SSH into EC2 and run:

cd /home/ubuntu/backend
docker build -t aws-api-lab .
docker run -d --name api -p 3000:3000 aws-api-lab

Check:

docker ps
curl http://localhost:3000/health
curl http://localhost:3000/users

From your own laptop, also check:

curl http://YOUR-EC2-PUBLIC-IP:3000/health

You should get:

{"status":"ok"}

Part 5 — Host Frontend on S3

Step 1: Create S3 bucket

Create an S3 bucket with a globally unique name, for example:

aisalkyn-aws-api-lab-frontend

Step 2: Enable static website hosting

In S3 bucket:

go to Properties
enable Static website hosting
index document: index.html

Step 3: Upload `frontend/index.html`

Before uploading, replace:

http://YOUR-EC2-PUBLIC-IP:3000

with your real IP.

Then upload the file.

Step 4: Make objects public

For a simple lab:

disable block public access for this bucket
allow read access to objects

Sample bucket policy:

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

Replace YOUR-BUCKET-NAME.

Step 5: Open S3 website URL

Now open the static website endpoint from S3.

When you click:

Get Users → frontend sends GET request to EC2 backend
Create User → frontend sends POST request to EC2 backend

That is the full frontend-to-backend flow.

Part 6 — Test with Postman

In Postman, use your EC2 public IP.

Health

GET http://YOUR-EC2-PUBLIC-IP:3000/health

Get all users

GET http://YOUR-EC2-PUBLIC-IP:3000/users

Create

POST http://YOUR-EC2-PUBLIC-IP:3000/users
Content-Type: application/json

{
  "name": "Aisalkyn API Student"
}

Update

PUT http://YOUR-EC2-PUBLIC-IP:3000/users/1
Content-Type: application/json

{
  "name": "Updated Name"
}

Delete

DELETE http://YOUR-EC2-PUBLIC-IP:3000/users/1

Part 7 — Run with Newman

Install Newman on your laptop:

npm install -g newman

Run:

cd postman
newman run collection.json

This is how DevOps engineers automate API checks.

Why Each HTTP Method Works

GET

Used to read information.
It does not usually change data.

Example:

GET /users

POST

Used to create new data.

Example:

POST /users

Body:

{
  "name": "New User"
}

PUT

Used to update existing data.

Example:

PUT /users/1

DELETE

Used to remove data.

Example:

DELETE /users/1

These methods matter because backend code behaves differently depending on the request type.

Why HTTP Is There

HTTP is there because systems need a standard language for communication.

Without HTTP:

browser would not know how to ask server for data
Postman would not know how to test endpoint
frontend would not know how to send create/update/delete actions
backend would not know how to interpret request type

HTTP gives structure:

method
URL
headers
body
response code

Important DevOps Understanding

A DevOps engineer does not always write large applications, but must understand:

where frontend is hosted
where backend is running
how requests reach backend
what ports are open
what security groups allow traffic
how to test health and endpoints
how to automate checks with Newman
how to troubleshoot if app fails

Common Problems and Fixes

1. Frontend opens but cannot reach backend

Usually:

EC2 security group does not allow port 3000
wrong EC2 public IP in frontend file
backend container is not running

Check:

docker ps
curl http://localhost:3000/health

2. Browser shows CORS error

You already included:

app.use(cors());

That fixes most basic CORS problems for this lab.

3. Newman says request URL is empty

That usually means collection JSON does not contain full URL, or placeholder was not replaced.

4. Port 3000 not reachable

Check EC2 security group inbound rules.

Commands Summary

Local backend test

cd backend
npm install
node server.js

Docker local

docker build -t aws-api-lab .
docker run -d -p 3000:3000 aws-api-lab

EC2 Docker

cd /home/ubuntu/backend
docker build -t aws-api-lab .
docker run -d --name api -p 3000:3000 aws-api-lab

Health check

curl http://YOUR-EC2-PUBLIC-IP:3000/health

Newman

newman run collection.json

Interview Value

This lab helps you answer questions like:

What is an API?

An API allows systems like frontend, Postman, or other services to communicate with backend using HTTP requests and responses.

Why do we use GET, POST, PUT, DELETE?

Because each method represents a different type of action on the resource: read, create, update, and delete.

What does a DevOps engineer check here?

backend availability
port accessibility
health endpoint
status codes
request/response correctness
frontend-to-backend connectivity
automated testing with Newman

LAB: DevOps API Pipeline

Aisalkyn Aidarova — Sat, 11 Apr 2026 14:01:06 +0000

What You Will Learn

How DevOps runs API tests in pipeline
How Docker is used
How CI/CD validates backend before deploy
Real workflow used in companies

1. PROJECT STRUCTURE

devops-api-pipeline/
├── backend/
│   ├── server.js
│   ├── package.json
│   └── Dockerfile
├── postman/
│   └── collection.json
├── .github/
│   └── workflows/
│       └── api-test.yml

2. BACKEND (same logic, slightly improved)

backend/server.js

const express = require('express');
const app = express();

app.use(express.json());

let users = [
  { id: 1, name: "John" },
  { id: 2, name: "Alice" }
];

// HEALTH CHECK (important in DevOps)
app.get('/health', (req, res) => {
  res.send("OK");
});

app.get('/users', (req, res) => {
  res.json(users);
});

app.post('/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

backend/package.json

{
  "name": "devops-api",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

3. DOCKER (IMPORTANT)

backend/Dockerfile

FROM node:18

WORKDIR /app

COPY package.json .
RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

Build & Run locally

cd backend

docker build -t devops-api .
docker run -p 3000:3000 devops-api

Test:

http://localhost:3000/health

4. POSTMAN COLLECTION (REAL TESTS)

postman/collection.json

{
  "info": {
    "name": "DevOps API Pipeline",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "item": [
    {
      "name": "Health Check",
      "request": {
        "method": "GET",
        "url": "http://localhost:3000/health"
      }
    },
    {
      "name": "Get Users",
      "request": {
        "method": "GET",
        "url": "http://localhost:3000/users"
      }
    },
    {
      "name": "Create User",
      "request": {
        "method": "POST",
        "header": [
          { "key": "Content-Type", "value": "application/json" }
        ],
        "body": {
          "mode": "raw",
          "raw": "{ \"name\": \"CI User\" }"
        },
        "url": "http://localhost:3000/users"
      }
    }
  ]
}

5. CI/CD PIPELINE

.github/workflows/api-test.yml

name: API Test Pipeline

on:
  push:
    branches: [ "main" ]

jobs:
  test-api:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Build Docker image
      run: docker build -t devops-api ./backend

    - name: Run container
      run: |
        docker run -d -p 3000:3000 --name api devops-api
        sleep 5

    - name: Install Newman
      run: npm install -g newman

    - name: Run API tests
      run: newman run postman/collection.json

6. HOW THIS WORKS (IMPORTANT)

Step-by-step:

Code pushed to GitHub
GitHub Actions triggers pipeline
Docker builds app
Container runs API
Newman tests endpoints
If tests fail → pipeline FAILS

7. WHY THIS IS REAL DEVOPS

This is exactly what companies do:

Validate API before deployment
Prevent broken code in production
Automate testing

8. ADDITIONAL IMPROVEMENTS (REAL WORLD)

You can extend:

Add assertions in Postman

Example:

pm.test("Status is 200", function () {
    pm.response.to.have.status(200);
});

Add environment variables

"url": "{{base_url}}/users"

Add Docker push (ECR / GHCR)

9. INTERVIEW ANSWERS

Q: How do you test APIs in CI/CD?
→ Using Postman collections executed via Newman inside pipeline.

Q: Why Docker here?
→ To ensure same environment everywhere.

Q: What if API fails?
→ Pipeline stops → deployment blocked.

10. WHAT YOU JUST BUILT

You built:

API
Docker image
Automated testing pipeline
Real DevOps workflow

LAB: Build + Test API (Full Flow)

Aisalkyn Aidarova — Sat, 11 Apr 2026 13:59:21 +0000

What You Will Learn

How API receives HTTP requests
How frontend talks to backend
How DevOps tests APIs
Why GET / POST / PUT / DELETE exist

1. PROJECT STRUCTURE

Create folder:

devops-api-lab/
├── backend/
│   └── server.js
├── frontend/
│   └── index.html
├── postman/
│   └── collection.json

2. BACKEND (API SERVER)

Install Node.js

Download from: Node.js

Create `backend/server.js`

const express = require('express');
const app = express();

app.use(express.json());

// Fake database
let users = [
  { id: 1, name: "John" },
  { id: 2, name: "Alice" }
];

// GET (READ)
app.get('/users', (req, res) => {
  res.json(users);
});

// POST (CREATE)
app.post('/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

// PUT (UPDATE)
app.put('/users/:id', (req, res) => {
  const user = users.find(u => u.id == req.params.id);
  if (!user) return res.status(404).send("User not found");

  user.name = req.body.name;
  res.json(user);
});

// DELETE (REMOVE)
app.delete('/users/:id', (req, res) => {
  users = users.filter(u => u.id != req.params.id);
  res.send("User deleted");
});

app.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});

Install dependencies

cd backend
npm init -y
npm install express
node server.js

3. FRONTEND (UI)

Create `frontend/index.html`

<!DOCTYPE html>
<html>
<head>
  <title>DevOps API Lab</title>
</head>
<body>

<h2>Users</h2>
<button onclick="getUsers()">Get Users</button>
<button onclick="addUser()">Add User</button>

<ul id="list"></ul>

<script>
async function getUsers() {
  const res = await fetch('http://localhost:3000/users');
  const data = await res.json();

  const list = document.getElementById('list');
  list.innerHTML = '';

  data.forEach(user => {
    const li = document.createElement('li');
    li.innerText = user.name;
    list.appendChild(li);
  });
}

async function addUser() {
  await fetch('http://localhost:3000/users', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ name: "New User" })
  });

  getUsers();
}
</script>

</body>
</html>

Run frontend

Just open file in browser:

frontend/index.html

4. WHAT IS HAPPENING (IMPORTANT)

HTTP FLOW

GET

GET /users

Used to READ data
No body

POST

POST /users

Used to CREATE
Sends JSON body

PUT

PUT /users/1

Used to UPDATE

DELETE

DELETE /users/1

Used to REMOVE

WHY HTTP EXISTS

HTTP is:

Standard communication protocol
Used between:
- Browser → Backend
- Frontend → API
- DevOps tools → Services

5. TEST WITH POSTMAN

Open Postman

Create requests:

GET

GET http://localhost:3000/users

POST

POST http://localhost:3000/users
Body:
{
  "name": "DevOps User"
}

PUT

PUT http://localhost:3000/users/1
Body:
{
  "name": "Updated User"
}

DELETE

DELETE http://localhost:3000/users/1

6. AUTOMATION WITH NEWMAN

Install:

npm install -g newman

Create `postman/collection.json`

{
  "info": {
    "name": "DevOps API Lab",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "item": [
    {
      "name": "Get Users",
      "request": {
        "method": "GET",
        "url": "http://localhost:3000/users"
      }
    },
    {
      "name": "Create User",
      "request": {
        "method": "POST",
        "header": [
          { "key": "Content-Type", "value": "application/json" }
        ],
        "body": {
          "mode": "raw",
          "raw": "{ \"name\": \"Newman User\" }"
        },
        "url": "http://localhost:3000/users"
      }
    }
  ]
}

Run Newman

cd postman
newman run collection.json

7. REAL DEVOPS CONNECTION

This lab simulates real work:

CI/CD pipeline runs Newman tests
Backend deployed on AWS EC2 / ECS
Frontend hosted on S3
DevOps validates API before deployment

8. INTERVIEW ANSWER (SHORT)

Q: What is API?
API allows communication between frontend and backend using HTTP methods.

Q: Why GET vs POST?

GET → fetch data
POST → create data
PUT → update
DELETE → remove

Q: What do DevOps test?

API availability
Response correctness
Status codes
Performance

Forem: Aisalkyn Aidarova

Lab: next lab sre

Current lab

Next lab

Why this helps for SRE

New lab goal

Final design

Subnet 1

Subnet 2

Router interfaces

What each part means in SRE terms

1. Client subnet

2. Service subnet

3. Router

4. ACL

5. Monitoring node

Lab roadmap

LAB: Next step after your subnetting lab

Step 1 — Keep the existing lab exactly as it is

Step 2 — Assign roles to devices

Left side

Right side

Step 3 — Verify baseline connectivity

What this teaches

SRE meaning

Step 4 — Make one machine the “monitoring node”

What this represents

What an SRE learns here

In real life

Step 5 — Add controlled access with ACL

Example rule

Router config

What this means

Why this matters for SRE

Step 6 — Test the policy

Expected

What this teaches

Step 7 — Keep monitoring node more privileged

Step 8 — Simulate a failure

Option A: bring down service-side router interface

What happens

SRE lesson

What to observe

Step 9 — Simulate partial failure

What happens

SRE lesson

Step 10 — Document expected behavior

What this lab teaches about SRE work

1. Segmentation

2. Access control

3. Monitoring

4. Failure testing

5. Troubleshooting

6. Reliability mindset

Stage 1 — Basic routing

Stage 2 — Service roles

Stage 3 — Monitoring

Stage 4 — ACL

Stage 5 — Failure drill

Stage 6 — Recovery

Very simple SRE interview explanation

LAB: Subnetting with Router (2 Networks)

🧠 PART 1 — WHAT YOU BUILT

🧠 PART 2 — WHY SUBNETTING IS IMPORTANT

❌ Without subnetting (one big network)

✅ With subnetting

🧠 PART 3 — SUBNET DESIGN (VERY IMPORTANT)

Subnet 1 (LEFT)

Subnet 2 (RIGHT)

💡 Explain /24

🧠 PART 4 — CONFIGURATION (STEP-BY-STEP)

🔹 1. Configure Router

🔹 2. Configure PCs (VERY IMPORTANT)

LEFT PCs

RIGHT PCs

🧠 PART 5 — HOW IT WORKS (CRITICAL)

🔁 Same Subnet Communication

🌍 Different Subnet Communication

🧠 PART 6 — TESTING

🔹 Test same subnet

💡 Explain `/24`