Skip to content

v3.0.0 Migration Guide

Jump to bottom
Bryan Soltis edited this page Dec 8, 2025 · 2 revisions

Azure Naming Tool v5.0.0 Migration Guide

Overview

Version 5.0.0 of the Azure Naming Tool introduces significant enhancements including a modern redesigned UI, SQLite database storage option, and Azure resource name validation capabilities. This guide will help you successfully migrate from previous versions to v5.0.0.

What's New in v5.0.0

.NET 10.0 Framework Upgrade

  • Latest .NET Version: Upgraded from .NET 8.0 to .NET 10.0
  • Performance Improvements: Enhanced runtime performance and efficiency
  • Security Updates: Latest security patches and improvements
  • Modern Features: Access to newest .NET capabilities
  • Long-term Support: Better long-term maintainability

Modern UI Redesign

  • New Dashboard: Two-column hero layout with logo and custom content
  • Configuration Overview: Stats grid showing all enabled component counts
  • Improved Navigation: Streamlined modern tab interface
  • Better Mobile Support: Responsive design improvements

SQLite Database Support

  • Enhanced Performance: Faster data access and queries
  • Better Scalability: Handles larger configurations more efficiently
  • Improved Reliability: Transactional support and data integrity
  • Easy Migration: Built-in migration tool from file-based storage

Azure Resource Name Validation

  • Real-time Validation: Check if resource names already exist in Azure
  • Conflict Detection: Prevent naming conflicts before deployment
  • Multi-subscription Support: Validate across multiple Azure subscriptions
  • Configurable: Enable/disable per your requirements

Enhanced API Capabilities

  • Bulk Operations: Process multiple naming requests in a single call
  • Improved Error Handling: Better error messages and validation
  • Extended Filtering: More options for querying configurations
  • Performance Improvements: Faster response times

Other Improvements

  • Fixed Component Name Matching: Resolved issues with ResourceOrg, ResourceProjAppSvc, and ResourceFunction
  • Custom Home Content: Now loads correctly in Admin page editor
  • Improved Logging: Enhanced admin logs for troubleshooting
  • Better Error Messages: More helpful error descriptions

🚨 CRITICAL REQUIREMENTS - READ BEFORE PROCEEDING

⚠️ BACKUP EVERYTHING BEFORE STARTING

Before performing ANY migration steps, you MUST create complete backups:

  • ✅ Export configuration JSON from Admin page
  • ✅ Backup repository folder (if using file-based storage)
  • ✅ Backup settings folder
  • ✅ Backup custom logo and CSS files
  • ✅ Document admin passwords and API keys
  • ✅ Store all backups in a safe location OUTSIDE the installation directory

🔄 RESTART APPLICATION AFTER EACH MAJOR STEP

The application MUST be restarted at these critical points:

  1. After initial v5.0.0 deployment - Restart to initialize new features
  2. After restoring configuration from JSON - Restart to load restored settings
  3. After SQLite migration - Restart to switch to new database (CRITICAL)

How to restart:

  • Azure App Service: Azure Portal → Your App Service → Click Restart
  • Docker: docker restart azurenamingtool
  • Stand-alone: Stop and restart the application process

💡 Pro Tip: After each restart, wait 30-60 seconds before accessing the application to ensure all services are fully initialized.

Migration Steps

Step 1: Backup Your Current Configuration

⚠️ DO NOT SKIP THIS STEP - This is your safety net if anything goes wrong!

Before upgrading, it's CRITICAL to backup your existing configuration to prevent any data loss. Complete ALL backup options below:

Option A: Using the Admin Page (Recommended - REQUIRED)

  1. Stop making changes to your current configuration
  2. Navigate to the Admin page in your current Azure Naming Tool installation
  3. Go to the Configuration tab
  4. Under Backup/Restore Configuration, click Export Configuration (JSON)
  5. Save the downloaded JSON file to a safe location
  6. Verify the file: Open the JSON file and confirm it contains your configuration data
  7. Store safely: Keep this file in a secure location OUTSIDE your installation directory
  8. Note: This backup includes all component configurations but excludes admin settings (passwords, API keys)

