How to Simplify IT Tasks with PowerShell Automation

PowerShell Automation: What is PowerShell Scripting Language?

Developed by Microsoft, PowerShell is an advanced command prompt supported by Windows, Linux, and macOS. The primary uses revolve around creating your own scripts, for complete task automation.

Built on .NET Common Language Runtime (CLR), PowerShell not only accepts and returns text, but also supports a pipeline for changing commands, a formatting system for easy output, and data formats such as CSV, JSON, and XML.

The fully developed PowerShell scripting language is object-based, simple to use, and task-oriented allowing many system administration modules to be fully automated.

Automating With PowerShell: Common PowerShell Tasks

Windows PowerShell commands, called cmdlets, enable the automation of highly administrative tasks, offering seamless integration with Windows applications and features.

Let’s check what the best practices and running PowerShell scripts include:

• Process management
• Generating reports
• Software administration
• Task automation
• Directory oversight
• Networking control

That’s just the tip of the iceberg. Running PowerShell scripts enables a vast range of possibilities for optimization and management, improving security and enhancing efficiency.

Let’s dig deeper and check how this works!

How To Write PowerShell Scripts? – PowerShell In Action!

To automate tasks, the PowerShell enables you to create and run script files to perform complex operations with minimal manual input.

How Does Automation PowerShell Scripts Work?

PowerShell window provides a command prompt that runs small built-in commands “cmdlets“, interacting with the operating system services, connected machines, data queries, and applications. This provides an excellent opportunity for administrators to automate tasks and manage complex computer operations.

PowerShell Cmdlets

Cmdlets or “command-lets”, are the foundation of the PowerShell scripting language, which can easily access data centers including system files, registries, and active directories. That sets PowerShell apart from other command prompts, allowing fast and efficient automation of administrative scripting tasks.

PowerShell provides access to over 130 cmdlets, so let’s name a few:

• Read, modify, and delete flow permissions
• Retrieve, and delete connections
• Configure and enforce security policies
• Integrate and synchronize information
• Automate, backup, and restore data
• Read, add, and remove URL patterns

Again, we’re just scratching the surface here. You can create and run Powershell script files of your own, which adds endless automatization opportunities. The Windows PowerShell ISE is easy to navigate and simple to understand as the default setting provides syntax coloring, tab completion, and more… The Windows PowerShell ISE is easy to navigate and simple to understand as the default setting provides syntax coloring, tab completion, and more…

Executable Scripts

Executables, having the .exe file extension are well-known to all of us and essential for the Windows operating system. They are the easiest way to automate tasks, and PowerShell can run any executable file with three main commands.

The syntax is simple, you write the command, type the file name and press enter!

1. The start-process cmdlet

The start-process cmdlet in PowerShell is one of the main ways to open an application, start a process, or create run commands, even if they are buried in a folder.

Here’s a simple example:

Start-Process "notepad.exe"

The main benefit of using the start-process cmdlet is the enhanced control allowing you to specify parameters, run processes asynchronously, and the available logging options for error handling. However, the complexity and performance overhead of these commands may not be the perfect way to write your first script.

2. The “invoke-expression”

Another way, perhaps the most popular cmdlet to run executables from any folder is the invoke-expression command, which is excellent due to its versatility and simplicity.

Another example with our well-known text editor:

Invoke-Expression "notepad.exe"

The primary advantages of scripts using this method are ease of use, compatibility, and flexibility. You can write and execute multiple commands and scripts stored in variables, delivering exceptional opportunities for automation. The potential downsides include the poorly sanitized inputs, which can be susceptible to attacks as well as the limited error handling compared to the “Start-Process” method.

3. Adding “.\” before the name

The rawest method of creating scripts to open executable files is by using the syntax “.\notepad.exe”, before the file name, which will run “notepad.exe” in the file menufile menu directory.

For example, if your .exe is in the folder, use the following command:

.\notepad.exe

