Linux for Cloud & DevOps Engineers

This lecture covers essential system-information commands: date (system time in UTC), cal (current month calendar), and uptime (how long the system has been running, plus load average — useful for checking if a server was rebooted). It then covers user-identity commands — whoami, who, w, id, users, and finger — showing how each reveals the logged-in user, login source, and public IP, with a demo of switching between ec2-user and root. It closes with the man command for looking up manual pages and usage examples for any command.

This lecture covers commands for viewing file contents in Linux (no double-click GUI here). It introduces ls (list files/directories) and pwd (show current path) as navigation basics, then compares ways to read files: cat (dumps the whole file, landing at the end), less/more (page-by-page viewing, navigated with space and quit with q), and head/tail (first/last 10 lines by default, or a custom count with -N). It closes noting page works similarly but isn't supported on all systems.

This lecture covers multiple ways to create files in Linux. touch creates a 0-byte file, and along the way it introduces ls flags — -l (long list), -t (sort by timestamp), -r (reverse order), combinable as ls -ltr — a common real-world command for spotting recently updated files. It then covers using cat > filename to create and write a file (exiting with Ctrl+C), and introduces text editors — nano and vi — as a more flexible option for creating and editing file content, unlike cat. The next lecture moves on to deleting and editing files.

This lecture demonstrates installing and using nano (via yum install nano -y, run as root) as a simpler alternative to vi for creating and editing files. It clarifies the key limitation of cat: cat > file overwrites existing content entirely, while cat >> file appends without touching existing data — but neither lets you truly edit a file's content. For real editing (modifying or removing existing lines), vi and nano are the safe options, since they let you insert, change, or delete content in place. The next lecture moves on to creating directories.

This lecture covers creating directories with mkdir (single or multiple at once, e.g., mkdir dir2 dir3 dir4) and identifying files vs. directories using ls -l, where the leading character shows - for a file and d for a directory. It introduces cd (change directory) for navigating into a directory — since there's no "double-click" equivalent in Linux — and demonstrates creating subdirectories inside an existing directory. The next lecture moves on to deleting files and directories.

This lecture covers deleting files with rm (with confirmation prompt, or -f to force it without asking) and multiple files at once. It introduces tree for visualizing directory structure and rmdir for removing empty directories — noting it fails if the directory still contains content. For non-empty directories, rm -rf (recursive + force) removes everything inside, including subdirectories. It closes with a strong caution about rm -rf *, since Linux has no recycle bin and deleted files can't be recovered — making backups essential.

This lecture covers the cp command for copying content: file-to-file (cp file1 file2), file-into-directory (cp file1 dir1, which creates the file inside the destination), and directory-to-directory using the -r (recursive) flag, since cp alone can't copy directories. It clarifies the source-to-destination logic throughout and notes that a directory can't be copied into a file.

This lecture covers the mv command, which works like cut-and-paste (unlike cp, which duplicates). Using the same source-destination syntax as cp, mv file dir moves a file into a directory. It also shows how mv oldname newname is used to rename a file in place — the content moves to the new name and the old filename disappears, which effectively renames it.

This lecture covers navigating with cd: using cd .. to move up to the parent directory, and reaching / (the top-level "root" of the filesystem, like C:\ in Windows). It distinguishes absolute paths (starting with /, always resolved from the top regardless of current location) from relative paths (starting from the current directory, e.g., dir1 or ..), showing how each lets you jump directly to a target directory like /tmp or /root/dir1. It closes with a reminder that rm -rf * run at / would wipe the entire system — reinforcing why the command must be used with extreme caution.

This lecture covers three commands. find locates files or directories by criteria — -name (filename), -user (owner), or -group — and searches recursively from a given path, such as find / -name file1. diff compares two files and highlights differing lines, demonstrated by editing copies of the same file and diffing them. file identifies a file's type — regular text, directory, character/block special file (under /dev), or symbolic link. The next lecture moves on to grep.

This lecture covers grep for finding a pattern in a file (grep pattern filename). It covers the -i flag to ignore case, and using the pipe (|) to feed one command's output into grep as if it were a file - e.g. ls -l | grep environment to search a directory listing. It also shows the ^ (caret) symbol to match a pattern only at the start of a line, useful for filtering ls -l | grep ^d down to actual directories rather than any line containing "d".