Option B: Manual File System Backup (Recommended - REQUIRED)

If using the file-based storage (default in v4.x):

  1. STOP the application before copying files:

    • Azure App Service: Azure Portal → Stop the App Service
    • Docker: docker stop azurenamingtool
    • Stand-alone: Stop the application process

  2. Navigate to your installation directory

  3. Copy the entire repository folder to a backup location

  4. Copy the entire settings folder to preserve admin settings

  5. Copy any custom files in wwwroot/images/ and wwwroot/css/

  6. Store these backups in a safe location OUTSIDE your installation directory

  7. Verify backups: Ensure all files were copied successfully and are readable

  8. START the application again if continuing to use the current version:

    • Azure App Service: Azure Portal → Start the App Service
    • Docker: docker start azurenamingtool
    • Stand-alone: Start the application process

Backup Checklist (Complete ALL items):

  • ✅ Configuration JSON exported from Admin page AND verified
  • ✅ repository folder backed up (if applicable)
  • ✅ settings folder backed up (if applicable)
  • ✅ Custom logo files backed up (if customized)
  • ✅ Custom CSS files backed up (if customized)
  • ✅ Documentation of admin password and API keys created
  • ✅ All backup files verified and stored in secure location
  • ✅ Application restarted if it was stopped for backup

Step 2: Backup Code Modifications/Customizations

If you have made any customizations to the Azure Naming Tool code:

  1. Document all code changes:

    • Note any modified files in the src directory
    • Document custom components or services added
    • Save copies of modified CSS/styling files

  2. Export customizations:

    • Custom logo: Located in wwwroot/images/ (if modified)
    • Custom CSS: Check wwwroot/css/ for any custom files
    • Modified resource types or components
    • Custom home content from Admin page

  3. Create a customization document:

    • List all custom changes made
    • Note file paths and specific modifications
    • Document any custom API integrations or webhooks

Step 3: Review Installation Process for Your Environment

Review the installation documentation for your specific deployment environment to ensure you understand the requirements for v5.0.0:

Supported Environments:

System Requirements:

  • .NET 10.0 Runtime (ASP.NET Core) - UPDATED FROM .NET 8.0
  • Minimum 512MB RAM (1GB recommended)
  • Persistent storage for database (file system or SQLite)

New in v5.0.0:

  • Upgraded to .NET 10.0 LTS - Improved performance and security (supported until November 2028)
  • Bootstrap removed - Custom modern CSS framework for better performance
  • Modern UI with improved performance and responsiveness
  • SQLite database option for better scalability (default for new installations)
  • Azure validation integration (requires Azure authentication)
  • Enhanced API capabilities
  • Updated dependencies: EF Core 10.0, Swashbuckle 10.0, jQuery 3.7.1

Step 4: Deploy Using Your Desired Installation Process

⚠️ Important: Before deploying, ensure you have completed Steps 1-3 and have all backups verified and secured.

Choose your deployment method and follow the installation guide:

Azure App Service Deployment

⚠️ CRITICAL: .NET 10.0 Runtime Update Required

v5.0.0 requires .NET 10.0 runtime. You MUST update your App Service runtime before deploying.

  1. Update App Service Runtime to .NET 10.0:

    Option A: Azure Portal (Recommended)

    • Go to Azure Portal → Your App Service
    • Navigate to Settings → Configuration
    • Click on General settings tab
    • Under Stack settings:
      • Windows App Service: .NET version → Select .NET 10
      • Linux App Service: Stack → Select .NET, Major version → .NET 10, Minor version → 10.0
    • Click Save at the top
    • Click Continue to confirm the restart
    • IMPORTANT: Wait 2-3 minutes for the runtime update to complete

    Option B: Azure CLI

    ⚠️ IMPORTANT: Azure CLI commands may not reliably set the runtime stack. After running these commands, you MUST verify and manually set the Stack Settings in the Azure Portal to ensure .NET 10 is properly configured.

    For Windows App Service:

    az webapp config set --resource-group <resource-group-name> --name <app-name> --net-framework-version "v10.0"

    For Linux App Service:

    # Use PowerShell variable to avoid pipe character issues
