Sync Framework Team Blog

SQL Azure Data Sync Service Update

Mark Scurrell — Mon, 21 Nov 2011 00:32:00 GMT

Thanks for trying out our Preview version and sending us suggestions and feedback. We released a minor service update a few days ago based on the input we have received so far.

Some of the important changes in this update are:

Log-ins with either username@server or just username are accepted.
Column names with spaces are now supported.
Columns with a NewSequentialID constraint are converted to NewID for SQL Azure databases in the sync group.
Administrators and non-Administrators alike are able to install the Data Sync Agent.
A new version of the Data Sync Agent is now available on the Download Center, but if you already have the Preview version of the Data Sync Agent it will continue to work.

More SQL Azure Data Sync Webcasts on Channel 9

Mark Scurrell — Sat, 19 Nov 2011 16:21:41 GMT

A quick note to let you know that there are two more webcasts posted on Channel 9! We've also created a series on the Channel 9 web site so you can easily see all our available webcasts by using the following URL - http://channel9.msdn.com/Series/SQL-Azure-Data-Sync

The latest two webcasts are presented by Sudhesh. In one webcast Sudhesh digs into more detail about setting up sync between on-premises SQL Server and SQL Azure; in the other he focuses on sync'ing between SQL Azure databases. He goes into more detail than I did with my overview presentation.

Next up I'm going to do a webcast covering database provisioning - how Data Sync creates the database tables on the member databases, that you have the option to create the database tables yourself, and why that may be preferable.

Thanks, Mark

SQL Azure Data Sync Webcast Overview

Mark Scurrell — Sat, 29 Oct 2011 01:25:00 GMT

I've just posted the first in a series of webcasts for SQL Azure Data Sync over on Channel 9 here.

This first webcast provides a high-level overvew of the service. There's a couple of slides to introduce the service, but most of the webcast is a demo of the service.

Here's what we've got planned for future webcasts:

More detailed walkthroughs for syncing between local SQL Server and SQL Azure as well as between SQL Azure databases.
Scenarios where you can use Data Sync in conjunction with other services, such as Reporting Services.
Deep dives into specific areas, such as filtering, provisioning, security considerations, best practices, conflicts, and so on.

Feel free to leave a comment with topics you'd like to see us cover in future webcasts.

It's been a few weeks now since we released the Data Sync Preview. If you've been using the service then please provide us feedback using the feature voting site here. If you haven't tried out CTP3, then why not? :-)

Thanks, Mark

SQL Azure Data Sync Preview is now available

_RussH — Thu, 13 Oct 2011 18:35:00 GMT

We are pleased to announce the availability of SQL Azure Data Sync Preview. The Preview does not require a registration code and is available to anyone who has a SQL Azure account.

Improvements for the Preview release include:

Now hosted on the Windows Azure Management site - https://windows.azure.com.
A completely redesigned UI which makes performing common tasks easy, straight-forward and intuitive. The UI includes tutorials and Help within the UI.
Richer sync group configuration options:

Synchronization schedules from 5 minutes to 1 month, and anywhere in between.
Settable conflict resolution policy.
More granular definition of synchronization data sets - down to the table and row level.

Synchronization direction selectable for each database.

Unfortunately we have not been able to add the functionality to update sync group configuration when the schema changes. We intend to add this functionality in a future service release.

During the Preview, like the previous CTPs, using the service is free – though there are the normal Windows Azure and SQL Azure charges. Pricing for the production version has not yet been announced.

Data Sync Preview is not backwardly compatible with CTP2. If you are upgrading from CTP2 you need to remove all databases from the CTP2 sync groups, de-provision each database using deprov.exe, delete all CTP2 sync groups, and uninstall the CTP2 client agent.

The CTP2 site will be taken down in a few weeks. The sooner you upgrade the better.

For More Information

Check out the SQL Azure Data Sync post on Windows Azure blog.

Other sites you may want to check out

Windows Azure Management Portal.
Documentation for the Preview on the SQL Azure Data Sync TechNet wiki.
Client Agent Preview download.
Suggest or vote for new features on the Feature Voting Forum.
Ask questions using the SQL Azure MSDN Forum.
Log a bug at the SQL Server and SQL Azure Connect site.

Give it a try. We think you will like it.

Sync Framework Toolkit now available for download

Sreedhar Pelluru — Sat, 10 Sep 2011 01:58:00 GMT

The Sync Framework Toolkit extends the Sync Framework capabilities for building offline applications, making it easier to expose data for synchronization to applications running on any client platform. Sync Framework 2.1 required clients to be based on Windows. This toolkit allows other Microsoft platforms to be used for offline clients such as Silverlight, Windows Phone 7, and Windows Mobile; in addition, non-Microsoft platforms such as iPhone, Android, and Blackberry can be utilized as well as HTML.

The Sync Framework Toolkit provides all the features enabled by the Sync Framework 4.0 October 2010 CTP. We are releasing the toolkit as source code samples on MSDN with the source code utilizing Sync Framework 2.1. Source code provides the flexibility to customize or extend the capabilities we have provided to suit your specific requirements. The client-side source code in the package is released under the Apache 2.0 license and the server-side source code under the MS-LPL license.

The toolkit is available for download on MSDN at: http://code.msdn.microsoft.com/Sync-Framework-Toolkit-4dc10f0e. After you extract files from the package, you will see a Visual Studio solution in the SRC folder that let you build the toolkit on your computer.

We will keep the forum used for Sync Framework V4 CTP available for community discussion and community support.

SQL Azure Data Sync Update

liamca — Tue, 08 Mar 2011 19:33:00 GMT

It’s been a while since we announced SQL Azure Data Sync CTP2 and I wanted to provide an update on how CTP2 is progressing as well as an update on the service in general.

Late last year at PDC we announced CTP2 and started accepting registrations for access to the preview release. In mid-December we started providing access to the service and have continued to work our way through the registrations, adding more users. We recently made a few updates to the service as a direct result of feedback we’ve received; bug fixes and a number of usability enhancements.

We’ve seen huge interest in CTP2, so much so that we may not be able to give everyone who registered access to the preview. We are going to continue to process registrations throughout March, but for those of you that do not get access we will be releasing CTP3 this summer and will make that preview release open to everyone. Feel free to continue to register for CTP2 as that will allow us to email you as soon as CTP3 becomes available.

While on the subject of CTP3, here are some of the new features planned:

A new user interface integrated with the Windows Azure portal.
The ability to select a subset of columns to sync as well as to specify a filter so that only a subset of rows are synced.
The ability to make certain schema changes to the database being synced without having to re-initialize the sync group and re-sync the data.
Conflict resolution policy can be specified.
General usability enhancements.

