PowerShell Core for Linux Administrators Cookbook

By : Prashanth Jayaram, Ram Iyer

PowerShell Core for Linux Administrators Cookbook

By: Prashanth Jayaram, Ram Iyer

Overview of this book

PowerShell Core, the open source, cross-platform that is based on the open source, cross-platform .NET Core, is not a shell that came out by accident; it was intentionally created to be versatile and easy to learn at the same time. PowerShell Core enables automation on systems ranging from the Raspberry Pi to the cloud. PowerShell Core for Linux Administrators Cookbook uses simple, real-world examples that teach you how to use PowerShell to effectively administer your environment. As you make your way through the book, you will cover interesting recipes on how PowerShell Core can be used to quickly automate complex, repetitive, and time-consuming tasks. In the concluding chapters, you will learn how to develop scripts to automate tasks that involve systems and enterprise management. By the end of this book, you will have learned about the automation capabilities of PowerShell Core, including remote management using OpenSSH, cross-platform enterprise management, working with Docker containers, and managing SQL databases.

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

Introducing PowerShell Core

Introduction

Installing PowerShell

Updating and using Help

Exploring about_ topics

Discovering cmdlets

Finding and installing PowerShell modules

Listing the various providers in PowerShell

Understanding objects

Parsing input from text to object

Comparing the outputs of Bash and PowerShell

Comparing Windows PowerShell and PowerShell Core

Working with aliases

Dissecting a .NET Core object

Listing out the execution policies and setting a suitable one

Preparing for Administration Using PowerShell

Introduction

Installing Visual Studio Code

Configuring automatic variables

Changing shell behavior using variables

Enabling automated execution of commands for each load

Customizing the Terminal prompt

Understanding standard redirection in PowerShell

Calling native Linux commands from PowerShell

Understanding cmdlets and parameters

Running cmdlets with minimal keystrokes

Finding parameter aliases

Calling a PowerShell script

Dot-sourcing a PowerShell script

Calling a PowerShell cmdlet from outside of PowerShell

Recording the cmdlets run on the PowerShell console

First Steps in Administration Using PowerShell

Introduction

Working with date properties

Working with date and time methods

Working with currently-running processes to measure resource consumption

Launching and stopping a process

Finding the owner of a process

Invoking an application based on the file type

Installing the CronTab PowerShell module

Scheduling jobs in PowerShell

Removing scheduled jobs in PowerShell

Passing Data through the Pipeline

Introduction

Selecting columns from the output

Limiting the number of output objects

Expanding the properties within properties

Filtering objects

Grouping the output

Sorting the output

Taking actions on the returned objects

Understanding pipeline-enabled parameters

Importing content into PowerShell

Using Variables and Objects

Introduction

Using environment variables

Storing the output of an instance of a .NET Core object

Adding custom properties to an object

Creating a custom object from a returned object

Understanding the extension of type data

Retaining object modifications across sessions

Removing custom type data

Understanding variables

Working with Strings

Introduction

Creating a literal string

Creating an expanding string

Understanding Here-Strings

Using basic string methods

Performing string matching operations

Replacing substrings within strings

Splitting and combining strings

Using the formatting operator

Flow Control Using Branches and Loops

Introduction

Using If–ElseIf–Else conditions to control script flow

Using Switch–Case conditions to control script flow

Learning to use delays

Writing a basic looping construct

Writing a more complex loop on a predefined array

Using the For loop construct

Using the While loop construct

Cleaning empty directories using the Do–While construct

Cleaning empty directories using the Do–Until construct

Performing Calculations

Introduction

Performing arithmetic operations

Performing calculations on the output

Working with administrative constants

Working with calculated properties

Working with binary numbers

Performing base conversions

Using Arrays and Hashtables

Introduction

Creating and working with a simple array

Accessing and manipulating array items

Sorting an array

Searching for an item in an array

Combining arrays

Item matching in an array

Removing elements from an array

Comparing arrays

Creating a simple hashtable

Performing simple tasks on a hashtable

Handling Files and Directories

Introduction

Reading content from a file

Sending output to a file

Adding and setting content to a file

Searching for content

Working with locations

Working with files and directories

Listing files and directories

Working with structured and unstructured files

Building Scripts and Functions

Introduction

Writing a simple script

Reading input from the host

Displaying an interactive menu

Showing progress of execution

Defining arguments for a script

Writing a simple function