$version = 'DOTNETCORE:10.0'
az webapp config set --resource-group <resource-group-name> --name <app-name> --linux-fx-version $version

    After running CLI commands, verify in Azure Portal:

    1. Go to Azure Portal → Your App Service
    2. Navigate to Settings → Configuration → General settings
    3. Check Stack settings - verify .NET 10 is selected
    4. If not correct, manually select .NET 10 and click Save

    Verify via CLI (optional):

    Windows:

    az webapp config show --resource-group <resource-group-name> --name <app-name> --query netFrameworkVersion
# Should return: "v10.0"

    Linux:

    az webapp config show --resource-group <resource-group-name> --name <app-name> --query linuxFxVersion
# Should return: "DOTNETCORE:10.0"

    Note: The Azure Portal's Stack Settings UI may not display the runtime correctly even when it's configured properly via CLI. Always verify the actual runtime configuration by checking the Portal and manually correcting if needed.

  2. STOP the current App Service:

    • Go to Azure Portal → Your App Service
    • Click Stop and wait for it to fully stop
    • This prevents file conflicts during deployment

  3. Download the latest v5.0.0 release from GitHub Releases

  4. Extract the files to a local directory

  5. Deploy to Azure App Service using one of these methods:

    • Visual Studio: Right-click project → Publish
    • Azure CLI: 
      az webapp deploy --resource-group <resource-group-name> --name <app-name> --src-path <path-to-zip-file> --type zip --restart true
    • GitHub Actions: Use provided workflow file
    • Azure Portal: Deployment Center → Deploy from zip file

  6. Configure App Settings (if needed):

    • Verify .NET 10 runtime is selected
    • Set ASPNETCORE_ENVIRONMENT if needed
    • Configure any custom environment variables

  7. START the App Service:

    • Click Start in Azure Portal
    • Wait 30-60 seconds for the application to fully initialize
    • Verify the application loads by accessing the URL

  8. VERIFY DEPLOYMENT:

    • Access your App Service URL
    • Check the footer or About page for version "5.0.0"
    • Verify the modern UI loads correctly
    • Test basic functionality (navigate to Configuration page)

Common Issues:

  • "HTTP Error 500.31": App Service runtime not updated to .NET 10.0 - go back to step 1
  • Application won't start: Check App Service logs in Portal → Diagnose and solve problems → Application Logs
  • Database errors: Normal for first start - will be resolved after configuration restore and restart

Docker Deployment

⚠️ IMPORTANT: .NET 10.0 Docker Image Required

v5.0.0 uses a new Docker image based on .NET 10.0 runtime.

  1. STOP the current container (if running):

    docker stop azurenamingtool
docker rm azurenamingtool

  2. Pull the latest v5.0.0 image:

    # Pull the .NET 10.0-based image
docker pull ghcr.io/mspnp/azurenamingtool:v5.0.0
# Or use latest tag (ensure it's v5.0.0 or higher)
docker pull ghcr.io/mspnp/azurenamingtool:latest

  3. Run with persistent storage:

    docker run -d \
  -p 80:80 \
  -v $(pwd)/repository:/app/repository \
  -v $(pwd)/settings:/app/settings \
  --name azurenamingtool \
  --restart unless-stopped \
  ghcr.io/mspnp/azurenamingtool:v5.0.0

    Windows PowerShell:

    docker run -d `
  -p 80:80 `
  -v ${PWD}/repository:/app/repository `
  -v ${PWD}/settings:/app/settings `
  --name azurenamingtool `
  --restart unless-stopped `
  ghcr.io/mspnp/azurenamingtool:v5.0.0

  4. Verify container started:

    # Check container is running
