Hands-on AWS + Linux project demonstrating server administration, security, monitoring, troubleshooting, automation, and operational practices using Ubuntu EC2.

This project demonstrates practical Linux System Administration on an Ubuntu Linux server hosted on Amazon EC2.

The environment was configured and managed to simulate real-world day-to-day responsibilities of a:

• Linux System Administrator
• AWS Cloud Support Engineer
• Junior DevOps Engineer

• Linux user and group administration
• File ownership and permissions
• SSH-based remote administration
• Nginx web server management
• UFW firewall configuration
• Process and systemd service management
• CPU, memory, disk, and network monitoring
• Linux and application log analysis
• Shell scripting
• Cron-based automation
• AWS CloudWatch monitoring
• CloudWatch Agent
• CloudWatch Metrics
• CloudWatch Alarms
• IAM role-based AWS access
• Amazon S3 report and log storage
• AWS CLI
• Git and GitHub

                         ☁️ AWS
                           │
                           ▼
                  ┌──────────────────┐
                  │   Amazon EC2     │
                  │   Ubuntu Linux   │
                  └────────┬─────────┘
                           │
          ┌────────────────┼────────────────┐
          │                │                │
          ▼                ▼                ▼
     🔐 SSH Access    🌐 Nginx        🐧 Linux Admin
          │                │                │
          ▼                ▼                ├── Users & Groups
     🔥 UFW Firewall   Nginx Logs          ├── Permissions
                                            ├── Processes
                                            ├── Services
                                            ├── Disk
                                            ├── Networking
                                            └── Troubleshooting
                           │
                           ▼
                  🐚 server_health.sh
                           │
                           ▼
                    ⏰ Cron - Every 5 Min
                           │
                           ▼
                      health.log
                           │
             ┌─────────────┴─────────────┐
             │                           │
             ▼                           ▼
      📊 CloudWatch                 ☁️ Amazon S3
             │                           │
      CloudWatch Agent             health-reports/
             │                           │
      ┌──────┼──────┐                    └── logs/
      ▼      ▼      ▼
     CPU    RAM    Disk
      │      │      │
      └──────┼──────┘
             ▼
      CloudWatch Metrics
             │
             ▼
      CloudWatch Alarms

• Ubuntu Linux

The project covers basic Linux user administration, including:

• User creation
• User verification
• User and group administration

Common commands:

adduser
id
groups

groupadd
usermod
groups

Administrative privileges can be configured using the appropriate Linux groups.

Example:

sudo usermod -aG sudo username

Common commands used:

mkdir
ls
ls -la
cp
cat
nano

chown

Example:

sudo chown username:group filename

chmod

Example:

chmod 640 filename

SSH was used to remotely access and administer the Ubuntu EC2 server.

• SSH login
• .pem key authentication
• SSH connectivity
• Port 22
• Secure remote administration

Example:

ssh -i linux-admin-key.pem ubuntu@PUBLIC-IP

Note: Replace linux-admin-key.pem and PUBLIC-IP with your actual key file and EC2 public IP address.

Linux processes were monitored and investigated using:

ps
ps aux
ps -ef
top

These commands help identify:

• Running processes
• CPU-consuming processes
• Memory-consuming processes
• Process IDs
• Process states

The Nginx service was managed using systemctl.

sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl status nginx
sudo systemctl enable nginx
sudo systemctl is-enabled nginx

Service failure scenarios were also considered for troubleshooting practice.

Nginx was installed and configured as a web server on the Ubuntu EC2 instance.

• Nginx installation
• Nginx service management
• Custom web page configuration
• Configuration validation
• Log analysis

Test Nginx configuration:

sudo nginx -t

/var/log/nginx/access.log
/var/log/nginx/error.log

Useful commands:

tail
journalctl

UFW was configured as the Linux host-based firewall.

sudo ufw allow 22
sudo ufw allow 80
sudo ufw allow 443
sudo ufw enable
sudo ufw status

AWS Security Groups should also be configured appropriately because UFW and AWS Security Groups operate at different network layers.

Network configuration and connectivity were checked using:

ip addr
ip route
ping
ss

Examples:

ping -c 4 8.8.8.8
ping -c 4 google.com
ss -tulpn

These commands help troubleshoot:

• IP configuration
• Routing
• Internet connectivity
• Listening ports
• Active network connections

Disk and storage utilization were monitored using:

df -h
du -sh
lsblk

Root filesystem check:

df -h /

These commands help identify:

• Disk utilization
• Large directories
• Mounted filesystems
• Available storage
• Block devices

System resource usage was checked using:

free -h
uptime
top

The monitoring focuses on:

• CPU utilization
• Memory utilization
• System uptime
• Running processes
• System load

The project includes practical log analysis of:

• Nginx access logs
• Nginx error logs
• System logs
• Cron output
• Server health logs

Useful commands:

tail
cat
journalctl

Example:

sudo tail -f /var/log/nginx/error.log

The main server health-check script is:

server_health.sh

The script checks important server health information such as:

• Hostname
• Uptime
• Memory usage
• Disk usage
• Nginx service status

Make the script executable:

chmod +x server_health.sh

Run manually:

./server_health.sh

The health-check script is scheduled to run every 5 minutes using Cron.

Example:

*/5 * * * * /home/ubuntu/Linux-Project/server_health.sh >> /home/ubuntu/Linux-Project/health.log 2>&1

The automated job:

1. Executes every 5 minutes
2. Checks server health
3. Appends output to health.log
4. Captures errors using 2>&1

