Content databases aren’t the only
databases that can be upgraded from SharePoint 2010 to SharePoint 2013.
There is an exclusive club of service applications whose databases can
also be upgraded to SharePoint 2013. Here are the members of that club:
- Business Connectivity Services
- Managed Metadata
- Performance Point
- Secure Store
- User Profile Service
- Search
In each of these cases the upgrade method is the
same. Restore a copy of your SharePoint 2010 database into your
SharePoint 2013’s SQL instance and start the service instance. Then
create a new version of the service application in your SharePoint 2013
farm with PowerShell and point it at the restored database. When the
service application is created, it will see a database is already there
and upgrade it. When the service application is created it will have
all the settings or content from the SharePoint 2010 version, depending
on the individual service app. Because each service app behaves just a
little differently, let’s take a look at each one.
Business Connectivity Services
If any entities were defined in your
SharePoint 2010 Business Connectivity Services (BCS) service
application it’s easy to bring them over to your new SharePoint 2013
farm. Following are the steps to upgrade your SharePoint 2010 BCS
database to SharePoint 2013:
1. Restore the
BCS database into your SharePoint 2013 SQL instance. The identity that
the service app app pool runs as will need to be given the db_owner
role on the database.
2. Start the
Business Connectivity Services service instance. You can do this in
Central Admin by selecting Application Management ⇒ Manage Services on
Server, or with the following PowerShell snippet:
Get-SPServiceInstance | where-object {$_.TypeName -eq "Business Data
Connectivity Service"} | Start-SPServiceInstance
3. Create the
BCS service application with PowerShell. The PowerShell assumes you
have a service app app pool named “Default SharePoint Service App
Pool.” If your app pool name is different, adjust it accordingly. It
also assumes the database from your SharePoint 2010 farm was named
BusinessConnectivityDB.
# Start the service instance
$serviceapppool = Get-SPServiceApplicationPool "Default SharePoint Service App
Pool"
# Create the service application
$bcsapp = New-SPBusinessDataCatalogServiceApplication -Name "Business Connectivity
Service" -ApplicationPool $serviceapppool -DatabaseName "BusinessConnectivyDB"
4. When the service application is created it creates its own proxy, so you don’t need to create one with PowerShell.
Managed Metadata
While the Managed Metadata service
(MMS) was new to SharePoint 2010, organizations were quick to adopt it.
In order to bring all those terms over to your SharePoint 2013 farm you
can upgrade your SharePoint 2010 MMS database. Following are
instructions on how to introduce all those tasty terms to your
SharePoint 2013 farm:
1. Restore the
MMS database into your SharePoint 2013 SQL instance. The identity that
the service app app pool runs as will need to be given the db_owner
role on the database.
2. Start the
Managed Metadata Services service instance. You can do this in Central
Admin by selecting Application Management ⇒ Manage Services on Server,
or with the following PowerShell snippet:
Get-SPServiceInstance | where-object {$_.TypeName -eq "Managed Metadata Web
Service"} | Start-SPServiceInstance
3. Create the
MMS service application with PowerShell. The PowerShell assumes you
have a service app app pool named “Default SharePoint Service App
Pool.” If your app pool name is different, adjust it accordingly. It
also assumes the database from your SharePoint 2010 farm was named
ManagedMetadataDB.
# Start the service instance
$serviceapppool = Get-SPServiceApplicationPool "Default SharePoint Service App
Pool"
# Create the service application
$mmsapp = New-SPMetadataServiceApplication -Name "Managed Metadata Service" -
ApplicationPool $serviceapppool -DatabaseName "ManagedMetadataDB"
# Create the servce proxy
New-SPMetadataServiceApplicationProxy -Name "Managed Metadata Service Proxy" -
ServiceApplication $mmsapp -DefaultProxyGroup
When you open the MMS management page in Central Admin, you should see all the terms from your SharePoint 2010 farm.
PerformancePoint
The PerformancePoint service
application can also be updated to SharePoint 2013. Following are the
instructions for bringing it over from your SharePoint 2010 farm:
1. Restore the
PerformancePoint database into your SharePoint 2013 SQL instance. The
identity that the service app app pool runs as will need to be given
the db_owner role on the database.
2. Start the
Managed Metadata Services service instance. You can do this in Central
Admin by selecting Application Management ⇒ Manage Services on Server,
or with the following PowerShell snippet:
Get-SPServiceInstance | where-object {$_.TypeName -eq "PerformancePoint Service" }
| Start-SPServiceInstance
3. Create the
PerformancePoint service application with PowerShell. The PowerShell
assumes you have a service app app pool named “Default SharePoint
Service App Pool.” If your app pool name is different, adjust it
accordingly. It also assumes the database from your SharePoint 2010
farm was named PerformancePointDB.
# Start the service instance
$serviceapppool = Get-SPServiceApplicationPool "Default SharePoint Service App
Pool"
# Create the service application
$perfpointapp = New- SPPerformancePointServiceApplication -Name "Performance Point
Service" -ApplicationPool $serviceapppool -DatabaseName "PerformancePointDB"
# Create the servce proxy
New- SPPerformancePointServiceApplicationProxy -Name "Performance Point Service
Proxy" -ServiceApplication $ perfpointapp -DefaultProxyGroup
Search
SharePoint 2010 contained two
SharePoint Search service applications. There was the bare-bones Search
that came with SharePoint Foundation, and there was the full-blown
Search service application that came with SharePoint Server 2010. It is
only possible to upgrade the SharePoint Services Search service
application. If you’re upgrading from SharePoint 2010 Foundation to
SharePoint 2013 Foundation, you have to build it all from scratch.
While that’s a tough pill to swallow, there is a silver lining. It will
be a brand-new Search service application and there won’t be any cruft
from the old Search messing things up. It will even have that new
service application smell.
SharePoint Server 2010 had three databases in its
stable; the Administration database, the Property database, and the
Crawl database. Of these, only the Administration database can be
brought over to SharePoint 2013. It contains all the settings and
configuration, so it’s the only one that offers any value to a new
farm. The steps for upgrading the Search Administration database are
similar to the steps for upgrading the other service applications, but
they require a little more PowerShell:
1. Restore the
Search Administration database into your SharePoint 2013 SQL instance.
The identity that the service app app pool runs as will need to be
given the db_owner role on the database.
2. Start the
Search Service service instance. Unlike the other service instances,
you cannot do this in Central Admin. It must be done in PowerShell. The
following snippet will do:
$SearchInstance = Get-SPEnterpriseSearchServiceInstance
Start-SPServiceInstance $SearchInst
3. Now create
the Search service application with PowerShell. The PowerShell assumes
you have a service app app pool named “Default SharePoint Service App
Pool.” If your app pool name is different, adjust it accordingly. It
also assumes the database from your SharePoint 2010 farm was named
Search_AdminDB, and the SQL instance is named SharePointSQL.
# Get the app pool and service instance
$serviceapppool = Get-SPServiceApplicationPool "Default SharePoint Service App
Pool"
$SearchInstance = Get-SPEnterpriseSearchServiceInstance
# Create the Search Service application by restoring the old Admin database
Restore-SPEnterpriseSearchServiceApplication -Name "Search Service Application" -
applicationpool $serviceapppool -databasename "Search_AdminDB" -databaseserver
"SharePointSQL" -AdminSearchServiceInstance $SearchInstance
# Create the service proxy
$ssa = Get-SPEnterpriseSearchServiceApplication
New-SPEnterpriseSearchServiceApplicationProxy -Name "Search Service Proxy" -
SearchApplication $ssa
# Add the proxy to the default proxy group
$SearchProxy = Get-SPEnterpriseSearchServiceApplicationProxy
Add-SPServiceApplicationProxyGroupMember –member $SearchProxy -identity " "
Secure Store
Upgrading the Secure Store service
application for SharePoint 2010 allows you to keep all the identify
mappings that you were using. These are usually used in conjunction
with other service applications. Because the contents of the Secure
Store database wouldn’t be very secure if you could restore it without
the encryption key it was encrypted with when it was created, you’ll
need that in order for the upgrade to work. Here are the steps to
upgrade your Secure Store database:
1. Restore the
Secure Store database into your SharePoint 2013 SQL instance. Be sure
to give the identity under which your service application app pool is
running the db_owner role in the database.
2. Start the
Secure Store service instance on one or more servers in your farm. You
can do this from Central Admin by selecting Application Management ⇒
Manage Services on Server, or with the following PowerShell:
Get-SPServiceInstance | Where-Object { $_.TypeName -eq "Secure Store Service" } |
Start-SPServiceInstance
3. Create the
Secure Store service application. The following PowerShell assumes you
have a service app app pool named “Default SharePoint Service App
Pool.” If your app pool name is different, adjust it accordingly. It
also assumes the database from your SharePoint 2010 farm was named
SecureStoreDB and your passphrase was pass@word1:
# Get the service application pool
$serviceapppool = Get-SPServiceApplicationPool "Default SharePoint Service App
Pool"
# Create the service application
$securestoreapp = New-SPSecureStoreServiceApplication -Name "Secure Store Service"
-ApplicationPool $serviceapppool -DatabaseName "SecureStoreDB"
# Create the service proxy
$securestoreproxy = New-SPSecureStoreApplicationProxy -Name "Secure Store Service
Proxy" -ServiceApplication $securestoreapp -DefaultProxyGroup
# Restore the passphrase
Update-SPSecureStoreApplicationServerKey -Passphrase "pass@word1" -
ServiceApplicationProxy $securestoreproxy
You now have a Secure Store service application
in SharePoint 2013 that contains all the credentials it had in your
SharePoint 2010 farm.
User Profile Service
It shouldn’t come as a surprise to
anyone that the User Profile Service (UPS) is a little more trouble
than the other service apps. It does have a certain reputation to
maintain, after all. Before upgrading your UPS service application,
make sure your MMS service application has upgraded correctly. The UPS
uses the MMS to store terms, so they should be in place before you
bring the upgraded UPS online.
The SharePoint 2010 UPS used three databases:
Profile, Social, and Sync. Only the Profile and Social databases
support being upgraded. The Sync database is scratch space for the UPS
while it’s doing imports and exports, so it doesn’t contain any useful
information to upgrade. Use the following steps to bring your
SharePoint 2010 profile information into your SharePoint 2013 farm:
1. Restore the
UPS Profile and optionally the UPS Social databases into your
SharePoint 2013 SQL instance. The identity under which the service app
app pool runs needs to be given the db_owner role on the database.
2. The UPS has
two service instances: the User Profile Service and the User Profile
Sync Service. You only want to start the former before you create the
service application. You can do this in Central Admin by selecting
Application Management ⇒ Manage Services on Server, or with the
following PowerShell snippet:
Get-SPServiceInstance | where-object {$_.TypeName -eq "User Profile Service" } |
Start-SPServiceInstance
3. Create the
UPS service application with PowerShell. The following PowerShell
assumes you have a service app app pool named “Default SharePoint
Service App Pool.” If your app pool name is different, adjust it
accordingly. It also assumes the Profile DB from your SharePoint 2010
farm was named UserProfile_ProfileDB, and your Social DB was named
UserProfile_SocialDB.
# Get the service app app pool
$serviceapppool = Get-SPServiceApplicationPool "Default SharePoint Service App
Pool"
# Create the service application
$upa = New-SPProfileServiceApplication -Name "User Profile Service"
-ApplicationPool $ serviceapppool -ProfileDBName "UserProfile_ProfileDB"
-SocialDBName "UserProfile_SocialDB" -ProfileSyncDBName "UserProfile_SyncDB"
# Create the service proxy
New-SPMetadataServiceApplicationProxy -Name "User Profile Service Proxy" -
ServiceApplication $upa -DefaultProxyGroup
4. The User
Profile Service’s Profile and Social databases should reflect the
content that was in SharePoint 2010.