docker ps

# View logs to verify .NET 10.0 startup
docker logs azurenamingtool

# Should see: "Now listening on: http://[::]:80"

  5. Wait 30-60 seconds, then access the application at http://localhost

  6. VERIFY DEPLOYMENT:

    • Check container logs: docker logs azurenamingtool | grep "Application started"
    • Access http://localhost and verify v5.0.0 loads
    • Check footer for version "5.0.0"

Docker Compose Example:

version: '3.8'
services:
  azurenamingtool:
    image: ghcr.io/mspnp/azurenamingtool:v5.0.0
    container_name: azurenamingtool
    ports:
      - "80:80"
    volumes:
      - ./repository:/app/repository
      - ./settings:/app/settings
    restart: unless-stopped
    environment:
      - ASPNETCORE_ENVIRONMENT=Production

Common Issues:

  • Container fails to start: Check logs with docker logs azurenamingtool - may need to remove old volumes
  • Port already in use: Change -p 8080:80 to use different host port
  • Volume permission issues: On Linux, ensure proper permissions: sudo chown -R 1000:1000 ./repository ./settings

Stand-alone Deployment

⚠️ CRITICAL: .NET 10.0 Runtime Installation Required

v5.0.0 requires .NET 10.0 runtime to be installed on your server/workstation.

  1. Install .NET 10.0 Runtime (if not already installed):

    Windows:

    • Download from: https://dotnet.microsoft.com/download/dotnet/10.0
    • Choose "ASP.NET Core Runtime 10.0.x" (includes .NET Runtime)
    • Run the installer (e.g., dotnet-runtime-10.0.0-win-x64.exe)
    • Verify installation: dotnet --list-runtimes
    • Look for: Microsoft.AspNetCore.App 10.0.x

    Linux (Ubuntu/Debian):

    # Add Microsoft package repository
wget https://packages.microsoft.com/config/ubuntu/22.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
rm packages-microsoft-prod.deb

# Install ASP.NET Core 10.0 Runtime
sudo apt-get update
sudo apt-get install -y aspnetcore-runtime-10.0

# Verify installation
dotnet --list-runtimes

    Linux (RHEL/CentOS):

    # Add Microsoft package repository
sudo rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm

# Install ASP.NET Core 10.0 Runtime
sudo yum install aspnetcore-runtime-10.0

# Verify installation
dotnet --list-runtimes

    macOS:

    # Using Homebrew
brew install dotnet@10

# Verify installation
dotnet --list-runtimes

  2. STOP the current application (if running):

    • Press Ctrl+C in the terminal/console
    • Or stop the Windows service if installed as a service
    • Or kill the process: pkill -f AzureNamingTool
    • Ensure the process is fully stopped: ps aux | grep AzureNamingTool

  3. Download and extract v5.0.0:

    • Download from GitHub Releases
    • Extract to your installation directory (backup old version first!)
    • Ensure file permissions are correct (Linux/macOS): chmod +x AzureNamingTool.dll

  4. START the application:

    # Navigate to installation directory
cd /path/to/azurenamingtool

# Run the application
dotnet AzureNamingTool.dll

    For production (run in background):

    # Linux (systemd service)
sudo systemctl restart azurenamingtool

# Or use nohup
nohup dotnet AzureNamingTool.dll > output.log 2>&1 &

  5. Wait 30-60 seconds for initialization

  6. Access the application at http://localhost:5000 (or your configured port)

  7. VERIFY DEPLOYMENT:

    • Check the console output for "Application started"
    • Look for: Now listening on: http://localhost:5000
    • Access the URL and verify v5.0.0 loads
    • Check footer for version "5.0.0"

Creating a Windows Service (Optional):

