포괄적인 PowerShell 주석 가이드

      # The following script narrow down the users who having logged in for 90 days.

$InactiveUsers = Get-ADUser -Filter {LastLogonDate -lt (Get-Date).AddDays(-90)}
      

      # This is another example of a single-line comment.

Get-Process -Name Notepad
      

      # Calculate the factorial of a number using recursion.

function Get-Factorial {

    param ([int]$number)

    if ($number -le 1) {

        return 1

    }

return $number * (Get-Factorial -number ($number - 1))

}
      

      # Store the list of server names to be checked for connectivity

$servers = @("Server1", "Server2", "Server3")
      

      # Debugging: Output the current value of the counter

# Write-Output "Counter value is $counter"
      

      <#

This script performs the following tasks:

1. Retrieves the list of all running processes on the system.

2. Filters the processes to include only those consuming more than 100 MB of memory.

3. Outputs the filtered list to the console for review.

Author: Admin

Date: 2025-01-07

#>

# Retrieve all running processes

$processes = Get-Process

# Filter processes using more than 100 MB of memory

$highMemoryProcesses = $processes | Where-Object { $_.WS -gt 100MB }

# Output the filtered processes

$highMemoryProcesses | Format-Table -AutoSize
      

      <#

Script Name: Cleanup-TempFiles.ps1

Author: Jon Mill

Description: This script deletes temporary files older than 30 days

             from specified directories to free up disk space.

Last Modified: 2025-01-07

#>
      

      <#

The following block of code checks the connectivity status of multiple servers.

If a server is unreachable, it logs the error and skips to the next one,

ensuring the script doesn't terminate unexpectedly.

#>

foreach ($server in $servers) {

    if (-Not (Test-Connection -ComputerName $server -Count 1 -Quiet)) {

        Write-Output "$server is unreachable" >> error.log

        continue

    }

    # Proceed with the next task

}
      

      <#

# Commented out the block below for debugging purposes

Write-Output "Starting debugging session"

$debugVar = $true

#>
      

      for ($i = 0; $i -lt 5; $i++) { # Loop from 0 to 4

Write-Output "Iteration $i" }
      

      .SYNOPSIS

Copies files from one directory to another.
      

      .DESCRIPTION

This function copies files from a source directory to a destination directory.

It allows users to copy files recursively and optionally overwrite existing files.
      

      .PARAMETER Source

The path of the source directory from which the files will be copied. The source must be a valid directory path.

.PARAMETER Destination

    The path to the destination directory where the files will be copied to.

    The destination must be a valid directory path.

.PARAMETER Overwrite

    A switch to determine whether existing files at the destination should be overwritten.

If not specified, existing files will not be overwritten.
      

      .EXAMPLE

    Copy-Files -Source "C:\Data" -Destination "D:\Backup" -Overwrite

    Copies files from C:\Data to D:\Backup, overwriting existing files at the destination.
      

      <#

.SYNOPSIS

Backs up files from the source to the destination folder.

.DESCRIPTION

This script copies all files from the specified source folder to the destination folder.

.PARAMETER Source

Specifies the path to the source folder.

.PARAMETER Destination

Specifies the path to the destination folder.

.EXAMPLE

.\Backup-Script.ps1 -Source "C:\Data" -Destination "D:\Backup"

Copies all files from C:\Data to D:\Backup.

#>

param (

    [string]$Source,

    [string]$Destination

)

if (-Not (Test-Path -Path $Source)) {

    Write-Error "Source path does not exist."

    exit

}

if (-Not (Test-Path -Path $Destination)) {

    Write-Host "Destination path does not exist. Creating it..."

    New-Item -ItemType Directory -Path $Destination

}

Copy-Item -Path "$Source\*" -Destination $Destination -Recurse

Write-Host "Backup completed successfully."
      

      # Get-Service returns all running services.

Get-Service

# Filter the results to include only services

# related to the World Wide Web.

Get-Service | Where-Object {$_.DisplayName -like "*WWW*"}

# Stop the selected WWW services.