Check configured Cron jobs:

crontab -l

The Amazon CloudWatch Agent is configured on the Ubuntu EC2 instance to collect additional system-level metrics.

• CPU
• Memory
• Disk

Linux/EC2

60 seconds

cpu_usage_idle
cpu_usage_user
cpu_usage_system

mem_used_percent

disk_used_percent

CloudWatch provides centralized visibility into the server's resource utilization.

The project includes monitoring plans/configuration for:

Linux-Server-High-CPU
Linux-Server-High-Memory
Linux-Server-High-Disk

Example threshold:

80%

These alarms are intended to identify high resource utilization and support proactive server monitoring.

An IAM role was created for the EC2 instance:

EC2-CloudWatch-Agent-Role

The role provides AWS permissions required by the EC2 server for CloudWatch monitoring and S3 operations.

Primary CloudWatch policy:

CloudWatchAgentServerPolicy

The EC2 instance uses an IAM role instead of storing long-term AWS access keys on the server.

This follows a more secure approach for accessing AWS services from EC2.

Amazon S3 is used to store generated health reports and log files.

prajwal-linux-admin-monitoring-2026

prajwal-linux-admin-monitoring-2026/
│
├── health-reports/
│   └── server-health.txt
│
└── logs/
    └── health.log

aws s3 cp server-health.txt \
s3://prajwal-linux-admin-monitoring-2026/health-reports/

aws s3 cp health.log \
s3://prajwal-linux-admin-monitoring-2026/logs/

aws s3 ls s3://prajwal-linux-admin-monitoring-2026/ --recursive

AWS CLI was used from the Ubuntu EC2 server to interact with AWS services.

Commands used include:

aws --version
aws s3 ls
aws s3 cp
aws s3api head-object

AWS CLI allows AWS resources and services to be managed directly from the Linux command line.

AWS-Linux-system-admin-monitoring/
│
├── configs/
│   └── CloudWatch configuration files
│
├── docs/
│   └── Project documentation
│
├── screenshots/
│   └── AWS and Linux screenshots
│
├── server_health.sh
├── .gitignore
└── README.md

whoami
hostname
pwd
ls
ls -la
cat
cp
nano
apt
adduser
groupadd
usermod
id
groups
chown
chmod
ps
top
systemctl
journalctl
nginx
ip
ping
ss
df
du
lsblk
free
uptime
crontab

aws --version
aws s3 ls
aws s3 cp
aws s3api head-object

git init
git add .
git commit
git branch
git remote
git push

The project provides hands-on practice with common Linux server issues.

top
ps aux
uptime

free -h
top

df -h
du -sh
lsblk

systemctl status nginx
nginx -t
journalctl
tail /var/log/nginx/error.log

ip addr
ip route
ping
ss -tulpn

tail
cat
journalctl

Ubuntu EC2
    │
    ▼
CloudWatch Agent
    │
    ├── CPU
    ├── Memory
    └── Disk
    │
    ▼
CloudWatch Metrics
    │
    ▼
CloudWatch Alarms
    │
    ▼
Resource Utilization Monitoring

Ubuntu EC2
    │
    ▼
server_health.sh
    │
    ▼
Cron - Every 5 Minutes
    │
    ▼
health.log / server-health.txt
    │
    ▼
AWS CLI
    │
    ▼
Amazon S3
    │
    ├── health-reports/
    └── logs/

The project demonstrates basic server and cloud security practices:

• SSH key-based authentication
• UFW firewall configuration
• AWS Security Group awareness
• IAM role-based AWS access
• Least-privilege oriented AWS access
• Linux file ownership and permissions
• No hard-coded AWS credentials in scripts
• Controlled network ports
• Secure remote administration

This project demonstrates practical skills in:

• Linux System Administration
• AWS EC2 Administration
• AWS IAM
• CloudWatch Monitoring
• Server Health Monitoring
• CPU / Memory / Disk Troubleshooting
• Nginx Administration
• SSH Administration
• Linux Firewall Management
• User & Group Management
• File Permissions
• Process Management
• systemd Service Management
• Network Troubleshooting
• Log Analysis
• Shell Scripting
• Cron Automation
• AWS CLI
• S3 Operations
• Git & GitHub

Screenshots and supporting documentation are maintained in:

screenshots/
docs/
configs/

• EC2 instance
• IAM role
• CloudWatch Agent
• CloudWatch metrics
• CloudWatch alarms
• S3 bucket
• Linux users and groups
• File permissions
• Nginx configuration and status
• UFW configuration
• Cron configuration
• Server health script
• AWS CLI commands

Prajwal Take

GitHub:

https://github.com/tprajwal14

An end-to-end hands-on AWS and Linux System Administration project covering EC2 server administration, security, Nginx, SSH, UFW, systemd, process management, disk and network troubleshooting, shell scripting, Cron automation, CloudWatch monitoring, IAM, S3, AWS CLI, Git, and GitHub.

• ☁️ Deployed and administered an Ubuntu Linux server on AWS EC2
• 🐧 Performed practical Linux administration and troubleshooting
• 🔐 Implemented SSH access, Linux permissions, UFW, and IAM-based access
• 🌐 Installed and managed Nginx web server
• 📊 Configured CloudWatch monitoring for system resources
• 🚨 Created monitoring and alerting concepts using CloudWatch Alarms
• 🐚 Automated server health checks using Bash and Cron
• ☁️ Stored reports and logs in Amazon S3 using AWS CLI
• 📝 Maintained project documentation, configuration files, and evidence using Git/GitHub