This lecture covers sed (stream editor) for finding and replacing text - by default it only changes the displayed output, not the original file. It walks through sed s/old/new/ (replaces the first match per line), adding g for global replacement (all matches, including partial word matches), and i for case-insensitive matching. Adding the -i flag makes the change permanent by updating the file itself, rather than just showing modified output. It also covers sed -n '5,10p' to display specific line ranges and sed '5,10d' to delete a range of lines, demonstrated using an ansible.cfg sample file.

This lecture introduces Linux's three user types: super user (root, home directory /root), system users (created automatically by installed software), and normal users (created by root under /home). It covers where user info is stored and what happens by default when a user is created - a home directory, a unique UID/GID, and a matching group. It demonstrates useradd for creating new users (John, Mark) and usermod -g for adding a user to an additional group, noting this is commonly needed when setting up Docker access. The next lecture covers setting a password and logging in as the new user.

This lecture covers setting a password for a user (passwd John) and shows that AWS EC2 instances allow only key-based SSH login by default - attempting password login fails with an authentication error. To enable it, the lecture edits sshd_config presents in /etc/ssh/, changing Password  Authentication from no to yes, then reloads the SSH service (service sshd reload) to apply the change. After this, logging in with the username and password succeeds, landing the user in their home directory (/home/john).

This lecture completes the breakdown of ls -l output (links, owner, group, size, date, filename) and explains how read/write/execute permissions differ in meaning for directories versus files: read lets you ls a directory's contents, write lets you add/rename/delete items inside it, and execute lets you cd into it. Using ls -ld to check directory-level permissions, it demonstrates that only the owner (John) can freely access and modify his home directory, other users (Mark, ec2-user) are denied entry, and root bypasses all restrictions. The next lecture covers changing file and directory permissions.

This lecture covers two ways to change file/directory permissions with chmod: the symbolic method (u/g/o for user/group/others, with +/-/= to add, remove, or overwrite permissions - e.g. u+x) and the absolute/numeric method (4=read, 2=write, 1=execute, combined into a single digit per category, e.g. chmod 764). It demonstrates applying these to files and to a directory, showing that a directory needs execute permission to be entered, read permission to list its contents, and write permission for others to create files inside it - and confirms only the file's owner or root can change its permissions. The next lecture covers changing file ownership.

This lecture covers chown for changing file ownership (chown user:group filename), demonstrating that only root can change ownership - even a file's current owner or the user attempting to claim it cannot run this command successfully as a regular user. Once root reassigns ownership, that user gains full control, including the ability to run chmod on the file. It also revisits the file command, confirming file types (regular text, directory, character special, block special, symbolic link) - the same behavior shown for permissions in the previous lecture.