CTP3 will be the last preview, before the final release later this year. We’ll announce the release dates on this blog when available.

Finally, here are some links that may be helpful:

To ask questions, report problems and provide feedback on SQL Azure Data Sync CTP2, use the SQL Azure forum: http://social.msdn.microsoft.com/forums/en-US/ssdsgetstarted/threads/
To submit new feature requests or vote on existing feature requests: http://www.mygreatwindowsazureidea.com/forums/44459-sql-azure-data-sync-feature-voting
To register for access to CTP2 and be notified about CTP3: http://go.microsoft.com/fwlink/?LinkID=204776&clcid=0x409

Best wishes, Mark

Synchronization Services for ADO .NET for Devices: Improving performance by skipping tables that don’t need synchronization

Sreedhar Pelluru — Wed, 02 Mar 2011 22:01:00 GMT

Performance is an important factor when you synchronize databases that consist of large number of tables. One way to improve performance is to identify tables that have no data to synchronize and exclude them from the synchronization process.

SqlCeClientProvider performs some processing for every table you request to be synchronized irrespective of whether the table has changed data or not. For a table full of changed data, this processing time is minimal compared to the time required for the actual synchronization. However, for a table with nothing to synchronize, the processing time is an overhead because it is the time that does not need to be spent. In fact, this overhead could affect performance of overall synchronization process significantly if there are large numbers of tables that have no changed data. Therefore, you should identify tables that have no data to synchronize and exclude them from the synchronization process to improve performance.

In a test we conducted in our labs, we used a database with 100 tables, out of which only 10 contained the changed data (200 rows inserted into each) that need to be synchronized. By skipping the other 90 tables during synchronization process, the overall synchronization time was reduced by 75-80%.

There are many ways to detect the changed tables on both server side and the client side. The following example code demonstrates one way to do this.

Construct sync agent's sync group with tables that have changed data:

private SyncAgent PrepareAgent(List<SyncTable> clientTables)

{

SyncGroup agentGroup = new SyncGroup("ChangedGroup");

SyncAgent changedAgent = new SyncAgent();

foreach (SyncTable table in clientTables)

{

table.SyncGroup = agentGroup;

changedAgent.Configuration.SyncTables.Add(table);

}

return changedAgent;

}

Get changed tables from local client database:

private List<SyncTable> GetChangedTablesOnClient()