# Using NSSM (Non-Sucking Service Manager)
nssm install AzureNamingTool "C:\Program Files\dotnet\dotnet.exe" "C:\AzureNamingTool\AzureNamingTool.dll"
nssm set AzureNamingTool AppDirectory "C:\AzureNamingTool"
nssm start AzureNamingTool

Creating a Linux systemd Service (Optional):

# Create service file
sudo nano /etc/systemd/system/azurenamingtool.service

# Add this content:
[Unit]
Description=Azure Naming Tool v5.0.0
After=network.target

[Service]
Type=notify
WorkingDirectory=/opt/azurenamingtool
ExecStart=/usr/bin/dotnet /opt/azurenamingtool/AzureNamingTool.dll
Restart=always
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=azurenamingtool
User=azurenamingtool
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

# Enable and start service
sudo systemctl daemon-reload
sudo systemctl enable azurenamingtool
sudo systemctl start azurenamingtool
sudo systemctl status azurenamingtool

Common Issues:

  • "No application to execute": Wrong directory - ensure you're in the folder containing AzureNamingTool.dll
  • "Framework not found": .NET 10.0 not installed - go back to step 1
  • Port already in use: Change port in appsettings.json or use environment variable: ASPNETCORE_URLS=http://localhost:8080
  • Permission denied (Linux): Ensure proper file permissions: chmod -R 755 /path/to/azurenamingtool

� CRITICAL: After deployment completes and the application starts, you MUST restart it again before proceeding to Step 5. This ensures all v5.0.0 features are properly initialized.

Restart again now:

  • Azure App Service: Azure Portal → Restart
  • Docker: docker restart azurenamingtool
  • Stand-alone: Stop (Ctrl+C) and run dotnet AzureNamingTool.dll again

Step 5: Restore Your Configuration (JSON)

After successfully deploying v5.0.0 and restarting the application, restore your configuration:

Prerequisites:

  • ✅ v5.0.0 is deployed and running
  • ✅ Application has been restarted at least once
  • ✅ You have your configuration JSON backup file ready

Restoration Process

  1. Access the Admin page:

    • Navigate to your new v5.0.0 installation
    • Log in with the default password (or your existing password if preserved)

  2. Navigate to Configuration tab:

    • Click on Admin in the navigation
    • Select the Configuration tab
    • Scroll to Backup/Restore Configuration

  3. Import your configuration:

    • Under Restore Configuration from JSON, click Choose File
    • Select your previously exported JSON backup file
    • Click Restore Configuration from JSON Backup
    • Confirm the restoration when prompted

  4. Verify the restoration:

    • Wait for the success message
    • Don't navigate away immediately

  5. 🔄 RESTART THE APPLICATION (REQUIRED):

    This step is CRITICAL - the application MUST be restarted after restoring configuration!

    • Azure App Service:

      • Go to Azure Portal → Your App Service
      • Click Restart
      • Wait for restart to complete (60-90 seconds)

    • Docker:

      docker restart azurenamingtool

      Wait 60 seconds after restart

    • Stand-alone:

      • Stop the application (Ctrl+C)
      • Wait 10 seconds
      • Restart with dotnet AzureNamingTool.dll

  6. Verify after restart:

    • Log back into the application
    • Navigate to the Configuration page
    • Verify all components are loaded correctly
    • Check Reference page to ensure resource types display properly
    • Test name generation on the Generate page
    • Confirm custom settings are preserved

⚠️ Warning: If you skip the restart after restoring configuration, some settings may not be properly loaded and the application may not function correctly.

Step 6: Upgrading Your Installation to SQLite (Optional)

v5.0.0 introduces SQLite database support for improved performance and reliability. This is optional but recommended for production environments.

⚠️ WARNING:

  • Migrating to SQLite is a ONE-WAY operation
  • BACKUP EVERYTHING before proceeding (even if you just did in Step 1)
  • The application MUST BE RESTARTED after migration completes
  • Ensure you have adequate disk space (at least 2x your current data size)

