PowerShell Commands Cheatsheet

Get-Help Get-Process
Get-Help Get-Process -Full
Get-Help Get-Process -Examples
Get-Help Get-Process -Online
Get-Help about_*                    # List about topics

Get-Alias
Get-Alias ls
Get-Alias -Definition Get-ChildItem

Get-Command                         # All commands
Get-Command *Service*               # Search commands
Get-Command -Module ActiveDirectory
Get-Command -Verb Get
Get-Command -Noun Process

Write-Host "Message"
Write-Output "Output"
Write-Warning "Warning"
Write-Error "Error"
Write-Verbose "Verbose" -Verbose
Write-Debug "Debug" -Debug

Clear-Host
cls                                 # Alias

Get-ChildItem
Get-ChildItem -Path C:\              # Specific path
Get-ChildItem -Recurse               # Recursive
Get-ChildItem -Hidden                # Hidden files
Get-ChildItem -File                  # Files only
Get-ChildItem -Directory             # Directories only
Get-ChildItem -Filter *.txt
Get-ChildItem -Include *.log -Recurse
Get-ChildItem -Exclude *.bak

Set-Location C:\Path
cd C:\Path                           # Alias
Push-Location C:\Temp                # Save location
Pop-Location                         # Return to saved

New-Item -ItemType File -Name "file.txt"
New-Item -ItemType Directory -Name "folder"
New-Item -Path C:\Temp\test.txt -Force
mkdir NewFolder                      # Alias

Copy-Item source.txt destination.txt
Copy-Item -Path C:\Source -Destination C:\Dest -Recurse
Copy-Item *.txt C:\Destination
cp source.txt dest.txt               # Alias

Move-Item old.txt new.txt
Move-Item C:\Source\file.txt C:\Destination\
Rename-Item old.txt new.txt
mv old.txt new.txt                   # Alias

Remove-Item file.txt
Remove-Item folder -Recurse
Remove-Item -Path C:\Temp\* -Force
rm file.txt                          # Alias

Get-Content file.txt
Get-Content file.txt -Head 10        # First 10 lines
Get-Content file.txt -Tail 10        # Last 10 lines
Get-Content file.txt -Wait           # Like tail -f
cat file.txt                         # Alias
type file.txt                        # Alias

Set-Content -Path file.txt -Value "Content"
Add-Content -Path file.txt -Value "More content"
"Content" | Out-File file.txt
"Content" | Out-File file.txt -Append

Get-Item file.txt
Get-ItemProperty file.txt
(Get-Item file.txt).Length          # File size
(Get-Item file.txt).LastWriteTime
Test-Path file.txt                  # Check if exists

$name = "John"
$age = 30
$PI = 3.14

[string]$name = "John"
[int]$age = 30
[double]$price = 99.99
[bool]$isActive = $true
[datetime]$date = Get-Date
[array]$numbers = 1,2,3,4,5

$global:var = "Global"
$script:var = "Script"
$local:var = "Local"
$private:var = "Private"

$PSVersionTable                     # PowerShell version
$HOME                               # User home directory
$PWD                                # Current directory
$_                                  # Current pipeline object
$?                                  # Last command success
$LASTEXITCODE                       # Last exit code
$args                               # Function arguments
$null                               # Null value

$env:PATH
$env:COMPUTERNAME
$env:USERNAME
Get-ChildItem Env:                  # All env variables
[Environment]::SetEnvironmentVariable("VAR", "value", "User")

Set-Variable -Name PI -Value 3.14 -Option Constant
New-Variable -Name MAX -Value 100 -Option ReadOnly

Get-Process | Where-Object {$_.CPU -gt 100}
Get-Service | Where-Object Status -eq 'Running'
Get-ChildItem | Where-Object Length -gt 1MB
Get-Process | ? {$_.Name -like "chrome*"}    # Alias

Get-Process | Select-Object Name, CPU
Get-Process | Select-Object -First 10
Get-Process | Select-Object -Last 5
Get-Process | Select-Object -Unique Name
Get-Process | Select-Object -Property *     # All properties
Get-Process | select Name, CPU              # Alias

Get-Process | Sort-Object CPU
Get-Process | Sort-Object CPU -Descending
Get-ChildItem | Sort-Object Length, Name
Get-Process | sort CPU                      # Alias