{

// Initialize the list of tables to synchronize

List<SyncTable> tables = new List<SyncTable>();

// Open connection to the database

if (clientSyncProvider.Connection.State == System.Data.ConnectionState.Closed)

{

clientSyncProvider.Connection.Open();

}

// Prepare Command

SqlCeCommand command = new SqlCeCommand();

command.Connection = (SqlCeConnection)clientSyncProvider.Connection;

command.Parameters.Add(new SqlCeParameter("@LCSN", System.Data.SqlDbType.BigInt));

// Retreive changed tables

foreach (string tableName in this.clientTables.Keys)

{

// Build a command for this table

command.CommandText = GetQueryString("[" + tableName + "]");

// Execute the command

long lcsn = GetLastSyncCsn(command.Connection, tableName);

command.Parameters["@LCSN"].Value = lcsn;

int result = (int)command.ExecuteScalar();

// If the table contains changed data

if (result > 0)

{

// then add it to the synchronization list

tables.Add(this.clientTables[tableName]);

}

command.Dispose();

return tables;

}

private string GetQueryString(string tableName)

{

return String.Format(@"select count(*) from {0} Tbl where (((Tbl.__sysInsertTxBsn IS NOT NULL) AND ((Tbl.__sysInsertTxBsn NOT IN (select __sysTxBsn from __sysTxCommitSequence) AND Tbl.__sysInsertTxBsn > @LCSN) OR (exists(select __sysTxBsn from __sysTxCommitSequence where Tbl.__sysInsertTxBsn = __sysTxBsn AND __sysTxCsn > @LCSN))))

OR ((Tbl.__sysChangeTxBsn IS NOT NULL) AND ((Tbl.__sysChangeTxBsn NOT IN (select __sysTxBsn from __sysTxCommitSequence) AND Tbl.__sysChangeTxBsn > @LCSN) OR (exists(select __sysTxBsn from __sysTxCommitSequence where Tbl.__sysChangeTxBsn = __sysTxBsn AND __sysTxCsn > @LCSN)))))", tableName);

}

private long GetLastSyncCsn(SqlCeConnection connection, string tableName)

{

SqlCeCommand command = null;

SqlCeDataReader reader = null;

long num3;

long num = 0L;

try

{

command = new SqlCeCommand();

command.Connection = connection;

command.CommandText = string.Format("select SentAnchor from {0} Where TableName = @tablename", "__sysSyncArticles");

command.Parameters.AddWithValue("@tablename", tableName);

reader = command.ExecuteReader();

bool flag = true;

byte[] buffer = new byte[60];

while (reader.Read())

{

if (!reader.IsDBNull(0))

{

reader.GetBytes(0, 0L, buffer, 0, 8);

long num2 = BitConverter.ToInt64(buffer, 0);

if (flag)

{

num = num2;

}

flag = false;

if (num2 < num)

{

num = num2;

}

num3 = num;

}

finally

{

if (command != null)

{

command.Dispose();

}

if (reader != null)

{

reader.Dispose();

}

return num3;

}

Get the changed tables from the server side

// service method

public Collection<string> GetServerChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession)

{

Collection<string> tables = new Collection<string>();

SyncContext changes = _serverSyncProvider.GetChanges(groupMetadata, syncSession);

if (changes.DataSet.Tables.Count > 0)

{

foreach (DataTable table in changes.DataSet.Tables)

{

if (table.Rows.Count > 0)

{

tables.Add(table.TableName);

}

return tables;

}

// client side methods to get the server changes by calling

// the service proxy method

private string[] GetServerChanges()

{

SyncGroupMetadata metaData = this.GetMetadata();

SyncSession session = new SyncSession();

session.ClientId = clientSyncProvider.ClientId;

return this.proxyExtension.GetServerChanges(metaData, session);

}

private SyncGroupMetadata GetMetadata(Collection<string> clientTables)

{

SyncGroupMetadata groupMetadata = new SyncGroupMetadata();

foreach (string tableName in clientTables)

{

SyncTableMetadata tableMetadata = new SyncTableMetadata();

tableMetadata.LastReceivedAnchor = clientSyncProvider.GetTableReceivedAnchor(tableName);

tableMetadata.TableName = tableName;

groupMetadata.TablesMetadata.Add(tableMetadata);

}

return groupMetadata;

}

Clarifying Sync Framework and SQL Server Compact Compatibility

LarenC_MSFT — Thu, 16 Dec 2010 19:20:30 GMT

http://j.mp/hpmQ4c

Sync Framework and SQL Server Compact install with several versions of Visual Studio and SQL Server, and each version of Sync Framework is compatible with different versions of SQL Server Compact. This can be pretty confusing!

This article on TechNet Wiki clarifies which versions of Sync Framework are installed with Visual Studio and SQL Server, lays out a matrix that shows which versions of SQL Server Compact are compatible with each version of Sync Framework, and walks you through the process of upgrading a SQL Server Compact 3.5 SP1 database to SQL Server Compact 3.5 SP2.

Sync Framework Tips and Troubleshooting on TechNet Wiki

LarenC_MSFT — Wed, 01 Dec 2010 19:17:59 GMT

http://j.mp/f1TQLi

I've started an article on the Technet Wiki that collects usage tips and troubleshooting for Sync Framework. This can be the first place you look when you have a nagging question that isn't answered anywhere else.

Some tips already collected are recommendations about how to speed up initialization of multiple SQL Server Compact databases, how to find the list of scopes currently provisioned to a database, and how to improve the performance of large replicas for file synchronization.

It's a wiki, so you can add to it! If the answer you need isn't in the article, or if you have more to say about a tip that's already in the article, post what you know. By sharing our knowledge, we can all make Sync Framework even more useful for everyone.

Check out the article, and share your tips: http://j.mp/f1TQLi!

Sync Framework 4.0 October 2010 CTP Refreshed on 11/16

Sreedhar Pelluru — Tue, 16 Nov 2010 22:45:00 GMT

We just refreshed the Sync Framework 4.0 CTP bits to add the following two features:

Tooling Wizard UI: This adds a UI wizard on top of the command line based SyncSvcUtil utility. This wizard allows you to select tables, columns, and even rows to define a sync scope, provision/de-provision a database and generate server-side/client-side code based on the data schema that you have. This minimizes the amount of code that you have to write yourself to build sync services or offline applications. This Tooling Wizard can be found at: C:\Program Files (x86)\Microsoft SDKs\Microsoft Sync Framework\4.0\bin\SyncSvcUtilHelper.exe.

iPhone Sample: This sample shows you how to develop an offline application on iPhone/iPad with SQLite for a particular remote schema by consuming the protocol directly. The iPhone sample can be found at: C:\Program Files (x86)\Microsoft SDKs\Microsoft Sync Framework\4.0\Samples\iPhoneSample.

More information about this release:

Download: The refreshed bits can be found at the same place of the public CTP released at PDC. You can find the download instructions at: here.
Documentation: We also refreshed the 4.0 CTP Documentation online at MSDN at: here.
PDC Session: To learn more about this release 4.0 in general, take a look at our PDC session recording "Building Offline Applications using Sync Framework and SQL Azure".

<In this release, we decided to bump the version of all binaries to 4.0, skipping version 3.0 to keep the version number consistent across all components.>

Updated Sync Framework 4.0 CTP Documentation

Sreedhar Pelluru — Tue, 16 Nov 2010 00:17:00 GMT

The Sync Framework 4.0 CTP documentation on MSDN library (http://msdn.microsoft.com/en-us/library/gg299051(v=SQL.110).aspx) has been updated. It now includes the documentation for the SyncSvcUtilHelper UI tool, which is built on top of the SyncSvcUtil command-line tool. This UI tool exposes all the functionalities supported by the command-line tool. In addition, it lets you create or edit a configuration file that you can use later to provision/deprovision SQL Server/SQL Azure databases and to generate server/client code.

Announcing SQL Azure Data Sync CTP2

liamca — Thu, 28 Oct 2010 18:23:00 GMT

Earlier this week I mentioned that we will have one additional sync session at PDC that would open up after the keynote. Now that the keynote is complete, I am really excited to point you to this session “Introduction to SQL Azure Data Sync” and tell you a little more about what was announced today.

In the keynote today, Bob Muglia announced an update to SQL Azure Data Sync (called CTP2) to enable synchronization of entire databases or specific tables between on-premises SQL Server and SQL Azure, giving you greater flexibility in building solutions that span on-premises and the cloud.

As many of you know, using SQL Azure Data Sync CTP1, you can now synchronize SQL Azure database across datacenters. This new capability will allow you to not only extend data from your on-premises SQL Servers to the cloud, but also enable you to easily extend data to SQL Servers sitting in remote offices or retail stores. All with NO-CODING required!

Later in the year, we will start on-boarding customers to this updated CTP2 service. If you are interested in getting access to SQL Azure Data Sync CTP2, please go here to register.If you would like to learn more and see some demonstrations of how this will work and some of the new features we have added to SQL Azure Data Sync, please take a look at my PDC session recording. Here is the direct video link and abstract.

Video: Introduction to SQL Azure Data Sync (Liam Cavanagh) – 27 min

In this session we will show you how SQL Azure Data Sync enables on-premises SQL Server data to be easily shared with SQL Azure allowing you to extend your on-premises data to begin creating new cloud-based applications. Using SQL Azure Data sync’s bi-directional data synchronization support, changes made either on SQL Server or SQL Azure are automatically synchronized back and forth. Next we show you how SQL Azure Data Sync provides symmetry between SQL Azure databases to allow you to easily geo-distribute that data to one or more SQL Azure data centers around the world. Now, no matter where you make changes to your data, it will be seamlessly synchronized to all of your databases whether that be on-premises or in any of the SQL Azure data centers.

Liam Cavanagh

Announcing Sync Framework 4.0 October 2010 CTP

Sreedhar Pelluru — Wed, 27 Oct 2010 23:48:00 GMT

We are extremely happy to announce the availability of Sync Framework 4.0 October 2010 CTP. To learn more about this release please take a look at our PDC session recording "Building Offline Applications using Sync Framework and SQL Azure".

The Microsoft Sync Framework 4.0 October 2010 CTP is built on top of Sync Framework 2.1 and it extends the Sync Framework capabilities of building offline application to any client platform that is capable of caching data. The release enables synchronization of data stored in SQL Server/SQL Azure over an open standard network format by a remote synchronization service handling all sync specific logic. Moving all synchronization logic off the client enables clients, which do not have the Sync Framework runtime installed, to cache data and participate in a synchronization topology. Earlier versions of Sync Framework required Windows systems with Sync Framework runtime installed on them as clients. This CTP allows other Microsoft platforms such as Silverlight, Windows Phone 7, and Windows Mobile and non-Microsoft platforms such as HTML5, iPhone, Android and other devices with no Sync Framework runtime installed on them as clients.

The major new features included in this CTP are:

Protocol: In this release, we apply the principles of OData to the problem of data-sync and add synchronization semantics to the protocol format. Clients and the service use the protocol to perform synchronization, where a full synchronization is performed the first time subsequently followed by smaller incremental synchronization. The protocol is designed with the goal to make it easy to implement the client-side of the protocol and all the synchronization logic will be running on the service side. It is intended to be used to enable synchronization for a variety of sources including, but not limited to, relational databases and file systems.
Server and Client Components: The release includes server components that make it easy for you to build a synchronization Web service that exposes data from SQL Server or SQL Azure via the Sync protocol. The CTP release includes client component’s that make it easy for you to build offline applications on Silverlight for desktop and Windows Phone 7 platforms.
SyncSvcUtil.exe utility: The release includes a command-line tool, SyncSvcUtil.exe, which helps you with defining and developing sync services and clients.
Business Logic Extensibility on Server: The release allows you to plug in to the synchronization runtime on the service and enable custom business logic configuration using SyncInterceptors.
Diagnostic Dashboard: The release supports a diagnostic dashboard to diagnose the health of the deployed sync services.
Samples and Tutorials: The CTP ships with samples that include a sample service exposing a ToDo list data model as a synchronization service. It also ships the Silverlight, Windows Phone 7, Windows Mobile 6.5 and HTML5 clients that synchronize with the service to show you how to use the components and the protocol. The documentation for CTP contains tutorials, which walk you through creating and consuming a sync service that you can deploy to an on-premise Windows Server or Windows Azure.

The following features will be available in few weeks after PDC10 as a refresh to this release. We will keep you updated on this release on Sync Framework forums and Sync Framework Blog. (Update on 11/16, we just refreshed the bits with the two new features!)

Tooling Wizard UI: This adds a UI wizard on top of the command line based SyncSvcUtil utility. This wizard allows you to select tables, columns, and even rows to define a sync scope, provision/de-provision a database and generate server-side/client-side code based on the data schema that you have. This minimizes the amount of code that you have to write yourself to build sync services or offline applications.
iPhone Sample: This sample shows you how to develop an offline application on iPhone/iPad with SQLite for a particular remote schema by consuming the protocol directly.

For more details please visit

Microsoft download center at: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=afd89099-d589-423c-9762-78096aa95ac2&displaylang=en
MSDN library at: http://msdn.microsoft.com/en-us/library/dd938837(SQL.10).aspx.

(In this release we decided to bump the version of all binaries to 4.0, skipping version 3.0 to keep the version number consistent across all components in the release.)

Improved Sync Framework 2.1 Documentation Released

LarenC_MSFT — Fri, 22 Oct 2010 22:46:25 GMT

http://j.mp/9eWpJq

We have improved the Sync Framework 2.1 documentation. This update includes new and better information in the following database synchronization topics:

Provisioning
Scopes
Intercepting and changing data during synchronization
Improvements to walkthroughs
Deploying to Windows Azure

We've also reorganized and rewritten many topics to help you more easily find and understand what you need to know to use Sync Framework.

Go here to read the improved documentation: http://j.mp/9eWpJq

Don't have Sync Framework 2.1? Download it today: http://j.mp/a3t6rJ

PDC Conference Sessions

liamca — Thu, 21 Oct 2010 23:14:56 GMT

The Professional Developer Conference (PDC) is fast approaching and I wanted to point you to a few sync related sessions that we have at the event. This year's conference will include live streaming of the keynotes, as well as concurrent live streaming of sessions. If you can’t join the live stream, you can still watch the video on-demand, or download all the content within 24 hours of live recording. The online event is free; no registration is required to join the live or on-demand stream.

At this conference we have two sync sessions (you can see a full list of the sessions here) including one additional one by myself that will be added to the session list after the keynote announcements :-). Here is a list of the sessions currently listed:

Building Offline Applications using the Sync Framework and SQL Azure (Nina Hu)
In this session you will learn how to build a client application that operates against locally stored data and uses synchronization to keep up-to-date with a SQL Azure database. See how Sync Framework can be used to build caching and offline capabilities into your client application, making your users productive when disconnected and making your user experience more compelling even when a connection is available. See how to develop offline applications for Windows Phone 7 and Silverlight, plus how the services support any other client platform, such as iPhone and HTML5 applications, using the open web-based sync protocol.

Connecting Cloud & On-Premises Apps with the Windows Azure Platform (Yousef Khalidi)
Not every application or service can be hosted entirely in the cloud. Cloud services often need to provide a combination of cloud-based data access as well as connectivity to on-premises assets in a variety of geographies. Getting access to your on-premises or partner hosted assets securely has never been easier. In this session, learn how to securely connect applications today that span the cloud to on-premises world using Windows Azure AppFabric Service Bus and SQL Azure Data Sync Service. Also, gain insight into future scenarios and technologies for assembling these types of services.

Liam

Windows Azure Sync Service Sample Available for Download

LarenC_MSFT — Thu, 07 Oct 2010 19:11:00 GMT

The Windows Azure Sync Service Sample is a complete sample that shows you how to extend the reach of your data to anyone that has an Internet connection. The sample uses Microsoft Sync Framework 2.1 deployed to a Windows Azure Hosted Service, so your data extends even to users who have a poor or intermittent connection because the data needed by the user is kept on the user's local computer and synchronized with the server database only when needed.

Download: http://j.mp/bibIdl.

The typical scenario for this sample is when you have data that is stored in a SQL Azure database and you want to allow remote users to have access to this data but you don't want to allow users to connect directly to your SQL Azure database. By creating a middle tier that runs as a Windows Azure Hosted Service, client applications connect to your hosted service, and the service connects to your SQL Azure database, providing a layer of security and business logic between the client and the server. Client applications can create a synchronization relationship with your server database, take their data offline, and synchronize changes back to the server database when a connection is available. In this way, client applications operate seamlessly even when the Internet connection is unreliable.

Why Deploy to Windows Azure Hosted Service?

Deploying Sync Framework in a middle tier component as a Windows Azure Hosted Service gives the following benefits:

Security: No need to allow users direct access to your SQL Azure database. You control the middle tier, so you control exactly what flows in and out of your database.
Business rules: The middle tier allows you to modify the data that flows between the server database and the client, enforcing any rules that are peculiar to your business.
Ease of connection: The hosted service in this sample uses Windows Communication Foundation (WCF) to communicate between the client and the middle tier component, allowing a flexible and standard way of communicating commands and data.

The sample is a 3-tier application that includes these components:

SyncServiceWorkerRole: a Windows Azure worker role that runs in the middle tier. This component handles the majority of synchronization operations and communicates with the web role component by using a job queue and blob storage.
WCFSyncServiceWebRole: a Windows Azure web role that runs in the middle tier combined with a proxy provider that runs in the client application. This component uses WCF to communicate between the proxy provider on the client and the web role on Windows Azure, and communicates with the worker role component by using a job queue and blob storage.
ClientUI: a Windows application that you use to establish a synchronization relationship between a SQL Server Compact database and the SQL Azure database. This component uses WCF to communicate with the web role component.

For a complete walkthrough of the sample, see Walkthrough of Windows Azure Sync Service Sample.

How to Sync Large SQL Server Databases to SQL Azure

liamca — Fri, 24 Sep 2010 16:02:37 GMT

Over the past few days I have seen a number of posts from people who have been looking to synchronize large databases to SQL Azure and have been having issues. In many of these posts, people have looked to use tools like SSIS, BCP and Sync Framework and have run into issues such as SQL Azure closing the transaction due to throttling of the connection (because it took to apply the data) and occasionally local out-of-memory issues as the data is sorted.

For today’s post I wanted to spend some time discussing the subject of synchronizing large data sets from SQL Server to SQL Azure using Sync Framework. By large database I mean databases that are larger than 500MB in size. If you are synchronizing smaller databases you may still find some of these techniques useful, but for the most part you should be just fine with the simple method I explained here.

For this situation, I believe there are three very useful capabilities within the Sync Framework:

1) MemoryDataCacheSize: This helps to limit the amount of memory that is allocated to Sync Framework during the creation of the data batches and data sorting. This typically helps to fix any out-of-memory issues. In general I typically allocate 100MB (100000) to this parameter as the best place to start, but if you have larger or smaller amounts of free memory, or if you still run out-of-memory, you can play with this number a bit.

RemoteProvider.MemoryDataCacheSize = 100000;

2) ApplicationTransactionSize (MATS): This tells the Sync Framework how much data to apply to the destination database (SQL Azure in this case) at one time. We typically call this Batching. Batching helps us to work around the issue where SQL Azure starts to throttle (or disconnect) us if it takes too long to apply the large set of data changes. MATS also has the advantage of allowing me to tell sync to pick up where it left off in case a connection drops off (I will talk more about this in a future post) and has the advantage that it provides me the ability to get add progress events to help me track how much data has been applied. Best of all it does not seem to affect performance of sync. I typically set this parameter to 50MB (50000) as it is a good amount of data that SQL Azure can commit easily, yet is small enough that if I need to resume sync during a network disconnect I do not have too much data to resend.

RemoteProvider.ApplicationTransactionSize = 50000;

3) ChangesApplied Progress Event: The Sync Framework database providers have an event called ChangesApplied. Although this does not help to improve performance, it does help in the case where I am synchronizing a large data set. When used with ApplicationTransactionSize I can tell my application to output whenever a batch (or chunk of data) has been applied. This helps me to track the progress of the amount of data that has been sent to SQL Azure and also how much data is left.

RemoteProvider.ChangesApplied += new EventHandler<DbChangesAppliedEventArgs>(RemoteProvider_ChangesApplied);

When I combine all of this together, I get the following new code that I can use to create a command line application to sync data from SQL Server to SQL Azure. Please make sure to update the connection strings and the tables to be synchronized.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data.SqlClient;

using Microsoft.Synchronization.Data.SqlServer;

using Microsoft.Synchronization.Data;

using Microsoft.Synchronization;

namespace SQLAzureDataSync

{

class Program

{

public static string sqlazureConnectionString = "Server=[Your SQL Azure Server].database.windows.net;Database=AdventureWorksLTSQLAzure;User ID=[Your SQL Azure User Name]@[Your SQL Azure Server];Password=[Your SQL Azure Password];Trusted_Connection=False;Encrypt=True;";

public static string sqllocalConnectionString = "Server=(local);Database=AdventureWorksLT2008;Trusted_Connection=True";

public static readonly string scopeName = "AllTablesSyncGroup";

public static int transactionCount;

public static uint BatchSize = 50000;

public static uint MemorySize = 100000;

static void Main(string[] args)

{

// Test if input arguments were supplied:

if (args.Length == 0)

{

System.Console.WriteLine("Please enter an argument.");

System.Console.WriteLine("Usage: SyncTest.exe -setup");

System.Console.WriteLine(" SyncTest.exe -sync");

}

else if (args[0] == "-setup")

Setup();

else if (args[0] == "-sync")

Sync();

}

public static void Setup()

{

try

{

SqlConnection sqlServerConn = new SqlConnection(sqllocalConnectionString);

SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);

DbSyncScopeDescription myScope = new DbSyncScopeDescription(scopeName);

DbSyncTableDescription TestSchema1 = SqlSyncDescriptionBuilder.GetDescriptionForTable("TestSchema1", sqlServerConn);

// Add the tables from above to the scope

myScope.Tables.Add(TestSchema1);

// Setup SQL Server for sync

SqlSyncScopeProvisioning sqlServerProv = new SqlSyncScopeProvisioning(sqlServerConn, myScope);

sqlServerProv.CommandTimeout = 60 * 30;

if (!sqlServerProv.ScopeExists(scopeName))

{

// Apply the scope provisioning.

Console.WriteLine("Provisioning SQL Server for sync " + DateTime.Now);

sqlServerProv.Apply();

Console.WriteLine("Done Provisioning SQL Server for sync " + DateTime.Now);

}

else

Console.WriteLine("SQL Server Database server already provisioned for sync " + DateTime.Now);

// Setup SQL Azure for sync

SqlSyncScopeProvisioning sqlAzureProv = new SqlSyncScopeProvisioning(sqlAzureConn, myScope);

if (!sqlAzureProv.ScopeExists(scopeName))

{

// Apply the scope provisioning.

Console.WriteLine("Provisioning SQL Azure for sync " + DateTime.Now);

sqlAzureProv.Apply();

Console.WriteLine("Done Provisioning SQL Azure for sync " + DateTime.Now);

}

else

Console.WriteLine("SQL Azure Database server already provisioned for sync " + DateTime.Now);

sqlAzureConn.Close();

sqlServerConn.Close();

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

public static void Sync()

{

try

{

SqlConnection sqlServerConn = new SqlConnection(sqllocalConnectionString);

SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);

SqlSyncProvider RemoteProvider = new SqlSyncProvider(scopeName, sqlAzureConn);

SqlSyncProvider LocalProvider = new SqlSyncProvider(scopeName, sqlServerConn);

//Set memory allocation to the database providers

RemoteProvider.MemoryDataCacheSize = MemorySize;

LocalProvider.MemoryDataCacheSize = MemorySize;

//Set application transaction size on destination provider.

RemoteProvider.ApplicationTransactionSize = BatchSize;

//Count transactions

RemoteProvider.ChangesApplied += new EventHandler<DbChangesAppliedEventArgs>(RemoteProvider_ChangesApplied);

SyncOrchestrator orch = new SyncOrchestrator();

orch.RemoteProvider = RemoteProvider;

orch.LocalProvider = LocalProvider;

orch.Direction = SyncDirectionOrder.UploadAndDownload;

Console.WriteLine("ScopeName={0} ", scopeName.ToUpper());

Console.WriteLine("Starting Sync " + DateTime.Now);

ShowStatistics(orch.Synchronize());

sqlAzureConn.Close();

sqlServerConn.Close();

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

public static void RemoteProvider_ChangesApplied(object sender, DbChangesAppliedEventArgs e)

{

transactionCount += 1;

int totalBytes = transactionCount * Convert.ToInt32(BatchSize);

Console.WriteLine("Changes Applied event fired: Transaction " + totalBytes+" bytes.");

}

public static void ShowStatistics(SyncOperationStatistics syncStats)

{

string message;

message = "\tSync Start Time :" + syncStats.SyncStartTime.ToString();

Console.WriteLine(message);

message = "\tSync End Time :" + syncStats.SyncEndTime.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Applied :" + syncStats.UploadChangesApplied.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Failed :" + syncStats.UploadChangesFailed.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Total :" + syncStats.UploadChangesTotal.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Applied :" + syncStats.DownloadChangesApplied.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Failed :" + syncStats.DownloadChangesFailed.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Total :" + syncStats.DownloadChangesTotal.ToString();

Console.WriteLine(message);

}

Liam Cavanagh

Extending SQL Azure data to SQL Compact using Sync Framework 2.1

liamca — Mon, 13 Sep 2010 22:11:00 GMT

I have just posted a webcast entitled "Extending SQL Azure data to SQL Compact using Sync Framework 2.1". This is part 2 to my original webcast where I showed how to use the Sync Framework to synchronize between an on-premises SQL Server database and a SQL Azure database. In this video I show you how to modify the code from the original webcast to allow a SQL Compact database to synchronize with a SQL Azure database.

Below I have included the main code (program.cs) associated with this console application that allows me to synchronize the Customer and Product table from the SQL Azure AdventureWorks databases to SQL Compact.

Make sure to update it with your own connection information and add references to the Sync Framework components.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data.SqlClient;

using System.Data.SqlServerCe;

using Microsoft.Synchronization.Data.SqlServer;

using Microsoft.Synchronization.Data.SqlServerCe;

using Microsoft.Synchronization.Data;

using Microsoft.Synchronization;

namespace SQLAzureDataSync

{

class Program

{

public static string sqlCeConnectionString = "Data Source=SyncTest.sdf";

public static readonly string scopeName = "alltablesyncgroup";

static void Main(string[] args)

{

// Test if input arguments were supplied:

if (args.Length == 0)

{

System.Console.WriteLine("Please enter an argument.");

System.Console.WriteLine("Usage: SyncTest.exe -setup");

System.Console.WriteLine(" SyncTest.exe -sync");

}

else if (args[0] == "-setup")

Setup();

else if (args[0] == "-sync")

Sync();

}

public static void Setup()

{

try

{

SqlCeConnection sqlCeConn = new SqlCeConnection(sqlCeConnectionString);

SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);

DbSyncScopeDescription myScope = new DbSyncScopeDescription(scopeName);

DbSyncTableDescription Customer = SqlSyncDescriptionBuilder.GetDescriptionForTable("SalesLt.Customer", sqlAzureConn);

DbSyncTableDescription Product = SqlSyncDescriptionBuilder.GetDescriptionForTable("SalesLt.Product", sqlAzureConn);

// Add the tables from above to the scope

myScope.Tables.Add(Customer);

myScope.Tables.Add(Product);

// Setup SQL Azure for sync

SqlSyncScopeProvisioning sqlAzureProv = new SqlSyncScopeProvisioning(sqlAzureConn, myScope);

if (!sqlAzureProv.ScopeExists(scopeName))

{

// Apply the scope provisioning.

Console.WriteLine("Provisioning SQL Azure for sync " + DateTime.Now);

sqlAzureProv.Apply();

Console.WriteLine("Done Provisioning SQL Azure for sync " + DateTime.Now);

}

else

Console.WriteLine("SQL Azure Database server already provisioned for sync " + DateTime.Now);

// Setup SQL CE for sync

if (!(System.IO.File.Exists("SyncTest.sdf")))

{

SqlCeEngine engine = new SqlCeEngine(sqlCeConnectionString);

engine.CreateDatabase();

}

SqlCeSyncScopeProvisioning sqlCeProv = new SqlCeSyncScopeProvisioning(sqlCeConn, myScope);

if (!sqlCeProv.ScopeExists(scopeName))

{

// Apply the scope provisioning.

Console.WriteLine("Provisioning SQL CE for sync " + DateTime.Now);

sqlCeProv.Apply();

Console.WriteLine("Done Provisioning SQL CE for sync " + DateTime.Now);

}

else

Console.WriteLine("SQL CE Database server already provisioned for sync " + DateTime.Now);

sqlAzureConn.Close();

sqlCeConn.Close();

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

public static void Sync()

{

try

{

SqlCeConnection sqlCeConn = new SqlCeConnection(sqlCeConnectionString);

SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);

SyncOrchestrator orch = new SyncOrchestrator

{

RemoteProvider = new SqlSyncProvider(scopeName, sqlAzureConn),

LocalProvider = new SqlCeSyncProvider(scopeName, sqlCeConn),

Direction = SyncDirectionOrder.UploadAndDownload

};

Console.WriteLine("ScopeName={0} ", scopeName.ToUpper());

Console.WriteLine("Starting Sync " + DateTime.Now);

ShowStatistics(orch.Synchronize());

sqlAzureConn.Close();

sqlCeConn.Close();

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

public static void ShowStatistics(SyncOperationStatistics syncStats)

{

string message;

message = "\tSync Start Time :" + syncStats.SyncStartTime.ToString();

Console.WriteLine(message);

message = "\tSync End Time :" + syncStats.SyncEndTime.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Applied :" + syncStats.UploadChangesApplied.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Failed :" + syncStats.UploadChangesFailed.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Total :" + syncStats.UploadChangesTotal.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Applied :" + syncStats.DownloadChangesApplied.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Failed :" + syncStats.DownloadChangesFailed.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Total :" + syncStats.DownloadChangesTotal.ToString();

Console.WriteLine(message);

}

Liam

SQL Server to SQL Azure Synchronization using Sync Framework 2.1

liamca — Tue, 31 Aug 2010 16:22:00 GMT

I have just posted a webcast to Channel 9 that shows you how to extend the capabilities of SQL Azure Data Sync by writing a custom sync applications to enable bi-directional data synchronization between SQL Server and SQL Azure. This enables you to add customization to your synchronization process such as custom business logic or custom conflict resolution through the use of Visual Studio and Sync Framework 2.1.

In this video I show you how to write the code to both setup (provision) the databases for sync and then to actually execute synchronization between the two databases. During the setup phase the tables used for synchronization are created in the SQL Azure database and the associated tables required for synchronization are also automatically generated.

Below I have included the main code (program.cs) associated with this console application that allows me to syncronize the Customer and Product table from the SQL Server AdventureWorks databases to SQL Azure. Make sure to update it with your own connection information and add references to the Sync Framework components.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data.SqlClient;

using Microsoft.Synchronization.Data.SqlServer;

using Microsoft.Synchronization.Data;

using Microsoft.Synchronization;

namespace SQLAzureDataSync

{

class Program

{

public static string sqllocalConnectionString = "Server=(local);Database=AdventureWorksLT2008;Trusted_Connection=True";

public static readonly string scopeName = "alltablesyncgroup";

static void Main(string[] args)

{

// Test if input arguments were supplied:

if (args.Length == 0)

{

System.Console.WriteLine("Please enter an argument.");

System.Console.WriteLine("Usage: SyncTest.exe -setup");

System.Console.WriteLine(" SyncTest.exe -sync");

}

else if (args[0] == "-setup")

Setup();

else if (args[0] == "-sync")

Sync();

}

public static void Setup()

{

try

{

SqlConnection sqlServerConn = new SqlConnection(sqllocalConnectionString);

SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);

DbSyncScopeDescription myScope = new DbSyncScopeDescription(scopeName);

DbSyncTableDescription Customer = SqlSyncDescriptionBuilder.GetDescriptionForTable("Customer", sqlServerConn);

DbSyncTableDescription Product = SqlSyncDescriptionBuilder.GetDescriptionForTable("Product", sqlServerConn);

// Add the tables from above to the scope

myScope.Tables.Add(Customer);

myScope.Tables.Add(Product);

// Setup SQL Server for sync

SqlSyncScopeProvisioning sqlServerProv = new SqlSyncScopeProvisioning(sqlServerConn, myScope);

if (!sqlServerProv.ScopeExists(scopeName))

{

// Apply the scope provisioning.

Console.WriteLine("Provisioning SQL Server for sync " + DateTime.Now);

sqlServerProv.Apply();

Console.WriteLine("Done Provisioning SQL Server for sync " + DateTime.Now);

}

else

Console.WriteLine("SQL Server Database server already provisioned for sync " + DateTime.Now);

// Setup SQL Azure for sync

SqlSyncScopeProvisioning sqlAzureProv = new SqlSyncScopeProvisioning(sqlAzureConn, myScope);

if (!sqlAzureProv.ScopeExists(scopeName))

{

// Apply the scope provisioning.

Console.WriteLine("Provisioning SQL Azure for sync " + DateTime.Now);

sqlAzureProv.Apply();

Console.WriteLine("Done Provisioning SQL Azure for sync " + DateTime.Now);

}

else

Console.WriteLine("SQL Azure Database server already provisioned for sync " + DateTime.Now);

sqlAzureConn.Close();

sqlServerConn.Close();

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

public static void Sync()

{

try

{

SqlConnection sqlServerConn = new SqlConnection(sqllocalConnectionString);

SqlConnection sqlAzureConn = new SqlConnection(sqlazureConnectionString);

SyncOrchestrator orch = new SyncOrchestrator

{

LocalProvider = new SqlSyncProvider(scopeName, sqlAzureConn),

RemoteProvider = new SqlSyncProvider(scopeName, sqlServerConn),

Direction = SyncDirectionOrder.UploadAndDownload

};

Console.WriteLine("ScopeName={0} ", scopeName.ToUpper());

Console.WriteLine("Starting Sync " + DateTime.Now);

ShowStatistics(orch.Synchronize());

sqlAzureConn.Close();

sqlServerConn.Close();

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

public static void ShowStatistics(SyncOperationStatistics syncStats)

{

string message;

message = "\tSync Start Time :" + syncStats.SyncStartTime.ToString();

Console.WriteLine(message);

message = "\tSync End Time :" + syncStats.SyncEndTime.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Applied :" + syncStats.UploadChangesApplied.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Failed :" + syncStats.UploadChangesFailed.ToString();

Console.WriteLine(message);

message = "\tUpload Changes Total :" + syncStats.UploadChangesTotal.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Applied :" + syncStats.DownloadChangesApplied.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Failed :" + syncStats.DownloadChangesFailed.ToString();

Console.WriteLine(message);

message = "\tDownload Changes Total :" + syncStats.DownloadChangesTotal.ToString();

Console.WriteLine(message);

}

Sync Framework 2.1 Available for Download

LarenC_MSFT — Wed, 18 Aug 2010 21:36:00 GMT

Sync Framework 2.1 is available for download.

Sync Framework 2.1 includes all the great functionality of our 2.0 release, enhanced by several exciting new features and improvements. The most exciting of these lets you synchronize data stored in SQL Server or SQL Server Compact with SQL Azure in the cloud. We’ve added top customer requests like parameter-based filtering and the ability to remove synchronization scopes and templates from a database, and of course we’ve made many performance enhancements to make synchronization faster and easier. Read on for more detail or start downloading now!

SQL Azure Synchronization

With Sync Framework 2.1, you can leverage the Windows Azure Platform to extend the reach of your data to anyone that has an internet connection, without making a significant investment in the infrastructure that is typically required. Specifically, Sync Framework 2.1 lets you extend your existing on premises SQL Server database to the cloud and removes the need for customers and business partners to connect directly to your corporate network. After you configure your SQL Azure database for synchronization, users can take the data offline and store it in a client database, such as SQL Server Compact or SQL Server Express, so that your applications operate while disconnected and your customers can stay productive without the need for a reliable network connection. Changes made to data in the field can be synchronized back to the SQL Azure database and ultimately back to the on premises SQL Server database. Sync Framework 2.1 also includes features to interact well with the shared environment of Windows Azure and SQL Azure. These features include performance enhancements, the ability to define the maximum size of a transaction to avoid throttling, and automatic retries of a transaction if it is throttled by Windows Azure. All of this is accomplished by using the same classes you use to synchronize a SQL Server database, such as SqlSyncProvider and SqlSyncScopeProvisioning, so you can use your existing knowledge of Sync Framework to easily synchronize with SQL Azure.

Bulk Application of Changes

Sync Framework 2.1 takes advantage of the table-valued parameter feature of SQL Server 2008 and SQL Azure to apply multiple inserts, updates, and deletes by using a single stored procedure call, instead of requiring a stored procedure call to apply each change. This greatly increases performance of these operations and reduces the number of round trips between client and server during change application. Bulk procedures are created by default when a SQL Server 2008 or SQL Azure database is provisioned.

Parameter-based Filtering

Sync Framework 2.1 enables you to create parameter-based filters that control what data is synchronized. Parameter-based filters are particularly useful when users want to filter data based on a field that can have many different values, such as user ID or region, or a combination of two or more fields. Parameter-based filters are created in two steps. First, filter and scope templates are defined. Then, a filtered scope is created that has specific values for the filter parameters. This two-step process has the following advantages:

Easy to set up. A filter template is defined one time. Creating a filter template is the only action that requires permission to create stored procedures in the database server. This step is typically performed by a database administrator.
Easy to subscribe. Clients specify parameter values to create and subscribe to filtered scopes on an as-needed basis. This step requires only permission to insert rows in synchronization tables in the database server. This step can be performed by a user.
Easy to maintain. Even when several parameters are combined and lots of filtered scopes are created, maintenance is simple because a single, parameter-based procedure is used to enumerate changes.

Removing Scopes and Templates

Sync Framework 2.1 adds the SqlSyncScopeDeprovisioning and SqlCeSyncScopeDeprovisioning classes to enable you to easily remove synchronization elements from databases that have been provisioned for synchronization. By using these classes you can remove scopes, filter templates, and the associated metadata tables, triggers, and stored procedures from your databases.

SQL Server Compact 3.5 SP2 Compatibility

The Sync Framework 2.1 SqlCeSyncProvider database provider object uses SQL Server Compact 3.5 SP2. Existing SQL Server Compact databases are automatically upgraded when Sync Framework connects to them. Among other new features, SQL Server Compact 3.5 SP2 makes available a change tracking API that provides the ability to configure, enable, and disable change tracking on a table, and to access the change tracking data for the table. SQL Server Compact 3.5 SP2 can be downloaded here.

For more information about Sync Framework 2.1, including feature comparisons, walkthroughs, how-to documents, and API reference, see the product documentation.

Download Sync Framework 2.1 today and find out what synchronization can do for you!

Try SQL Azure Data Sync Service with a Free SQL Azure Database

liamca — Mon, 09 Aug 2010 16:22:27 GMT

Although the SQL Azure Data Sync Service is currently free, it does require you to have at least two SQL Azure databases to sync your data with. Until now, there was no free version of SQL Azure to allow you to get started. That has now changed as Windows Azure has started a free one month trial of Windows Azure. Using this link, you can register for a one month pass to try out SQL Azure and Windows Azure - without having to submit a credit card. This is a great way to give the SQL Azure Data Sync Service a try without having to make any financial investment.

Liam

Data Sync Service - Registration

liamca — Thu, 22 Jul 2010 22:38:00 GMT

Today we have opened up access to the Data Sync Service for SQL Azure CTP to all users. Previously, users who wanted to use the Data Sync Service to synchronize their SQL Azure databases were asked to register for access using a Live ID from which we slowly added users to the service in a controlled fashion. I am happy to announce that we have now approved all of these requests and now any users who register will be automatically approved.

To get started please visit: http://sqlazurelabs.com and click on "SQL Azure Data Sync"

Liam

Using Project "Houston" to help with SQL Azure Data Sync Management

liamca — Wed, 21 Jul 2010 14:05:00 GMT

Today the SQL Azure team released CTP1 of Microsoft® Project Code-Named “Houston” on SQL Azure Labs. This is a new web based tool hosted in Windows Azure that can be used to manage your SQL Azure database.

In the past the primary mechanism for managing SQL Azure has been SQL Server Management Studio. For me one of the biggest challenges of using SQL Server Management Studio was when I wanted to work with a new customer on the Data Sync Service for SQL Azure. If this customer wanted to try the Data Sync Service, it would require them to install a copy of SQL Server Management Studio to get started. Now with Microsoft® Project Code-Named “Houston”, people can go directly to this web based management tool and start creating their SQL Azure databases without installing anything. Once they created their databases, they can launch the Data Sync Service to start synchronizing that database to one or more SQL Azure databases around the world.

The other big benefit I find with Microsoft® Project Code-Named “Houston” is the performance. Since it is hosted in the Windows Azure data centers, the latency (or time to communicate back and forth) with my SQL Azure database is much less than with SQL Server Management Studio which in many cases has far greater distance to communicate with my SQL Azure database.

If you would like to learn more about Microsoft® Project Code-Named “Houston”, please check out the SQL Azure blog.

Congratulations to the team on this CTP release! Definitely a very useful management tool.

Liam

Introduction to Data Sync Service for SQL Azure

liamca — Tue, 06 Jul 2010 23:25:00 GMT

Just a quick update to let you know of a new blog post Wayne Berry of the SQL Azure team created for our new Data Sync Service for SQL Azure. I think it is a great overview of the service for anyone looking to get started with sharing data over multiple geographically distributed SQL Azure databases.

Introduction to Data Sync Service for SQL Azure

[Update] Wayne has posted part 2 of his set of Data Sync Service blog posts. In this post he talks about how to use the Data Sync Service for SQL Azure to support the scenario where you want to limit the number of tables that a user has access to, such as for reporting scenarios.

Partial Synchronization with Data Sync Service

Liam

Introducing Data Sync Service for SQL Azure

liamca — Mon, 07 Jun 2010 15:13:00 GMT

I am extremely happy to announce the public preview of our new Data Sync Service for SQL Azure. For those of you who have been following this blog, you might recall our Project “Huron”. In this project we talked about our vision of creating a Data Hub in the cloud to provide users with the ability to seamlessly share and collaborate on data regardless of the location and regardless of network connectivity. Back in November ’09 we introduced SQL Azure Data Sync as the first part of this vision which was to take SQL Server data and extend that to the cloud and then take that data and share it with other SQL Server databases.

Now with the Data Sync Service we are extending on the "Huron" vision. With no code, you can configure your SQL Azure database to be synchronized with one or more SQL Azure databases in any of our Windows Azure data centers. By doing so, it provides you the ability to extend that data to the location closest to your end users. All the while our scheduled synchronization service moves changes back and forth between these databases ensuring that changes get propagated to each of the databases in the data center. In conjunction with SQL Azure Data Sync, this data can also be synchronized back on-premises.

I have a TechEd session this week where I will be demonstrating all of this as well as how we will be extending the capabilities of the sync framework for creating offline applications, specifically allowing Silverlight, Windows Phone 7 and even non-MSFT platforms to be used for the clients.

If you are interested in giving the Data Sync Service a try please go to http://sqlazurelabs.com and click on “SQL Azure Data Sync Service” and send us your registration code. Starting early next week we will start adding registered users to the service.

I am really looking forward to your feedback.

Liam Cavanagh