Introduction

Are you interested in becoming an AWS DevOps Engineer but don't know where to start?

Are you a fresher with little or no technical experience, confused about which technologies to learn, what order to follow, and how to gain practical experience?

You're not alone.

DevOps is one of the important practices in modern software development. It brings development and operations teams together to improve collaboration, automate repetitive tasks, accelerate software delivery, and maintain reliable applications.

AWS (Amazon Web Services) provides cloud infrastructure and services that help organizations build, deploy, manage, and scale applications. When AWS is combined with DevOps practices and tools such as Linux, Git, Python, Terraform, Docker, Kubernetes, and CI/CD platforms, engineers can automate much of the software delivery lifecycle.

However, learning all these technologies without a proper sequence can be overwhelming.

That's why this guide provides a structured 12–15 month AWS DevOps learning roadmap, designed for beginners who want to progress from computer fundamentals to building and managing production-style cloud environments.

Throughout this roadmap, you'll discover:

• What an AWS DevOps Engineer does.
• Which technical fundamentals you should learn first.
• How to learn Linux, networking, Git, and scripting.
• How to work with AWS cloud services.
• How to automate infrastructure using Terraform.
• How to containerize applications using Docker.
• How to build CI/CD pipelines.
• How to deploy applications using Kubernetes.
• How to implement monitoring, logging, and security.
• Which hands-on projects can help you demonstrate your skills.
• How to prepare for AWS DevOps interviews as a fresher.

Who should read this guide?

This roadmap is suitable for:

• Freshers starting their IT careers.
• Students and recent graduates.
• System administrators interested in cloud technologies.
• Developers interested in learning DevOps.
• Anyone who wants to understand AWS DevOps from the fundamentals.

A quick note: You don't need to learn every tool in the DevOps ecosystem to get your first job. Focus on understanding fundamentals, developing practical skills, and building projects that demonstrate what you know.

Table of Contents

1. What Is DevOps?
2. What Does an AWS DevOps Engineer Do?
3. Computer Fundamentals
4. Linux Administration
5. Networking Fundamentals
6. Git and GitHub
7. Python and Bash Scripting
8. AWS Fundamentals
9. Advanced AWS Services and Cloud Architecture
10. Terraform and Infrastructure as Code
11. Docker and Containerization
12. CI/CD Pipelines and Automation
13. Kubernetes and Container Orchestration
14. AWS Container Services
15. Monitoring, Logging, and Observability
16. Security and DevSecOps
17. Advanced DevOps, GitOps, and SRE
18. Real-World AWS DevOps Project Portfolio
19. Resume, GitHub, Interview Preparation, and Job Search

1. What Is DevOps?

DevOps is a combination of two words: Development (Dev) and Operations (Ops).

It is a set of practices, principles, cultural philosophies, and tools that help development and IT operations teams work together throughout the software development lifecycle.

The primary goal of DevOps is to deliver software faster, improve collaboration, automate repetitive tasks, and maintain application reliability.

1.1 Understanding Traditional Software Development

Before DevOps became widely adopted, many organizations followed a traditional approach in which development and operations teams worked separately.

• Development team: Responsible for writing application code, developing features, and fixing bugs.
• Operations team: Responsible for servers, infrastructure, deployments, application availability, and maintenance.

This separation often created communication gaps.

For example:

1. Developers completed an application and handed it over to the operations team.
2. The operations team attempted to deploy the application.
3. The application failed because of differences between development and production environments.
4. Both teams spent time identifying who was responsible for the issue.

This type of problem is commonly described as the "It works on my machine" problem.

1.2 Why Do We Need DevOps?

DevOps helps organizations overcome these challenges through collaboration and automation.

Some important benefits include:

• Faster software delivery.
• Improved collaboration between teams.
• Continuous Integration and Continuous Delivery (CI/CD).
• Reduced manual work through automation.
• Consistent deployment environments.
• Faster identification and resolution of failures.
• Better application reliability.

1.3 How Does DevOps Work?

