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.
Connectez-vous à la console AWS Transform
Choisissez Créer une tâche de modernisation
Sélectionnez la tâche de modernisation de Windows, puis sélectionnez la modernisation de SQL Server
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
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
Dans le cadre de votre travail de modernisation de SQL Server, accédez à Connect to resources
Choisissez Connect to SQL Server database
Choisissez Créer un nouveau connecteur
Entrez les informations du connecteur :
Nom du connecteur : nom descriptif
AWS ID de compte : compte sur lequel SQL Server est hébergé
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.
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
Ouvrez la AWS Secrets Manager console.
Choisissez Store a new secret (Stocker un nouveau secret).
Pour Secret type (Type de secret), choisissez Other type of secret (Autre type de secret).
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
tokenavec votre PAT comme valeur.Pour Azure DevOps avec une organisation spécifique, ajoutez également une clé
organizationportant le nom de votre organisation.Pour les mots de passe des applications Bitbucket (ATBB), ajoutez également une clé nommée
usernameavec votre nom d'utilisateur Bitbucket. Pour les jetons d'API de compte Bitbucket (ATAT), ajoutez une cléemailportant 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) ettoken(votre PAT).Pour Azure DevOps avec une organisation spécifique, ajoutez également une clé
organizationportant le nom de votre organisation.Pour les mots de passe des applications Bitbucket (ATBB), ajoutez également une clé nommée
usernameavec votre nom d'utilisateur Bitbucket. Pour les jetons d'API de compte Bitbucket (ATAT), ajoutez une cléemailportant 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" }Choisissez Suivant.
Entrez un nom secret, par exemple
github-pat-myproject.(Facultatif) Sélectionnez une clé KMS gérée par le client pour le chiffrement.
Complétez l'assistant et choisissez Store.
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 :
Ouvrez la console AWS KMS à l'adresse
https://console.aws.amazon.com/kms.Dans le panneau de navigation, choisissez Clés gérées par le client.
Sélectionnez votre clé KMS.
Dans l'onglet Stratégie de clé choisissez Modifier.
Ajoutez la déclaration de politique à la politique existante.
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
Dans votre tâche de AWS transformation, accédez à Connect to resources.
Choisissez Connect source code repository.
Sélectionnez le connecteur PAT comme méthode d'authentification.
Entrez l'ARN secret indiqué à l'étape 2.
(Facultatif) Entrez l'ARN de la clé KMS si vous avez utilisé une clé KMS gérée par le client.
Sélectionnez votre dépôt et votre branche.
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 :
Générez un nouveau PAT dans votre fournisseur de code source avec les mêmes autorisations.
Mettez à jour la valeur secrète dans AWS Secrets Manager.
Vérifiez que votre tâche de AWS transformation peut accéder au référentiel avec le nouveau jeton.
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.
Dans le cadre de votre travail de modernisation de SQL Server, accédez à Connect to resources.
Choisissez Connect source code repository.
Si vous n'avez pas de connexion existante, choisissez Créer une connexion.
Sélectionnez votre fournisseur de dépôt :
GitHub / GitHub Entreprise
GitLab.com
Bitbucket Cloud
Référentiels Azure
Suivez le flux d'autorisation de votre fournisseur.
Après autorisation, choisissez Connect.
Sélectionnez votre dépôt et votre branche
Sélectionnez votre dépôt dans la liste.
Choisissez la branche que vous souhaitez transformer (généralement main, master ou develop).
(Facultatif) Spécifiez un sous-répertoire si votre application .NET ne se trouve pas dans la racine du référentiel.
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 :
AWS Transform affiche un lien de vérification.
Partagez ce lien avec l'administrateur de votre dépôt.
L'administrateur examine et approuve la demande dans les paramètres de son référentiel.
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
Sélectionnez Oui si vous souhaitez déployer vos applications. Si vous sélectionnez Non, cette étape sera ignorée.
Ajoutez votre AWS compte sur lequel vous souhaitez déployer les applications transformées.
Ajoutez un nom qui vous permettra de vous souvenir facilement du connecteur
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.
AWS Transform affiche un lien de vérification
Partagez ce lien avec l'administrateur de votre AWS compte
L'administrateur examine et approuve la demande dans les paramètres de son référentiel
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
Accédez à Confirmer vos ressources dans le plan de travail
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
Si tous les éléments apparaissent comme complets, choisissez Continuer
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
Accédez à Wave Planning dans le plan de travail
Passez en revue les vagues proposées
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 :
Choisissez Télécharger toutes les vagues pour obtenir un fichier JSON contenant toutes les vagues
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
Rechargez le fichier JSON sur la console en choisissant Upload wave plan
AWS Transform valide vos modifications et vous avertit en cas de violation des dépendances
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
Après avoir révisé et personnalisé (si nécessaire), choisissez Approuver le plan de vague
AWS Transform verrouille le plan de vague et passe à la transformation
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
Accédez à la conversion du schéma dans le plan de travail
Vérifiez les paramètres de conversion :
Version de PostgreSQL cible
Options d'extension (ltree, PostGIS, etc.)
Convention d'appellation
Choisissez Commencer la conversion
Suivez les progrès dans le journal de travail
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
Choisissez Afficher les éléments d'action
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
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
Après avoir examiné tous les éléments d'action et apporté les modifications nécessaires
Choisissez Approuver la conversion du schéma
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
Accédez à la migration des données dans le plan de travail
Choisissez votre option de migration :
Migrer les données de production
Ignorer la migration des données
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 :
Synchronisation initiale : AWS DMS effectue le chargement complet de toutes les tables
Réplication continue : (si le CDC est activé) Maintient les données synchronisées
Validation : vérifie le nombre de lignes et l'intégrité des données
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
Accédez à la transformation des applications dans le plan de travail
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
Choisissez Démarrer la transformation
Suivez les progrès dans le journal de travail
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
Accédez au résumé de la transformation dans le plan de travail
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 :
Choisissez Générer un rapport
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
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
Accédez à Validation dans le plan de travail
Choisissez Exécuter la validation
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
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
Accédez à Déploiement dans le plan de travail
Choisissez Deploy to ECS
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
Réviser l'infrastructure en tant que code (CloudFormation modèle ou AWS code CDK)
Choisissez Deploy
Surveiller le déploiement
AWS Transform déploie votre application :
Crée un cluster Aurora PostgreSQL
Appliquer le schéma de base de données
Charge les données (le cas échéant)
Déploie des conteneurs d'applications
Configure l'équilibreur de charge
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