This lecture covers commands for checking system state and history. history lists previously run commands (stored in .bash_history, visible with ls -la since it's a hidden file). free shows memory usage (also viewable via /proc/meminfo), and /proc/cpuinfo shows processor details. uname -a displays kernel and OS info, while /etc/redhat-release shows the OS version. du reports disk usage per directory (with -m or -k for size units, often piped with sort to find the largest files), whereis and which locate where a command is installed and run from, and df shows filesystem disk space usage.

Installing Packages - yum (install, remove)

This lecture introduces yum, the primary tool for installing, removing, updating, and querying software packages on Red Hat-based systems (pulling from official or third-party repositories). It covers yum install packagename (demonstrated with unzip and telnet), noting that package installation requires root privileges - a regular user gets an error. It also covers yum install -y to skip the confirmation prompt, and yum remove packagename to uninstall a package, confirmed by the command no longer being found afterward. The next lecture covers updating and listing packages.

Updating and Getting Package Info - yum (update, list, info)

This lecture covers yum update packagename -y for upgrading a package to its latest version (though it has no effect if already current), and yum info packagename for details like version, release, architecture, and size. It also covers yum list installed and yum list available, often piped with grep, to check whether a package exists on the local system versus whether it's simply available in the connected repository. Deeper use cases for yum are noted as coming up in later classes.

Collecting Network Info - hostname, ping, wget, ifconfig, curl

This lecture covers key networking commands. hostname shows/sets the system name, backed by /etc/hostname for permanent changes (requiring a reboot via init 6) versus temporary changes that apply instantly. ping tests whether a target system or website is reachable, showing packet loss if it isn't. wget downloads files or packages directly onto the Linux system using a copied download link. ifconfig (or ip addr) displays the system's IP address(es), and curl fetches a webpage's content from the command line - useful for quickly checking if a deployed application is accessible. telnet is noted as coming in the next lecture.

Telnet Explained

This lecture introduces IP addresses and port numbers using a room-and-lockers analogy: a server has one (or more) IP address, and applications running on it are each identified by a port number, with common defaults like SSH (22), HTTP (80), HTTPS (443), and Telnet (23). It shows netstat -tulpn to list which ports are actively in use (listening) on the system, and demonstrates using telnet host port to check whether a specific port is open - "connection refused" means nothing is listening, while a successful connection confirms the service is running.

Managing Services - service (status, start, stop)

This lecture explains services as processes controlled with commands like service httpd status/start/stop/restart/reload, and chkconfig for setting whether a service starts automatically at boot. It walks through installing Apache (yum install httpd), checking its inactive status, starting it, and confirming with netstat -tulpn that port 80 is now listening. Accessing the server's public IP in a browser initially fails until the AWS security group is updated to allow inbound traffic on port 80 - after which the page loads, also verifiable via telnet to port 80. The next lecture continues with more service and chkconfig commands.

Services - chkconfig and systemctl

This lecture covers SSH (port 22, sshd daemon, (etc/ssh/sshd_config) and HTTP (port 80, httpd daemon, (etc/httpd/conf/httpd.conf) service basics, then demonstrates editing httpd's default page (/var/www/html/index.html) and reloading the service to apply changes - noting reload avoids the disruption caused by stop/start or restart. It shows that a service doesn't survive a reboot unless explicitly enabled, using chkconfig httpd on (or off) to control startup-at-boot behavior. It closes by introducing systemctl as an equivalent to the service command for checking status and starting/stopping services.

Process Management - ps, fg, bg, top

This lecture explains processes in Linux - programs running in the foreground or background, each consuming CPU and memory and identified by a PID (with PID 1 as the root parent). It covers ps -ef to list running processes (and grep to filter for a specific one), kill and kill -9 to stop a process (demonstrated by killing httpd and a logged-in user's session), and using Ctrl+Z, bg, and fg to move jobs between stopped, background, and foreground states. It closes with top, which shows real-time CPU and memory usage across running processes for monitoring system performance.

This lecture covers compressing and decompressing files with gzip/gunzip and zip/unzip, noting these tools work on files, not directories. For directories, it introduces tar -cvf (create, verbose, filename) to archive a directory into a single .tar file, and tar -xvf to extract it back - demonstrated by archiving, deleting, and restoring a directory. It also shows combining compression with archiving: gzip-ing a .tar file, and using tar -xvzf as a single command to both unzip and extract a compressed tarball in one step.

This lecture introduces crontab for scheduling recurring jobs, handled by the cron daemon so tasks run regardless of whether a user is logged in. It covers the required 6-field format (minute, hour, day of month, month, day of week, command) with * meaning "every," and walks through examples like running a job daily at 8:30 AM, every Saturday at 2 PM, and on the 25th of every month. It demonstrates crontab -l to list jobs and crontab -e to edit them (per-user), verifying scheduled jobs actually execute at their set time, including a job set to run every minute (* * * * *).

Softlink and Hardlink - ln

This lecture explains the difference between soft links (shortcut-like references, minimal size, broken if the original file is deleted) and hard links (independent backup copies, same size as the original, unaffected by the original's deletion). It demonstrates ln -s for creating a soft link and ln for a hard link, confirming both stay in sync when the source file is updated. It also shows a practical use case - creating a soft link under /usr/local/bin for a shell script (hello.sh), letting it run as a simple command (hello) from anywhere on the system.

Copying Files from Windows to Linux - scp

This lecture covers transferring files between systems using GUI and command-line methods. It shows MobaXterm's built-in SFTP panel (and WinSCP as an alternative) for drag-and-drop file transfers between Windows and Linux. For Linux-to-Linux transfers, it introduces scp (secure copy) with the syntax scp source user@host:destination, demonstrating both pushing and pulling files, and using the -r flag to copy entire directories. It also covers enabling password-based SSH authentication (via etc/ssh/sshd_config) on a new server so scp can prompt for a password rather than requiring a key.