DevOps encourages teams to follow a continuous lifecycle.

The commonly represented DevOps lifecycle includes these stages:

1. Plan: Define requirements, tasks, and development goals.
2. Code: Write and maintain application source code.
3. Build: Convert source code into deployable artifacts.
4. Test: Validate application functionality and quality.
5. Release: Prepare an application version for deployment.
6. Deploy: Deliver the application to the target environment.
7. Operate: Manage and maintain the running application.
8. Monitor: Track application performance, availability, and errors.

These stages form a continuous feedback loop. Monitoring results and user feedback help teams plan future improvements.

1.4 Real-World Example

Imagine an organization developing an online shopping application.

Without DevOps, developers might manually send application files to the operations team, who then deploy them to servers.

With DevOps practices:

1. Developers push code to GitHub.
2. A CI/CD pipeline automatically starts.
3. The pipeline builds the application.
4. Automated tests check the application.
5. Docker packages the application into a container.
6. The container image is stored in Amazon ECR.
7. The application is deployed to Amazon EKS.
8. Prometheus and Grafana help monitor application health and performance.

This workflow reduces manual effort and makes application delivery more consistent.

1.5 DevOps Is More Than Just Tools

One common misconception among beginners is that DevOps means simply learning Docker, Kubernetes, Jenkins, and AWS.

However, DevOps is not just a collection of tools.

It also involves:

• Collaboration and communication.
• Automation.
• Continuous improvement.
• Shared responsibility.
• Infrastructure as Code.
• Monitoring and feedback.
• Security throughout the delivery lifecycle.

Key takeaway: DevOps combines people, processes, and technology to help organizations deliver reliable software efficiently and continuously.

2. What Does an AWS DevOps Engineer Do?

An AWS DevOps Engineer is responsible for automating, managing, deploying, and maintaining applications and infrastructure using Amazon Web Services (AWS) and DevOps practices.

The role combines cloud computing, infrastructure management, automation, software deployment, monitoring, and security.

An AWS DevOps Engineer helps development teams deliver applications reliably while ensuring that the underlying infrastructure is scalable, secure, and available.

2.1 Key Responsibilities of an AWS DevOps Engineer

Let's understand the major responsibilities.

1. Cloud Infrastructure Management

AWS DevOps Engineers create and manage cloud infrastructure using services such as:

• Amazon EC2 – Virtual servers.
• Amazon S3 – Object storage.
• Amazon VPC – Network isolation and configuration.
• AWS IAM – Identity and access management.
• Amazon RDS – Managed relational databases.
• Elastic Load Balancing – Distributes incoming application traffic.

2. Infrastructure as Code (IaC)

Instead of creating infrastructure manually through the AWS Management Console, engineers use Infrastructure as Code tools to define and provision resources.

Common tools include:

• Terraform.
• AWS CloudFormation.
• AWS CDK.

For example, Terraform can be used to create an AWS VPC, subnets, security groups, and EC2 instances through configuration files.

3. CI/CD Pipeline Automation

AWS DevOps Engineers build automated pipelines to test, build, and deploy applications.

Common tools include:

• Jenkins.
• GitHub Actions.
• GitLab CI/CD.
• AWS CodePipeline.
• AWS CodeBuild.

4. Containerization

Applications can be packaged with their dependencies using containers.

Common technologies include:

• Docker.
• Amazon Elastic Container Registry (ECR).
• Amazon Elastic Container Service (ECS).
• Amazon Elastic Kubernetes Service (EKS).

5. Configuration Management and Automation

Engineers automate server configuration, software installation, and repetitive administrative tasks.

Common tools include:

• Ansible.
• Python.
• Bash scripting.

6. Monitoring and Logging

Monitoring helps engineers understand application and infrastructure health.

Common tools include:

• Amazon CloudWatch.
• Prometheus.
• Grafana.
• OpenSearch.
• Elasticsearch and Kibana.

7. Security and Access Management

Security is an important responsibility throughout the DevOps lifecycle.