Get-Process | Group-Object Name
Get-Service | Group-Object Status
Get-ChildItem | Group-Object Extension

Get-Process | Measure-Object
Get-ChildItem | Measure-Object -Property Length -Sum
Get-Content file.txt | Measure-Object -Line -Word -Character

Get-Process | ForEach-Object {$_.Kill()}
1..10 | ForEach-Object {$_ * 2}
Get-ChildItem | % {$_.Name}                 # Alias

Get-Process | Tee-Object -FilePath process.txt | Sort-Object CPU

if ($age -gt 18) {
    Write-Host "Adult"
}

if ($age -ge 18) {
    Write-Host "Adult"
} else {
    Write-Host "Minor"
}

if ($score -ge 90) {
    Write-Host "A"
} elseif ($score -ge 80) {
    Write-Host "B"
} else {
    Write-Host "C"
}

switch ($value) {
    1 { "One" }
    2 { "Two" }
    3 { "Three" }
    default { "Other" }
}
 
switch -Wildcard ($string) {
    "*.txt" { "Text file" }
    "*.log" { "Log file" }
    default { "Unknown" }
}

-eq     # Equal
-ne     # Not equal
-gt     # Greater than
-ge     # Greater than or equal
-lt     # Less than
-le     # Less than or equal
-like   # Wildcard match
-notlike
-match  # Regex match
-notmatch
-contains
-notcontains
-in
-notin

-and
-or
-not
!
-xor

foreach ($item in $collection) {
    Write-Host $item
}
 
foreach ($file in Get-ChildItem) {
    $file.Name
}

for ($i = 0; $i -lt 10; $i++) {
    Write-Host $i
}

$i = 0
while ($i -lt 10) {
    Write-Host $i
    $i++
}

$i = 0
do {
    Write-Host $i
    $i++
} while ($i -lt 10)

$i = 0
do {
    Write-Host $i
    $i++
} until ($i -ge 10)

foreach ($i in 1..10) {
    if ($i -eq 5) { continue }      # Skip iteration
    if ($i -eq 8) { break }         # Exit loop
    Write-Host $i
}

function Get-Greeting {
    Write-Host "Hello, World!"
}
 
Get-Greeting

function Get-Sum {
    param($a, $b)
    return $a + $b
}
 
$result = Get-Sum 5 3

function Get-UserInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$UserName,
        
        [Parameter()]
        [int]$Age = 0
    )
    
    Write-Output "User: $UserName, Age: $Age"
}

function Get-SquareRoot {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipeline=$true)]
        [double]$Number
    )
    
    process {
        [Math]::Sqrt($Number)
    }
}
 
16, 25, 36 | Get-SquareRoot

function Set-Age {
    param(
        [ValidateRange(0,120)]
        [int]$Age,
        
        [ValidateSet("Male","Female","Other")]
        [string]$Gender,
        
        [ValidatePattern("^\d{3}-\d{2}-\d{4}$")]
        [string]$SSN
    )
}

$array = @(1, 2, 3, 4, 5)
$fruits = @("apple", "banana", "cherry")
$empty = @()
$range = 1..10

$array[0]                           # First element
$array[-1]                          # Last element
$array[0..2]                        # Range
$array.Count                        # Array length

$array += 6                         # Add element
$array = $array + @(7, 8)          # Add multiple
$array = $array | Where-Object {$_ -ne 3}  # Remove element

$array -contains 5                  # Check if contains
$array -join ", "                   # Join to string
$array | Sort-Object
$array | Get-Unique

$list = New-Object System.Collections.ArrayList
$list.Add("item1")
$list.AddRange(@("item2", "item3"))
$list.Remove("item1")
$list.Count

$matrix = @(
    @(1, 2, 3),
    @(4, 5, 6),
    @(7, 8, 9)
)
$matrix[0][1]                       # Access element

$hash = @{
    Name = "John"
    Age = 30
    Email = "john@example.com"
}

$hash["Name"]
$hash.Name
$hash.Keys
$hash.Values
$hash.Count

$hash["City"] = "New York"          # Add key
$hash.Remove("Email")               # Remove key
$hash.ContainsKey("Name")           # Check if exists

foreach ($key in $hash.Keys) {
    Write-Host "$key : $($hash[$key])"
}
 
$hash.GetEnumerator() | ForEach-Object {
    Write-Host "$($_.Key) : $($_.Value)"
}

