Data migration is a complex but increasingly necessary process for small-to-medium businesses (SMBs) and mid-market companies looking to modernize their technology stack. This often involves moving legacy on-premises systems to the Microsoft Azure cloud platform. A key success factor in Azure migrations is the concept of "retaining" - preserving existing data, configurations, and customizations in the cloud to minimize business disruption.
For SMBs and mid-market organizations running applications built on .NET and SQL Server, leveraging automated tools to retain application settings, database schemas, and user-level permissions can dramatically accelerate migration projects. It allows these companies to realize the elasticity, cost savings, and innovation velocity of the cloud much faster.
What Data Can Be Retained During Azure Migration?
When migrating a line-of-business .NET application backed by SQL Server to Azure, several types of data can be automatically retained to simplify the transition process and reduce friction for end-users.
You may also like: 7 Common Cloud Migration Pitfalls to Avoid
Configuration Settings
.NET Framework applications commonly store user-level and application-level configuration settings in XML files like web.config or app.config. During an Azure migration, these settings can be seamlessly retained using the Azure App Configuration service.
Imagine a regional SMB manufacturer migrating from a bespoke ASP.NET MVC inventory management system to Azure App Service. By linking the application to an Azure App Configuration store, any custom configuration settings set at the application level can be retained with minimal effort:
```xml
<appSettings>
<add key="LowStockAlertThreshold" value="100"/>
<add key="DefaultManufacturingFacility" value="NorthRegion"/>
<add key="ProcurementOrderApprover" value="[email protected]"/>
<add key="AutomaticallyCreateWorkOrders" value="true"/>
</appSettings>
```
For more modern .NET Core applications, configuration settings can be retained using Azure App Configuration's dedicated .NET Core client library which allows for direct integration of App Configuration values into the application's configuration builder:
```csharp
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
webBuilder.UseStartup<Startup>())
.ConfigureAppConfiguration((hostingContext, config) =>
{
var settings = config.Build();
config.AddAzureAppConfiguration(options =>
options.Connect(settings["AppConfig:ConnectionString"]));
});
```
You may also like: Emergent Software Azure Cloud Migration Services
Metadata
When migrating on-premises SQL Server databases to Azure SQL Database or Azure SQL Managed Instance, it's crucial to retain the metadata columns and extended properties that are commonly used for auditing, data lineage tracking, and Master Data Management (MDM) purposes. These often include columns like CreatedDate, CreatedBy, ModifiedDate, ModifiedBy, RecordVersion, and IsDeleted.
Consider a mid-market financial services firm migrating their on-premises enterprise data warehouse to Azure Synapse Analytics. A typical Products dimension table in their data warehouse might have an extended metadata schema such as:
```sql
CREATE TABLE DimProduct (
ProductKey INT IDENTITY(1,1) PRIMARY KEY,
ProductID INT NOT NULL,
ProductName VARCHAR(100) NOT NULL,
ProductCategory VARCHAR(50),
ProductColor VARCHAR(20),
UnitPrice DECIMAL(10,2),
CreatedDate DATETIME,
CreatedBy NVARCHAR(50),
ModifiedDate DATETIME,
ModifiedBy NVARCHAR(50),
RecordVersion INT,
IsDeleted BIT
);
```
By using the Azure Database Migration Service (DMS) to migrate this dimension table and configuring the migration project to retain all metadata columns and extended properties, this valuable contextual information about the provenance and lifecycle of each product record would be fully retained in the cloud environment.
Relationships Between Data Elements
Retaining referential integrity constraints between related tables is of paramount importance when migrating relational databases to Azure to maintain data consistency and accuracy.
Consider a mid-market retailer migrating a mission-critical e-commerce system from SQL Server to Azure SQL Database. At the heart of their relational data model, the Orders and OrderItems tables are typically linked via foreign key constraints like this:
```sql
CREATE TABLE Orders (
OrderID INT IDENTITY(1,1) PRIMARY KEY,
CustomerID INT NOT NULL,
OrderDate DATETIME NOT NULL,
OrderTotal DECIMAL(10,2),
CONSTRAINT FK_Orders_Customers FOREIGN KEY (CustomerID)
REFERENCES Customers(CustomerID)
);
CREATE TABLE OrderItems (
OrderItemID INT IDENTITY(1,1) PRIMARY KEY,
OrderID INT NOT NULL,
ProductID INT NOT NULL,
Quantity SMALLINT NOT NULL,
UnitPrice DECIMAL(10,2) NOT NULL,
CONSTRAINT FK_OrderItems_Orders FOREIGN KEY (OrderID)
REFERENCES Orders(OrderID),
CONSTRAINT FK_OrderItems_Products FOREIGN KEY (ProductID)
REFERENCES Products(ProductID)
);
```
By using a tool like Azure Data Factory to execute the migration of these tables and crucially retaining the foreign key constraints between them, it ensures the referential integrity of the order data is maintained in the cloud and the migrated database will properly support order processing and fulfillment workflows in the Azure environment.
Access Controls and Permissions
When migrating on-premises ASP.NET web applications that use Windows authentication or Forms authentication to Azure App Service, it's critically important to retain the existing role-based access control rules that govern which users can access specific application functions. This can be accomplished by integrating the application with Azure Active Directory (Azure AD) for authentication and authorization in the cloud environment.
Imagine a regional healthcare provider migrating their in-house ASP.NET patient portal system to Azure App Service. The on-premises application might define user roles and permissions like this:
```csharp
public enum PatientPortalRoles
{
Patient,
Caregiver,
Nurse,
Doctor,
BillingRepresentative,
SystemAdministrator
}
```
And then restrict access to sensitive functionality based on a user's assigned role(s) using .NET attributes:
```csharp
[Authorize(Roles = "Patient,Caregiver")]
public class PatientInfoController : Controller
{
// Only authenticated patients and linked caregivers
// can view/edit patient demographic and clinical info
// ...
}
[Authorize(Roles = "BillingRepresentative,SystemAdministrator")]
public class BillingController : Controller
{
// Only authorized billing staff can view/edit
// patient financial and insurance data
// ...
}
```
By configuring the migrated application to use Azure AD for authentication and carefully retaining each user's role assignments and permission levels, the same granular access controls can be enforced and regulatory compliance maintained in the cloud.
You may also like: What to Expect When You Migrate to Azure VMware Solution (AVS) with Emergent Software
Benefits of Retaining Data During Azure Migration
Automatically retaining application data, configuration settings, and role-based access controls offers multiple compelling benefits for resource-constrained SMBs and mid-market organizations migrating their mission-critical .NET applications and SQL Server databases to Azure.
Preserves Continuity for End Users
Retaining familiar application customizations, user-level configurations, and granular role-based permissions makes the switch to Azure as seamless and low-friction as possible for business users. It allows them to pick up right where they left off with minimal disruption or need for retraining on the new cloud platform.
Saves Time and Effort
Leveraging automated migration tools and processes to programmatically retain application settings, database metadata, and user security roles eliminates the time-consuming burden of having to manually reconfigure these items in the Azure environment. This enables leaner IT teams at SMBs and mid-market companies to execute migrations much faster and more efficiently.
Reduces Risk of Data Loss
The complex nature of enterprise .NET applications and SQL Server databases means that attempting to manually reconstruct application configurations, user permission levels, and schema metadata in Azure would be highly error prone. iIntroducing human errors could result in loss or inconsistency of business-critical data. Retaining this information via rigorous automated migration tools is far more reliable.
Retaining Best Practices
Below are some essential best practices that SMBs and mid-market organizations should diligently follow to ensure successful retention of application data, configurations, and security controls when migrating their technology stack to Microsoft Azure:
Thorough Planning and Mapping
Invest sufficient time upfront to exhaustively analyze and document the configuration settings, metadata structures, and security model of the source .NET applications and SQL Server databases. Create a complete mapping of all the application elements and database attributes that must be retained to maintain full fidelity and functionality in the cloud post-migration.
Rigorous Validation and Testing
After the data migration has been executed, it's vital to allocate adequate time and resources for comprehensive testing and validation of the retained application data and configurations in the target Azure environment. Meticulously scrutinize the values of migrated configuration settings, verify the correctness of retained user permissions, and thoroughly regression test the functionality of the .NET applications to confirm that relational data integrity and application behavior have been properly preserved during the migration process.
Robust Fallback Planning
Even with proper planning and testing, unanticipated challenges can still emerge during the final cutover data migration due to the inherent complexity of enterprise data. So, it's wise to have well-documented fallback plans and procedures ready to quickly revert to the source on-premises systems in the event that irreconcilable data retaining or validation issues arise. This helps avoid costly unplanned downtime and minimize disruption to the business. Using proven Microsoft Azure migration tools that offer point-in-time restore capabilities is highly recommended.
Conclusion
For SMBs and mid-market companies whose business operations depend on industry-specific .NET applications and SQL Server databases, the prospect of migrating these complex mission-critical workloads to Microsoft Azure can seem daunting. But leveraging Azure's extensive platform capabilities to automatically retain familiar application configurations, granular role-based access controls, and relational data integrity during the migration process is essential.
By combining this rigorous methodology with the power and flexibility of best-in-class Microsoft migration tools like Azure DMS and Azure Data Factory, SMBs and mid-market enterprises can unlock the full agility, scalability, and cost optimization advantages of the Azure cloud much faster and with greater confidence - allowing them to maintain their competitive edge in an increasingly cloud-centric IT landscape.
If you need additional support while navigating Azure migration, please reach out and we will be happy to help! To learn more about migration with Emergent Software, check out our blog: Why Work with Emergent Software for Azure Migration?
Frequently Asked Questions
What is the retain migration strategy?
The retain migration strategy involves preserving existing data, configurations, and customizations when moving to a new system or platform.
What are the 7 common migration strategies?
The 7 common migration strategies are: Retain, Rehost, Replatform, Refactor, Rearchitect, Rebuild, and Replace.
What are the 5 R's of migration?
The 5 R's of migration are: Rehost, Refactor, Revise, Rebuild, and Replace.
What are 6 R's in migration?
The 6 R's in migration are: Rehost, Replatform, Repurchase, Refactor, Retain, and Retire.