Working with a script block

Measuring running duration

Important points to remember

Advanced Concepts of Functions

Introduction

Defining parameters

Working with parameter aliases

Working with parameter sets

Adding default values to the parameter

Adding validation to parameter input

Handling dependencies and prerequisites

Adding safety switches to functions

Adding help to functions

Adding support for pipeline input

Using the Main function

Writing a script module

Handling module cleanup

Debugging and Error Handling

Introduction

The Debug tab of Visual Studio Code

Writing debug output

Running a script in Debug mode

Tracing errors

Using breakpoints

Using conditional breakpoints

Using exit codes

Working with the Error variable

Controlling flow based on errors

Sending verbose output to a file

Enterprise Administration Using PowerShell

Introduction to OpenSSH

Installing OpenSSH on Windows

Configuring OpenSSH using sshd_config on Windows

Installing and configuring OpenSSH on Linux

Testing PowerShell remoting using OpenSSH

Testing PowerShell remoting with OpenSSH using keys between Linux machines

Testing PowerShell remoting with OpenSSH using keys between Linux and Windows machines

Running cmdlets on remote computers

Managing the administration of remote machines with PowerShell Jobs

Generating HTML reports

Sending email messages

PowerShell and Cloud Operations

Introduction to PowerShell for Cloud operations on Azure and AWS

Installation of the AzureRM.Netcore PowerShell module on Linux machines

Installation of the AWSPowerShell.NetCore module on Linux machines

Discovering AzureRM cmdlets discovery functions

Azure Cloud Shell in action

Provisioning a Ubuntu 18.04 LTS VM using AzureRM.Netcore cmdlets on the Azure Cloud

Provisioning Linux Docker containers using Docker Machine on Azure

Provisioning Linux VM using PowerShell script

Performing management tasks using ARM PowerShell cmdlets

PowerShell remoting to Azure VM using OpenSSH

Managing AWS credentials

Connecting an EC2 Linux instance using SSH from PowerShell

Using PowerShell for SQL Database Management

Introduction to PowerShell, SQL Server, and Python

Technical requirements

Installing .Net Core on Linux

Installing the SqlServer module

Overview of SQL Server SMO

Running cross-platform T-SQL queries

Running cross-platform T-SQL queries on multiple servers

Creating a repository for Get-Process in the SQL database

Data formatting examples with PowerShell

Overview of PowerShell, Bash, and Python integration

Using PowerShell with Docker

Introduction to Docker

Installation of Docker on Linux

Getting and listing the Docker management cmdlets

Overview of Docker Hub and its operations

Building an image from a Dockerfile using PowerShell

Pulling a Docker container image from the repository

Listing Docker containers and the images

Starting and stopping Docker containers

Removing containers and container images

Working with a container using miscellaneous Docker PowerShell cmdlets

Running a PowerShell script to set up Docker containers

Finding Docker tags using PowerShell cmdlets from the remote registry

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Listing out the execution policies and setting a suitable one

This is a Windows-only recipe. Skip this if you never plan to work on Windows.

There was a time when running scripts on Windows computers was a cakewalk. Windows computers were highly prone to remote script executions. With PowerShell, Microsoft added a safety belt that allowed the user some control over how PowerShell scripts were loaded. Some specific models of script executions got restricted, which plugged some holes in the system.

It is important to remember that execution policies are not a security feature. There are ways to circumvent this fence. Execution policies are in place only to ensure that users don't accidentally run scripts without awareness.

PowerShell Core on Windows and Windows PowerShell contain this feature. Running PowerShell scripts on Windows is still restricted by default. On PowerShell Core on Linux, execution policies do not work at the moment, and, based on the interactions in the community, it is uncertain whether this feature will ever make it to PowerShell on Linux. Regardless, if you are reading this book, you are more than capable of understanding the perils of scripts from unknown sources.

An execution policy determines what type of scripts can be executed. Here are the six execution policies (excluding Default):

AllSigned
RemoteSigned
Restricted
Unrestricted
Bypass
Undefined

There are three scopes as well:

Process
CurrentUser
LocalMachine

A combination of an execution policy and a scope are what determine the condition that scripts can be loaded under. Microsoft has documented in detail what each of the policies is. In general, AllSigned requires that all of the scripts that run on the computer are signed using a code-signing certificate by a trusted certification authority. If this policy is set, PowerShell will not run unsigned scripts, even if you were the one to create them.

