http://www.eventbrite.com/event/792195478

Please be sure to not only click the “Add to my calendar” but also the “Register” button so that we can plan accordingly for food and drinks. 

Date:  August 25th 2010
Time: 5:00 pm – 7:00 pm
Location: Stanley A. Milner library
Map: 7 Sir Winston Churchill Square
Meeting Room: Centennial Room – Basement
Speaker: Aaron Nelson
Topic: Powershell for Database Professionals

Session Abstract:

In this session we will begin exploring the amazing world of the PowerShell language. We will learn to perform several everyday DBA tasks like backing up user databases, scripting table objects and evaluating disk space usage with PowerShell; then we will change these into multi-server scripts by adding only a single line of code.  We will also take a look at some data visualization techniques that require only a small amount of code.  Only a basic understanding of PowerShell or DOS is needed. This session should serve as a good introduction to PowerShell for database users.  The goal is to get data professionals feet wet about PowerShell and ready to practice it when they leave.  Yes you will get a copy of the scripts I use.

Presenter Information:  Aaron Nelson (@SQLvariant)  sqlvariant.com/wordpress/
Aaron Nelson is a Senior SQL Server Architect with over 10 years experience in architecture, business intelligence, development, and performance tuning of SQL Server.
He has experience managing enterprise-wide data needs in both transactional and data warehouse environments.  Aaron holds certifications for MCITP: Business Intelligence Developer, Database Administrator, Database Developer; as well as MCTS: Windows Server Virtualization, Configuration (meaning Hyper-V).

Agenda:
5:00 pm – Pizza and Socializing
5:30 pm – Sponsor Presentation
5:45 pm – Feature Presentation
7:00 pm – Wrap Up and Draws

If you haven’t signed up already at EDMPASS.com please do so now to receive meeting notifications, news, and updates from EDMPASS.

Hope to see you there.

Enjoy!!

• Pinging a list of production level servers
• Checking specific services on those servers
• Checking website availability for a list of websites
• All information and history needs to be tracked in a database for SLA analysis.

So where am I going to get my list of servers from?

# REMOVE FILE FOR NEW EXECUTION RESULTS
del F:\MonitoringDB\AllDomainServers.txt 
 
# SEARCH CRITERIA COMPUTERS THAT HAVE WINDOWS*SERVER AS AN OS
$SearchCategory = "computer"
$SearchOS = "Windows*Server*"
 
$Domain = New-Object System.DirectoryServices.DirectoryEntry
 
$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
$objSearcher.SearchRoot = $Domain
$objSearcher.Filter = ("OperatingSystem=$SearchOS")
 
$ServerName = "name"
 
foreach ($i in $ServerName)
{
	$objSearcher.PropertiesToLoad.Add($i)
}
 
$Results = $objSearcher.FindAll()
 
foreach ($ResultRow in $Results)
{
	$Computer = $ResultRow.Properties;
	$Computer.name |Out-File F:\MonitoringDB\AllDomainServers.txt -Append
}

Now let’s create a database called MonitoringDB on a SQL Server 2008 Instance and run the following script to create the tables needed:

CREATE TABLE [dbo].[ServerList](
	[ServerID] [int] IDENTITY(1,1) NOT NULL,
	[ServerName] [nvarchar](255) NOT NULL,
	[Environment] [nvarchar](10) NULL,
	[CreateDateTime] [datetime] NOT NULL,
	[LastModDateTime] [datetime] NOT NULL,
	[ActiveInd] [bit] NOT NULL,
 CONSTRAINT [PK_ServerList] PRIMARY KEY CLUSTERED
(
	[ServerID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
 
GO
ALTER TABLE [dbo].[ServerList] ADD  CONSTRAINT [DF_ServerList_CreateDateTime]  DEFAULT (getdate()) FOR [CreateDateTime]
GO
ALTER TABLE [dbo].[ServerList] ADD  CONSTRAINT [DF_ServerList_LastModDateTime]  DEFAULT (getdate()) FOR [LastModDateTime]
GO
ALTER TABLE [dbo].[ServerList] ADD  CONSTRAINT [DF_ServerList_ActiveInd]  DEFAULT ((1)) FOR [ActiveInd]
GO
CREATE TABLE [dbo].[ServiceCheck](
	[ServiceCheckID] [int] IDENTITY(1,1) NOT NULL,
	[ServerID] [int] NOT NULL,
	[ServiceName] [nvarchar](255) NOT NULL,
	[ServiceType] [nvarchar](10) NULL,
	[Notes] [nvarchar](500) NULL,
	[ActiveInd] [bit] NOT NULL,
	[CreateDateTime] [datetime] NOT NULL,
	[LastModDateTime] [datetime] NOT NULL,
 CONSTRAINT [PK_ServiceCheck_1] PRIMARY KEY CLUSTERED
(
	[ServiceCheckID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[ServiceCheck] ADD  CONSTRAINT [DF_ServiceCheck_ActiveInd]  DEFAULT ((1)) FOR [ActiveInd]
GO
ALTER TABLE [dbo].[ServiceCheck] ADD  CONSTRAINT [DF_ServiceCheck_CreateDateTime]  DEFAULT (getdate()) FOR [CreateDateTime]
GO
ALTER TABLE [dbo].[ServiceCheck] ADD  CONSTRAINT [DF_ServiceCheck_LastModDateTime]  DEFAULT (getdate()) FOR [LastModDateTime]
GO
CREATE TABLE [dbo].[ServiceCheckHistoryAudit](
	[ServiceCheckHistoryAuditID] [bigint] IDENTITY(1,1) NOT NULL,
	[ServiceCheckID] [int] NOT NULL,
	[AuditDateTime] [datetime] NOT NULL,
	[ServiceState] [bit] NOT NULL,
 CONSTRAINT [PK_ServiceCheckHistoryAudit] PRIMARY KEY CLUSTERED
(
	[ServiceCheckHistoryAuditID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[ServiceCheckHistoryAudit] ADD  CONSTRAINT [DF_ServiceCheckHistoryAudit_AuditDateTime]  DEFAULT (getdate()) FOR [AuditDateTime]
GO

OK now that we have our list of servers and a database to store them in, import your list into the ServerList table. If you’re having troubles with this step an easy way to do this is just to:

• Right click on the MonitoringDB database, Tasks, Import Data.
• Choose a flatfile source and browse to your AllDomainServers.txt file
• Import it into the ServerList table making sure to map the only column in the txt file to the ServerName column

OK so let’s pick a couple of development SQL Servers instances and update the active indicator (ActiveInd) so that those servers are the only ones that are going to be used in this post. Your script should look something like:

UPDATE	dbo.ServerList
SET	ActiveInd = 0
WHERE	ServerName NOT IN ('Server1', 'Server2', 'Server3')

OK so let’s first populate some services that we want to check. Hmmmmmm how are we going to know the service names? Don’t worry I wont leave ya hanging… Here is yet another PowerShell script that you can use to get the list of services and their current status:

$WMI = Get-WmiObject -Class win32_service -computer "Server1"
 
	foreach($service in $WMI)
	{
		foreach($srv in $serviceArray)
		{
			$service.name + "`t" + $service.state
 
		}
	}

So Cherrypick a few services that you’d like to check from each of the servers that you left the ActiveInd to 1. I’m a DBA so if I had to pick two I’ll use MSSQLSERVER and SQLSERVERAGENT.

So let’s get the ServerIDs of our testing servers by using the following script:

SELECT	ServerID, ServerName
FROM	ServerList
WHERE	ActiveInd = 1

OK for my example my ServerIDs are 70, 79, and 363.

Now we’re going to open the ServiecCheck Table and populate 2 rows per test server… something like this:

ServerID: 70
ServiceName: MSSQLSERVER
ServiceType: SERVICE

ServerID: 70
ServiceName: SQLSERVERAGENT
ServiceType: SERVICE

ServerID: 79
ServiceName: MSSQL$DEVE
ServiceType: SERVICE

ServerID: 79
ServiceName: SQLAGENT$DEVE
ServiceType: SERVICE

ServerID: 363
ServiceName: MSSQLSERVER
ServiceType: SERVICE

ServerID: 363
ServiceName: SQLSERVERAGENT
ServiceType: SERVICE

You’ll notice that my ServerID 79 is a named instance so the SQL Server service and the SQL Server Agent service are named a bit differently. You’ll also notice that I’ve populated the ServiceType filed with “Service” this is to distinguish between services and websites. You’ll see what I do with this field later.

Let’s throw in a website availability checks as well.

ServerID: 0
ServiceName: http://BenchmarkITConsulting.com
ServiceType: WEBSITE
Notes: *Colin Stasiuk*

OK so a little different setup then the service check. There is no “server” to check on a website availability check so I set the ServerID to 0. The service name is the http:// address of the site you’re looking to check. The service type is “WEBSITE” and the Notes column for a website is used to hold the search criteria for what the check looks for on the page to validate it’s availability.

Now we’re going to create a couple views to filter out the services and servers that we want to check by using the following script:

CREATE VIEW [dbo].[vwServerListActive] AS
SELECT	ServerID, ServerName
FROM	dbo.ServerList
WHERE	ActiveInd = 1
GO
CREATE VIEW [dbo].[vwActiveServiceChecks] AS
SELECT	A.ServiceCheckID, A.ServerID, B.ServerName, A.ServiceName, A.ActiveInd, A.CreateDateTime, A.LastModDateTime
FROM	dbo.ServiceCheck A INNER JOIN
		dbo.vwServerListActive B ON A.ServerID = B.ServerID
WHERE	A.ActiveInd = 1 AND
		A.ServiceType = 'SERVICE'
GO
CREATE VIEW [dbo].[vwActiveServiceChecks_Websites] AS
SELECT	A.ServiceCheckID, A.ServiceName, A.Notes, A.ActiveInd, A.CreateDateTime, A.LastModDateTime
FROM	dbo.ServiceCheck A
WHERE	A.ActiveInd = 1 AND
		A.ServiceType = 'WEBSITE'

OK finally we’re going to get to the “bacon” of this blog post…. the more I think I should of done a multi-part post but if you’ve stuck with me this long we’ve just got one more script to go…

So here we go… This is the script that you want to schedule to run as often as you feel necessary (I have mine running every 5 minutes)… first I’ll show the script and then break it down a bit.

$Server = "MySQL2008Server"
$Database = "MonitoringDB"
 
$emailFrom = "blah@blah.com"
$emailTo = "DBA@blah.com"
$subject = "Service Check Failure"
$smtpServer = "SMTPServer.blah.com"
 
$FailureCount = 0
 
###################		WINDOWS SERVICE CHECKS	(start)		###################
 
$con = "server=$Server;database=$Database;Integrated Security=sspi"
$cmd = "SELECT DISTINCT ServerName FROM dbo.vwActiveServiceChecks"
 
  $da = new-object System.Data.SqlClient.SqlDataAdapter ($cmd, $con)
 
  $dt = new-object System.Data.DataTable
 
  $da.fill($dt) | out-null
 
  foreach ($srv in $dt)
  {
	$ServerName = $srv.ServerName
 
	$ping = new-object System.Net.NetworkInformation.Ping
	$Reply = $ping.send($ServerName)
 
	if ($Reply.status –eq “Success”)
	{
		$cmd2 = "SELECT ServiceCheckID, ServiceName FROM dbo.vwActiveServiceChecks WHERE ServerName = '$ServerName'"
		$da2 = new-object System.Data.SqlClient.SqlDataAdapter ($cmd2, $con)
		$dt2 = new-object System.Data.DataTable
		$da2.fill($dt2) | out-null
 
		foreach ($svc in $dt2)
		{
 
			$ServiceCheckID = $svc.ServiceCheckID
			$ServiceName = $svc.ServiceName
 
			$colOS = get-wmiobject win32_service -filter "name='$ServiceName'" -computerName $ServerName 
 
			if ($colos)
			{
				foreach($objComp in $colOS)
				{
					$State = $objComp.State
 
					if ($objComp.State -eq "Running")
					{
						$sql = "INSERT INTO dbo.ServiceCheckHistoryAudit(ServiceCheckID, ServiceState) SELECT '$ServiceCheckID', '1'"
					}
					else
					{
						$sql = "INSERT INTO dbo.ServiceCheckHistoryAudit(ServiceCheckID, ServiceState) SELECT '$ServiceCheckID', '0'"
					        $body = $body + "`r`r" + "Service Check Failure: " + $ServerName + " (" + $ServiceName + ")"
						$FailureCount = 1
					}
					invoke-sqlcmd -serverinstance $Server -database $Database -query $sql
				}
			}
			else
			{
				$FailureCount = 1
				$Body = $Body + "`r`r" + "Bad Service Name: " + $ServerName + " (" + $ServiceName + ")"	
 
				$sql = "INSERT INTO dbo.ServiceCheckHistoryAudit(ServiceCheckID, ServiceState) SELECT '$ServiceCheckID', '0'"
				invoke-sqlcmd -serverinstance $Server -database $Database -query $sql		
 
			}
		}
	}
	else
	{
		$FailureCount = 1
		$Body = $Body + "`r`r" + "Failed Ping: " + $ServerName 
 
		$cmd3 = "SELECT ServiceCheckID, ServiceName FROM dbo.vwActiveServiceChecks WHERE ServerName = '$ServerName'"
		$da3 = new-object System.Data.SqlClient.SqlDataAdapter ($cmd3, $con)
		$dt3 = new-object System.Data.DataTable
		$da3.fill($dt3) | out-null
 
		foreach ($svc2 in $dt3)
		{
			$ServiceCheckID = $svc2.ServiceCheckID
			$ServiceName = $svc2.ServiceName
			$sql = "INSERT INTO dbo.ServiceCheckHistoryAudit(ServiceCheckID, ServiceState) SELECT '$ServiceCheckID', '0'"
			invoke-sqlcmd -serverinstance $Server -database $Database -query $sql	
 
			$FailureCount = 1
			$body = $body + "`r`r" + "Service Check Failure: " + $ServerName + " (" + $ServiceName + ")"
 
		}
 
	}
 
	$Reply = ""
 
  }
 
###################		WINDOWS SERVICE CHECKS	(End)		###################
 
###################		WEBSITE CHECKS	(start)			###################
 
$conWeb = "server=$Server;database=$Database;Integrated Security=sspi"
$cmdWeb = "SELECT ServiceCheckID, ServiceName, Notes FROM dbo.vwActiveServiceChecks_Websites"
 
$daWeb = new-object System.Data.SqlClient.SqlDataAdapter ($cmdWeb, $conWeb)
$dtWeb = new-object System.Data.DataTable
$daWeb.fill($dtWeb) | out-null
 
foreach ($Website in $dtWeb)
{
	$ServiceCheckID = $WebSite.ServiceCheckID
	$ServiceName = $Website.ServiceName
	$Notes = $Website.Notes
 
	trap
	{
		continue
	}
 
	$webclient= new-object System.Net.WebClient
	$webclient.Credentials = [System.Net.CredentialCache]::DefaultCredentials
	if($webclient.Proxy -ne $null)
	{
        	$webclient.Proxy.Credentials =
                [System.Net.CredentialCache]::DefaultNetworkCredentials
	}
 
	$Output = $webclient.DownloadString($ServiceName)
 
		IF ($Output -like $Notes)
		{
			$sql = "INSERT INTO dbo.ServiceCheckHistoryAudit(ServiceCheckID, ServiceState) SELECT '$ServiceCheckID', '1'"
			invoke-sqlcmd -serverinstance $Server -database $Database -query $sql
		}
		ELSE
		{
			$FailureCount = 1
			$Body = $Body + "`r`r" + "Bad Website or Search String: " + $ServiceName + " (" + $Notes + ")"
 
			$sql = "INSERT INTO dbo.ServiceCheckHistoryAudit(ServiceCheckID, ServiceState) SELECT '$ServiceCheckID', '0'"
			invoke-sqlcmd -serverinstance $Server -database $Database -query $sql
		}
 
	$Output = ""
 
}
 
###################		WEBSITE CHECKS	(End)			###################
 
###################		MAIL	(start)			###################
 
if ($FailureCount -eq "1")
{
	$smtp = new-object Net.Mail.SmtpClient($smtpServer)
	$smtp.Send($emailFrom,$emailTo,$subject,$body)
 
}
 
###################		MAIL	(End)			###################

OK let’s step through this a bit to see what we’re doing…

*** There are some variables at the top that will need to be populated with information from your environment ***

• First we connect to the database and get the list of all servers that have services that need to be checked
• For each of those severs we first ping to see if we can even connect to the server
• If we can’t ping then for all the services for that server are marked as failed and the body of our failure email is appended to
• If we can ping then we pull the services to check for that server
• For each service in that list we check the status… if it’s running we audit accordingly if it’s not then we audit accordingly and the body of our failure email is appended to
• Next… For each website we look at the source and compare it to our search criteria in the notes column
• If it can find the search criteria we audit accordingly… if it can’t find the search string or can’t connect at all then we audit accordingly and the body of our failure email is appended to
• Finally after everything is done the failure email (if there are any failures) get sent out.

A quick SELECT from the ServiceCheckHistoryAudit table will give you a look as to what passed and what failed by the ServiceState column.

I setup my job to run every 5 minutes and I’m currently looking at over 200 services and websites and my average duration of my job is 1 minute and 20 seconds (not bad in my opinion)…. anyways this is very much a v1 of this script/process and I’m hoping that people can not only find a good use for it but also look to take the script and add to it, optimize it, etc.  I’m still a rookie with PowerShell so any and all help and suggestions would be greatly appreciated

EDIT:  I also have a stored proc that runs monthly to “clean up” the data on days when a service has a clean record for the full 24 hour period… but I’ve already taken up enough of your time so we’ll save that for another post another day LOL

Enjoy!!

So what do you do if you’re in a VM environment and you want/need to reboot your server but you can’t connect via RDP and you can’t connect to the console using the VM Infrastructure Client, and all other attempts to connect just don’t work.  I decided to go down the route of using PowerShell.

$ServerToRestart = Get-WMIObject win32_operatingsystem -computer <<Your Server Name Here>>
$ServerToRestart.reboot()

Get-WMIObject – Windows PowerShell: The WMI Connection

Simple, easy and very dangerous/powerful.  I’ll channel my inner “Uncle Ben” (see Spiderman quotes) and just leave this message as a closing thought:

“With Great Power Comes Great Responsibility”

Enjoy!!

Translation: Fail Whale for SQL Server Management Studio and Central Management Server for Policy Based Managment using PowerShell…. lol simple eh?

So this is a Microsoft Connect Item in the making…

I had created a PowerShell script to run a bunch of policies against a list of servers that I defined in a ServerList.txt file.  I decided that I didn’t like the idea of needing to maintain a text file and instead of storing the Instance Names in a table somewhere I decided to hook into the Central Managment Server.

So I logged into the server that is currently running the SQL Server Agent job that was doing all this using a ServerList.txt file.  I changed the PowerShell Script to point to my CMS server instead and ran the .ps1 directly on the server using “sqlps F:\PBM\EvaluatePolicies.ps1″.  The script ran as expected, used my CMS server, and everything was tickidyboo.  Or so I thought….

I decided to do my final check and run the SQL Server Agent job itself… and it failed.

Hmmmm that’s weird… so I confirmed that the SQL Server Agent account had access to the CMS server and even granted it explicit sysadmin rights (just for my troubleshooting).

FAIL

I started tweeting about the problem and got some immediate advice from @afernandez, @russjohnson, @wendy_dance, and @SQLChicken.  While none of the advice solved my problem it was great to have some other “eyes” reading my problem and confirming the stuff that I had already thought of and tested.

The SQL Server Agent Service Account is a secure account that I don’t even have access or the password for so I asked for some help from one of our Server Admins for my troubleshooting… he logged into the server for me and I tried to run the ps1 file….

FAIL

So I opened up SSMS and checked if I could connect to the CMS directly….

SOLUTION:  In order to use a PowerShell script to connect to the Central Management Server using the SQL Server Agent the service account that SQL Server Agent is running under must REGISTER the CMS Server through SSMS on the Server that is running the job.

Did you get all that…. because I had never Remote Desktopped onto the Server using the SQL Server Agent service account and Registered the CMS Server in SSMS using that account when I tried to access the CMS Server through my PowerShell script it failed.

I registered the CMS Server using the SQL Server Agent Service Account and everything started sizzling like bacon on a hot pan.

Enjoy!!

OK so the last time I handed out a SQL Bacon Nugget of Excellence Award was July 8th for @SQLAgentMan ‘s article on Determining Free Space, Consumed Space, and Total Space Allocated for Microsoft SQL Server Databases

and this time around @SQLGal has put something together that can only be described as a SQL Bacon Nugget of Excellence.  So a little background story on this one… I’ve been doing more with Policy Based Management lately and coincidently more with PowerShell as well.  So I started playing around with having an automated policy checker run in the night via PowerShell and email me the “non conformists”

I was almost done my initial release when I all of a sudden found that if I ran the powershell script from the server directly that I couldn’t connect to some of my servers (SQL 2000).  I re-ran… nothing… tried a few different ideas… no dice.  So as I like to do from time to time if my “googling” doesn’t help much is I posed the question to the Twitterverse.

As always (cause Twitter is just great for community support) I got a couple replies and offers of assistance.  One reply was from @Timbo_B_Edwards.  His tweet pointed me to a site that suprisingly (with my googling on Policy Based Management and Powershell) I didn’t find before.

Enterprise Policy Management Framework

This offering from @SQLGal puts my ragamuffin first attempt at Policy Based Management via Powershell to shame.

The Enterprise Policy Managment Framework uses PowerShell to evaluate policies against your SQL Server Environment, shreds the XML for you, and then renders and delivers your policy history reports via Reporting Services.

So for the love of all things good and pure in this world… if you have SQL Server 2008 (and if you don’t this is one heck of a good reason to start) this is something you HAVE TO check out and spend some quality time with. 

Lara Rubbelke

• Laura on SQLBlog.com
• @SQLGal on Twitter
• Enterprise Policy Management Framework

P.S. I found the solution to my problem on the top of the Enterprise Policy Management Framework page…

“Update on SP1: You must install SQL Server 2008 SP1 Cumulative Update 3 (http://support.microsoft.com/kb/971491) if you have installed SP1 on the Central Management Server. SP1 Cumulative Update 3 will fix the SP1 bug which prevented down version policy evaluation.”

Enjoy!!

No not THAT KISS… the Keep It Simple Stupid theory.

So when it comes to backups… if I’m not needing to “trick them out” or do anything custom I don’t have any problems with setting up a nice and easy maintenance plan and calling it a day.  I know there are some strong opinions out there that you should avoid Maintenance Plans like the plague and I agree that in some situations that they are not your best option but I don’t like to write them off altogether.

Sorry… that went longer then expected…ok back on topic…

xp_delete_file… So I needed to build a custom backup job because with the size of the database I would get greater performance by backing up to multiple backup files (an option that is not available in a maintenance plan).  Now normally I would just attach the maintenance cleanup task to another maintenance plan but I thought “Hey… let’s get crazy” I’m going to click on that View T-SQL Button and see what happens.

Well isn’t that easy?

EXECUTE master.dbo.xp_delete_file 0,N'\\ServerName\Folder',N'BAK','2009-08-13T08:14:17',1

Could it REALLY be that simple?

Hey… what’s with that “0″ at the front and the “1″ at the end?  What are those parameters for?

I BINGed the question (OK I really GOOGLEd it… sorry Microsoft I just can’t break my google ties) and found that the first arguement determines if it’s a backup file or a report file (0 and 1 respectively) and the last arguement determines whether or not to include first level subfolders (0 – no 1 – yes)

Great… it looks like I’ve found my solution….. but wait for it…… wait for it……..

ENTER PowerShell….

(Great picture BTW by Joe Brinkman – The Accidental Geek )

OK admittedly I’m one of the 42% on Brent Ozar’s Powershell Poll that don’t currently use PowerShell but want to.  So I thought here is my chance…

 I started out simple:

Built myself a nice little .ps1 file with this:

$directory = “C:\”
Get-ChildItem $directory

Ran that bad boy and low and behold… I’m a PowerShell developer

So I thought… let’s add my network share location for my backup files:

$directory = “\\servername\folder”
Get-ChildItem $directory

Ran that and I’m back to being a PowerShell failure:

Get-ChildItem : Cannot find path ‘\\servername\folder’ because it does not exist.

Turns out you need to map a drive for a network share (or at least that’s how I solved my problem… please comment if there is a more elegant solution):

$directory = “\\ServerName\Folder”
New-PSDrive -name X -psprovider FileSystem -root $directory
Get-ChildItem X:\

 Now we’re cooking with fire

Next I changed my Get-ChildItem statement to filter only the *.BAK files and I set it to recursively go through subdirectories:

$directory = “\\ServerName\Folder”
New-PSDrive -name X -psprovider FileSystem -root $directory
Get-ChildItem X:\ -include *.BAK -recurse

This is getting good now Now I wanted to only get the *.BAK files that are older then 4 hours… this took some googling to get my syntax right:

$directory = “\\ServerName\Folder”
New-PSDrive -name X -psprovider FileSystem -root $directory
Get-ChildItem X:\ -include *.BAK -recurse | where {((get-date)-$_.creationTime).hours -ge 4}

 And finally I wanted to delete these files so we “pipe in” a remove-item and we’re done:

$directory = “\\ServerName\Folder”
New-PSDrive -name X -psprovider FileSystem -root $directory
Get-ChildItem X:\ -include *.BAK -recurse | where {((get-date)-$_.creationTime).hours -ge 4} | remove-item -force -recurse

And if you wanted to add your transaction log backups as well you could copy/paste your Get-ChildItem and change accordingly

Get-ChildItem X:\ -include *.TRN -recurse | where {((get-date)-$_.creationTime).days -ge 1.5} | remove-item -force -recurse

And there you go… I’m not sure if this means I’m now a PowerShell user but I’m definitely starting to drink the KoolAid for sure.

Enjoy!!