The core benefit here is simplicity and consistency allowing you to reduce the typing efforts and avoid potential errors since it doesn’t require the file’s path. Sadly, the downsides overwhelmed this approach, since your executable must be in the given folder/directory. It also brings a range of security concerns.

PowerShell Scripts and Functions:

The PowerShell scripts are written in cmdlets, later used to create and run automation for a variety of different tasks. For example, For example, there are three major types of scripts:

• Get: The “get” command is used for acquiring data from a system file.
• Set: The “set” command can edit Windows components and properties.
• Remove: The “remove” command is self-explanatory, it deletes operations.

The PowerShell scripts are saved in .ps1 format and contain a series of cmdlets and commands, which when executed can automate tasks. In contrast, the PowerShell functions are clusters of reusable code, defined in a script or module, which can be called upon repetitively, through the scriptthrough the script.

There are also advanced functions that have the properties of basic functions with additional features.

How to Create a PowerShell Script File?

Now that we’ve gone through the basics of PowerShell commands and popular scripts, it’s time to create your first script!

We are going to show you how to create and run an easy PowerShell script and simultaneously open the Windows “NotePad” and “Calculator”.

To create a new script, press the Windows button, and type “Windows PowerShell” in the search bar to open the PowerShell window. Then use the “Start-Process” cmdlet to test whether both commands will work as intended.

You can use the following commands:

• Start-Process “notepad.exe”
• Start-Process “calc.exe”

If they work separately, use any text files software to paste the script save the file with a “.ps1” extension, and mark “Save as type” to “All Files” to prevent saving your script as a NotePad file. You can later convert your PowerShell script executable into a .exe file by using the PS2EXE from Github.

You can also use the “Write-Host” cmdlet to display output directly into the PowerShell ISE, which can be useful in providing feedback during script file execution. In addition, changing the execution policy is “Set-ExecutionPolicy” can be used for balancing security, requiring a signature from a trusted publisher.

That was just a silly example, but that’s about it for your first script!

What Can You Do With PowerShell ISE Scripts?

With the correct instructions written, you can find and remove apps from a file menu, auto-scan devices, improve machine performance, and monitor hardware utilization.

Let’s take an in-depth look at some of the main PowerShell script usage examples:

1. Identify and Disarm Malware

Using Powershell scripts you can create strategies for automation such as protocol disabling to tackle legacy or vulnerable protocols. In addition, you can automate security configuration “Windows turnkey” for automatic settings adjustment against security threats.

You can also create an automated system scanning for outdated software, drivers, and unpatched vulnerabilities, and alerting the system administration.

2. Scheduling and Maintenance

As a system administrator or IT professional, you undoubtedly face repetitive tasks to keep servers running efficiently and smoothly. With PowerShell automation scripts, you can leverage the Windows Task Scheduler, allowing you to outsource routine maintenance tasks.

3. Tailoring Ticket Distribution

In the IT environment, the support teams are often overloaded with tickets and messages in one active directory, some of which do not even require their attention. Powershell scripts can use robust logic to monitor your ticketing system and distribute tickets effectively.

This includes extracting relevant information such as client, request, and priority, and then dynamically forwarding tickets to respective departments.

Real-Word Examples of PowerShell Automation:

Here are a few examples of real-world PowerShell automation:

Data Systematization: PowerShell’s versatility shines through when you can easily parse new CSV files, and save large databases into simple reports using a simple script.

Example:

# Define source and target directories
$sourceDir = "C:\Source"
$targetDir = "C:\Organized"

# Ensure target directory exists
if (-not (Test-Path -Path $targetDir)) {
    New-Item -ItemType Directory -Path $targetDir | Out-Null
}

# Organize files by extension
Get-ChildItem -Path $sourceDir -File | ForEach-Object {
    $extension = $_.Extension.TrimStart(".") # Get file extension
    $destination = Join-Path -Path $targetDir -ChildPath $extension
    if (-not (Test-Path -Path $destination)) {
        New-Item -ItemType Directory -Path $destination | Out-Null
    }
    Move-Item -Path $_.FullName -Destination $destination
}
Write-Output "Files organized by extension in $targetDir"

