The following script (credit to Bryan Hart) will update the certicate in a single elevated PowerShell prompt.

###################################
# Apply Certificate to FAST
###################################
write-host "Applying Certificate to FAST" -ForegroundColor Yellow

Add-PSSnapin AdminSnapIn
Add-PSSnapin Microsoft.FASTSearch.PowerShell
Add-PSSnapin Microsoft.SharePoint.PowerShell

stop-service FAST*

$installerdir = $env:FASTSEARCH + "installer\scripts"

cd $installerdir

$pw = ConvertTo-SecureString -AsPlainText -force pass@word1

.\ReplaceDefaultCertificate.ps1 -generateNewCertificate $true -certificatePassword $pw

$cert = @(dir cert:\LocalMachine\My -recurse | ? { $_.Subject -eq 'CN=FASTSearchCert' })[0]

$thumb = $cert.Thumbprint

Start-service FAST*

.\SecureFASTSearchConnector.ps1 -certThumbprint $thumb -ssaName "FASTContent" -username "contoso\administrator"

Reference

• Remember to give your SharePoint 2010 Information Worker Virtual Machine a fresh certificate

With thousands of document libraries in an established farm, the prospect of visiting thousands of List Settings pages was not at all appealing. PowerShell to the rescue.

The Script

The following script accepts a parent web and enumerates all of its children (optional), altering the libaries that match the criteria “Not a System/Style/Hidden library” and “has minor versioning currently enabled”. The matching libraries are updated to force document checkouts and accept an unlimited numer of major versions (Governance decision, no listening to reason there).

function Reset-SPDocumentLibaries {
	param (
		[string] $WebUrl = $(Read-Host -prompt "Enter a Url"),
        [switch] $ProcessChildren
	) 

	$web = Get-SPWeb $WebUrl;

	ProcessWeb $web $ProcessChildren;
}

function ProcessWeb($web, $processChildren) {

	Write-Host "Processing Web",$web.Title,"(",$web.Url,")" -foregroundcolor "Green";

	$lists = @($web.Lists | Where-Object { ($_.BaseType -eq "DocumentLibrary") -and ($_.BaseTemplate -eq "DocumentLibrary") -and ($_.IsSiteAssetsLibrary -eq $false) -and ($_.EnableMinorVersions -eq $true) -and ($_.Hidden -eq $false) -and ($_.Description -notlike "*system*") -and ($_.Description -notlike "*style*") })

    if ($lists.Count -gt 0) {
    	foreach ($list in $lists) {
    		if ($list.Title.Length -gt 0) {
    			Write-Host "   Processing List",$list.Title -foregroundcolor "Green";

    			$list.EnableVersioning = $true;
    			$list.EnableMinorVersions = $false;
    			$list.MajorVersionLimit = 0;
    			$list.ForceCheckout = $true;

    			$list.Update();
    		}
    		else {
    			Write-Host "   Invalid List Encountered" -foregroundcolor "Red"
    		}
    	}
    } else {
        Write-Host "   No lists matching filter were found" -foregroundcolor "Red"
    }

    if ($processChildren) {
    	foreach ($subWeb in $web.Webs) {
    		ProcessWeb $subWeb $processChildren
    	}
    }
}

The PowerShell function outlined below allows for setting the UIVersion on all of the site collections and sites in a given content database in one shot.

function Set-SPUIVersion(
    [string]$dbName = $(Read-Host -prompt "Content Database Name"),
    [int32]$uiVersion = $(Read-Host -prompt "UI Version"))
    {
	$db = Get-SPContentDatabase $dbName

	foreach ($s in $db.Sites) {
		foreach ($w in $s.AllWebs) {
			$w.UIversion = $uiVersion;
			switch ($uiVersion) {
				3 { $w.UIVersionConfigurationEnabled = $true; }
				4 { $w.UIVersionConfigurationEnabled = $false; }
			}
			$w.Update();
		}
	}
}

