View a markdown version of this page

Flux de travail de modernisation de SQL Server - AWS Transformation

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Flux de travail de modernisation de SQL Server

Cette section décrit étape par étape le processus complet de modernisation de SQL Server à l'aide de AWS Transform.

Étape 1 : Création d'une tâche de modernisation de SQL Server

Commencez votre parcours de modernisation en créant une nouvelle tâche de transformation dans la console AWS Transform.

  1. Connectez-vous à la console AWS Transform

  2. Choisissez Créer une tâche de modernisation

  3. Sélectionnez la tâche de modernisation de Windows, puis sélectionnez la modernisation de SQL Server

  4. Entrez les détails du poste :

    • Nom du poste : nom descriptif de votre projet

    • Description : Description facultative

    • Région cible : AWS région de déploiement

  5. Choisissez Create job (Créer un travail).

    Important

    N'incluez pas d'informations personnelles identifiables (PII) dans le nom de votre poste.

Étape 2 : Connexion à la base de données SQL Server

Connect AWS Transform à votre base de données SQL Server pour permettre l'analyse et la conversion des schémas.

Création d'un connecteur de base de données

  1. Dans le cadre de votre travail de modernisation de SQL Server, accédez à Connect to resources

  2. Choisissez Connect to SQL Server database

  3. Choisissez Créer un nouveau connecteur

  4. Entrez les informations du connecteur :

    • Nom du connecteur : nom descriptif

    • AWS ID de compte : compte sur lequel SQL Server est hébergé

  5. Une fois confirmé, vous recevrez un lien pour approbation. Copiez le lien d'approbation pour obtenir l'approbation de votre AWS administrateur pour le compte. Une fois qu'ils ont approuvé, vous pouvez passer à l'étape suivante.

  6. Une fois que votre administrateur a approuvé la demande de connecteur, cliquez sur Soumettre pour procéder à la configuration de la connexion par code source.

Étape 3 : Connecter le référentiel de code source

AWS Transform a besoin d'accéder au code source de votre application .NET pour analyser et transformer le code qui interagit avec votre base de données SQL Server. AWS Transform prend en charge trois méthodes pour fournir du code source.

Choisissez votre méthode d'authentification

Connecteur PAT (Personal Access Token) (recommandé)

Idéal pour les équipes qui ont besoin de champs d'autorisation personnalisés, d'une assistance auto-hébergée par un fournisseur ou d'un accès à des API spécifiques au fournisseur, telles que Secrets. GitHub Vous créez un PAT dans votre fournisseur de code source avec des autorisations personnalisées, vous le stockez et AWS Transform le récupère en AWS Secrets Manager cas de besoin. Vous êtes responsable de la gestion de la rotation et de l'expiration des jetons.

AWS CodeConnections

Idéal pour les équipes qui souhaitent une gestion automatisée des informations d'identification. AWS CodeConnections utilise une intégration de fournisseur géré qui gère l'authentification via un flux d'autorisation OAuth 2.0. AWS gère l'ensemble du cycle de vie des informations d'identification, y compris l'actualisation et la rotation automatiques des jetons. Aucune gestion manuelle des informations d'identification n'est requise.

Amazon S3

Téléchargez votre code source directement dans un compartiment Amazon S3. AWS Transform accède au code depuis le compartiment pendant le travail de transformation.

Fonctionnalité Connecteur PAT (recommandé) AWS CodeConnections
Gestion des informations d’identification Manuel (géré par le client) Automatique (AWS géré)
Cycle de vie des jetons Rotation manuelle requise Actualisation automatique
Flexibilité des autorisations Des oscilloscopes entièrement personnalisables Autorisations fixes
Self-hosted assistance aux fournisseurs Pris en charge Non disponible
Complexité de configuration Modéré (création et stockage manuels de jetons) Faible (autorisation unique)
Stockage de jetons Du client AWS Secrets Manager Géré par AWS

Configuration d'un connecteur PAT (recommandé)

Avec un connecteur PAT, vous créez un jeton d'accès personnel dans votre fournisseur de code source avec des autorisations personnalisées, vous le stockez en AWS Secrets Manager toute sécurité et AWS Transform le récupère en cas de besoin. Vous êtes responsable de la gestion du cycle de vie des jetons, y compris leur rotation et leur expiration. AWS Transform crée automatiquement le rôle IAM nécessaire avec les autorisations nécessaires pour accéder à votre secret.

Le connecteur PAT prend en charge les fournisseurs suivants, y compris les DNS/URL versions auto-hébergées et personnalisées :

  • GitHub et GitHub Enterprise Server

  • GitLab.com et GitLab Self-Managed

  • Bitbucket Cloud et Bitbucket Data Center

  • Azure DevOps et Azure DevOps Server

Création d'un jeton d'accès personnel

Créez un PAT dans votre fournisseur de code source. Les autorisations requises varient d'un fournisseur à l'autre. Choisissez l'onglet correspondant à votre fournisseur.

Important

Copiez le jeton immédiatement après sa création. Vous ne pouvez pas le voir à nouveau. Définissez l'expiration pour la durée de la tâche de transformation. Ne configurez pas l'expiration pour qu'elle n'expire jamais.

Avertissement

Ne publiez jamais de jetons PAT dans des référentiels de code et ne les partagez jamais via des canaux non sécurisés. Rangez-les toujours dedans AWS Secrets Manager.