$ordered = [ordered]@{
    First = 1
    Second = 2
    Third = 3
}

$str = "Hello World"
$str.Length
$str.ToUpper()
$str.ToLower()
$str.Contains("World")
$str.StartsWith("Hello")
$str.EndsWith("World")

$str.Substring(0, 5)                # "Hello"
$str.Substring(6)                   # "World"

$str.Replace("World", "PowerShell")
$str -replace "World", "PowerShell"
$str -replace "\s+", "-"            # Regex replace

$str.Split(" ")
$str -split " "
$words -join ", "

$name = "John"
$age = 30
"Name: $name, Age: $age"            # String interpolation
"Name: {0}, Age: {1}" -f $name, $age    # Format operator
[string]::Format("Name: {0}", $name)

$text = @"
Line 1
Line 2
Line 3
"@

"  text  ".Trim()
"  text  ".TrimStart()
"  text  ".TrimEnd()

$obj = [PSCustomObject]@{
    Name = "John"
    Age = 30
    Email = "john@example.com"
}

$obj | Add-Member -MemberType NoteProperty -Name "City" -Value "NYC"
$obj | Add-Member -MemberType ScriptProperty -Name "Info" -Value {
    "$($this.Name) - $($this.Age)"
}

$obj | Get-Member
$obj.PSObject.Properties
$obj.PSObject.Methods

$obj | ConvertTo-Json
$obj | ConvertTo-Csv
$obj | ConvertTo-Html
$obj | ConvertTo-Xml
$json | ConvertFrom-Json
$csv | ConvertFrom-Csv

$data | Export-Csv data.csv
$data | Import-Csv data.csv
$data | Export-Clixml data.xml
$data | Import-Clixml data.xml

Get-Process
Get-Process -Name chrome
Get-Process -Id 1234
Get-Process | Where-Object CPU -gt 100

Start-Process notepad
Start-Process "C:\Program.exe" -ArgumentList "/arg1", "/arg2"
Start-Process cmd -Verb RunAs        # Run as administrator
Start-Process -FilePath "script.ps1" -NoNewWindow

Stop-Process -Name chrome
Stop-Process -Id 1234
Stop-Process -Name chrome -Force
Get-Process chrome | Stop-Process

Wait-Process -Name notepad
Wait-Process -Id 1234

Get-Process | Select-Object Name, CPU, Memory
(Get-Process chrome).Count
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

Get-Service
Get-Service -Name wuauserv
Get-Service -DisplayName "Windows Update"
Get-Service | Where-Object Status -eq 'Running'

Start-Service -Name wuauserv
Stop-Service -Name wuauserv
Restart-Service -Name wuauserv
Suspend-Service -Name wuauserv
Resume-Service -Name wuauserv

Set-Service -Name wuauserv -StartupType Automatic
Set-Service -Name wuauserv -StartupType Manual
Set-Service -Name wuauserv -StartupType Disabled

New-Service -Name "MyService" -BinaryPathName "C:\Path\service.exe"

Test-Connection google.com
Test-Connection -ComputerName 192.168.1.1 -Count 4
Test-Connection google.com -Quiet         # Returns $true/$false