The Script

function SPGetFarmSolutions {
	param (
		[string] $directory = $(Read-Host -prompt "Enter a directory (use ""."" for current dir)")
	)

	if ($directory.Length -lt 2) {
		$directory = [string]$pwd + "\\";
	}

	$farm = [Microsoft.SharePoint.Administration.SPFarm]::Local;
	$solutions = $farm.Solutions;
	$solutions | ForEach-Object {
		Write-Host "Found solution $_.name";
		$_.SolutionFile.SaveAs($directory + $_.name);
	}
}

or the one liner:

(Get-SPFarm).Solutions | ForEach-Object{$var = (Get-Location).Path + "\" + $_.Name; $_.SolutionFile.SaveAs($var)}

The Script

# Outputs CSV of the specified termset from the specificed termstore/group
# Example calls:
# Create-SPFoldersFromTermSet "http://sp2010/PublicDocuments" "Documents" "Managed Metadata Service" "Enterprise Metadata" "Business Terms"

[Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint.Taxonomy")

function Create-SPFoldersFromTermSet(
	[string]$webUrl = $(Read-Host -prompt "Web Site URL"),
	[string]$listName = $(Read-Host -prompt "List Name"),
	[string]$termStoreName = $(Read-Host -prompt "Term Store Name"),
	[string]$termGroupName = $(Read-Host -prompt "Term Group Name"),
	[string]$termSetName = $(Read-Host -prompt "Term Set Name"))
	{

	$isValid = $true;
	$message = "";

	if ($webUrl.Length -eq 0) { $message += "`nPlease provide a web site URL"; $isValid = $false; }
	if ($listName.Length -eq 0) { $message += "`nPlease provide a list name"; $isValid = $false; }
	if ($termStoreName.Length -eq 0) { $message += "`nPlease provide a Term Store Name"; $isValid = $false; }
	if ($termGroupName.Length -eq 0) { $message += "`nPlease provide a Term Store Group Name"; $isValid = $false; }
	if ($termSetName.Length -eq 0) { $message += "`nPlease provide a Term Set Name"; $isValid = $false; }

	if ($isValid -eq $false)
	{
		write-host "`n`nERROR OCCURRED`n`t$message`n`n"
		write-host "NAME`n`tCreate-SPFoldersFromTermSet`n"
		write-host "SYNOPSIS`n`tCreates a set of folders in a destination library based on the supplied term set.`n"
		write-host "SYNTAX`n`tCreate-SPFoldersFromTermSet webUrl listName termStoreName termGroupName termSetName`n"
		write-host "EXAMPLES`n`n Create-SPFoldersFromTermSet ""http://sp2010/PublicDocuments"" ""Documents"" ""Managed Metadata Service"" ""Enterprise MetaData"" ""Business Terms""`n"
		return;
	}

	try
	{
		$ErrorActionPreference = "Stop";

		$web = $null;
		$list = $null;

		try
		{
			$web = Get-SPWeb $webUrl;
			$list = $web.Lists[$listName];

			if ($list -eq $null)
			{
				return "Unable to find a list with the name $listName"
			}
		}
		catch { "Error acquiring web/list" }

		try
		{
			$taxSession = Get-SPTaxonomySession -Site $web.Site.Url;

			try
			{
				$termStore = $taxSession.TermStores[$termStoreName];

				if ($termStore -ne $null)
				{
					try
					{
						$termGroup = $termStore.Groups[$termGroupName];

						if ($termGroup -ne $null)
						{
							try
							{
								$termSet = $termGroup.TermSets[$termSetName];

								if ($termSet -ne $null)
								{
									$rootFolder = $list.RootFolder;

									foreach ($term in $termSet.Terms)
									{
										Create-SPFolderFromTerm $rootFolder $term
									}
								}
								else
								{
									return "Termset $termSetName does not exist in the term store group $termGroupName";
								}
							}
							catch
							{
								"Unable to acquire the termset $termSetName from the term group $termGroupName"
							}
						}
						else
						{
							return "Term store group $termGroupName does not exist in the term store $termStoreName";
						}
					}
					catch
					{
						"Unable to acquire term store group $termGroupName from $termStoreName"
					}
				}
				else
				{
					return "Term store $termStoreName does not exist";
				}
			}
			catch
			{
				"Unable to acquire term store for $termStoreName"
			}
		}
		catch
		{
			"Unable to acquire session for the site $webUrl"
		}
	}
	catch
	{

	}
	finally
	{
		$ErrorActionPreference = "Continue";
	}
}

function Create-SPFolderFromTerm(
	[Microsoft.SharePoint.SPFolder]$parentFolder,
	[Microsoft.SharePoint.Taxonomy.Term]$term)
{
	$childFolder = $parentFolder.SubFolders[$term.Name];
	if ($childFolder -eq $null)
	{
		$parentFolder.SubFolders.Add($term.Name);
		$childFolder = $parentFolder.SubFolders[$term.Name];
	}

	if ($term.Terms.Count -gt 0)
	{
		foreach ($childTerm in $term.Terms)
		{
			Create-SPFolderFromTerm $childFolder $childTerm
		}
	}
}

File Format

The Script

# Inputs CSV of the specified termset into the specificed termstore/group
# Example calls:
# Import-SPTermStoreGroupTerms "http://sp2010" "Managed Metadata Service" "Enterprise Metadata" "Business Units" "C:\Users\Me\Desktop\input.csv"

[Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint.Taxonomy")

function Import-SPTermStoreGroupTerms(
	[string]$siteUrl = $(Read-Host -prompt "Site Collection URL"),
	[string]$termStoreName = $(Read-Host -prompt "Term Store Name"),
	[string]$termGroupName = $(Read-Host -prompt "Term Group Name"),
	[string]$termSetName = $(Read-Host -prompt "Term Set Name"),
	[string]$inputFile = $(Read-Host -prompt "Input File (including full path)")) {

	$isValid = $true;
	$message = "";

	if ($siteUrl.Length -eq 0) { $message = "`nPlease provide a site URL"; $isValid = $false; }
	if ($termStoreName.Length -eq 0) { $message += "`nPlease provide a Term Store Name"; $isValid = $false; }
	if ($termGroupName.Length -eq 0) { $message += "`nPlease provide a Term Store Group Name"; $isValid = $false; }
	if ($termSetName.Length -eq 0) { $message += "`nPlease provide a Term Set Name"; $isValid = $false; }
	if ($inputFile.Length -eq 0) { $message += "`nPlease provide an input file"; $isValid = $false; }

	if ($isValid -eq $false) {
		write-host "`n`nERROR OCCURRED`n`t$message`n`n"
		write-host "NAME`n`tImport-SPTermStoreGroupTerms`n"
		write-host "SYNOPSIS`n`tConsumes a CSV file containing a listing of term names and creates them if needed in the specified term set.`n"
		write-host "SYNTAX`n`tImport-SPTermStoreGroupTerms siteUrl termStoreName termGroupName termSetName inputFile`n"
		write-host "EXAMPLES`n`n Import-SPTermStoreGroupTerms ""http://sp2010"" ""Managed Metadata Service"" ""Enterprise Metadata"" ""Business Units"" ""C:\Users\Me\Desktop\input.csv""`n"
		write-host "SAMPLE INPUT FILE`n`tTerm`n`tSample Term 1`n`tSample Term 2`n`tSample Term 3`n"
		return;
	}

	try {
		$ErrorActionPreference = "Stop";

		try {
			$taxSession = Get-SPTaxonomySession -Site $siteUrl;

			try {
				$termStore = $taxSession.TermStores[$termStoreName];

				if ($termStore -ne $null) {
					try {
						$termGroup = $termStore.Groups[$termGroupName];

						if ($termGroup -ne $null) {
							try {
								$termSet = $termGroup.TermSets[$termSetName];

								if ($termSet -ne $null) {
									$csv = Import-csv -path $inputFile

									if ($csv -ne $null) {
										foreach($line in $csv)
										{
											[string]$termName = $line.Term;

											if (![string]::IsNullOrEmpty($termName)) {
												$term = $null;

												try {
													[string]$normalizedTermName = [Microsoft.SharePoint.Taxonomy.TermSet]::NormalizeName($termName);
													$term = $termSet.Terms[$normalizedTermName];
													write-host "Term $termName already exists"
												}
												catch { }

												if ($term -eq $null) {
													$t = $termSet.CreateTerm($termName, 1033);
													$termSet.TermStore.CommitAll();
													write-host "Term $termName has been created"
												}
											}
										}
									}
									else {
										return "Argument supplied for input file was invalid.";
									}
								}
								else {
									return "Termset $termSetName does not exist in the term store group $termGroupName";
								}
							}
							catch {
								"Unable to acquire the termset $termSetName from the term group $termGroupName"
							}
						}
						else {
							return "Term store group $termGroupName does not exist in the term store $termStoreName";
						}
					}
					catch {
						"Unable to acquire term store group $termGroupName from $termStoreName"
					}
				}
				else {
					return "Term store $termStoreName does not exist";
				}
			}
			catch {
				"Unable to acquire term store for $termStoreName"
			}
		}
		catch {
			"Unable to acquire session for the site $siteUrl"
		}
	}
	catch { }
	finally {
		$ErrorActionPreference = "Continue";
	}
}

Updated: There was an error in the previous version of this script. It did not account for the fact that the ampersand character (“&”) is stored as a fullwidth ampersand (“\uFF06“) when a term is created. The script has been adjusted to replace any fullwidth ampersands with a basic Latin ampersand in the output.

The Script

# Outputs CSV of the specified termset from the specificed termstore/group
# Example call:
# Export-SPTermStoreGroupTerms "http://sp2010" "Managed Metadata Service" "Enterprise Metadata" "Business Units"

function Export-SPTermStoreGroupTerms {
	param (
		[string]$siteUrl = $(Read-Host -prompt "Site Collection URL"),
		[string]$termStoreName = $(Read-Host -prompt "Term Store Name"),
		[string]$termGroupName = $(Read-Host -prompt "Term Group Name"),
		[string]$termSetName = $(Read-Host -prompt "Term Set Name"),
		[string]$outPutDir = ""
	)

	$isValid = $true;
	$message = "";

	if ($siteUrl.Length -eq 0) { $message = "`nPlease provide a site URL"; $isValid = $false; }
	if ($termStoreName.Length -eq 0) { $message += "`nPlease provide a Term Store Name"; $isValid = $false; }
	if ($termGroupName.Length -eq 0) { $message += "`nPlease provide a Term Store Group Name"; $isValid = $false; }
	if ($termSetName.Length -eq 0) { $message += "`nPlease provide a Term Set Name"; $isValid = $false; }

	if ($isValid -eq $false)
	{
		write-host "`n`nERROR OCCURRED`n`t$message`n`n"
		write-host "NAME`n`tExport-SPTermStoreGroupTerms`n"
		write-host "SYNOPSIS`n`tReturns a CSV file containing a listing of term names and identifiers from the supplied term set.`n"
		write-host "SYNTAX`n`tExport-SPTermStoreGroupTerms siteUrl termStoreName termGroupName termSetName outPutDir`n"
		write-host "EXAMPLES`n`n Export-SPTermStoreGroupTerms ""http://sp2010"" ""Managed Metadata Service"" ""Enterprise Metadata"" ""Business Units""`n"
		return;
	}

	try
	{
		$ErrorActionPreference = "Stop";

		try
		{
			$site = Get-SPSite $siteUrl;
			$taxSession = new-object Microsoft.SharePoint.Taxonomy.TaxonomySession($site, $true);

			try
			{
				$termStore = $taxSession.TermStores[$termStoreName];

				if ($termStore -ne $null)
				{
					try
					{
						$termGroup = $termStore.Groups[$termGroupName];

						if ($termGroup -ne $null)
						{
							try
							{
								$termSet = $termGroup.TermSets[$termSetName];

								if ($termSet -ne $null)
								{
									[string]$csvDir = "";

									if ($outPutDir.Length -gt 0)
									{
										$csvDir = $outPutDir;
									}
									else
									{
										$csvDir = $pwd;
									}

									$outPutFile = $csvDir + "\output.csv";

									$sw = new-object system.IO.StreamWriter($outPutFile);

									$sw.writeline("Name,Id");

									foreach ($term in $termSet.GetAllTerms())
									{
										[Byte[]] $ampersand = 0xEF,0xBC,0x86;

										$sw.writeline("""" + $term.Name.Replace([System.Text.Encoding]::UTF8.GetString($ampersand), "&") + """" + "," + $term.Id);
									}

									$sw.close();

									write-host "Your CSV has been created at $outPutFile";
								}
								else
								{
									return "Termset $termSetName does not exist in the term store group $termGroupName";
								}
							}
							catch
							{
								"Unable to acquire the termset $termSetName from the term group $termGroupName"
							}
						}
						else
						{
							return "Term store group $termGroupName does not exist in the term store $termStoreName";
						}
					}
					catch
					{
						"Unable to acquire term store group $termGroupName from $termStoreName"
					}
				}
				else
				{
					return "Term store $termStoreName does not exist";
				}
			}
			catch
			{
				"Unable to acquire term store for $termStoreName"
			}
		}
		catch
		{
			"Unable to acquire session for the site $siteUrl"
		}
	}
	catch
	{

	}
	finally
	{
		$ErrorActionPreference = "Continue";
	}
}

############################################################################
# Assumptions:
# - Running on machine with WSS/MOSS
# - C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN in path
# - For development servers only, does not dispose of objects
############################################################################
# Example usage:
# $list = get-splist -webUrl "http://site" -listName "Announcements"
############################################################################

$12HiveDir = "${env:CommonProgramFiles}\Microsoft Shared\web server extensions\12\"

[void][reflection.assembly]::Loadwithpartialname("Microsoft.SharePoint") | out-null
[void][reflection.assembly]::Loadwithpartialname("Microsoft.Office.Server.Search") | out-null
[void][reflection.assembly]::Loadwithpartialname("Microsoft.Office.Server") | out-null

# Returns the SPWebApplication at the specified URL
function get-spwebapplication ([String]$webUrl=$(throw 'Parameter -webUrl is missing!'))
{
    return [Microsoft.SharePoint.Administration.SPWebApplication]::Lookup("$webUrl")
}

# Returns the SPSite at the specified URL
function get-spsite ([String]$webUrl=$(throw 'Parameter -webUrl is missing!'))
{
    return New-Object -TypeName "Microsoft.SharePoint.SPSite" -ArgumentList "$webUrl"
}

# Returns the SPSite object from the specified URL
function get-spweb ([String]$webUrl=$(throw 'Parameter -webUrl is missing!'))
{
    $site = New-Object -TypeName "Microsoft.SharePoint.SPSite" -ArgumentList "$webUrl"
    return $site.OpenWeb()
}

# Returns the SPList object from the specified URL and list name
function get-splist ([String]$webUrl=$(throw 'Parameter -webUrl is missing!'),
[String]$listName=$(throw 'Parameter -listName is missing!'))
{
    $site = New-Object -TypeName "Microsoft.SharePoint.SPSite" -ArgumentList "$webUrl"
    $web = $site.OpenWeb()
    return $web.Lists[$listName]
}

Reference

• Getting started with PowerShell and SharePoint

If anything, it can serve as a handy guide for how to script out individual actions pertaining to installation and farm maintenance.

Reference

• SharePoint 2010 Products scripted deployment SPModule .zip file
• Install SharePoint Server 2010 by using Windows PowerShell
• Install SharePoint Foundation 2010 by using Windows PowerShell

1. Install the SharePoint binaries on each server in your farm. Select “Complete” as the installation type. This will allow you to create a farm as opposed to a single server installation.After the install has completed, you will asked if you would like to complete the “SharePoint Products Configuration Wizard”. Do not run the wizard at this time.
2. On the server which you wish to provision Central Administration:
   1. Open the  ”SharePoint 2010 Management Shell” (right-click and select “Run as administrator”). The shell will load with a message that the local farm is not accessible. This is expected as we have only installed the binaries.
   2. Run the following command to create the initial configuration/content database for the farm.

      New-SPConfigurationDatabase –DatabaseName “SharePoint2010_Config” –DatabaseServer “SharePoint2010SQL” –AdministrationContentDatabaseName “SharePoint2010_Content_Admin” –Passphrase (ConvertTo-SecureString “Pass@word1” –AsPlaintext –Force) –FarmCredentials (Get-Credential)
      

   3. After the initial creation of the farm, close and reload the “SharePoint 2010 Management Shell”. You should no longer receive any error messages.
   4. Install the help files.

      Install-SPHelpCollection -All
      

   5. Secure the resources used by the server (files and registry).

      Initialize-SPResourceSecurity
      

   6. Install and provision the farm services.

      Install-SPService
      

   7. Install the features on the server.

      Install-SPFeature –AllExistingFeatures
      

   8. Provision Central Administration.

      New-SPCentralAdministration -Port 1234  -WindowsAuthProvider "NTLM"
      

   9. Install the application content.

      Install-SPApplicationContent
      

   10. Optional: Disable the loopback check. If this is a development install, outright disabling the check should be fine. For production environments, the loopback check should be left in place and BackConnectionHostNames should be used in its place. See KB 896861.

       New-ItemProperty HKLM:\System\CurrentControlSet\Control\Lsa -Name "DisableLoopbackCheck"  -value "1" -PropertyType dword
       

3. On each additional server that you wish to converge in the farm:
   1. Open the  ”SharePoint 2010 Management Shell” (right-click and select “Run as administrator”). The shell will load with a message that the local farm is not accessible. This is expected as we have only installed the binaries.
   2. Connect the server to the farm with the following command:

      Connect-SPConfigurationDatabase -DatabaseName "SharePoint2010_Config" -DatabaseServer "SharePoint2010SQL" -Passphrase (ConvertTo-SecureString "Pass@word1" -AsPlaintext -Force)
      

   3. Install the help files.

      Install-SPHelpCollection -All
      

   4. Secure the resources used by the server (files and registry).

      Initialize-SPResourceSecurity
      

   5. Install and provision the farm services.

      Install-SPService
      

   6. Install the features on the server.

      Install-SPFeature –AllExistingFeatures
      

   7. Install the application content.

      Install-SPApplicationContent
      

   8. Optional: Disable the loopback check. If this is a development install, outright disabling the check should be fine. For production environments, the loopback check should be left in place and BackConnectionHostNames should be used in its place. See KB 896861.

      New-ItemProperty HKLM:\System\CurrentControlSet\Control\Lsa -Name "DisableLoopbackCheck"  -value "1" -PropertyType dword
      

Reference

• Eric Kraus’ SharePoint/.NET Blog – SharePoint 2010 Provisioning A New Farm with Powershell
• You receive error 401.1 when you browse a Web site that uses Integrated Authentication and is hosted on IIS 5.1 or a later version
• SharePoint Automation: SharePoint 2010 PSConfig and Powershell