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.
# Modèle de métadonnées dans la conversion du schéma DMS
Lorsque vous utilisez DMS Schema Conversion, le service représente les schémas de votre base de données sous la forme d'une arborescence hiérarchique. Cet arbre est appelé *arbre de métadonnées* et s'applique à la fois aux schémas source et cible. Chaque élément de l'arborescence, y compris l'élément racine (« Serveurs »), est un modèle de métadonnées.
L'arborescence des métadonnées contient deux types d'éléments :
+ **Objets** : représentent des objets de base de données réels tels que des tables, des fonctions, des vues, des séquences et des index. Vous pouvez récupérer la définition SQL d'un objet à l'aide de la [DescribeMetadataModel](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModel.html)requête.
+ **Catégories** — Conteneurs de regroupement virtuels tels que « Schémas », « Tables », « Fonctions » et « Index ». Les catégories organisent les objets dans l'arborescence à des fins de navigation, mais elles ne contiennent pas de définitions SQL en tant que telles.
L'arborescence de métadonnées charge les données uniquement lorsque vous les demandez. Cette approche est appelée chargement à la demande (également appelé chargement différé), ce qui signifie que DMS Schema Conversion extrait les données de votre base de données uniquement lorsque cela est nécessaire. Vous utilisez l'opération d'importation pour charger les métadonnées, soit en actualisant un modèle de métadonnées spécifique, soit en important une sous-arborescence complète en une seule fois. Les opérations telles que l'évaluation et la conversion chargent également automatiquement l'arborescence des métadonnées.
## Fonctionnement du modèle de métadonnées
Le modèle de métadonnées de DMS Schema Conversion suit un cycle de vie d'opérations. Les opérations qui modifient l'arborescence des métadonnées (telles que l'importation et la conversion) sont asynchrones. Vous lancez une demande pour ces opérations, qui s'exécute en arrière-plan. Appelez l'API de description correspondante pour vérifier l'état de la demande. Les opérations de lecture de l'arborescence (telles que la description des enfants ou des définitions) sont synchrones.
**Note**
Dans DMS Schema Conversion, les termes *opération* et *demande* sont utilisés de manière interchangeable.
Le flux de travail typique comprend les étapes suivantes :
1. **Importer** : chargez les métadonnées de votre base de données source ou cible dans l'arborescence des métadonnées. Vous pouvez charger le modèle de métadonnées initial ou recharger un modèle existant depuis la base de données. Pour de plus amples informations, veuillez consulter [Naviguez dans l'arborescence](#sc-metadata-model-navigating). Pour la référence de l'API, voir [StartMetadataModelImport](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelImport.html).
1. **Évaluer** : analysez les modèles de métadonnées source sélectionnés pour identifier la complexité de la conversion et les problèmes potentiels. Pour de plus amples informations, veuillez consulter [Création de rapports d’évaluation de migration de base de données avec la conversion de schéma DMS](assessment-reports.md).
1. **Convertir** — Convertit les modèles de métadonnées source sélectionnés dans un format compatible avec la cible. Les définitions converties sont stockées dans le cadre de l'arborescence de métadonnées cible. Pour de plus amples informations, veuillez consulter [Conversion de schémas de base de données dans DMS Schema Conversion : guide étape par étape](schema-conversion-convert.md).
1. **Exporter** — Enregistrez les définitions des métadonnées. Vous pouvez exporter les métadonnées source et cible sous forme de scripts SQL vers votre compartiment Amazon S3. Pour les cibles non virtuelles, vous pouvez également appliquer des objets convertis directement à votre base de données cible. Pour plus d'informations sur les cibles virtuelles, consultez[Fournisseur de données virtuelles](virtual-data-provider.md). Pour plus d'informations sur l'application d'objets convertis, consultez[Application de votre code converti](schema-conversion-save-apply.md#schema-conversion-apply).
Après avoir évalué ou converti les modèles de métadonnées source, vous pouvez générer un rapport d'évaluation pour examiner les résultats. Pour de plus amples informations, veuillez consulter [Création de rapports d’évaluation de migration de base de données avec la conversion de schéma DMS](assessment-reports.md).
Pour les paires de migration prises en charge, vous pouvez également créer des modèles de métadonnées d'instructions personnalisés à partir de définitions SQL à l'aide de [StartMetadataModelCreation](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelCreation.html). Pour de plus amples informations, veuillez consulter [Créez des modèles de déclarations](#sc-metadata-model-creation).
## Naviguer dans l'arbre du modèle de métadonnées
Vous pouvez parcourir l'arborescence des métadonnées à l'aide des requêtes d'API suivantes :
+ [DescribeMetadataModelChildren](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModelChildren.html)— Renvoie les enfants d'un modèle de métadonnées donné. Chaque enfant inclut des règles de sélection (filtres qui identifient des modèles de métadonnées spécifiques) que vous pouvez transmettre à l'appel suivant pour approfondir vos connaissances.
+ [DescribeMetadataModel](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModel.html)— Renvoie le nom, le type et la définition SQL d'un modèle de métadonnées spécifique.
Les deux demandes nécessitent le `Origin` paramètre (`SOURCE`ou`TARGET`) et utilisent des règles de sélection pour identifier le modèle de métadonnées. Le modèle de navigation est le même pour les arborescences source et cible. Pour plus d'informations sur le format des règles de sélection, consultez[Règles de sélection dans la conversion de schémas DMS](sc-selection-rules.md).
Choisissez votre interface préférée pour consulter les instructions de navigation.
------
#### [ AWS Management Console ]
Après avoir ouvert votre projet de conversion de schéma, vous pouvez parcourir les arborescences de métadonnées source et cible. Pour plus d'informations sur l'ouverture d'un projet, consultez[Conversion de schémas de base de données dans DMS Schema Conversion : guide étape par étape](schema-conversion-convert.md).
La console affiche deux panneaux d'arborescence : l'arborescence source sur la gauche et l'arborescence cible sur la droite. Chaque panneau comprend un en-tête qui montre le moteur de base de données, un menu Actions et l'arborescence de métadonnées elle-même.
Le menu Actions dépend du contexte. Toutes les actions ne sont pas disponibles dans tous les modèles de métadonnées. Les arborescences source et cible ont des listes d'actions différentes.
Pour afficher la définition SQL et les propriétés d'un modèle de métadonnées, sélectionnez-le dans l'arborescence. Le panneau central affiche les onglets SQL source et SQL cible avec la définition, ainsi qu'un onglet Propriétés avec les attributs de métadonnées. Des onglets supplémentaires peuvent apparaître en fonction du type de modèle de métadonnées, par exemple, des colonnes pour les tables et les vues, ou des paramètres pour les routines.
Pour développer les enfants d'un modèle de métadonnées, cliquez sur l'icône d'extension (triangle noir) située à côté de celui-ci. Choisissez l'icône d'extension ou le nom du modèle de métadonnées pour charger automatiquement ses enfants.
Lorsque vous choisissez un modèle de métadonnées source qui a été converti, le modèle de métadonnées cible correspondant est automatiquement sélectionné dans le panneau de l'arborescence cible.
La procédure pas à pas suivante montre comment parcourir l'arborescence des métadonnées et afficher la définition d'un modèle de métadonnées.
1. Dans l'arborescence, cliquez sur l'icône de développement à côté de votre serveur pour afficher les catégories de niveau supérieur, telles que les **bases de données** ou les **schémas**, en fonction du moteur de base de données.
1. Continuez à développer les catégories pour accéder au modèle de métadonnées que vous souhaitez explorer. Par exemple, développez **Databases**, puis une base de données spécifique, puis **Schemas**, puis un nom de schéma, puis une catégorie telle que **Tables**, **Views** ou **Procedures**. Certains moteurs de base de données n'ont pas le niveau **Bases** de données. Dans ce cas, développez directement **les schémas**.
1. Choisissez un modèle de métadonnées pour afficher sa définition SQL dans le panneau central. L'onglet **Source SQL** affiche la définition de la source, et l'onglet **Target SQL** affiche la définition convertie si le modèle de métadonnées a été converti.
------
#### [ AWS CLI ]
Pour parcourir l'arborescence des métadonnées, vous devez suivre un schéma récurrent : importez des métadonnées à un niveau, puis décrivez les enfants de ce niveau. Répétez ce processus pour percer plus profondément dans l'arbre.
Commencez par appeler [start-metadata-model-import](https://docs.aws.amazon.com/cli/latest/reference/dms/start-metadata-model-import.html) avec une règle de sélection qui identifie le modèle de métadonnées de niveau supérieur. Incluez le `server-name` et un niveau supérieur `category-name` (l'un `Databases` ou l'autre ou`Schemas`, selon le moteur de base de données) dans le`object-locator`. Pour plus d'informations sur la structure des règles de sélection, consultez[Règles de sélection dans la conversion de schémas DMS](sc-selection-rules.md).
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--refresh \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}","category-name":"{{top-level-category}}"},"rule-action":"explicit"}]}'
```
Les demandes d'importation sont asynchrones. Utilisez [describe-metadata-model-imports](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model-imports.html) pour vérifier le statut avant de naviguer. Utilisez le `request-id` filtre avec la `RequestIdentifier` valeur renvoyée par `start-metadata-model-import` pour rechercher une importation spécifique :
```
aws dms describe-metadata-model-imports \
--migration-project-identifier "{{my-migration-project}}" \
--filters Name=request-id,Values={{request-identifier}}
```
Une fois l'importation terminée, appelez [describe-metadata-model-children pour récupérer les enfants](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model-children.html) à ce niveau :
```
aws dms describe-metadata-model-children \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}"},
"rule-action":"explicit"}]}'
```
Chaque enfant de la réponse inclut un `SelectionRules` champ. Transférez ces règles de sélection à l'importation suivante et décrivez les appels à effectuer pour approfondir la question :
```
{
"MetadataModelChildren": [
{
"MetadataModelName": "Schemas",
"SelectionRules": "{\"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"object-locator\":{\"server-name\":\"src-database-server\",\"category-name\":\"Schemas\"},\"rule-action\":\"explicit\"}]}"
}
]
}
```
Pour passer au niveau suivant, importez à ce niveau en utilisant les règles de sélection renvoyées lors de l'`describe-metadata-model-children`appel précédent, puis décrivez ses enfants :
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--refresh \
--selection-rules '{{selection-rules-from-previous-response}}'
```
Avant de décrire les enfants, assurez-vous que l'importation est terminée en vérifiant son statut auprès de`describe-metadata-model-imports`. Appelez ensuite `describe-metadata-model-children` :
```
aws dms describe-metadata-model-children \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{{selection-rules-from-previous-response}}'
```
La réponse renvoie les enfants à ce niveau, chacun ayant ses propres règles de sélection. Transmettez ces règles de sélection à l'importation suivante et décrivez les appels à effectuer pour continuer à approfondir l'arbre.
```
{
"MetadataModelChildren": [
{
"MetadataModelName": "{{child-name}}",
"SelectionRules": "{{selection-rules-JSON-string}}"
}
]
}
```
**Utilisation de --refresh par rapport à une importation complète**
`--refresh`À utiliser pour recharger un modèle de métadonnées spécifique depuis la base de données. Cela charge également les noms de ses enfants directs. Vous pouvez répertorier ces enfants en utilisant`describe-metadata-model-children`, mais pour les décrire ou les parcourir plus en détail, vous devez exécuter une autre importation au niveau de l'enfant.
Pour charger un sous-arbre complet (par exemple, tous les objets d'un schéma, d'une base de données ou d'une catégorie spécifique telle que les tables ou les procédures), omettez l'`--refresh`indicateur et remplacez-le `include` dans `rule-action` les règles de sélection :
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{{{...}}},
"rule-action":"include"}]}'
```
Le chargement d'une sous-arborescence complète peut prendre des minutes, voire des heures pour les schémas volumineux, et entraîne une charge sur votre base de données. Pour une exploration interactive, utilisez `--refresh` et explorez des branches spécifiques selon vos besoins.
Pour récupérer la définition SQL d'un modèle de métadonnées, utilisez [describe-metadata-model](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model.html). Appliquez les règles de sélection qui identifient le modèle de métadonnées spécifique à partir d'une `describe-metadata-model-children` réponse précédente :
```
aws dms describe-metadata-model \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{{selection-rules-for-target-object}}'
```
La réponse inclut le nom, le type et la définition SQL du modèle de métadonnées :
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"Definition": "CREATE TABLE hr.employees(\n id integer NOT NULL,\n name varchar(100),\n department_id integer\n);"
}
```
**Note**
Le `Definition` champ peut ne pas être renseigné pour certains modèles de métadonnées, tels que les schémas et les catégories.
Après avoir converti les modèles de métadonnées source, les définitions converties sont disponibles dans l'arborescence cible. Il existe trois manières de les récupérer.
**Utilisation des règles de sélection des cibles à partir de la réponse source**
Lorsque vous décrivez un modèle de métadonnées source après la conversion, la réponse inclut un `TargetMetadataModels` champ contenant les règles de sélection des cibles :
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"TargetMetadataModels": [
{
"MetadataModelName": "employees",
"SelectionRules": "{\"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"object-locator\":{\"server-name\":\"tgt-database-server\",\"schema-name\":\"hr\",\"table-name\":\"employees\",\"table-type\":\"table\"},\"rule-action\":\"explicit\"}]}"
}
],
"Definition": "CREATE TABLE hr.employees(\n id integer NOT NULL,\n name varchar(100),\n department_id integer\n);"
}
```
Passez les règles de sélection de `TargetMetadataModels` à `describe-metadata-model` avec `--origin TARGET` :
```
aws dms describe-metadata-model \
--migration-project-identifier "{{my-migration-project}}" \
--origin TARGET \
--selection-rules '{{selection-rules-from-TargetMetadataModels}}'
```
La réponse contient la définition SQL convertie dans la syntaxe du moteur cible :
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"Definition": "CREATE TABLE hr.employees (\nid INT NOT NULL,\nname VARCHAR(100) DEFAULT NULL,\ndepartment_id INT DEFAULT NULL,\nPRIMARY KEY (id)\n);"
}
```
**Utilisation de get-target-selection-rules**
Vous pouvez utiliser [get-target-selection-rules pour convertir directement les règles](https://docs.aws.amazon.com/cli/latest/reference/dms/get-target-selection-rules.html) de sélection de source en leurs homologues cibles, sans avoir à appeler au préalable la source : `describe-metadata-model`
```
aws dms get-target-selection-rules \
--migration-project-identifier "{{my-migration-project}}" \
--selection-rules '{{source-selection-rules}}'
```
**Naviguer directement dans l'arborescence cible**
Vous pouvez également parcourir l'arborescence cible de la même manière que l'arborescence source, en utilisant`--origin TARGET`. Cela est utile lorsque vous souhaitez explorer tous les objets convertis sans partir de la source.
------
## Création de modèles de métadonnées de relevés
**Note**
La création d'instructions ne prend actuellement en charge que les directions suivantes : de SQL Server à Aurora PostgreSQL, ou de SQL Server à Amazon RDS for PostgreSQL.
Vous pouvez créer des modèles de métadonnées d'instructions à partir de définitions SQL à l'aide de [StartMetadataModelCreation](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelCreation.html). Cela est utile lorsque vous souhaitez convertir des instructions SQL qui n'existent pas sous forme d'objets dans votre base de données source, par exemple des requêtes d'application ou du code SQL ad hoc.
------
#### [ AWS Management Console ]
La création de modèles de métadonnées de relevés n'est pas disponible dans la console AWS de gestion. Utilisez plutôt le AWS CLI ou un AWS SDK.
------
#### [ AWS CLI ]
Pour créer un modèle de métadonnées de déclaration, utilisez [start-metadata-model-creation](https://docs.aws.amazon.com/cli/latest/reference/dms/start-metadata-model-creation.html). Les règles de sélection doivent spécifier un schéma existant dans votre base de données source. Le modèle de métadonnées créé apparaît sous la `Statements` catégorie de ce schéma.
```
aws dms start-metadata-model-creation \
--migration-project-identifier "{{my-migration-project}}" \
--metadata-model-name "{{GetAllEmployees}}" \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}",
"database-name":"{{my_database}}","schema-name":"{{dbo}}"},
"rule-action":"explicit"}]}' \
--properties '{"StatementProperties":{"Definition":"SELECT * FROM dbo.Employees;"}}'
```
Après sa création, vous pouvez trouver le modèle de métadonnées dans l'arborescence sous la `Statements` catégorie et le décrire :
```
{
"MetadataModelName": "GetAllEmployees",
"MetadataModelType": "statement",
"Definition": "SELECT * FROM dbo.Employees;"
}
```
Après la création, vous pouvez exécuter n'importe quelle opération prise en charge sur le modèle de métadonnées de relevé, telle que l'évaluation, la conversion ou l'exportation.
------