Engineers work with:

• IAM roles and policies.
• Least-privilege access.
• Secrets Manager.
• AWS KMS.
• Security groups.
• Vulnerability scanning tools.

2.2 A Typical Day in the Life of an AWS DevOps Engineer

Here is an example of what an AWS DevOps Engineer might do during a normal working day:

1. Check application health and infrastructure monitoring dashboards.
2. Review code changes and deployment requests.
3. Investigate build or deployment failures.
4. Update infrastructure using Terraform.
5. Maintain CI/CD pipelines.
6. Troubleshoot Docker containers or Kubernetes workloads.
7. Review logs and resolve application issues.
8. Coordinate with developers and other engineering teams.

Responsibilities vary depending on the organization, team size, infrastructure, and seniority of the engineer.

2.3 Skills Required to Become an AWS DevOps Engineer

A beginner should gradually develop skills in the following areas:

Key takeaway: An AWS DevOps Engineer is not expected to know every tool from day one. The goal is to understand the fundamentals first and gradually develop practical skills through hands-on experience and real-world projects.

3. Phase 1: Computer Fundamentals (Weeks 1–2)

Before learning cloud computing and DevOps tools, it is important to understand basic computer concepts.

You do not need to become a computer hardware expert. However, understanding how computers work will make it easier to learn operating systems, networking, cloud infrastructure, and application deployment.

3.1 Understanding Computer Hardware

A computer consists of several physical components that work together to execute instructions and process information.

The most important components are:

1. CPU (Central Processing Unit)

The CPU is commonly called the brain of a computer.

It executes instructions, performs calculations, and processes data.

In a cloud environment, an AWS EC2 instance uses virtualized computing resources, including CPU capacity, to run applications.

2. RAM (Random Access Memory)

RAM is temporary memory used by a computer to store data and instructions that are currently being processed.

For example, when you run a web server, the operating system and application use RAM while executing.

RAM is volatile, which means its contents are lost when power is removed.

3. Storage

Storage is used to save data permanently, even after a computer is switched off.

Common storage technologies include:

• HDD (Hard Disk Drive).
• SSD (Solid State Drive).
• NVMe SSD.

In AWS, Amazon EBS provides block storage volumes that can be attached to EC2 instances.

4. Network Interface Card (NIC)

A Network Interface Card allows a computer to communicate with other devices over a network.

It can provide wired or wireless network connectivity.

In AWS, an EC2 instance communicates with other resources through virtual network interfaces.

3.2 Understanding Software

Software is a collection of programs and instructions that tell a computer what to do.

Software can be broadly classified into two categories.

1. System Software

System software manages computer hardware and provides the environment required to run applications.

Examples:

• Windows.
• Linux.
• macOS.
• Device drivers.

2. Application Software

Application software helps users perform specific tasks.

Examples:

• Google Chrome.
• Visual Studio Code.
• Microsoft Word.
• Web applications.

3.3 What Is an Operating System?

An Operating System (OS) is system software that manages computer hardware and software resources.

It acts as an interface between users, applications, and computer hardware.

Major responsibilities include:

• Process management.
• Memory management.
• File system management.
• Device management.
• User management.
• Security and access control.

Popular operating systems include:

• Windows.
• Linux.
• macOS.
• Unix.

Why is Linux important for DevOps?

Linux is widely used in cloud infrastructure, servers, containers, and automation environments.

AWS EC2 instances frequently run Linux distributions such as Amazon Linux, Ubuntu, and Red Hat Enterprise Linux.

Therefore, Linux administration is one of the most important foundational skills for an AWS DevOps Engineer.

3.4 Understanding Files, Directories, and File Systems

A file is a collection of information stored on a computer.

A directory (also called a folder) is used to organize files and other directories.

For example, a Linux system contains directories such as:

• /home – User home directories.
• /etc – System and application configuration files.
• /var – Variable data such as logs.
• /tmp – Temporary files.
• /opt – Optional application software.