Prerequisites

  1. Complete Steps 1-5 (Deploy v5.0.0 and restore configuration)
  2. Create a NEW backup of your current configuration (even if already on v5.0.0):
    • Export Configuration JSON from Admin page
    • Save with a name like pre-sqlite-backup-[date].json
    • Store in a safe location
  3. Ensure the application is running on file-based storage (default)
  4. Verify disk space is available (check storage size in Azure or local disk)

Pre-Migration Backup (REQUIRED)

DO NOT proceed without completing this backup:

  1. Stop making any changes to your configuration
  2. Navigate to Admin → Configuration tab
  3. Under Backup/Restore Configuration, click Export Configuration (JSON)
  4. Save as pre-sqlite-backup-[date].json
  5. Verify the backup file is complete and readable
  6. Store in a secure location

Migration Process

  1. Access Admin page:

    • Navigate to Admin → Configuration tab
    • Scroll to Storage Migration section

  2. Review migration information:

    • Current storage provider is shown (should be "FileSystem")
    • Read the migration warnings and requirements carefully
    • Ensure you understand this is a one-way operation

  3. Create pre-migration backup (if not done above):

    • Click Export Configuration (JSON) one more time
    • This is your last safety net before migration

  4. Initiate migration:

    • Click Migrate to SQLite
    • You will see two confirmation prompts:
      • First confirmation: Acknowledge the migration process
      • Second confirmation: Type MIGRATE to proceed
    • Click Confirm on both prompts
    • DO NOT close the browser or navigate away during migration

  5. Monitor migration progress:

    • The migration process will:
      • Export current configuration to JSON
      • Initialize SQLite database
      • Import all data to SQLite
      • Update storage provider setting
    • This may take several minutes depending on data size
    • Wait for the success message before proceeding

  6. 🔄 RESTART THE APPLICATION (ABSOLUTELY CRITICAL):

    The application WILL NOT work with SQLite until it is restarted!

    • Azure App Service:

      • Go to Azure Portal → Your App Service
      • Click Stop and wait for it to fully stop
      • Click Start and wait 60-90 seconds

    • Docker:

      docker stop azurenamingtool
# Wait 10 seconds
docker start azurenamingtool
# Wait 60 seconds

    • Stand-alone:

      • Stop the application (Ctrl+C)
      • Wait 10 seconds for cleanup
      • Restart with dotnet AzureNamingTool.dll
      • Wait 60 seconds for initialization

  7. Verify migration (after restart):

    • Wait 60-90 seconds after restart before testing
    • Log back into the Admin page
    • Check Admin → Configuration tab → Storage Migration section
    • Verify "Current Storage Provider" shows SQLite
    • Navigate to Configuration page and verify all components loaded
    • Test name generation to ensure functionality
    • Check Generated Names Log (if you had entries before)
    • Test all major features before proceeding

⚠️ If application doesn't work after restart:

  1. Check Admin Logs for errors
  2. Verify azurenamingtool.db file exists in the application directory
  3. Check file permissions on the database file
  4. If issues persist, use the Rollback Procedure below

Post-Migration Cleanup (Optional)

After successful migration and verification (wait at least 24-48 hours):

  1. The original file-based storage remains in the repository folder
  2. You can archive this folder for long-term backup purposes
  3. DO NOT delete until:
    • SQLite has been working correctly for several days
    • You have multiple backups of the SQLite database
    • You are confident you won't need to rollback

Rollback Procedure