Get-Service | Where-Object {$_.DisplayName -like "*WWW*"} | Stop-Service
      

      # Assign the value 10 to the variable $number

$number = 10

# Add 5 to the variable $number

$number = $number + 5
      

      $users = Get-ADUser -Filter * | Where-Object {$_.Enabled -eq $false}

$users | ForEach-Object {

    Set-ADUser -Identity $_.SamAccountName -Enabled $true

}
      

      # Log the value of the Source variable for debugging

Write-Host "Debug: Source path is $Source"

# Temporarily disable file copying to test directory creation

# Copy-Item -Path "$Source\*" -Destination $Destination -Recurse

      

      # Calculate the factorial of a number

function Calculate-Factorial {

    param(

        [int]$Number

)

# Base case: Factorial of 0 is 1

    if ($Number -eq 0) {

        return 1

    }

# Recursive case: Factorial of N is N * Factorial(N-1)

    else {

        return $Number * (Calculate-Factorial ($Number - 1))

    }

}
      

      # Retry the operation up to 3 times to handle intermittent network failures

# This prevents the script from failing on occasional, recoverable issues

for ($i = 0; $i -lt 3; $i++) {

    try {

        # Attempt the operation

        Copy-Item -Path $Source -Destination $Destination

        break  # Exit the loop if the operation is successful

    }

    catch {

        if ($i -eq 2) { throw "Failed after 3 attempts" }

        Start-Sleep -Seconds 2  # Wait before retrying

    }

}
      

      # This function retrieves a list of all running processes.

function Get-RunningProcesses {

    # Get all running processes

    Get-Process |

        # Select only the process name and ID

        Select-Object ProcessName, ID

}
      

      # Version 2.0 - 2025-01-10

# Added a new parameter for logging options and enhanced error handling.

# Updated the file backup logic to support incremental backups.

param (

    [string]$Source,

    [string]$Destination,

    [switch]$EnableLogging  # New parameter to enable logging

)

# Check if source exists

if (-Not (Test-Path -Path $Source)) {

    Write-Error "Source path does not exist."

    exit

}

# Log file creation if logging is enabled

if ($EnableLogging) {

    $logPath = "$Destination\backup_log.txt"

    "Backup started at $(Get-Date)" | Out-File -Append $logPath

}

# Backup files (incremental logic added in Version 2.0)

if (-Not (Test-Path -Path $Destination)) {

    New-Item -ItemType Directory -Path $Destination

}

Copy-Item -Path "$Source\*" -Destination $Destination -Recurse

# Log completion if logging is enabled

if ($EnableLogging) {

"Backup completed at $(Get-Date)" | Out-File -Append $logPath

}
      

      <#region Introduction

    This script retrieves a list of all running processes.

    It then filters the list to include only processes

    that match a specific criterion.

#>

# Get all running processes

$Processes = Get-Process

<#region Filtering

    Filter processes based on criteria

    (e.g., process name, CPU usage).

#>

$FilteredProcesses = $Processes | Where-Object {$_.ProcessName -eq "notepad"}

<#endregion Filtering

<#region Output

    Display the filtered processes.

#>

$FilteredProcesses | Format-List

<#endregion Output

<#endregion Introduction
      

      # Get-Service returns an error on some server versions due to a known bug.

# Workaround: Use WMI to retrieve service status.

try {

    Get-Service -Name "SensorService"

} catch {

    Get-WmiObject Win32_Service -Filter "Name=''SensorService"

}
      

      <#

Script Name: Create-ADUserAccounts.ps1

Description: Automates the creation of Active Directory user accounts from a CSV file.

Prerequisites:

  - Active Directory module installed.

  - A valid CSV file with columns: FirstName, LastName, UserName, and Email.

Parameters:

  -CSVPath: Path to the input CSV file.

  -OU: Organizational Unit where accounts will be created.

Usage:

  .\Create-ADUserAccounts.ps1 -CSVPath "C:\Users.csv" -OU "OU=Users,DC=Domain,DC=Com"

#>
      

      <#

Script Name: Ensure-ServiceRunning.ps1

Description: Checks if a specified service is running and restarts it if necessary.