Restricted is the default policy: commands can be run, but not scripts. RemoteSigned allows scripts that have been created on your own computer to run. Scripts that have been downloaded from the internet cannot be run.

Bypass is similar to Unrestricted, however, it is used in specific scenarios, such as when PowerShell forms the basis of a certain application, and the application has its own security implementation.

Unrestricted means that all scripts and commands can run after a simple confirmation. Undefined means that no policy has been defined for a particular scope. Follow the recipe to find the execution policy that is effective on the session, and change it to suit your needs.

Getting ready

This recipe can only be run on Windows. If you're running a pure Linux environment, you cannot work with this recipe. You may run the commands, but you will see the Unrestricted policy set at all levels.

If you have a Windows computer to work with, you can proceed with this recipe, regardless of whether it has PowerShell or Windows PowerShell.

How to do it...

Open a PowerShell window by running pwsh or powershell. The pwsh command calls PowerShell, and powershell calls Windows PowerShell.

Windows PowerShell comes preinstalled on all modern Windows operating systems; PowerShell, on the other hand, has to be installed. Note that all of the current PowerShell cmdlets will run on Windows PowerShell as well:

First, run the Get-Command cmdlet to find out how to work with execution policies:

PS> Get-Command -Noun Execution*

Now, let's get help on running the cmdlet:

PS> Get-Help Get-ExecutionPolicy

We want to know the execution policy set on the machine. Therefore, we will run the following code:

PS> Get-ExecutionPolicy

This shows that the execution policy is currently effective on the current PowerShell session.

To list out the policies set at various scopes, run the following command:

PS> Get-ExecutionPolicy -List

We can see that the policy is only set at the LocalMachine level, and that it is set as RemoteSigned, which is the same as what is reflected in the previous step. The policy at the LocalUser and the Process scopes is Undefined, which made the session pick the execution policy from LocalMachine.

Now, let's set the execution policy for the local machine to be Undefined and see what our session picks up.

For this to work, close the current PowerShell session and open a new session as the administrator.
Next, run the following command:

PS> Get-Help Set-ExecutionPolicy

The help document shows that the value of the ExecutionPolicy parameter is mandatory, and that Undefined is one of the valid values it will accept. We want to set the policy at the LocalMachine scope, and so we will use the following code:

You will need to launch PowerShell (either Core or Windows) with elevated privileges to set the policy at the LocalMachine level.

PS> Set-ExecutionPolicy -ExecutionPolicy Undefined -Scope LocalMachine

Now, list the execution policies at the various scopes:

PS> Get-ExecutionPolicy -List

Now, let's check the currently effective execution policy:

PS> Get-ExecutionPolicy

Finally, let's set the execution policy back to how it was before we began the recipe. You may want to change the policy to suit your needs, based on what authority you have on the computer:

PS> Set-ExecutionPolicy RemoteSigned -Scope LocalMachine

How it works...

Execution policies are nothing but conditions that are set on the system to avoid accidental script runs. They work at different scopes.

There are three scopes in PowerShell, as we have already stated. The LocalSystem scope is at the end of the chain. Right above it is the CurrentUser scope. At the top is the Process scope. The level of precedence is Process > CurrentUser > LocalMachine. Therefore, if any policy other than Undefined is set at the Process scope, the session will use the policy that's currently set on the process. In case it is Undefined, it will look for the policy set on the CurrrentUser scope. If CurrentUser has the policy marked as Undefined as well, the session will apply the policy that was applied at the LocalMachine level. If LocalMachine has Undefined set, the session will pick the Default policy, which is based on what PowerShell has defined as the policy, which may vary based on the version of your operating system. On Windows 2016, for instance, the default policy is RemoteSigned.

The policies set at the CurrentUser and LocalMachine levels are stored in the Windows Registry. The policy set on the Process scope is stored in the ephemeral environment variable, that is, $env:PSExecutionPolicyPreference.

PowerShell Core for Linux Administrators Cookbook

By : Prashanth Jayaram, Ram Iyer

PowerShell Core for Linux Administrators Cookbook

By: Prashanth Jayaram, Ram Iyer

Overview of this book

Related Content you might be interested in

Current Title:

PowerShell Core for Linux Administrators Cookbook

PowerShell 7 Workshop

Powershell Core 6.2 Cookbook

Mastering PowerShell Scripting