Understanding the Linux file system will become important when working with servers and troubleshooting applications.

3.5 Understanding Processes and Services

A process is a program that is currently executing.

For example, when you start a Python application, the operating system creates a process to execute it.

A service is a program designed to perform a specific function, often running in the background.

Examples include:

• Web servers.
• Database servers.
• SSH services.
• Monitoring agents.

In DevOps, engineers regularly inspect processes, manage services, and troubleshoot applications that fail to start or consume excessive resources.

3.6 Understanding Client-Server Architecture

Client-server architecture is a computing model in which a client requests a service or resource from a server.

The server receives the request, processes it, and sends a response.

Example: Opening a website

1. A user opens a browser.
2. The browser sends a request to a web server.
3. The web server processes the request.
4. The server sends the requested web page.
5. The browser displays the page to the user.

This architecture is fundamental to understanding web applications, cloud infrastructure, load balancers, and application deployment.

3.7 Understanding Virtualization

Virtualization is a technology that allows multiple virtual computing environments to run on a single physical machine.

A Hypervisor is software that creates and manages virtual machines.

Each virtual machine can have its own operating system and allocated computing resources.

Common examples include:

• VMware.
• Oracle VirtualBox.
• Microsoft Hyper-V.

Why is virtualization important for AWS?

Cloud providers use virtualization and other resource-isolation technologies to provide computing resources to customers.

For example, Amazon EC2 allows users to create virtual server instances without purchasing and maintaining physical servers themselves.

3.8 Introduction to Cloud Computing

Cloud computing is the delivery of computing resources over a network, typically the internet.

Instead of purchasing physical servers, organizations can obtain computing resources from cloud providers.

Popular cloud providers include:

• Amazon Web Services (AWS).
• Microsoft Azure.
• Google Cloud Platform (GCP).

Common cloud service models include:

Infrastructure as a Service (IaaS): Provides computing infrastructure such as virtual machines, storage, and networking.

Example: Amazon EC2.

Platform as a Service (PaaS): Provides a managed environment for developing and deploying applications without managing all the underlying infrastructure.

Software as a Service (SaaS): Provides ready-to-use software applications over the internet.

Example: Google Workspace.

3.9 Hands-On Practice

Beginners should perform the following activities:

1. Identify CPU, RAM, and storage details on their computer.
2. Understand the difference between system software and application software.
3. Explore the Windows or Linux file system.
4. Open Task Manager on Windows and identify running processes.
5. Understand how a browser communicates with a web server.
6. Install Oracle VirtualBox and explore how virtual machines work (optional).
7. Explore the AWS website and understand its major service categories.

3.10 Learning Resources

• Computer Fundamentals – GeeksforGeeks
• Linux Documentation
• AWS Cloud Computing Concepts

3.11 Phase 1 Completion Checklist

Before moving to the next phase, make sure you can explain:

• What are CPU, RAM, and storage?
• What is the difference between hardware and software?
• What is an operating system?
• What is the difference between a process and a service?
• What is client-server architecture?
• What is virtualization?
• What is cloud computing?
• What are IaaS, PaaS, and SaaS?

Expected outcome:

By the end of this phase, you should understand basic computer architecture, operating system concepts, virtualization, and cloud computing fundamentals.

These concepts will prepare you for the next phase: Linux Administration.

4. Phase 2: Linux Administration (Weeks 3–6)

Linux is one of the most important operating systems in the DevOps ecosystem.

Many organizations use Linux-based servers to host applications, databases, containers, and cloud infrastructure.

An AWS DevOps Engineer should understand how to work with Linux servers, manage users, configure permissions, troubleshoot processes, analyze logs, and automate administrative tasks.

In this phase, beginners will learn Linux administration from the fundamentals to practical server management.

4.1 What Is Linux?

Linux is an open-source, Unix-like operating system kernel.

Linux distributions combine the Linux kernel with system utilities, package managers, libraries, and other software to provide a complete operating system.

Popular Linux distributions include:

• Ubuntu.
• Amazon Linux.
• Red Hat Enterprise Linux (RHEL).
• Debian.
• Rocky Linux.
• AlmaLinux.

Which Linux distribution should beginners learn?

Ubuntu is a good starting point because it is beginner-friendly and has extensive documentation.

You should also become familiar with Amazon Linux because it is commonly used with AWS EC2 instances.

4.2 Understanding Linux Architecture

A simplified Linux architecture consists of the following layers:

1. Hardware: CPU, RAM, storage, and network devices.
2. Kernel: Manages hardware resources, processes, memory, and device communication.
3. System Libraries: Provide interfaces that applications can use to interact with the kernel.
4. Shell: Provides a command-line interface for executing commands.
5. User Applications: Programs and services running on the operating system.

Understanding these components helps engineers troubleshoot Linux systems effectively.

4.3 Linux File System Hierarchy

Linux organizes files and directories through a hierarchical file system.

Important directories include:

An AWS DevOps Engineer frequently works with configuration files, application logs, and system directories.

4.4 Essential Linux Commands

Beginners should become comfortable with command-line operations.

Navigation commands

• pwd – Display the current working directory.
• ls – List files and directories.
• cd – Change the current directory.

File and directory management

• mkdir – Create a directory.
• touch – Create an empty file or update its timestamp.
• cat – Display file contents.
• cp – Copy files and directories.
• mv – Move or rename files and directories.
• rm – Remove files or directories.

File viewing commands

• head – Display the beginning of a file.
• tail – Display the end of a file.
• less – View large files page by page.
• grep – Search for matching text.
• find – Search for files and directories.

System information commands

• uname – Display system information.
• hostname – Display the system hostname.
• whoami – Display the current username.
• df -h – Display file system disk usage.
• free -h – Display memory usage.
• uptime – Display how long the system has been running.

4.5 Linux File Permissions

Linux uses permissions to control who can read, modify, and execute files.

There are three basic permission categories:

• Owner: The user who owns the file.
• Group: Users belonging to the file's group.
• Others: All other users.

The three main permissions are:

For example:

chmod 755 script.sh

This grants:

• Owner: Read, write, and execute.
• Group: Read and execute.
• Others: Read and execute.

Other important commands include:

• chmod – Change file permissions.
• chown – Change file ownership.
• chgrp – Change group ownership.
• umask – Set default permission restrictions for newly created files.

Understanding permissions is important when troubleshooting application deployment failures and access-related errors.

4.6 Linux User and Group Management

Linux supports multiple users and groups.

User and group management is important for controlling access to servers and applications.

Important commands include:

• useradd – Create a user.
• passwd – Set or change a user's password.
• usermod – Modify user account properties.
• userdel – Delete a user.
• groupadd – Create a group.
• groupdel – Delete a group.
• id – Display user and group IDs.
• groups – Display group memberships.
• sudo – Execute permitted commands with elevated privileges.
• su – Switch to another user.

Important Linux account files:

• /etc/passwd – Stores user account information.
• /etc/shadow – Stores password hashes and password-related information.
• /etc/group – Stores group information.

Never share password hashes or sensitive account information.

4.7 Process Management

A process is an instance of a running program.

DevOps Engineers need to identify running processes, monitor resource consumption, and troubleshoot processes that behave unexpectedly.

Important commands:

• ps – Display process information.
• top – Monitor running processes and resource usage.
• htop – Interactive process monitoring tool, when installed.
• pgrep – Find processes by name or other attributes.
• kill – Send a signal to a process.
• kill -9 – Forcefully terminate a process using SIGKILL.
• nice – Start a process with a specified scheduling priority.
• renice – Change the priority of an existing process.

Use forceful termination carefully because it does not allow a process to perform its normal cleanup.

4.8 Linux Services and Systemd

A service is a program that provides functionality in the background.

Examples include SSH servers, web servers, database servers, and monitoring agents.

Many modern Linux distributions use systemd to manage system services.

Important commands:

• systemctl status service_name – Check service status.
• systemctl start service_name – Start a service.
• systemctl stop service_name – Stop a service.
• systemctl restart service_name – Restart a service.
• systemctl enable service_name – Configure a service to start during boot.
• systemctl disable service_name – Prevent automatic startup during boot.

For example:

sudo systemctl status ssh

The service name can differ between Linux distributions. On some systems, the SSH service is named sshd.

4.9 Package Management

Package managers help install, update, and remove software.

Different Linux distributions use different package management systems.

Ubuntu and Debian

Common commands:

• sudo apt update
• sudo apt upgrade
• sudo apt install package_name
• sudo apt remove package_name

Amazon Linux and RHEL-based distributions

Depending on the distribution and version, common commands include:

• sudo dnf check-update
• sudo dnf install package_name
• sudo dnf update
• sudo dnf remove package_name

Beginners should understand the differences between package managers and avoid blindly executing commands intended for another distribution.

4.10 Disk and Storage Management

Linux administrators should understand how disks and file systems are managed.

Important commands include:

• lsblk – Display block devices.
• blkid – Display block device attributes.
• df -h – Check file system space.
• du -sh directory_name – Check directory size.
• mount – Attach a file system to a directory.
• umount – Detach a mounted file system.

In AWS, these concepts are useful when working with Amazon EBS volumes attached to EC2 instances.

4.11 Linux Networking Commands

Linux servers communicate with other systems through networks.

Important commands include:

• ip addr – Display network interface addresses.
• ip route – Display routing information.
• ping – Test network reachability.
• ss -tulnp – Inspect listening network sockets.
• curl – Transfer data using supported URL protocols.
• wget – Retrieve files from network locations.
• traceroute – Inspect network paths, when installed.
• dig – Perform DNS queries, when installed.
• hostname -I – Display assigned IP addresses.

These commands are useful when troubleshooting DNS resolution, connectivity, and application ports.

4.12 SSH and Remote Server Management

SSH (Secure Shell) is a protocol used to securely access remote systems.

DevOps Engineers frequently use SSH to connect to Linux servers.

For example:

ssh username@server_ip

AWS EC2 instances can be accessed through SSH when the instance, network configuration, security group, credentials, and user account are correctly configured.

SSH authentication can use key pairs instead of passwords.

Protect private keys carefully and never upload them to public repositories.

4.13 Linux Log Management and Troubleshooting

Logs provide information about system activity, application behavior, and errors.

Common locations and tools include:

• /var/log – Common directory for system and application logs.
• journalctl – Query logs collected by systemd's journal.
• dmesg – Display kernel ring buffer messages.
• tail -f – Follow a log file as new entries are written.
• grep – Search log entries for specific error messages.

For example:

sudo journalctl -u nginx -n 50

This displays recent journal entries for the Nginx service, if the service is managed by systemd and its logs are available there.

Log analysis is one of the most important troubleshooting skills in production environments.

4.14 Bash Shell Scripting

Bash is a command-line shell commonly used for Linux administration and automation.

Shell scripts allow engineers to automate repetitive tasks.

Topics to learn include:

• Variables.
• User input.
• Conditional statements.
• Loops.
• Functions.
• Command-line arguments.
• Exit codes.
• Error handling.
• Scheduling tasks with cron.

Example:

#!/bin/bash echo "Checking disk usage" df -h echo "Disk usage check completed" 

Save the script as disk_check.sh.

Make it executable:

chmod +x disk_check.sh

Execute it:

./disk_check.sh

Bash scripting is useful for automating server administration, log analysis, backups, and deployment tasks.

4.15 Hands-On Linux Projects

Practice the following activities:

Project 1: Linux User Management

• Create three Linux users.
• Create a group.
• Add users to the group.
• Configure file ownership and permissions.
• Verify access restrictions.

Project 2: Linux Service Management

• Install Nginx.
• Start and enable the service.
• Check service status.
• Stop and restart the service.
• Inspect service logs.

Project 3: Linux System Monitoring

