Azure High Trust Account Essential Linux Commands for Azure VM Users
Why Linux on Azure Feels Like Wizardry (But Without the Wand)
If you’re using Linux in an Azure VM, congratulations: you’ve chosen the platform where “I’ll just check one thing” can accidentally turn into “why is the entire server arguing with DNS?” Still, the command line is your trusty broomstick. The trick is learning a handful of spells—also known as essential Linux commands—that help you connect, inspect, troubleshoot, and fix problems quickly.
This article is a practical, readable tour of the commands Azure VM users reach for constantly. We’ll cover safe ways to authenticate, check system health, manage files and storage, control services, inspect networking, view logs, and understand what processes are doing. You won’t just memorize commands—you’ll learn why they matter, what outputs to expect, and what common mistakes to avoid. Think of it as giving your fingers a map. The alternative is wandering the filesystem and accidentally deleting the universe.
Before We Start: A Quick Mindset for Command-Line Success
Linux commands tend to be simple in structure but powerful in consequence. A single character can change the meaning of a command. For example: “rm” is already a little dramatic, but “rm -rf” is basically the command line’s version of throwing a house party in a library. So before you run anything risky, keep these habits:
- Use copy-paste carefully. If you see “sudo rm -rf /path,” pause and read it like it’s a bedtime story you don’t fully trust.
- Prefer harmless inspection. Use “ls,” “cat,” “head,” “tail,” and “less” to look around first.
- Understand permissions. “Permission denied” is Linux’s way of saying, “Nice try, citizen.”
- Learn to spot errors quickly. A command that returns nothing may be fine; a command that prints warnings might be telling you something important.
With that, let’s get into the commands you’ll actually use.
Connecting to Your Azure VM: SSH Basics That Won’t Betray You
ssh: The “Hello, VM” Button
Most of your Linux life starts with SSH. On your local machine:
ssh <user>@<vm-ip-or-hostname>
Common useful variations:
- Use a specific private key: ssh -i ~/.ssh/mykey.pem <user>@<host>
- Set a port (if non-standard): ssh -p 2222 <user>@<host>
- Disable password auth (if you’re configured for keys): Usually handled via server config, but at least verify you’re using keys.
Gotcha: Azure networking sometimes means your VM is reachable via a public IP, but sometimes you’re using private networking. Make sure you’re connecting through the right route (and that security rules allow it).
ssh-keygen and ssh-copy-id: Key Management With Less Drama
If you’re setting up key-based access, you may use:
- Generate a key pair: ssh-keygen -t ed25519 -C "[email protected]"
- Copy your public key to the VM: ssh-copy-id <user>@<host>
If ssh-copy-id isn’t installed or you’re in an environment that doesn’t support it, you can still add your public key to the VM manually. You’d typically place it in the user’s `~/.ssh/authorized_keys` file. The file expects correct permissions; otherwise SSH may refuse it.
Getting Oriented: “What Is This Machine and What’s It Doing?”
uname: The Quick Reality Check
To learn your kernel and OS basics:
uname -a
This prints something like kernel name, version, architecture, etc. Useful when you need to correlate behavior with kernel versions.
cat / head / tail / less: Read Files Like a Responsible Adult
File reading commands are your daily bread.
- cat prints a file immediately: cat /etc/os-release
- head shows the top lines: head -n 20 /var/log/syslog
- tail shows the bottom lines: tail -n 50 /var/log/syslog
- tail -f “follows” updates: tail -f /var/log/syslog
- less allows scrolling: less /etc/nginx/nginx.conf
For troubleshooting, tail -f is a favorite. It’s like watching a movie’s final scene—but for logs.
/etc/os-release: Know Your Distro
Azure VMs can be Ubuntu, Debian, CentOS/RHEL, AlmaLinux, and others. You can identify the OS via:
cat /etc/os-release
This is one of those files that always feels welcoming, even when your server isn’t.
whoami, hostname, and uptime: Identity, Name, and Life Expectancy
- whoami: tells you your current user.
- hostname: shows the machine name.
- uptime: how long the system has been running, plus load averages.
“Uptime” is not just trivia. It’s a quick indicator of whether you’re dealing with a freshly restarted system or one that has been steadily chugging along since the dawn of time.
System Monitoring: CPU, Memory, Disk, and Friends
free -h: Memory Without the Guesswork
To see RAM usage in human-readable format:
free -h
Watch the “available” memory field. If “available” is low, your system may be under memory pressure even if buffers/caches look okay.
top and htop: Who’s Hogging Resources?
top is usually installed by default. It shows live CPU and memory usage by process. Run:
top
If you want a friendlier interface and htop is available, install it and use:
htop
In top/htop, you can usually sort by CPU or memory and spot the “why is this one process eating everything” culprit.
df -h: Disk Space on Mounted Filesystems
To check disk space:
df -h
This tells you free space for mounted filesystems. It’s often the fastest way to answer the question: “Do we have disk space, or is the server about to implode?”
du -sh: Folder Size Summaries
When you suspect a directory is growing without permission:
du -sh /var/log
To drill down further:
Azure High Trust Account du -h --max-depth=1 /var
Note: du can be slow on huge directory trees. Like a lazy coworker, it might take a while but it will eventually tell you the truth.
Package Management: Installing Tools Without Breaking Reality
apt (Ubuntu/Debian) and yum/dnf (RHEL-family)
Azure High Trust Account Azure VMs come in different distros, so your package manager depends on the OS.
On Ubuntu/Debian:
- Update package lists: sudo apt update
- Install packages: sudo apt install <package>
- Remove packages: sudo apt remove <package>
On RHEL/CentOS-family:
- Update: sudo yum update (or sudo dnf update on newer systems)
- Install: sudo yum install <package> (or sudo dnf install <package>)
Pro tip: when you install troubleshooting tools (like curl, netcat, or htop), you’ll feel smarter immediately. Then you’ll feel smug, which is fine as long as you don’t catch yourself making jokes at prod expense.
Files and Directories: The Survival Toolkit
ls: Listing Without Losing Your Mind
Azure High Trust Account ls shows directory contents. Useful variants:
- Detailed list: ls -l
- Human-readable sizes: ls -lh
- Include hidden files: ls -la
- Sort by time: ls -lt
When logs are involved, sorting by time is a quick way to avoid scrolling through the archaeology section.
pwd: Where You Actually Are
pwd prints the current directory path. This is essential when you’ve run a few commands and your brain is no longer aligned with the filesystem. It happens to everyone. Humans are squishy. Disks are not.
cd: Navigate Like a Person With a Map
- cd /var/log
- cd .. (parent directory)
- cd ~ (home directory)
Pro tip: use tab completion. It’s the command line’s way of saying, “I want you to succeed.”
cp, mv, rm: Copy, Move, Delete (Choose Wisely)
- Copy: cp source destination
- Move/Rename: mv old new
- Delete: rm file
Common caution: rm -r removes directories recursively. rm -rf removes without prompting. Use with extreme care, especially with wildcards like * or when you’re not 100% sure about the path.
chmod and chown: Permissions, Ownership, and the Eternal Permission Denied
Two commands that save you from endless suffering:
- chmod changes permissions: chmod 600 ~/.ssh/authorized_keys
- chown changes ownership: sudo chown -R www-data:www-data /var/www/html
If something won’t run or won’t let you read a file, permissions are usually the reason. Linux is very consistent that way, like a vending machine that refuses your money until you press the exact right button.
Process Management: What’s Running and How to Deal With It
ps and grep: Search Processes Like a Detective
ps aux shows running processes. Common patterns:
- ps aux | grep nginx
- ps -ef | grep java
grep is a filter. It helps you locate processes by name. Remember that grep itself will appear in the output unless you design around it (the classic grep-from-stdout effect). It’s not fatal—it’s just funny in a “the math checks out but the world feels off” way.
pgrep: Find Processes by Pattern
Instead of listing everything and filtering, you can directly find matching processes:
pgrep -fl nginx
-f shows the full command line; -l shows names (depending on distro behavior).
systemctl: Services, Status, and the “Is It Running?” Question
Most modern Linux distributions use systemd. systemctl is your best friend when dealing with services.
- Status: sudo systemctl status <service>
- Start: sudo systemctl start <service>
- Stop: sudo systemctl stop <service>
- Restart: sudo systemctl restart <service>
- Enable on boot: sudo systemctl enable <service>
- Reload config (when supported): sudo systemctl reload <service>
Azure High Trust Account Example: sudo systemctl status nginx
If you’re troubleshooting “my site is down,” checking systemctl status often gets you 80% of the way there. The remaining 20% is usually logs.
Networking: Your Server’s Ability to Speak to the World
ip: The Modern Network Swiss Army Knife
ip a or ip addr shows network interfaces and IP addresses.
ip route shows routing table. If you’re dealing with connectivity problems, routes matter.
Examples:
- ip a
- ip route
- ip -s link (shows interface statistics)
ping: Quick Connectivity Test
ping -c 4 <host>
It sends a few packets and shows latency. If ping fails, it could be firewall rules, routing issues, or just the remote host being dramatic.
curl: Fetch URLs Like You Mean It
For HTTP checks, curl is extremely handy:
- curl -I https://example.com (fetch headers)
- curl -v http://localhost:8080 (verbose debugging)
- curl -sS <url> (silent but show errors)
If a web service is misbehaving, curl tells you what response you’re actually getting, rather than what you wish you were getting.
ss and netstat: Ports and Listening Services
To see listening ports:
ss -lntp
Azure High Trust Account Explanation in plain language: show listening (-l), numeric addresses (-n), TCP (-t), with process info (-p). This is excellent when you want to know which service is bound to which port.
netstat may exist, but ss is the modern default on many systems.
Logs: The Oracle of Useful Information
journalctl: The Log Collector You’ll Eventually Love
On systemd-based systems, logs are often available through journalctl.
- sudo journalctl -u <service> --since "1 hour ago"
- sudo journalctl -xe (show recent errors and extended messages)
- sudo journalctl -f (follow new log entries)
- sudo journalctl --no-pager (less paging for easy copy/paste)
Example workflow: you restart a service, it fails again, so you check its log history with journalctl and look for the reason. The reason is usually in there, waiting patiently like a coworker who only speaks when the meeting is nearly over.
/var/log: Traditional Log Files That Still Pull Their Weight
You may also inspect log files directly:
- /var/log/syslog (Debian/Ubuntu common)
- /var/log/messages (RHEL/CentOS common)
- /var/log/auth.log (authentication events)
- /var/log/nginx/ (web server logs)
- /var/log/apache2/ or /var/log/httpd/ (depending on server)
Useful commands:
- tail -n 100 /var/log/syslog
- tail -f /var/log/auth.log
- less /var/log/nginx/error.log
If your server is misbehaving, logs are the first place you check after you verify configuration files. (Also after you confirm you didn’t accidentally deploy a config intended for staging to production. Everyone swears it won’t happen. Everyone is wrong.)
Disk and Storage Management: Because Space Is Finite and Karma Is Real
lsblk: See Block Devices Clearly
lsblk shows disks and partitions. Example:
lsblk -f
-f includes filesystem type and mount info. This helps you map storage devices to mount points.
mount and /etc/fstab: What’s Mounted and What Should Be
mount shows current mounts.
cat /etc/fstab shows the configuration for mounting at boot. If something isn’t mounting correctly, fstab is often implicated.
When adjusting storage, always test carefully. Incorrect fstab entries can cause boot delays or failures. Linux will not warn you politely; it will simply do the thing you typed.
swapon and free: Swap Space Insights
Swap can prevent crashes, but too much swap can signal memory pressure.
- swapon --show
- free -h
Azure High Trust Account If swap is heavily used, you might need to investigate memory-hungry processes or application behavior.
User and Group Management: Access Control Without Regrets
who and w: Who’s Logged In and What Are They Doing
To see logged-in users:
- who
- w
w provides more details, including idle times and current activities. It’s useful when you suspect someone’s session is stuck or causing confusion.
id: Know Your Identity and Group Membership
id prints user ID and group info.
Azure High Trust Account Example: id <username>
This helps when permission issues are involved.
useradd/usermod and groups: Administrative Touchpoints
For creating or modifying users, you’ll commonly use:
- sudo useradd <username>
- sudo usermod -aG <group> <username>
- groups <username>
Be careful with usermod. Changing groups is often what you want, but changing the wrong thing can lead to access problems later.
Superpowers (And Safety Rails): sudo and Shell Habits
sudo: The Permission Gate You Need
sudo runs commands as an elevated user (commonly root). Example:
sudo systemctl restart nginx
If a command fails because of permissions, try to understand why before you blindly add sudo to everything. Some operations should be done carefully, and sudo should be used with intention.
Environment Variables: PATH and Friends
When a command isn’t found, it’s often PATH-related. You can check your PATH:
echo $PATH
And check which binary is used:
which <command>
These quick checks save you from the classic “it works on my machine” problem, except now it’s “it works on my session, not on yours.”
Essential Troubleshooting Commands: The “I Need Answers Now” Set
Checking Connectivity and Name Resolution
If you can’t reach a host, you need to know if it’s DNS, routing, or firewall.
- ping -c 4 <host>
- curl -I <url> (if HTTP is expected)
- nslookup <host> (if installed)
- dig <host> (if installed)
To inspect DNS configuration:
cat /etc/resolv.conf
On Azure, DNS configuration may be provided by the VM’s networking environment, but it’s still worth checking when things feel off.
Finding Logs and Errors Quickly
When things break, you want the right logs fast.
- sudo journalctl -xe
- sudo journalctl -u <service> --since "today"
- tail -n 200 /var/log/<relevant-file>
If the system is failing, journalctl’s “since” filters are especially useful because they narrow the noise to the relevant time window.
Checking Service Status and Binding
For a web service that “should be listening” but isn’t:
- sudo systemctl status <service>
- ss -lntp | grep <port>
- tail -n 100 /var/log/<service>/error.log (if applicable)
This combo quickly tells you: is it running, is it listening, and what is complaining?
File and Configuration Management: Editing Without Losing Your Soul
nano, vi, or vim: Pick Your Editor Personality
Depending on your environment, you’ll use an editor to change config files. Common ones:
- nano for a friendly interface
- vim for power-user speed (with a learning curve)
- vi as a default vim-like editor
When editing system files, use sudo with care:
sudo nano /etc/someconfig.conf
If you’re using vim and you’re new, remember the basic survival rule: press i to insert, then Esc to exit insert mode, then :wq to save and quit. If that sentence makes you sweat, nano may be the kinder option for your first few edits.
Backing Up Before You Change Things
Before editing a config, make a backup:
Azure High Trust Account sudo cp /etc/someconfig.conf /etc/someconfig.conf.bak
Then if you mess something up (we’ve all been there), you can restore the previous version. This doesn’t guarantee success, but it does reduce the panic levels significantly.
Command Combinations: How Experts Think (Without the Mystic Monks)
Using Pipes and Redirection: | and >
Two symbols that multiply your effectiveness:
- Pipe (|) passes output to another command.
- Redirection (> or >>) sends output to a file.
Examples:
- Azure High Trust Account ps aux | grep python
- journalctl -u nginx --since "1 hour ago" > nginx-logs.txt
- tail -f /var/log/syslog > syslog-follow.txt (be careful: this can grow quickly)
These techniques help you filter output, save logs for later, and communicate what you found to someone else (or to your future self, who will definitely need it).
Quoting and Escaping: Tiny Details, Big Consequences
When searching or running commands with spaces or special characters, quoting matters.
Example:
- cat "My File.txt"
- Azure High Trust Account grep "error" /var/log/syslog
If commands mysteriously fail, check your quotes first. Linux is not trying to prank you; it’s just interpreting your input literally.
A Practical “If Something’s Wrong” Workflow
Here’s a simple troubleshooting workflow you can reuse for many Azure VM incidents. It won’t solve every problem magically, but it will keep you from thrashing around like a hamster in a server rack.
- Confirm the symptom. Is the service down? Is latency high? Is disk full?
- Azure High Trust Account Check the service state. Use sudo systemctl status <service>
- Inspect logs around the time of failure. Use journalctl -u <service> --since "1 hour ago" or tail appropriate log files.
- Check resources. Use free -h, top, df -h.
- Check connectivity/ports. Use ss -lntp, curl -I, ping.
- Check configuration. Look at relevant config file(s) and confirm environment variables or config values.
- Apply changes carefully. Backup configs first, restart or reload services, and verify.
This workflow is basically: observe, verify, narrow, and then act. The command line is fast, but your time is valuable, so don’t let speed turn into chaos.
Common Command Line Mistakes (So You Don’t Become a Cautionary Tale)
Running commands as the wrong user
If you get “permission denied,” it might be fixable with sudo, but it might also be a sign you’re touching the wrong directory or file. Learn to interpret errors instead of immediately escalating.
Editing the wrong file
This happens more than anyone likes to admit. Always confirm paths with pwd and ls, and consider copying config files with backups.
Deleting logs or system directories “to free space”
Yes, you might want to clean up disk space, but deleting random directories can cause services to fail. Prefer using tools that rotate logs or understand the application’s log structure. If you delete logs, make sure it won’t break something unexpectedly.
Azure High Trust Account Quick Reference: Essential Commands You Should Keep Handy
Let’s consolidate the essentials into a tidy list. You won’t memorize all of these overnight (and that’s okay). Over time, your fingers will learn them by repetition, like a training montage, except with fewer montage songs.
- Connection: ssh, (optionally) ssh-keygen, ssh-copy-id
- System basics: uname -a, cat /etc/os-release, hostname, uptime
- File viewing: cat, head, tail, less, tail -f
- Disk and memory: df -h, du -sh, free -h, lsblk
- Processes: ps aux, pgrep -fl, top, (or htop if installed)
- Services: systemctl status/start/stop/restart/enable/reload
- Logs: journalctl, tail on /var/log files
- Networking: ip a, ip route, ping, curl, ss -lntp
- Permissions: chmod, chown
- Power moves: sudo
That’s the starter pack. Now let’s wrap up with a realistic expectation: you’ll still run into problems you haven’t seen before. But with these commands, you’ll be able to investigate instead of guessing.
Final Thoughts: Become the Person Who Can Diagnose Things Fast
Operating Azure VMs with Linux is a blend of infrastructure thinking and detective work. The essential commands in this article cover the majority of what you’ll do daily: connect securely, check system status, monitor resources, inspect networking, manage services, and read logs like your life depends on it. Because sometimes, it kind of does—mostly in the “production incident” sense, but also in the “my pager has started vibing angrily” sense.
When you practice these commands a few times, you’ll notice the difference immediately. Troubleshooting becomes less of a frantic search and more of a methodical process. And if you ever feel lost, just remember: Linux gives you the clues. You just have to know where to look.
Now go forth and command your Azure VM with confidence. May your disks stay roomy, your services stay healthy, and your logs always reveal the truth before you lose your patience.