Account Management: With PowerShell scripts, you can create, modify, save, and manage user accounts and their permissions automatically.

Example:

# Create a new local user account
$username = "TestUser"
$password = ConvertTo-SecureString "Password123" -AsPlainText -Force

New-LocalUser -Name $username -Password $password -FullName "Test User" -Description "A test user account" -UserMayNotChangePassword $false -PasswordNeverExpires $false

# Add user to a group (e.g., Administrators)
Add-LocalGroupMember -Group "Administrators" -Member $username

Write-Output "User account $username created and added to Administrators group."

System Maintenance: Using PowerShell scripts, you can run disk defragmentation, Windows updates, and disk clean-up on a schedule, without any manual inputs.

Example:

# Define directories to clean
$tempPaths = @("C:\Windows\Temp", "$env:USERPROFILE\AppData\Local\Temp")

# Remove temporary files
foreach ($path in $tempPaths) {
    if (Test-Path -Path $path) {
        Get-ChildItem -Path $path -Recurse -Force -ErrorAction SilentlyContinue | Remove-Item -Force -Recurse -ErrorAction SilentlyContinue
        Write-Output "Cleaned temporary files from $path"
    } else {
        Write-Output "$path not found."
    }
}
Write-Output "System maintenance completed."

Error-Handling and Logs: Using premade PowerShell scripts, you can generate and systematize error-handling reports, logs, and audits.

Example:

# Define log file
$logFile = "C:\Logs\error-log.txt"
if (-not (Test-Path -Path $logFile)) {
    New-Item -ItemType File -Path $logFile -Force | Out-Null
}

# Try block with error handling
try {
    # Example: Attempt to read a non-existent file
    Get-Content -Path "C:\NonExistentFile.txt"
} catch {
    # Log the error details
    $errorMessage = "[$(Get-Date)] ERROR: $($_.Exception.Message)"
    Add-Content -Path $logFile -Value $errorMessage
    Write-Output $errorMessage
}

Automatic Data Backups: Using PowerShell, you schedule automatic backups and recovery processes to ensure that sensitive data is protected.

Example:

# Define source and backup directories
$sourceDir = "C:\Data"
$backupRootDir = "C:\Backups"

# Create a timestamped backup folder
$timestamp = (Get-Date).ToString("yyyyMMdd_HHmmss")
$backupDir = Join-Path -Path $backupRootDir -ChildPath $timestamp
New-Item -ItemType Directory -Path $backupDir | Out-Null

# Copy files to the backup directory
Copy-Item -Path $sourceDir\* -Destination $backupDir -Recurse -Force

Write-Output "Backup completed. Files copied to $backupDir"

Best Real-World PowerShell Scripting Practices:

Here are a few examples of the best practices in PowerShell scripting:

• Easy-to-understand variable names: Employing easy-to-understand variable names and including comments in between the lines, makes it easy for team members to share scripts.
• Implementing error-handling logging: By incorporating a script for error-handling and an automatic system that responds to common errors, can help diagnose issues quickly and efficiently.
• Avoiding sensitive script information: Validation is a must, hence the best scripting practices include keeping sensitive information away from the script.

To wrap things up, we can say that configuring the PowerShell’s execution policy to allow digitally signed scripts can enhance security while maintaining a flexible environment.

Automation With PowerShell – More Than a Command Prompt!

PowerShell is far more than a simple prompt-it’s a powerful automation engine capable of transforming heavy workloads into one-click tasks. By leveraging a customized script creation, you can streamline difficult operations, defend networks, and turn routine computer tasks into strategic advantages.

That’s just the tip of everything that the PowerShell’s integrated scripting environment is capable of and all of the possible PowerShell scripts for automation.

Take Your Automation to the Next Level With ServerMania:

With the right environment, PowerShell scripts can become even more powerful. ServerMania offers high-performance dedicated, colocation and cloud servers that support advanced automation and scripting requirements. So, streamline your IT operations and ensure seamless performance today!