• Check CPU and memory usage.
• Inspect running processes.
• Identify disk usage.
• Find large files.
• Investigate a sample service failure.

Project 4: Bash Automation

• Write a script to check disk usage.
• Write a script to check memory usage.
• Create a basic backup script.
• Schedule a script using cron.

4.16 Learning Resources

• Linux Journey
• Ubuntu Documentation
• Red Hat Documentation
• The Linux Documentation Project

4.17 Phase 2 Completion Checklist

Before moving to the next phase, make sure you can:

• Navigate the Linux file system.
• Create, copy, move, and delete files.
• Understand Linux permissions and ownership.
• Create and manage users and groups.
• Monitor and manage processes.
• Start, stop, and troubleshoot services.
• Install and update packages.
• Inspect disk and memory usage.
• Use basic networking commands.
• Connect to remote servers using SSH.
• Read and analyze Linux logs.
• Write basic Bash scripts.

Expected outcome:

By the end of this phase, you should be comfortable administering a Linux server, performing common troubleshooting tasks, managing users and services, and automating basic operations using Bash.

These skills will prepare you for the next phase: Networking Fundamentals.

5. Phase 3: Networking Fundamentals (Weeks 7–8)

Networking is one of the core foundations of Cloud Computing and DevOps.

Applications, servers, databases, containers, and cloud services communicate with each other through networks.

An AWS DevOps Engineer must understand how data travels between systems, how network communication works, and how to troubleshoot connectivity problems.

For example, imagine an application running on an AWS EC2 instance. Users access the application through a web browser. To make this communication possible, engineers must understand IP addresses, DNS, ports, protocols, routing, firewalls, and load balancing.

Let's explore the important networking concepts step by step.

5.1 What Is Computer Networking?

A computer network is a collection of connected devices that communicate and exchange information.

Examples include:

• Home Wi-Fi networks.
• Office networks.
• Data center networks.
• Cloud networks.
• The internet.

Networking allows computers, servers, and applications to share resources and communicate with each other.

5.2 Understanding IP Addresses

An IP (Internet Protocol) address is a numerical address used to identify a device or network interface in an IP network.

There are two major IP versions:

IPv4

IPv4 uses a 32-bit address.

Example:

192.168.1.10

IPv4 addresses are commonly written as four decimal numbers separated by dots.

IPv6

IPv6 uses a 128-bit address.

Example:

2001:db8::1

IPv6 was developed to provide a much larger address space than IPv4.

Public IP Address

A public IP address is globally routable and can be used to communicate over the public internet, subject to network and security configuration.

Private IP Address

A private IP address is used within private networks and is not directly routable over the public internet.

Common private IPv4 ranges include:

• 10.0.0.0/8
• 172.16.0.0/12
• 192.168.0.0/16

In AWS, EC2 instances can have private IP addresses within a VPC. Public connectivity depends on the instance's network configuration and associated routing.

5.3 Understanding Subnetting and CIDR

A subnet is a logical subdivision of an IP network.

Subnetting helps organizations divide networks into smaller address ranges.

CIDR stands for Classless Inter-Domain Routing.

CIDR notation represents an IP address range using a prefix length.

Example:

192.168.1.0/24

The /24 indicates that the first 24 bits represent the network portion of the address.

Another example:

10.0.0.0/16

A smaller prefix length generally represents a larger address range, while a larger prefix length represents a smaller address range.

Why is CIDR important in AWS?

When creating an AWS VPC, engineers specify a CIDR block.

For example:

10.0.0.0/16

They can then create smaller subnets within that VPC, such as:

• 10.0.1.0/24
• 10.0.2.0/24
• 10.0.3.0/24

These subnets can be used to organize application servers, databases, and other resources.

5.4 Understanding MAC Addresses

A MAC (Media Access Control) address is a link-layer address associated with a network interface.

It is commonly represented as six groups of hexadecimal digits.

Example:

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

MAC addresses are primarily used for communication within a local network at the data link layer.