If you need to rollback from SQLite to file-based storage:

  1. STOP the application:

    • Azure App Service: Azure Portal → Stop
    • Docker: docker stop azurenamingtool
    • Stand-alone: Stop the process (Ctrl+C)

  2. Restore backup files:

    • Restore your pre-migration backup JSON or files to the repository folder
    • Ensure all files are in place

  3. Remove SQLite database:

    • Delete or rename the azurenamingtool.db file
    • This prevents the app from trying to use SQLite

  4. Update configuration:

    • Edit appsettings.json
    • Find the storage provider setting
    • Change from "Sqlite" back to "FileSystem"

  5. START the application:

    • Azure App Service: Azure Portal → Start → Wait 60 seconds
    • Docker: docker start azurenamingtool → Wait 60 seconds
    • Stand-alone: Run dotnet AzureNamingTool.dll → Wait 60 seconds

  6. Verify rollback:

    • Log into Admin page
    • Check that FileSystem storage is active
    • Verify configuration loaded correctly

Troubleshooting

Common Issues

Configuration Not Restored

Symptom: After importing JSON, components don't appear

Solution:

  1. Verify the JSON file is valid and not corrupted
  2. Check Admin Logs for any error messages
  3. Restart the application after restoring
  4. Try importing individual components using the Component Import feature

SQLite Migration Failed

Symptom: Migration process stops or shows errors

Solution:

  1. Ensure you have a valid backup before retrying
  2. Check available disk space (SQLite needs space to create database)
  3. Review Admin Logs for specific error messages
  4. If migration fails, the application remains on file-based storage
  5. Contact support with error logs if issue persists

Application Won't Start After Migration

Symptom: Application fails to start after SQLite migration

Solution:

  1. Check application logs for error details
  2. Verify azurenamingtool.db file was created
  3. Ensure file permissions allow read/write to database
  4. Try rollback procedure (see Step 6)
  5. Restore from pre-migration backup

Azure Validation Not Working

Symptom: Azure validation features are not available

Solution:

  1. Ensure proper Azure authentication is configured
  2. Check that Managed Identity or Service Principal has necessary permissions
  3. Verify network connectivity to Azure Resource Manager
  4. Review Admin → Azure Validation settings
  5. Check Admin Logs for authentication errors

Post-Migration Checklist

After completing the migration, verify these items:

  • ✅ All resource components appear in Configuration page
  • ✅ Custom components (if any) are present
  • ✅ Resource types display correctly on Reference page
  • ✅ Name generation works on Generate page
  • ✅ Admin settings preserved (verify password, API keys)
  • ✅ Custom logo appears (if customized)
  • ✅ Custom home content displays on dashboard (if configured)
  • ✅ Generated Names Log contains previous entries (if applicable)
  • ✅ API endpoints respond correctly (test with Swagger)
  • ✅ Azure validation configured and working (if enabled)
  • ✅ Application performance is acceptable
  • ✅ All backups are stored safely and verified

📋 Quick Reference: Critical Steps Summary

Always BACKUP Before:

  1. ✅ Before deploying v5.0.0 - Export JSON + backup folders
  2. ✅ Before SQLite migration - Export JSON again as safety net
  3. ✅ Store backups safely - Outside installation directory

Always RESTART After:

  1. 🔄 After deploying v5.0.0 - Restart to initialize features
  2. 🔄 After restoring configuration - Restart to load settings
  3. 🔄 After SQLite migration - CRITICAL restart to switch database

How to Stop/Start Application:

  • Azure App Service: Portal → Stop/Start (wait 60-90 seconds)
  • Docker: docker stop/start azurenamingtool (wait 60 seconds)
  • Stand-alone: Ctrl+C to stop, dotnet AzureNamingTool.dll to start

Verification After Each Step:

  1. ✅ Wait 60 seconds after restart
  2. ✅ Access application URL
  3. ✅ Log into Admin page
  4. ✅ Check Configuration page loads
  5. ✅ Test name generation works

Getting Help

If you encounter issues during migration:

  1. Check Admin Logs: Admin page → View Admin Log
  2. Review Documentation: Azure Naming Tool Wiki
  3. Search Issues: GitHub Issues
  4. Report Bugs: Create New Issue
  5. Community Support: Join discussions on GitHub

Additional Resources

Clone this wiki locally