Invoke-WebRequest https://api.example.com
Invoke-RestMethod https://api.example.com/data
(Invoke-WebRequest https://example.com).Content

Invoke-WebRequest -Uri "https://example.com/file.zip" -OutFile "file.zip"
Start-BitsTransfer -Source "https://example.com/file.zip" -Destination "file.zip"

Resolve-DnsName google.com
Resolve-DnsName -Name google.com -Type A
Resolve-DnsName -Name google.com -Type MX

Get-NetAdapter
Get-NetIPAddress
Get-NetIPConfiguration
Get-NetRoute

Test-NetConnection google.com -Port 443
Test-NetConnection -ComputerName server -Port 3389
(Test-NetConnection google.com -Port 443).TcpTestSucceeded

Get-NetTCPConnection
Get-NetTCPConnection -State Established
Get-NetTCPConnection -LocalPort 80

Get-PSDrive
Get-PSDrive -PSProvider FileSystem
Get-Volume

Get-Disk
Get-Partition
Get-Volume
Get-PhysicalDisk

(Get-ChildItem C:\Folder -Recurse | Measure-Object -Property Length -Sum).Sum / 1GB

Get-ChildItem -Recurse | Where-Object {$_.Length -gt 100MB} | 
    Sort-Object Length -Descending

Get-Acl C:\Folder
$acl = Get-Acl C:\Folder
$permission = "DOMAIN\User","FullControl","Allow"
$rule = New-Object System.Security.AccessControl.FileSystemAccessRule $permission
$acl.SetAccessRule($rule)
Set-Acl C:\Folder $acl

Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion"
Get-ItemPropertyValue -Path "HKCU:\Software\MyApp" -Name "Setting"

New-Item -Path "HKCU:\Software\MyApp"
New-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Setting" -Value "Value"
Set-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Setting" -Value "NewValue"

Remove-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Setting"
Remove-Item -Path "HKCU:\Software\MyApp" -Recurse

Get-EventLog -LogName System -Newest 10
Get-EventLog -LogName Application -EntryType Error
Get-EventLog -LogName Security -After (Get-Date).AddDays(-1)

Get-WinEvent -LogName Application
Get-WinEvent -FilterHashtable @{
    LogName='System'
    Level=2
    StartTime=(Get-Date).AddDays(-7)
}

Write-EventLog -LogName Application -Source "MyApp" -EventID 1000 -Message "Test"

Get-EventLog -LogName System | Export-Csv events.csv
Get-WinEvent -LogName System | ConvertTo-Json | Out-File events.json

try {
    Get-Content NonExistentFile.txt
} catch {
    Write-Error "An error occurred: $_"
} finally {
    Write-Host "Cleanup"
}

try {
    1/0
} catch [System.DivideByZeroException] {
    Write-Error "Cannot divide by zero"
} catch {
    Write-Error "Unknown error: $_"
}

$ErrorActionPreference = "Stop"          # Stop on error
$ErrorActionPreference = "Continue"      # Continue on error (default)
$ErrorActionPreference = "SilentlyContinue"  # Suppress errors
Get-Process NonExistent -ErrorAction SilentlyContinue

throw "Custom error message"
throw New-Object System.ArgumentException("Invalid argument")

Get-Process NonExistent -ErrorVariable MyError -ErrorAction SilentlyContinue
$MyError
$Error[0]                               # Last error
$Error.Clear()                          # Clear error history

Get-Module
Get-Module -ListAvailable
Get-Module -Name ActiveDirectory

Import-Module ActiveDirectory
Import-Module -Name MyModule -Force

Remove-Module ActiveDirectory

Find-Module -Name Az
Find-Module -Tag Azure

Install-Module -Name Az -Scope CurrentUser
Install-Module -Name Pester -Force
Update-Module -Name Az

New-ModuleManifest -Path MyModule.psd1

Enter-PSSession -ComputerName Server01
Enter-PSSession -ComputerName Server01 -Credential (Get-Credential)
Exit-PSSession

Invoke-Command -ComputerName Server01 -ScriptBlock { Get-Service }
Invoke-Command -ComputerName Server01,Server02 -ScriptBlock { Get-Process }
Invoke-Command -ComputerName Server01 -FilePath C:\Scripts\script.ps1

$session = New-PSSession -ComputerName Server01
Invoke-Command -Session $session -ScriptBlock { Get-Process }
Remove-PSSession $session
Get-PSSession

Enable-PSRemoting -Force
Set-Item WSMan:\localhost\Client\TrustedHosts -Value "Server01"
Test-WSMan Server01

$session = New-PSSession -ComputerName Server01
Copy-Item -Path C:\Local\file.txt -Destination C:\Remote\ -ToSession $session
Copy-Item -Path C:\Remote\file.txt -Destination C:\Local\ -FromSession $session

Get-ADUser -Filter *
Get-ADUser -Identity johndoe
Get-ADUser -Filter {Enabled -eq $true}
Get-ADUser -Filter {Department -eq "IT"} -Properties *

New-ADUser -Name "John Doe" -SamAccountName johndoe -UserPrincipalName johndoe@domain.com

Set-ADUser -Identity johndoe -Department "Engineering"
Set-ADUser -Identity johndoe -Enabled $true

Remove-ADUser -Identity johndoe -Confirm:$false

Get-ADGroup -Filter *
Get-ADGroup -Identity "Domain Admins"
Get-ADGroupMember -Identity "Domain Admins"

Add-ADGroupMember -Identity "IT Staff" -Members johndoe
Remove-ADGroupMember -Identity "IT Staff" -Members johndoe

Get-ADComputer -Filter *
Get-ADComputer -Filter {OperatingSystem -like "*Server*"}

Connect-AzAccount
Connect-AzAccount -Tenant "tenant-id"
Disconnect-AzAccount

Get-AzSubscription
Set-AzContext -Subscription "subscription-name"

Get-AzResourceGroup
New-AzResourceGroup -Name "MyRG" -Location "EastUS"
Remove-AzResourceGroup -Name "MyRG"

Get-AzVM
Get-AzVM -Name "MyVM" -ResourceGroupName "MyRG"
Start-AzVM -Name "MyVM" -ResourceGroupName "MyRG"
Stop-AzVM -Name "MyVM" -ResourceGroupName "MyRG"
Restart-AzVM -Name "MyVM" -ResourceGroupName "MyRG"

Get-AzStorageAccount
New-AzStorageAccount -Name "mystorageaccount" -ResourceGroupName "MyRG" -Location "EastUS" -SkuName Standard_LRS

Get-AzWebApp
New-AzWebApp -Name "MyWebApp" -ResourceGroupName "MyRG" -Location "EastUS"
Restart-AzWebApp -Name "MyWebApp" -ResourceGroupName "MyRG"

docker ps                               # List running containers
docker ps -a                            # List all containers
docker run -d nginx                     # Run container
docker stop container_id
docker start container_id
docker rm container_id

docker images
docker pull nginx:latest
docker rmi image_id
docker build -t myapp .

docker volume ls
docker volume create myvolume
docker volume rm myvolume

Set-AWSCredential -AccessKey "key" -SecretKey "secret" -StoreAs MyProfile
Initialize-AWSDefaultConfiguration -ProfileName MyProfile -Region us-east-1

Get-EC2Instance
Start-EC2Instance -InstanceId i-1234567890abcdef0
Stop-EC2Instance -InstanceId i-1234567890abcdef0

Get-S3Bucket
New-S3Bucket -BucketName my-bucket
Write-S3Object -BucketName my-bucket -File file.txt
Read-S3Object -BucketName my-bucket -Key file.txt -File downloaded.txt

$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-File C:\script.ps1"
$trigger = New-ScheduledTaskTrigger -Daily -At 2am
Register-ScheduledTask -TaskName "MyTask" -Action $action -Trigger $trigger

Get-WmiObject -Class Win32_OperatingSystem
Get-WmiObject -Class Win32_ComputerSystem
Get-WmiObject -Query "SELECT * FROM Win32_Service WHERE State='Running'"
Get-CimInstance -ClassName Win32_OperatingSystem        # Modern alternative

Get-Counter '\Processor(_Total)\% Processor Time'
Get-Counter '\Memory\Available MBytes'

Start-Job -ScriptBlock { Get-Process }
Get-Job
Receive-Job -Id 1
Remove-Job -Id 1
Wait-Job -Id 1

Start-Transcript -Path C:\log.txt
# ... commands ...
Stop-Transcript

Get-ExecutionPolicy
Set-ExecutionPolicy RemoteSigned
Set-ExecutionPolicy Bypass -Scope Process       # Current session only

$PROFILE                                # Profile path
Test-Path $PROFILE
New-Item -Path $PROFILE -Type File -Force
notepad $PROFILE

$cert = Get-ChildItem Cert:\CurrentUser\My -CodeSigningCert
Set-AuthenticodeSignature -FilePath script.ps1 -Certificate $cert

[xml]$xml = Get-Content config.xml
$xml.root.element
$xml.SelectNodes("//node")

$json = Get-Content data.json | ConvertFrom-Json
$json.property
$obj | ConvertTo-Json -Depth 10

<#
.SYNOPSIS
    Brief description
.DESCRIPTION
    Detailed description
.PARAMETER Name
    Parameter description
.EXAMPLE
    Example usage
#>
 
[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [string]$Name
)
 
Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"
 
try {
    # Main logic here
} catch {
    Write-Error "Error: $_"
    exit 1
}

param(
    [ValidateNotNullOrEmpty()]
    [string]$Name,
    
    [ValidateRange(1,100)]
    [int]$Age,
    
    [ValidateSet("Dev","Test","Prod")]
    [string]$Environment,
    
    [ValidateScript({Test-Path $_})]
    [string]$Path
)

$params = @{
    ComputerName = "Server01"
    Credential = Get-Credential
    ScriptBlock = { Get-Service }
}
Invoke-Command @params

$items = 1..100
$i = 0
foreach ($item in $items) {
    $i++
    Write-Progress -Activity "Processing" -Status "$i of $($items.Count)" -PercentComplete (($i / $items.Count) * 100)
    Start-Sleep -Milliseconds 50
}

<#
.SYNOPSIS
    Get user information
.DESCRIPTION
    Retrieves detailed user information from Active Directory
.PARAMETER UserName
    The username to query
.EXAMPLE
    Get-UserInfo -UserName "johndoe"
.NOTES
    Author: Your Name
    Date: 2026-02-15
#>

Get-ChildItem -Path C:\Data -Recurse -File | 
    Where-Object {$_.Length -gt 1GB} | 
    Sort-Object Length -Descending | 
    Select-Object FullName, @{N='SizeGB';E={[math]::Round($_.Length/1GB,2)}}

$serviceName = "MyService"
$service = Get-Service -Name $serviceName
 
if ($service.Status -ne 'Running') {
    Start-Service -Name $serviceName
    Start-Sleep -Seconds 5
    
    $service = Get-Service -Name $serviceName
    if ($service.Status -eq 'Running') {
        Write-Host "Service restarted successfully"
        Send-MailMessage -To "admin@example.com" -Subject "Service Restarted" -Body "Service $serviceName was restarted"
    } else {
        Write-Error "Failed to restart service"
    }
}

$users = Import-Csv users.csv
 
foreach ($user in $users) {
    $params = @{
        Name = $user.FullName
        SamAccountName = $user.UserName
        UserPrincipalName = "$($user.UserName)@domain.com"
        AccountPassword = (ConvertTo-SecureString "TempPass123!" -AsPlainText -Force)
        Enabled = $true
        Department = $user.Department
        Title = $user.Title
    }
    
    try {
        New-ADUser @params
        Write-Host "Created user: $($user.UserName)" -ForegroundColor Green
    } catch {
        Write-Warning "Failed to create $($user.UserName): $_"
    }
}

$servers = Get-Content servers.txt
$report = foreach ($server in $servers) {
    try {
        Get-WmiObject Win32_LogicalDisk -ComputerName $server -Filter "DriveType=3" | 
            Select-Object @{N='Server';E={$server}}, 
                         DeviceID, 
                         @{N='SizeGB';E={[math]::Round($_.Size/1GB,2)}},
                         @{N='FreeGB';E={[math]::Round($_.FreeSpace/1GB,2)}},
                         @{N='PercentFree';E={[math]::Round(($_.FreeSpace/$_.Size)*100,2)}}
    } catch {
        [PSCustomObject]@{
            Server = $server
            DeviceID = "N/A"
            SizeGB = 0
            FreeGB = 0
            PercentFree = 0
        }
    }
}
 
$report | Export-Csv disk_report.csv -NoTypeInformation
$report | Where-Object {$_.PercentFree -lt 20} | Format-Table -AutoSize

$path = "C:\Logs"
$days = 30
$date = (Get-Date).AddDays(-$days)
 
Get-ChildItem -Path $path -Recurse -Filter "*.log" | 
    Where-Object {$_.LastWriteTime -lt $date} | 
    ForEach-Object {
        Write-Host "Deleting: $($_.FullName)"
        Remove-Item $_.FullName -Force
    }

Connect-AzAccount
 
$vms = Get-AzVM -Status
$report = $vms | Select-Object @{N='Name';E={$_.Name}},
                              @{N='ResourceGroup';E={$_.ResourceGroupName}},
                              @{N='Location';E={$_.Location}},
                              @{N='PowerState';E={($_.PowerState -split ' ')[1]}},
                              @{N='Size';E={$_.HardwareProfile.VmSize}}
 
$report | Export-Csv azure_vms.csv -NoTypeInformation
$report | Format-Table -AutoSize

$daysToExpire = 7
$maxPasswordAge = (Get-ADDefaultDomainPasswordPolicy).MaxPasswordAge.Days
$expireDate = (Get-Date).AddDays($daysToExpire)
 
Get-ADUser -Filter {Enabled -eq $true -and PasswordNeverExpires -eq $false} -Properties PasswordLastSet, EmailAddress | 
    Where-Object {
        $_.PasswordLastSet -ne $null
    } | 
    ForEach-Object {
        $expiry = $_.PasswordLastSet.AddDays($maxPasswordAge)
        if ($expiry -le $expireDate -and $expiry -gt (Get-Date)) {
            [PSCustomObject]@{
                UserName = $_.SamAccountName
                Email = $_.EmailAddress
                ExpiryDate = $expiry
                DaysLeft = ($expiry - (Get-Date)).Days
            }
        }
    } | 
    Sort-Object DaysLeft | 
    Export-Csv expiring_passwords.csv -NoTypeInformation

$websites = @(
    "https://www.google.com",
    "https://www.microsoft.com",
    "https://www.github.com"
)
 
foreach ($site in $websites) {
    try {
        $response = Invoke-WebRequest -Uri $site -TimeoutSec 10 -UseBasicParsing
        if ($response.StatusCode -eq 200) {
            Write-Host "$site is UP (Status: $($response.StatusCode))" -ForegroundColor Green
        } else {
            Write-Warning "$site returned status: $($response.StatusCode)"
        }
    } catch {
        Write-Error "$site is DOWN - Error: $_"
        # Send alert email
        Send-MailMessage -To "admin@example.com" -Subject "Website Down: $site" -Body "Error: $_"
    }
}

function Test-CertificateExpiration {
    param([string]$URL)
    
    try {
        $req = [Net.HttpWebRequest]::Create($URL)
        $req.GetResponse() | Out-Null
        $cert = $req.ServicePoint.Certificate
        $expiry = [DateTime]::Parse($cert.GetExpirationDateString())
        $daysLeft = ($expiry - (Get-Date)).Days
        
        [PSCustomObject]@{
            URL = $URL
            Expiry = $expiry
            DaysLeft = $daysLeft
            Status = if ($daysLeft -lt 30) { "WARNING" } else { "OK" }
        }
    } catch {
        [PSCustomObject]@{
            URL = $URL
            Expiry = "N/A"
            DaysLeft = 0
            Status = "ERROR"
        }
    }
}
 
$sites = @("https://google.com", "https://microsoft.com")
$sites | ForEach-Object { Test-CertificateExpiration $_ } | Format-Table -AutoSize

param(
    [string]$SourcePath = "C:\Data",
    [string]$BackupPath = "D:\Backups",
    [int]$RetentionDays = 7
)
 
$timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
$backupFolder = Join-Path $BackupPath "Backup_$timestamp"
 
try {
    # Create backup
    Write-Host "Starting backup..."
    Copy-Item -Path $SourcePath -Destination $backupFolder -Recurse
    
    # Compress backup
    $zipFile = "$backupFolder.zip"
    Compress-Archive -Path $backupFolder -DestinationPath $zipFile
    Remove-Item -Path $backupFolder -Recurse -Force
    
    Write-Host "Backup completed: $zipFile" -ForegroundColor Green
    
    # Cleanup old backups
    $cutoffDate = (Get-Date).AddDays(-$RetentionDays)
    Get-ChildItem -Path $BackupPath -Filter "Backup_*.zip" | 
        Where-Object {$_.LastWriteTime -lt $cutoffDate} | 
        ForEach-Object {
            Write-Host "Removing old backup: $($_.Name)"
            Remove-Item $_.FullName -Force
        }
        
} catch {
    Write-Error "Backup failed: $_"
    exit 1
}

# PowerShell 7+ on Linux/Mac
Get-Process
Get-ChildItem /var/log
sudo pwsh                           # Run as root

ssh user@server
ssh -i keyfile.pem user@server

-eq     Equal
-ne     Not equal
-gt     Greater than
-ge     Greater than or equal
-lt     Less than
-le     Less than or equal
-like   Wildcard comparison
-match  Regex match
-contains  Array contains value
-in     Value in array

ls      Get-ChildItem
cd      Set-Location
pwd     Get-Location
cat     Get-Content
cp      Copy-Item
mv      Move-Item
rm      Remove-Item
mkdir   New-Item -ItemType Directory

0       Success
1-255   Error codes
$LASTEXITCODE to check last exit code