GitHub

Accédez aux paramètres, aux paramètres du développeur, aux jetons d'accès personnels, aux Fine-grained jetons. Sélectionnez les référentiels à transformer et accordez les autorisations suivantes.

Autorisations du référentiel

Autorisations Accès Objectif
Table des matières Lisez et écrivez Lit le code source et réécrit le code transformé dans le référentiel
Métadonnées Read-only Accède aux informations de base du référentiel

Autorisations de l'organisation (obligatoires pour les référentiels de l'organisation)

Autorisations Accès Objectif
Members Read-only Répertorie les organisations auxquelles le jeton a accès pour la découverte du référentiel
GitLab

Accédez à Modifier le profil, Accédez aux jetons. Sélectionnez les étendues suivantes.

Scope Objectif
read_api Lit les métadonnées du référentiel, les informations sur le projet, les détails des utilisateurs et répertorie les groupes et les branches
read_repository Lit les fichiers de code source et la structure du référentiel à des fins d'analyse
write_repository Réécrit le code transformé dans le référentiel
Bitbucket

Accédez aux paramètres du compte, à la sécurité, à la création et à la gestion des jetons d'API. Les étendues requises dépendent du type de jeton.

Workspace/Repository Jeton (ATCT — Auth du porteur, aucun nom d'utilisateur requis)

Autorisations Accès Objectif
Référentiels Lisez et écrivez Répertorie les dépôts, lit les branches et écrit le code transformé via git push

Jeton d'API de compte (ATAT — authentification de base avec e-mail) ou mot de passe d'application (ATBB — authentification de base avec nom d'utilisateur)

Scope Objectif
read:account Identifie l'utilisateur authentifié pour résoudre le problème d'appartenance au référentiel
read:workspace:bitbucket Répertorie les espaces de travail auxquels le jeton peut accéder afin que AWS Transform puisse énumérer leurs référentiels. Non obligatoire si vous spécifiez une liste d'espaces de travail dans le secret.
read:repository:bitbucket Répertorie les référentiels et lit les métadonnées et les informations de branche
write:repository:bitbucket Réécrit le code transformé dans le dépôt via git push
Azure DevOps

Accédez aux paramètres utilisateur, puis aux jetons d'accès personnels. Sélectionnez Étendue définie sur mesure. Pour l'étendue de l'organisation, choisissez Toutes les organisations accessibles (recommandé) ou spécifiez une seule organisation.

Scope Accès Objectif
Code Lire et écrire Lit le code source, répertorie les référentiels et les branches, et réécrit le code transformé
Profil de l'utilisateur Lecture Valide l'accès par jeton et découvre l'identité de l'utilisateur pour la recherche dans l'organisation
Gestion des droits des membres Lecture Répertorie les organisations auxquelles le jeton a accès pour la découverte du référentiel

Stockez le PAT dans AWS Secrets Manager

  1. Ouvrez la AWS Secrets Manager console.

  2. Choisissez Store a new secret (Stocker un nouveau secret).

  3. Pour Secret type (Type de secret), choisissez Other type of secret (Autre type de secret).

  4. Ajoutez des paires clé-valeur en fonction de votre fournisseur et de votre type d'hébergement :

    • Cloud-hosted providers — Ajoutez une clé nommée token avec votre PAT comme valeur.

      • Pour Azure DevOps avec une organisation spécifique, ajoutez également une clé organization portant le nom de votre organisation.

      • Pour les mots de passe des applications Bitbucket (ATBB), ajoutez également une clé nommée username avec votre nom d'utilisateur Bitbucket. Pour les jetons d'API de compte Bitbucket (ATAT), ajoutez une clé email portant le nom de votre adresse e-mail Bitbucket.

    • Self-hosted et DNS/URL fournisseurs personnalisés — Ajoutez les clés suivantes : host (l'URL de votre serveur, par exemplehttps://github.mycompany.com)github, provider_type (gitlab,bitbucket, ouado) et token (votre PAT).

      • Pour Azure DevOps avec une organisation spécifique, ajoutez également une clé organization portant le nom de votre organisation.

      • Pour les mots de passe des applications Bitbucket (ATBB), ajoutez également une clé nommée username avec votre nom d'utilisateur Bitbucket. Pour les jetons d'API de compte Bitbucket (ATAT), ajoutez une clé email portant le nom de votre adresse e-mail Bitbucket.

    L'exemple suivant montre comment un secret est découvert AWS Secrets Manager pour un fournisseur GitHub hébergé dans le cloud :

    { "token": "your-github-personal-access-token" }

    L'exemple suivant montre le mot de passe d'une application Bitbucket (ATBB) :

    { "token": "your-bitbucket-app-password", "username": "my-bitbucket-username" }

    L'exemple suivant montre une GitLab instance auto-hébergée :

    { "host": "https://gitlab.mycompany.com", "provider_type": "gitlab", "token": "your-gitlab-personal-access-token" }
  5. Choisissez Suivant.

  6. Entrez un nom secret, par exemplegithub-pat-myproject.

  7. (Facultatif) Sélectionnez une clé KMS gérée par le client pour le chiffrement.

  8. Complétez l'assistant et choisissez Store.

  9. Copiez l'ARN secret. Vous avez besoin de cette valeur lorsque vous configurez la tâche de AWS transformation.

Si vous utilisez une clé KMS gérée par le client pour chiffrer votre secret (au lieu de la clé AWS gérée par défaut), vous devez mettre à jour la politique relative aux clés KMS pour permettre à AWS Transform de déchiffrer le secret. Ajoutez la déclaration suivante à votre politique de clés KMS gérée par le client :

{ "Sid": "Allow AWS Transform to decrypt secrets", "Effect": "Allow", "Principal": { "Service": "transform.amazonaws.com" }, "Action": [ "kms:Decrypt", "kms:DescribeKey" ], "Resource": "*", "Condition": { "StringEquals": { "kms:ViaService": "secretsmanager.REGION.amazonaws.com", "kms:EncryptionContext:SecretARN": "YOUR-SECRET-ARN" } } }

REGIONRemplacez-le par votre AWS région (par exemple,us-east-1) et YOUR-SECRET-ARN par l'ARN de votre secret. Cette kms:ViaService condition garantit que la clé KMS ne peut être utilisée que via le AWS Secrets Manager service. La kms:EncryptionContext:SecretARN condition limite le déchiffrement à votre secret spécifique.

Pour mettre à jour votre politique relative aux clés KMS :

  1. Ouvrez la console AWS KMS à l'adressehttps://console.aws.amazon.com/kms.

  2. Dans le panneau de navigation, choisissez Clés gérées par le client.

  3. Sélectionnez votre clé KMS.

  4. Dans l'onglet Stratégie de clé choisissez Modifier.

  5. Ajoutez la déclaration de politique à la politique existante.

  6. Sélectionnez Enregistrer les modifications.

Note

Si vous utilisez la clé AWS gérée par défaut (aws/secretsmanager), vous n'avez pas besoin de modifier la politique de clé KMS.

Configurez le AWS Transformez le travail

  1. Dans votre tâche de AWS transformation, accédez à Connect to resources.

  2. Choisissez Connect source code repository.

  3. Sélectionnez le connecteur PAT comme méthode d'authentification.

  4. Entrez l'ARN secret indiqué à l'étape 2.

  5. (Facultatif) Entrez l'ARN de la clé KMS si vous avez utilisé une clé KMS gérée par le client.

  6. Sélectionnez votre dépôt et votre branche.

  7. Sélectionnez Continuer.

AWS Transform crée automatiquement un rôle IAM avec les autorisations requises pour accéder à votre secret.

Rotation et maintenance des jetons

Vous êtes responsable de la rotation des jetons PAT avant leur expiration. Pour faire pivoter un jeton :

  1. Générez un nouveau PAT dans votre fournisseur de code source avec les mêmes autorisations.

  2. Mettez à jour la valeur secrète dans AWS Secrets Manager.

  3. Vérifiez que votre tâche de AWS transformation peut accéder au référentiel avec le nouveau jeton.

  4. Révoquez l'ancien PAT dans votre fournisseur de code source.

Résoudre les problèmes liés au connecteur PAT

Accès refusé — PAT non valide

Vérifiez que le PAT n'a pas expiré. Vérifiez que le PAT possède les champs d'application requis pour votre fournisseur. Vérifiez que le PAT est correctement enregistré dans AWS Secrets Manager.

Impossible de récupérer le secret

Vérifiez que l'ARN secret est correct. Consultez les journaux des tâches pour confirmer que AWS Transform a créé le rôle IAM. Si vous utilisez une clé KMS gérée par le client, vérifiez la politique en matière de clés.

Autorisations insuffisantes

Le PAT n'a peut-être pas les étendues requises pour l'opération. Régénérez le PAT avec les étendues requises et mettez à jour la valeur secrète dans. AWS Secrets Manager

Configuration AWS CodeConnections

AWS CodeConnections utilise une intégration de fournisseur géré qui récupère automatiquement les informations d'identification OAuth temporaires via un flux d'autorisation OAuth 2.0. Les autorisations sont configurées dans l'application du fournisseur et entièrement gérées par AWS. Vous n'autorisez l'application qu'une seule fois et vous gérez l' AWS ensemble de la gestion des informations d'identification.

  1. Dans le cadre de votre travail de modernisation de SQL Server, accédez à Connect to resources.

  2. Choisissez Connect source code repository.

  3. Si vous n'avez pas de connexion existante, choisissez Créer une connexion.

  4. Sélectionnez votre fournisseur de dépôt :

    • GitHub / GitHub Entreprise

    • GitLab.com

    • Bitbucket Cloud

    • Référentiels Azure

  5. Suivez le flux d'autorisation de votre fournisseur.

  6. Après autorisation, choisissez Connect.

Sélectionnez votre dépôt et votre branche

  1. Sélectionnez votre dépôt dans la liste.

  2. Choisissez la branche que vous souhaitez transformer (généralement main, master ou develop).

  3. (Facultatif) Spécifiez un sous-répertoire si votre application .NET ne se trouve pas dans la racine du référentiel.

  4. Sélectionnez Continuer.

Note

AWS Transform crée une nouvelle branche pour le code transformé. Vous pouvez vérifier et fusionner les modifications dans le cadre de votre processus normal de révision du code.

Approbation de l'accès au référentiel

Pour GitHub certaines autres plateformes, l'administrateur du référentiel doit approuver la demande de connexion :

  1. AWS Transform affiche un lien de vérification.

  2. Partagez ce lien avec l'administrateur de votre dépôt.

  3. L'administrateur examine et approuve la demande dans les paramètres de son référentiel.

  4. Une fois que l'administrateur a approuvé la demande, l'état de la connexion passe à Approuvé.

Important

Le processus d'approbation peut prendre du temps en fonction des politiques de votre organisation. Planifiez en conséquence.

Étape 4 : créer un connecteur de déploiement (facultatif)

Si vous souhaitez déployer les applications transformées dans votre AWS compte, vous avez la possibilité de sélectionner un connecteur de déploiement.

Configurer le connecteur de déploiement

  1. Sélectionnez Oui si vous souhaitez déployer vos applications. Si vous sélectionnez Non, cette étape sera ignorée.

  2. Ajoutez votre AWS compte sur lequel vous souhaitez déployer les applications transformées.

  3. Ajoutez un nom qui vous permettra de vous souvenir facilement du connecteur

  4. Soumettez la demande de connecteur pour approbation.

Approbation du connecteur de déploiement

L'administrateur de votre AWS compte doit approuver la demande de connexion pour le connecteur de déploiement.

  1. AWS Transform affiche un lien de vérification

  2. Partagez ce lien avec l'administrateur de votre AWS compte

  3. L'administrateur examine et approuve la demande dans les paramètres de son référentiel

  4. Une fois approuvée, l'état de la connexion passe à Approuvé

Important

Le processus d'approbation peut prendre du temps en fonction des politiques de votre organisation. Planifiez en conséquence.

Étape 5 : Confirmez vos ressources

Une fois connecté à votre base de données et à votre référentiel, AWS Transform vérifie que toutes les ressources requises sont accessibles et prêtes à être transformées.

Quoi AWS Transform vérifie

  • Connectivité à la base de données : la connexion est active, l'utilisateur dispose des autorisations requises, les bases de données sont accessibles, la version est prise en charge

  • Accès au référentiel : le référentiel est accessible, la branche existe, les fichiers de projet .NET sont détectés, les connexions à la base de données sont détectables

  • Préparation à l'environnement : la configuration VPC prend en charge le DMS, les rôles de AWS service requis existent, la connectivité réseau est établie, la compatibilité régionale est confirmée

Consultez la liste de vérification avant le vol

  1. Accédez à Confirmer vos ressources dans le plan de travail

  2. Passez en revue les éléments de la liste de contrôle :

    • ✅ Connexion à la base de données vérifiée

    • ✅ Accès au référentiel confirmé

    • ✅ Version .NET prise en charge

    • ✅ Entity Framework ou ADO.NET détecté

    • ✅ Configuration réseau valide

    • ✅ Autorisations requises accordées

  3. Si tous les éléments apparaissent comme complets, choisissez Continuer

  4. Si des éléments comportent des avertissements ou des erreurs, corrigez-les avant de continuer

Étape 6 : Découverte et évaluation

AWS Transform analyse votre base de données SQL Server et votre application .NET pour comprendre l'étendue et la complexité de la modernisation.

Ce qui est découvert

  • Objets de base de données : tables, vues, index, procédures stockées, fonctions, déclencheurs, contraintes, types de données, colonnes calculées, colonnes d'identité, relations entre clés étrangères

  • Code d'application : structure de projet .NET, modèles et configurations d'Entity Framework, code d'accès aux ADO.NET données, chaînes de connexion à la base de données, appels de procédures stockées, requêtes SQL dans le code

  • Dépendances : quelles applications utilisent quelles bases de données, dépendances entre bases de données, procédures stockées partagées, modèles d'accès aux données communs

Processus de découverte

  • AWS Transform lance automatiquement la découverte après confirmation de la ressource

  • La découverte prend généralement 5 à 15 minutes en fonction de la taille de la base de données et de la complexité de l'application

  • Suivez les progrès dans le journal de travail

  • AWS Transform affiche des mises à jour en temps réel à mesure que des objets sont découverts

Examiner les résultats de découverte

Une fois la découverte terminée, accédez à Découverte et évaluation pour passer en revue :

Analyse de base de données :

  • Nombre d'objets : nombre de tables, de vues, de procédures stockées, de fonctions, de déclencheurs

  • Score de complexité : évaluation de la complexité de la transformation (faible, moyenne, élevée)

  • Éléments d'action : objets pouvant nécessiter une attention humaine

  • Fonctionnalités prises en charge : fonctionnalités de base de données qui se convertissent automatiquement

  • Fonctionnalités non prises en charge : fonctionnalités nécessitant des solutions de contournement

Analyse des applications :

  • Type de projet : ASP.NET Core, application console, bibliothèque de classes, etc.

  • Version .NET : version .NET Core détectée

  • Cadre d'accès aux données : version Entity Framework ou ADO.NET

  • Connexions à la base de données : nombre de chaînes de connexion trouvées

  • Complexité du code : évaluation de la complexité de la transformation

Carte des dépendances :

  • Représentation visuelle des relations entre l'application et la base de données

  • Cross-database dépendances

  • Composants partagés

Comprendre l'évaluation de la complexité

AWS Transform classe votre modernisation en trois catégories :

Complexité Caractéristiques Résultat attendu
Faible (classe A) Modèles SQL standard (ANSI SQL), procédures stockées simples, types de données de base, Entity Framework avec configurations standard Intervention humaine minimale attendue, taux de réussite élevé de l'automatisation
Moyen (classe B) T-SQL Modèles avancés, procédures stockées complexes avec logique métier, fonctions définies par l'utilisateur, colonnes calculées Une certaine intervention humaine est requise, un examen par un expert est recommandé
Élevé (classe C) Assemblages CLR, serveurs liés, Service Broker, recherche complexe en texte intégral Une importante refactorisation humaine est requise, envisagez une approche progressive

Rapport d’évaluation

AWS Transform génère un rapport d'évaluation détaillé qui inclut :

  • Résumé avec aperçu de haut niveau

  • Inventaire complet des bases de données

  • Inventaire des applications

  • Pourcentage de préparation à la transformation

  • Estimation de l'effort

  • Stratégies d'évaluation et d'atténuation des risques

  • Approche recommandée

Vous pouvez télécharger le rapport d'évaluation pour le consulter hors ligne et le partager avec les parties prenantes.

Étape 7 : Générer et revoir le plan de vague

Pour les grands parcs dotés de plusieurs bases de données et applications, AWS Transform génère un plan de vague qui organise la modernisation en groupes logiques.

Qu'est-ce qu'un plan de vagues ?

Un plan par vagues organise votre modernisation en phases (vagues) en fonction de :

  • Dépendances entre les bases de données et les applications

  • Priorités commerciales

  • Tolérance au risque

  • Disponibilité des ressources

  • Complexité technique

Chaque vague contient un groupe de bases de données et d'applications qui peuvent être modernisées ensemble sans rompre les dépendances.

Passez en revue le plan des vagues

  1. Accédez à Wave Planning dans le plan de travail

  2. Passez en revue les vagues proposées

  3. Pour chaque vague, passez en revue :

    • Bases de données incluses

    • Applications incluses

    • Dépendances à l'égard d'autres vagues

    • Temps de transformation estimé

    • Niveau de complexité

    • Applications déployables

Personnalisez le plan de vagues

Vous pouvez personnaliser le plan de vague en fonction des besoins de votre entreprise de deux manières :

À l'aide de JSON :

  1. Choisissez Télécharger toutes les vagues pour obtenir un fichier JSON contenant toutes les vagues

  2. Modifiez les vagues dans le JSON en :

    • Déplacer des bases de données entre les vagues

    • Diviser les vagues en petits groupes

    • Fusionner des vagues

    • Modification de la séquence d'ondes

    • Ajouter ou supprimer des bases de données du champ d'application

  3. Rechargez le fichier JSON sur la console en choisissant Upload wave plan

  4. AWS Transform valide vos modifications et vous avertit en cas de violation des dépendances

  5. Choisissez Confirmer les vagues pour mettre à jour le plan des vagues

En utilisant le chat :

Vous pouvez modifier les plans de vagues en discutant avec l'agent et en lui demandant de déplacer les référentiels et les bases de données vers des vagues spécifiques. Cette approche fonctionne bien si vous devez apporter des modifications mineures aux vagues.

Important

Assurez-vous que les dépendances sont respectées lors de la personnalisation des vagues. La transformation d'une application dépendante avant sa base de données peut entraîner des problèmes.

Modernisation d'une seule base

Si vous modernisez une seule base de données et une seule application, AWS Transform crée un plan simple en une seule étape. Vous pouvez passer directement à la transformation sans planification des vagues.

Approuver le plan de vagues

  1. Après avoir révisé et personnalisé (si nécessaire), choisissez Approuver le plan de vague

  2. AWS Transform verrouille le plan de vague et passe à la transformation

  3. Vous pouvez toujours modifier le plan ultérieurement en choisissant Modifier le plan de vagues

Étape 8 : Conversion du schéma

AWS Transform convertit le schéma de votre base de données SQL Server en Aurora PostgreSQL, y compris les tables, les vues, les procédures stockées, les fonctions et les déclencheurs.

Comment fonctionne la conversion de schéma

AWS Transform utilise la conversion de schéma AWS DMS améliorée par l'IA générative pour :

  • Analyser les schémas et les relations de SQL Server

  • Mappez les types de données de SQL Server à des équivalents PostgreSQL

  • T-SQL Transformez-vous en PL/pgSQL

  • Gérer les colonnes d'identité, les colonnes calculées et les contraintes

  • Valider la conversion et l'intégrité référentielle

  • Générez des éléments d'action pour les objets nécessitant un examen humain

Conversions prises en charge

Converti automatiquement :

  • Tables, vues et index

  • Clés primaires et clés étrangères

  • Vérifier les contraintes et les valeurs par défaut

  • Types de données les plus courants

  • Procédures stockées simples

  • Fonctions de base et déclencheurs

  • Colonnes d'identité (converties en SERIAL ou GENERATED)

  • Colonnes les plus calculées

Peut nécessiter un examen humain :

  • Procédures stockées complexes dotées de fonctionnalités avancées T-SQL

  • Server-specific Fonctions SQL (GETUTCDATE, SUSER_SNAME, etc.)

  • Colonnes calculées avec expressions complexes

  • Full-text index de recherche

  • Opérations sur les types de données XML

  • Type de données HIERARCHYID (nécessite l'extension ltree)

Non converti automatiquement :

  • Assemblages CLR

  • Serveurs liés

  • Courtier de services

  • Offres d'emploi dans SQL Server Agent

Lancer la conversion du schéma

  1. Accédez à la conversion du schéma dans le plan de travail

  2. Vérifiez les paramètres de conversion :

    • Version de PostgreSQL cible

    • Options d'extension (ltree, PostGIS, etc.)

    • Convention d'appellation

  3. Choisissez Commencer la conversion

  4. Suivez les progrès dans le journal de travail

  5. La conversion prend généralement 10 à 30 minutes selon le nombre d'objets de base de données

Consulter les résultats de conversion

Une fois la conversion terminée, accédez à Revoir la conversion du schéma :

Résumé de la conversion :

  • Objets convertis : nombre d'objets convertis avec succès

  • Éléments d'action : objets nécessitant une attention humaine

  • Avertissements : problèmes potentiels à examiner

  • Erreurs : objets qui n'ont pas pu être convertis

Révision par type d'objet :

  • Tableaux : mappages de types de données, contraintes, index

  • Procédures stockées : T-SQL vers la PL/pgSQL conversion

  • Fonctions : signature de la fonction et modifications de logique

  • Déclencheurs : modifications de syntaxe et de synchronisation des déclencheurs

Passer en revue les éléments d'action

  1. Choisissez Afficher les éléments d'action

  2. Pour chaque élément d'action, passez en revue :

    • Nom de l'objet : objet de base de données

    • Type de problème : Ce qui nécessite une attention particulière

    • Gravité : critique, avertissement ou information

    • Recommandation : résolution suggérée

    • Code d'origine : version de SQL Server

    • Code converti : version PostgreSQL

  3. Pour chaque action, vous pouvez :

    • Accepter : utilisez le code converti

    • Modifier : modifiez le code converti

    • Signaler pour plus tard : Marquer pour examen humain après la transformation

Exemple : conversion de procédures stockées

Serveur SQL T-SQL :

CREATE PROCEDURE GetProductsByCategory @CategoryId INT, @PageSize INT = 10 AS BEGIN SET NOCOUNT ON; SELECT TOP (@PageSize) ProductId, Name, Price, DATEDIFF(DAY, CreatedDate, GETUTCDATE()) AS DaysOld FROM Products WHERE CategoryId = @CategoryId ORDER BY Name END

PostgreSQL PL/pgSQL converti :

CREATE OR REPLACE FUNCTION get_products_by_category( p_category_id INTEGER, p_page_size INTEGER DEFAULT 10 ) RETURNS TABLE ( product_id INTEGER, name VARCHAR(255), price NUMERIC(18,2), days_old INTEGER ) AS $$ BEGIN RETURN QUERY SELECT p.product_id, p.name, p.price, EXTRACT(DAY FROM (NOW() - p.created_date))::INTEGER AS days_old FROM products p WHERE p.category_id = p_category_id ORDER BY p.name LIMIT p_page_size; END; $$ LANGUAGE plpgsql;

Modifications apportées :

  • Procédure convertie en fonction renvoyant TABLE

  • Noms de paramètres préfixés par p_

  • TOP converti en LIMIT

  • DATEDIFF converti en EXTRACT

  • GETUTCDATE () converti en NOW ()

  • Noms de colonnes convertis en minuscules (convention PostgreSQL)

Approuver la conversion du schéma

  1. Après avoir examiné tous les éléments d'action et apporté les modifications nécessaires

  2. Choisissez Approuver la conversion du schéma

  3. AWS Transform prépare le schéma converti pour le déploiement sur Aurora PostgreSQL

Note

Vous pouvez télécharger le schéma converti sous forme de scripts SQL pour une révision hors ligne ou un contrôle de version.

Étape 9 : Migration des données (facultatif)

AWS Transform propose des options pour la migration des données de SQL Server vers Aurora PostgreSQL. La migration des données est facultative et peut être ignorée si vous n'avez besoin que de la transformation du schéma et du code.

Options de migration des données

Option 1 : migration des données de production

Migrez vos données de production réelles à l'aide du AWS DMS :

  • Chargement initial complet de toutes les données

  • Réplication continue pendant les tests (CDC)

  • Réduction minimale des temps d'arrêt

  • Validation des données et contrôles d'intégrité

Option 2 : ignorer la migration des données

Transformez le schéma et le code uniquement :

  • Utile pour les development/testing environnements

  • Quand les données seront migrées séparément

  • Pour les projets de validation de concept

Configuration de la migration des données

  1. Accédez à la migration des données dans le plan de travail

  2. Choisissez votre option de migration :

    • Migrer les données de production

    • Ignorer la migration des données

  3. Si vous migrez des données de production, configurez :

    • Type de migration : chargement complet ou chargement complet + CDC

    • Validation : activer la validation des données

    • Performances : taille de l'instance DMS

    • Choisissez >Commencer la migration

Processus de migration des données de production

Si vous choisissez de migrer les données de production :

  1. Synchronisation initiale : AWS DMS effectue le chargement complet de toutes les tables

  2. Réplication continue : (si le CDC est activé) Maintient les données synchronisées

  3. Validation : vérifie le nombre de lignes et l'intégrité des données

  4. Préparation du passage : prépare la synchronisation finale

Chronologie de la migration :

  • Bases de données de petite taille (< 10 Go) : 30 minutes - 2 heures

  • Bases de données de taille moyenne (10 à 100 Go) : 2 à 8 heures

  • Bases de données volumineuses (> 100 Go) : plus de 8 heures

Validation des données

AWS Transform valide les données migrées à l'aide des contrôles suivants :

  • Comparaison du nombre de lignes (source et cible)

  • Intégrité des clés primaires

  • Relations clés avec des acteurs étrangers

  • Compatibilité des types de données

  • Résultats des colonnes calculés

  • Gestion des valeurs nulles

Étape 10 : Transformation du code d'application

AWS Transform transforme le code de votre application .NET pour qu'il fonctionne avec Aurora PostgreSQL plutôt qu'avec SQL Server. Il demande un nom de branche cible dans vos référentiels pour valider le code source transformé. Une fois que vous avez saisi le nom de la branche, AWS Transform crée une nouvelle branche et lance la transformation pour qu'elle corresponde à la base de données PostgreSQL.

Ce qui se transforme

Modifications du cadre d'entité :

  • Fournisseur de base de données : UseSqlServer () → UseNpgsql ()

  • Chaînes de connexion : format SQL Server → format PostgreSQL

  • Mappages de types de données : types SQL Server → types PostgreSQL

  • DbContext configurations : SQL Server-specific → PostgreSQL-specific

  • Fichiers de migration : mis à jour pour assurer la compatibilité avec PostgreSQL

ADO.NET Changements :

  • Classes de connexion : SqlConnection → NpgsqlConnection

  • Classes de commandes : SqlCommand → NpgsqlCommand

  • Lecteur de données : SqlDataReader → NpgsqlDataReader

  • Paramètres : SqlParameter → NpgsqlParameter

  • Syntaxe SQL : T-SQL → PostgreSQL SQL

Changements de configuration :

  • Chaînes de connexion dans appsettings.json

  • NuGet Packages destinés aux fournisseurs de bases

  • Configurations d'injection de dépendances

  • Startup/Program.cs configurations

Lancer la transformation du code

  1. Accédez à la transformation des applications dans le plan de travail

  2. Vérifiez les paramètres de transformation :

    • Version .NET cible (en cas de mise à niveau)

    • Version du fournisseur PostgreSQL

    • Préférences de style de code

  3. Choisissez Démarrer la transformation

  4. Suivez les progrès dans le journal de travail

  5. La transformation prend généralement 15 à 45 minutes selon la taille de la base de code

Étape 11 : Examiner les résultats de la transformation

Avant de procéder au déploiement, passez en revue les résultats complets de la transformation pour vous assurer que tout est prêt pour les tests.

Vous pouvez télécharger le code transformé depuis la branche du référentiel pour :

  • Tests et validation locaux

  • Révision du code dans votre IDE

  • Intégration à votre CI/CD pipeline

  • Commit de contrôle de version

Vous pouvez également télécharger le résumé de la transformation pour passer en revue les modifications du langage naturel apportées par AWS Transform dans le cadre de la transformation.

Résumé de la transformation

  1. Accédez au résumé de la transformation dans le plan de travail

  2. Passez en revue les résultats globaux :

    • Conversion de schéma : objets convertis, actions à entreprendre, avertissements

    • Migration des données : tables migrées, lignes transférées, état de validation

    • Transformation du code : fichiers modifiés, lignes modifiées, problèmes résolus

    • Score de préparation : niveau de préparation global pour le déploiement

Générer un rapport de transformation

AWS Transform génère un rapport de transformation complet :

  1. Choisissez Générer un rapport

  2. Sélectionnez le type de rapport :

    • Résumé : High-level aperçu à l'intention des parties prenantes

    • Détails techniques : documentation complète de transformation

    • Éléments d'action : Liste des tâches humaines requises

  3. Choisissez Télécharger le rapport

Le rapport inclut :

  • Portée et objectifs de la transformation

  • Objets et code transformés

  • Problèmes rencontrés et solutions

  • Résultats de la validation

  • Évaluation de la préparation au déploiement

  • Recommandations pour les tests

Étape 12 : Validation et tests

Avant le déploiement en production, vérifiez que l'application transformée fonctionne correctement avec Aurora PostgreSQL.

Types de validation

Validation automatisée : AWS Transform effectue des contrôles automatisés :

  • Validation du schéma sur la base de données source

  • Vérification de l'intégrité des données

  • Test d'équivalence des requêtes

  • Validation des chaînes de connexion

  • Validation de configuration

Validation humaine : vous devez effectuer des tests supplémentaires :

  • Tests fonctionnels des fonctionnalités de l'application

  • Tests d'intégration avec d'autres systèmes

  • Tests de performance et analyse comparative

  • Tests d'acceptation par les utilisateurs

  • Tests de sécurité

Exécuter la validation automatique

  1. Accédez à Validation dans le plan de travail

  2. Choisissez Exécuter la validation

  3. AWS Transform exécute des tests de validation :

    • Connectivité à la base

    • Compatibilité des schémas

    • Intégrité des données

    • Création d'applications

    • Fonctionnalité de base

  4. Passez en revue les résultats de validation :

    • Réussi : Tests réussis

    • Échec : tests nécessitant une attention particulière

    • Avertissements : problèmes potentiels à examiner

Liste de contrôle pour les tests

Fonctionnalité de base de données :

  • Toutes les tables sont accessibles

  • Les procédures stockées s'exécutent correctement

  • Les fonctions renvoient les résultats attendus

  • Les déclencheurs se déclenchent correctement

  • Contraintes appliquées correctement

  • Les index améliorent les performances des requêtes

Fonctionnalité de l'application :

  • L'application démarre correctement

  • Connexions aux bases de données établies

  • Les opérations CRUD fonctionnent correctement

  • Les appels de procédure stockée aboutissent

  • Transactions commit/rollback correctement

  • La gestion des erreurs fonctionne comme prévu

Intégrité des données :

  • Le nombre de lignes correspond à la source

  • Clés primaires uniques

  • Clés étrangères valides

  • Colonnes calculées correctes

  • Traitement des valeurs nulles approprié

  • Types de données compatibles

Rendement :

  • Temps de réponse aux requêtes acceptables

  • Regroupement de connexions configuré

  • Index optimisés

  • Aucun problème de requête N+1

  • Opérations par lots efficaces

  • Utilisation des ressources raisonnable

Étape 13 : Déploiement

Une fois la validation réussie, déployez votre application et votre base de données modernisées en production.

Options de déploiement

  • Amazon ECS et Amazon EC2 Linux

Pre-deployment liste de contrôle

Avant le déploiement en production :

  • Tous les tests de validation ont été réussis

  • Tests de performance terminés

  • Examen de sécurité terminé

  • Plan de sauvegarde et de restauration documenté

  • Surveillance et alertes configurées

  • Équipe formée au nouvel environnement

  • Les parties prenantes informées du déploiement

  • Fenêtre de maintenance planifiée

Déploiement sur Amazon ECS

  1. Accédez à Déploiement dans le plan de travail

  2. Choisissez Deploy to ECS

  3. Configurez les paramètres de déploiement :

    • Cluster : sélectionnez ou créez un cluster ECS

    • Service : configurer le service ECS

    • Définition de tâche : révision de la définition de tâche générée

    • Équilibreur de charge : configurer ALB/NLB

    • Auto-scaling: Définissez des politiques de dimensionnement

  4. Réviser l'infrastructure en tant que code (CloudFormation modèle ou AWS code CDK)

  5. Choisissez Deploy

Surveiller le déploiement

AWS Transform déploie votre application :

  1. Crée un cluster Aurora PostgreSQL

  2. Appliquer le schéma de base de données

  3. Charge les données (le cas échéant)

  4. Déploie des conteneurs d'applications

  5. Configure l'équilibreur de charge

  6. Configure l'auto-scaling

Surveillez la progression du déploiement et vérifiez :

  • Provisionnement de l'infrastructure

  • Initialisation de la base de données

  • Déploiement de l'application

  • Bilans de santé réussis

  • Application accessible

  • Les connexions aux bases de données fonctionnent

  • Journaux indiquant un fonctionnement normal

Post-deployment validation

Après le déploiement :

Test de fumée :

  • Vérifiez les fonctionnalités critiques

  • Testez les flux de travail des utilisateurs clés

  • Vérifiez les points d'intégration

  • Surveillez les taux d'erreur

Surveillance des performances :

  • Suivez les temps de réponse

  • Surveillance des requêtes de base de données

  • Vérifier l'utilisation des ressources

  • Consulter les journaux des applications

Validation utilisateur :

  • Réaliser des tests d'acceptation par les utilisateurs

  • Recueillez des commentaires

  • Résolvez tous les problèmes

  • Documenter les leçons apprises

Procédures de rétrogradation

Si des problèmes surviennent après le déploiement :

Annulation immédiate :

  • Revenir à la version précédente de l'application

  • Revenez à SQL Server (s'il est toujours disponible)

  • Restaurer à partir d'une sauvegarde si nécessaire

Annulation partielle :

  • Restaurer des composants spécifiques

  • Conserver les modifications de la base

  • Annuler le code de l'application uniquement

Correctif avancé :

  • Appliquer le correctif à la version d'Aurora PostgreSQL

  • Déployer le code d'application mis à

  • Surveillez la résolution

Important

Maintenez votre base de données SQL Server disponible pendant un certain temps après le passage afin de permettre la restauration si nécessaire.

Post-deployment optimisation

Après un déploiement réussi :

Réglage des performances :

  • Optimisez les requêtes lentes

  • Régler les paramètres du pool de connexions

  • Fine-tune Paramètres d'Aurora PostgreSQL

  • Passez en revue et optimisez les index

Optimisation des coûts :

  • Right-size Instance Aurora

  • Configurer l'auto-scaling de manière appropriée

  • Vérifiez les paramètres de stockage

  • Optimisez la conservation des sauvegardes

Configuration de la surveillance :

  • Configuration des CloudWatch tableaux de bord

  • Configurer les alertes

  • Activer la surveillance améliorée

  • Configurer Performance Insights

Documentation :

  • Mettre à jour les runbooks

  • Modifications de l'architecture des documents

  • Équipe chargée des opérations ferroviaires

  • Création de guides de résolution des problèmes