An IP address identifies an endpoint at the network layer, while a MAC address is used for local link-layer delivery.

5.5 Understanding DNS

DNS stands for Domain Name System.

It translates human-readable domain names into IP addresses or other DNS records.

For example:

When a user enters:

www.example.com

The DNS resolution process helps the client discover the IP address associated with that domain name.

Important DNS record types include:

• A: Maps a hostname to an IPv4 address.
• AAAA: Maps a hostname to an IPv6 address.
• CNAME: Creates an alias for another domain name.
• MX: Identifies mail servers for a domain.
• TXT: Stores text information, commonly used for domain verification and email authentication.
• NS: Identifies authoritative name servers.

Why is DNS important in AWS?

Amazon Route 53 is an AWS service that provides DNS management, domain registration, and health-check-based routing capabilities.

DevOps Engineers use DNS to connect domain names to applications and cloud infrastructure.

5.6 Understanding Network Ports

A port is a logical communication endpoint used by transport-layer protocols such as TCP and UDP.

Ports help a system direct network traffic to the correct application or service.

Common ports include:

These are common default or conventional ports. Actual application configurations can differ.

Example:

When a user accesses a website using HTTPS, the client typically connects to the web server using TCP port 443.

In AWS, security groups can control which inbound and outbound traffic is allowed to reach an EC2 instance.

5.7 Understanding TCP and UDP

TCP and UDP are transport-layer protocols.

TCP (Transmission Control Protocol)

TCP provides reliable, connection-oriented communication.

Important characteristics include:

• Connection establishment.
• Ordered data delivery.
• Error detection.
• Retransmission of lost data.
• Flow and congestion control.

Examples of applications that commonly use TCP include HTTPS, SSH, and many database connections.

UDP (User Datagram Protocol)

UDP provides connectionless communication with lower protocol overhead.

It does not guarantee delivery, ordering, or retransmission at the transport layer.

Common uses include:

• DNS queries in many configurations.
• Real-time audio and video.
• Online gaming.
• Certain monitoring and streaming protocols.

5.8 Understanding the TCP Three-Way Handshake

TCP establishes a connection using a three-way handshake.

The three steps are:

1. SYN: The client sends a connection request to the server.
2. SYN-ACK: The server acknowledges the request and responds.
3. ACK: The client acknowledges the server's response.

After the handshake, TCP data communication can begin.

Understanding this process helps when troubleshooting connection establishment problems.

5.9 Understanding HTTP and HTTPS

HTTP stands for Hypertext Transfer Protocol.

It is an application-layer protocol used for communication between clients and web servers.

HTTPS is HTTP secured using TLS (Transport Layer Security).

Important HTTP methods include:

• GET – Retrieve a resource.
• POST – Submit data or create a resource.
• PUT – Replace a resource.
• PATCH – Partially update a resource.
• DELETE – Delete a resource.

Common HTTP status codes include:

DevOps Engineers frequently investigate HTTP errors during application deployments and production incidents.

5.10 Understanding OSI and TCP/IP Models

Networking communication is commonly explained through layered models.

OSI Model

The OSI model has seven layers:

1. Physical – Transmits raw bits through physical media.
2. Data Link – Handles local link communication and frames.
3. Network – Handles logical addressing and routing.
4. Transport – Provides end-to-end transport using TCP or UDP.
5. Session – Manages communication sessions.
6. Presentation – Handles data representation, encoding, and related transformations.
7. Application – Provides network services used by applications.

TCP/IP Model

The commonly used four-layer TCP/IP model includes:

1. Network Access.
2. Internet.
3. Transport.
4. Application.

Understanding these models helps engineers identify where network communication problems may occur.

5.11 Understanding Routing and Gateways

Routing is the process of determining how network packets travel from a source to a destination.

A router forwards packets between different networks based on routing information.

A default gateway is the next-hop device used when a destination does not match a more specific route.

In AWS, route tables determine where network traffic from a subnet is directed.

For example, a public subnet may have a route to an...