Purpose:

  - Ensures critical services stay operational without manual intervention.

Decisions:

  - Used “Get-Service” for simplicity and compatibility.

  - Restart logic avoids redundancy by checking the current status first.

Usage:

  .\Ensure-ServiceRunning.ps1 -ServiceName "Spooler"

#>

param (

    [Parameter(Mandatory)]

    [string]$ServiceName  # Name of the service to check

)

# Check the current status of the service

$service = Get-Service -Name $ServiceName -ErrorAction Stop

if ($service.Status -ne "Running") {

    # Log and attempt to restart the service if not running

    Write-Host "Service '$ServiceName' is not running. Attempting to restart..."

    try {

        Restart-Service -Name $ServiceName -Force

        Write-Host "Service '$ServiceName' has been restarted successfully."

    } catch {

        Write-Error "Failed to restart the service '$ServiceName': $_"

    }

} else {

    Write-Host "Service '$ServiceName' is already running."

}
      

      <#

Script Name: Monitor-DiskUsage.ps1

Description: Checks each logical drive and sends an alert if free space is below the defined threshold.

Purpose:

  - Prevents system issues caused by insufficient storage.

Usage:

  .\Monitor-DiskUsage.ps1 -Threshold 10 -Email "admin@Netwrix.com"

#>

param (

    [Parameter(Mandatory)]

    [int]$Threshold,       # Minimum free space in GB to trigger an alert

    [Parameter(Mandatory)]

    [string]$Email         # Email address for the alert

)

# Retrieve disk information

$drives = Get-PSDrive -PSProvider FileSystem

foreach ($drive in $drives) {

    if ($drive.Free -gt 0) {

        $freeSpaceGB = [math]::Round($drive.Free / 1GB, 2)

        if ($freeSpaceGB -lt $Threshold) {

            Write-Warning "Drive $($drive.Name) has low space: $freeSpaceGB GB remaining."

            # Send an alert email (replace with real SMTP details)

            try {

                Send-MailMessage -From "alerts@netwrix.com" -To $Email -Subject "Low Disk Space Alert" `

                    -Body "Drive $($drive.Name) has only $freeSpaceGB GB remaining." `

                    -SmtpServer "smtp.domain.com"

            } catch {

                Write-Error "Failed to send alert email: $_"

            }

        }

    }

}
      

      <#

Script Name: Cleanup-ADUsers.ps1

Description: Disables and moves inactive user accounts to a specified OU.

Purpose:

  - Helps maintain a clean and secure Active Directory environment.

Usage:

  .\Cleanup-ADUsers.ps1 -OU "OU=Inactive,DC=Netwrix,DC=Com" -DaysInactive 90

#>

param (

    [Parameter(Mandatory)]

    [string]$OU,           # Target OU for inactive users

    [Parameter(Mandatory)]

    [int]$DaysInactive     # Number of days since last logon

)

# Get the current date and calculate the inactivity threshold

$thresholdDate = (Get-Date).AddDays(-$DaysInactive)

# Find inactive user accounts

$inactiveUsers = Get-ADUser -Filter {LastLogonDate -lt $thresholdDate -and Enabled -eq $true}

foreach ($user in $inactiveUsers) {

    Write-Host "Disabling and moving user: $($user.SamAccountName)"

    # Disable the account

    Disable-ADAccount -Identity $user.SamAccountName

    # Move the account to the specified OU

    Move-ADObject -Identity $user.DistinguishedName -TargetPath $OU

}
      

      # Set the variable to 5

$number = 5
      

      # Assign the default retry count to handle intermittent failures

$retryCount = 5
      

      # This script backs up data to a network drive

Backup-Data -Path "C:\Data"
      

      # Initialize the variable

$number = 10

# Increment the variable by 1

$number++
      

      $finalPrice = $basePrice * (1 - $discountPercentage) * 1.15
      

      # Calculate the final price including a 15% tax and applying the discount

$finalPrice = $basePrice * (1 - $discountPercentage) * 1.15
      

      # $oldValue = Get-Item "C:\OldFile.txt"

# $oldValue.Delete()